DependencyProperty VS управление состоянием без избыточности

Вы можете использовать INotifyPropertyChanged. Просто отправьте уведомление об изменении для данного WindowXVisible при изменении CurrentState (DP имеет обратный вызов для этого).

Вы можете использовать этот инструмент для автоматической генерации вызовов уведомлений (без усложнения кода за счет немного). Он на удивление хорошо справляется даже с такими нетривиальными случаями.

РЕДАКТИРОВАТЬ:

Зарегистрируйте это в PropertyMetadata CurrentStateProperty.

    private static void OnCurrentStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        this.OnPropertyChanged("CurrentState");
        this.OnPropertyChanged("Window1Visible");
        this.OnPropertyChanged("Window2Visible");
    }

OnPropertyChanged просто вызывает событие PropertyChanged с this в качестве отправителя и строкой в ​​качестве имени свойства.

Это приведет к обновлению привязок Window1Visible и Window2Visible и получению новых значений.

Кстати, вы должны попытаться придумать имена получше, чем Window1 и WIndow2.

Есть несколько хороших ответов, поэтому я не буду предлагать конкретное решение, но я рассмотрю общую проблему, с которой вы столкнулись. Вы опасаетесь, что добавление некоторого механизма свойств зависимостей для воспроизведения кажущихся простыми концепций сопоставления состояний, которые у вас уже есть, потенциально избыточно или, что еще хуже, может работать неправильно.

Правда в том, что вы будете просто повторно реализовывать одни и те же концепции, используя инфраструктуру свойств зависимостей вместо инфраструктуры CLR. Да, это будет немного более подробно, но это очень надежный материал, на котором основан весь WPF. Например, у ListBox есть SelectedItem и SelectedIndex, которые необходимо синхронизировать, как в вашем примере. Как только вы сделаете это правильно, независимо от того, что вы делаете, они никогда не будут рассинхронизированы.

Единственный раз, когда видимость может измениться, — это когда изменяется состояние, поэтому вы можете установить видимость из обратного вызова изменения состояния, если вы уверены, что обратный вызов будет вызван. На самом деле, даже без свойств зависимостей вы иногда видите программистов, использующих именно эту стратегию, чтобы избежать вычислений в геттере для свойства. Так что думайте об этом не как об избыточности, а просто о другом способе достижения той же цели.

Вы можете привязаться к CurrentState и написать IValueConverter, который преобразуется в видимость.

Этот вопрос может быть полезен.

РЕДАКТИРОВАТЬ. Предполагая, что вам нужно свойство зависимости для целей привязки данных. В противном случае INotifyPropertyChanged проще.

Привязка не работает для объектов CLR. Это работает только для свойств зависимостей. Следовательно, я бы превратил WindowXStyle в свойство зависимости только для чтения:

using System;
using System.ComponentModel;
using System.Windows;

namespace MyNamespace
{
    public enum Phases { Phase1, Phase2, Phase3 }

    public class UIStateModel : DependencyObject
    {
        static UIStateModel()
        {
            CurrentStateProperty = DependencyProperty.Register("CurrentState", typeof(Phases), typeof(UIStateModel),
                new FrameworkPropertyMetadata
                {
                    PropertyChangedCallback = new PropertyChangedCallback(OnCurrentStateChanged)
                });

            Window1VisibilityPropertyKey = DependencyProperty.RegisterReadOnly("Window1Visiblity", typeof(Visibility), typeof(UIStateModel),
                new PropertyMetadata());
            Window1VisibilityProperty = Window1VisibilityPropertyKey.DependencyProperty;

            Window2VisibilityPropertyKey = DependencyProperty.RegisterReadOnly("Window2Visiblity", typeof(Visibility), typeof(UIStateModel),
                new PropertyMetadata());
            Window2VisibilityProperty = Window2VisibilityPropertyKey.DependencyProperty;
        }

        public Phases CurrentState
        {
            get { return (Phases)GetValue(CurrentStateProperty); }
            set { SetValue(CurrentStateProperty, value); }
        }

        public static DependencyProperty CurrentStateProperty;

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Visibility Window1Visibility
        {
            get { return (Visibility)GetValue(Window1VisibilityProperty); }
            protected set { SetValue(Window1VisibilityPropertyKey, value); }
        }

        public static readonly DependencyProperty Window1VisibilityProperty;
        private static readonly DependencyPropertyKey Window1VisibilityPropertyKey;

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Visibility Window2Visibility
        {
            get { return (Visibility)GetValue(Window2VisibilityProperty); }
            protected set { SetValue(Window2VisibilityPropertyKey, value); }
        }

        public static readonly DependencyProperty Window2VisibilityProperty;
        private static readonly DependencyPropertyKey Window2VisibilityPropertyKey;


        public Visibility Window1Visible // Databound to Window1.Visibility
        {
            get
            {
                if (this.CurrentState == Phases.Phase1) return Visibility.Visible;
                else return Visibility.Hidden;
            }
        }
        public Visibility Window2Visible // Databound to Window2.Visibility
        {
            get
            {
                if (this.CurrentState == Phases.Phase2) return Visibility.Visible;
                else return Visibility.Hidden;
            }
        }

        private static void OnCurrentPageChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            UIStateModel element = (UIStateModel)obj;

            Phases oldPhase = (Phases)e.OldValue;
            Phases newPhase = (Phases)e.NewValue;

            //Probably want to use Collapsed as apposed to Hidden for UI Measure/Arrange purposes
            switch (oldPhase)
            {
                case Phases.Phase1:
                    element.Window1Visibility = Visibility.Hidden;
                    break;
                case Phases.Phase2:
                    element.Window2Visibility = Visibility.Hidden;
                    break;
                case Phases.Phase3:
                    //element.Window3Visiblity = Visibility.Hidden;
                    break;
                default:
                    //??
                    break;
            }

            switch (newPhase)
            {
                case Phases.Phase1:
                    element.Window1Visibility = Visibility.Visible;
                    break;
                case Phases.Phase2:
                    element.Window2Visibility = Visibility.Visible;
                    break;
                case Phases.Phase3:
                    //element.Window3Visiblity = Visibility.Visible;
                    break;
                default:
                    //??
                    break;
            }
        }

        //...
    }
}

Обратите внимание, что вы также, вероятно, захотите использовать Visiblity.Collapsed в отличие от Visiblity.Hidden... Collapsed не только скрывает объект, но и не влияет на измерение/расположение других элементов UI. Скрытый влияет на измерение и расположение других элементов, но на самом деле не рисует элемент (подумайте об этом больше как о «невидимом»).