INotifyPropertyChanged und statische Eigenschaften

Ich bin binden mich in Knoten über ein einfaches problem. Ich habe eine Klasse, die INotifyPropertyChanged. Einige der Instanz-Eigenschaften' Getter verwenden Sie statische Eigenschaften und damit auch Ihre Werte ändern kann, wenn die statische Eigenschaft ändert? Hier ist ein Vereinfachtes Beispiel.

class ExampleClass : INotifyPropertyChanged
{

    private static int _MinimumLength = 5;
    public static int MinimumLength
    {
        get
        {
            return _MinimumLength;
        }
        set
        {
            if (_MinimumLength != value)
            {
                _MinimumLength = value;
                //WHAT GOES HERE
            }
        }
    }

    private int _length = -1;
    public int length
    {
        get
        {
            return (_length > _MinimumLength) ? _length : _MinimumLength;
        }
        set
        {
            var oldValue = (_length > _MinimumLength) ? _length : _MinimumLength;
            if (_length != value)
            {
                _length = value;
                var newValue = (_length > _MinimumLength) ? _length : _MinimumLength;
                if (newValue != oldValue)
                {
                    OnPropertyChanged("length");
                }
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    [NotifyPropertyChangedInvocator]
    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

}

Klar, wenn die statische Eigenschaft MinimumLength änderungen, die dann jede Instanz der Eigenschaft length können sich auch ändern. Aber wie sollte der statische Konstanteneigenschaft signal das mögliche änderung der Instanzen? Es kann nicht rufen OnPropertyChanged da, dass ist nicht statisch.

Ich könnte eine Liste in der Klasse alle Instanzen und rufen Sie eine Methode auf jeden, aber irgendwie fühlt sich das wie overkill. Oder ich könnte ziehen Sie die statischen Eigenschaften, die sich in einer singleton-Klasse, aber logisch, Sie Leben in der Klasse. Gibt es ein etabliertes Muster für diese oder sollte ich mir Gedanken über das anders?

InformationsquelleAutor der Frage dumbledad | 2013-01-30

.net c#inotifypropertychanged static

Wenn man geneigt zu behaupten, dass design dann würde ich mit einer Lösung wie der folgenden:

public static int MinimumLength
{
    get { return _MinimumLength; }
    set
    {
        if (_MinimumLength != value)
        {
            _MinimumLength = value;
            OnGlobalPropertyChanged("MinimumLength");
        }
    }
}
static event PropertyChangedEventHandler GlobalPropertyChanged = delegate { };
static void OnGlobalPropertyChanged(string propertyName)
{
    GlobalPropertyChanged(
        typeof (ExampleClass), 
        new PropertyChangedEventArgs(propertyName));
}
public ExampleClass()
{
    //This should use a weak event handler instead of normal handler
    GlobalPropertyChanged += this.HandleGlobalPropertyChanged;
}
void HandleGlobalPropertyChanged(object sender, PropertyChangedEventArgs e)
{
    switch (e.PropertyName)
    {
        case "MinimumLength":
            if (length > MinimumLength)
                length = MinimumLength;
            break;
    }
}

Dies ist sehr viel entspricht die Aufrechterhaltung einer Liste von Instanzen, aber ich finde es besser zu warten und übersichtlicher. Auch Sie wirklich brauchen, um eine schwache event-handler-Strategie, sonst, Ihre Instanzen werden nicht von der garbage Collection eingesammelt, weil Sie immer im Zusammenhang mit der statischen Ereignis, das wirkt wie eine GC root.

Lesen Sie mehr über die schwache event-Handler in den folgenden blog-Beiträge (die wurden von mir geschrieben, bin ich also voreingenommen):

.NET Schwach-Event-Handler – Teil I

In ein unbedeutender Hinweis: Ihr code ist derzeit feuern Eigenschaft geändert, wenn in der Tat der Wert der Eigenschaft nicht geändert. Zum Beispiel:

Set minimumlength enthält, 5;
Einstellen der Länge bis zu 10; (event feuert da ändert sich der Wert von der Standardeinstellung von 0 bis 5)
Set Länge bis 11; (event feuert, aber sollte es nicht, da die Länge noch 5)

InformationsquelleAutor der Antwort João Angelo

Könnte die erwähnte Technik in Bindung statische Eigenschaft und die Implementierung von INotifyPropertyChanged aber auch das eine Meldung gegen die "Länge", z.B.

class ExampleClass : INotifyPropertyChanged
{
    private static int _MinimumLength = 5;

    public int MinimumLength
    {
        get
        {
            return _MinimumLength;
        }
        set
        {
            if (_MinimumLength != value)
            {
                _MinimumLength = value;

                OnPropertyChanged("MinimumLength");
                OnPropertyChanged("length");
            }
        }
    }
    ...
}

InformationsquelleAutor der Antwort Phil

Stand ich vor dem gleichen problem. Hier ist die Lösung, die ich haben an Ort und Stelle.

public class ZoomDataVm : ModelBase
{
    public ZoomDataVm()
    {
        //initialise the zoom
    }

    private double _zoomLevel;
    public double ZoomLevel
    {
        get { return _zoomLevel; }
        set
        {
            if (_zoomLevel != value)
            {
                _zoomLevel = value;
                RaisePropertyChanged(() => ZoomLevel);
                //
                //persist zoom info
            }
        }
    }
}

public class ZoomVm : ModelBase
{
    public static ZoomDataVm _instance;

    static ZoomVm()
    {
        _instance = new ZoomDataVm();
    }

    public ZoomDataVm Instance
    {
        get { return _instance; }
    }
}

Dann benutze ich es im XAML, dass

<StackPanel>
    <StackPanel.Resources>
        <screenControls:ZoomVm x:Key="ZoomVm" />
    </StackPanel.Resources>
    <TextBlock Text="{Binding ElementName=uiScaleSliderContainer, Path=Tag}" Foreground="White" Margin="0,0,20,0" />
    <Control Name="uiScaleSliderContainer"
        Margin="0,0,0,0"
        VerticalAlignment="Center"
        HorizontalAlignment="Left"
        Tag="{Binding Source={StaticResource ZoomVm}, Path=Instance.ZoomLevel}">
        <Control.Template>
            <ControlTemplate>
                <Slider Orientation="Horizontal"
                    Width="400"
                    x:Name="uiScaleSlider"
                    ToolTip="Zoom"
                    Value="{Binding ElementName=uiScaleSliderContainer, Path=Tag}"
                    Minimum="0.1"
                    Maximum="2"
                    TickFrequency="0.1"
                    IsSnapToTickEnabled="True">
                </Slider>
            </ControlTemplate>
        </Control.Template>
    </Control>
</StackPanel>

InformationsquelleAutor der Antwort Claude Catonio

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.