C# getter-und setter-Kürzel

Wenn mein Verständnis der internen Arbeitsweise dieser Zeile korrekt ist:

public int MyInt { get; set; }

Dann ist es hinter den kulissen bedeutet dies:

private int _MyInt { get; set; }
Public int MyInt {
    get{return _MyInt;}
    set{_MyInt = value;}
}

Was ich wirklich brauche ist:

private bool IsDirty { get; set; }

private int _MyInt { get; set; }
Public int MyInt {
    get{return _MyInt;}
    set{_MyInt = value; IsDirty = true;}
}

Aber ich möchte es schreiben so etwas wie:

private bool IsDirty { get; set; }

public int MyInt { get; set{this = value; IsDirty = true;} }

Welches nicht funktioniert. Die Sache ist einige der Dinge die ich tun müssen, um die IsDirty-auf Dutzenden von Eigenschaften und ich hoffe es gibt einen Weg, verwenden Sie die automatische getter/setter aber noch IsDirty, wenn das Feld geändert wird.

Ist das möglich oder muss ich nur haben, um mich abfinden zu verdreifachen die Menge an code in meinen Klassen?

InformationsquelleAutor der Frage William | 2011-02-15

c#getter-setter shorthand

21

Werden Sie brauchen, um diese zu bewältigen sich selbst:
```
private bool IsDirty { get; set; }

private int _myInt; //Doesn't need to be a property
Public int MyInt {
    get{return _myInt;}
    set{_myInt = value; IsDirty = true;}
}
```
Gibt es keine syntax zur Verfügung, die fügt eine benutzerdefinierte Logik für einen setter, während Sie immer noch die automatische property-Mechanismus. Sie schreiben müssen, mit Ihrem eigenen Feld sichern.

Dies ist ein häufiges Problem - zum Beispiel bei der Umsetzung der INotifyPropertyChanged.

InformationsquelleAutor der Antwort Reed Copsey

Erstellen Sie ein IsDirty-decorator (design pattern) zu wickeln, einige Ihrer Eigenschaften erfordern die isDirty-flag-Funktionalität.

public class IsDirtyDecorator<T>
{
    public bool IsDirty { get; private set; }

    private T _myValue;
    public T Value
    {
        get { return _myValue; }
        set { _myValue = value; IsDirty = true; }
    }
}

public class MyClass
{
    private IsDirtyDecorator<int> MyInt = new IsDirtyDecorator<int>();
    private IsDirtyDecorator<string> MyString = new IsDirtyDecorator<string>();

    public MyClass()
    {
        MyInt.Value = 123;
        MyString.Value = "Hello";
        Console.WriteLine(MyInt.Value);
        Console.WriteLine(MyInt.IsDirty);
        Console.WriteLine(MyString.Value);
        Console.WriteLine(MyString.IsDirty);
    }
}

InformationsquelleAutor der Antwort Simon Hughes

Können Sie machen es einfach oder Komplex. Es hängt davon ab, wie viel Arbeit Sie investieren wollen. Sie verwenden können, Aspekt-orientierte Programmierung hinzufügen der Aspekt über eine IL weaver in den IL-code mit z.B. PostSharp.
Oder Sie erstellen eine einfache Klasse, nicht umgehen, die der Staat für Ihre Immobilie. Es ist so einfach, dass der erste Ansatz zahlt sich nur aus, wenn Sie wirklich viele Eigenschaften zu behandeln diese Art und Weise.

using System;

class Dirty<T>
{
    T _Value;
    bool _IsDirty;

    public T Value
    {
        get { return _Value; }
        set
        {
            _IsDirty = true;
            _Value = value;
        }
    }

    public bool IsDirty
    {
        get { return _IsDirty; }
    }

    public Dirty(T initValue)
    {
        _Value = initValue;
    }
}

class Program
{
    static Dirty<int> _Integer;
    static int Integer
    {
        get { return _Integer.Value; }
        set { _Integer.Value = value;  }
    }

    static void Main(string[] args)
    {
        _Integer = new Dirty<int>(10);
        Console.WriteLine("Dirty: {0}, value: {1}", _Integer.IsDirty, Integer);
        Integer = 15;
        Console.WriteLine("Dirty: {0}, value: {1}", _Integer.IsDirty, Integer);
    }
}

Andere Möglichkeit ist die Verwendung einer proxy-Klasse, die zur Laufzeit generiert, die nicht fügen Sie den Aspekt für Sie. Mit .NET 4 gibt es eine Klasse, die nicht umgehen, diesen Aspekt bereits für Sie. Es heißt ExpandObjectdie nicht informieren, Sie über ein Ereignis, wenn sich eine Eigenschaft ändert. Das schöne ist, dass ExpandoObject können Sie definieren, zur Laufzeit beliebige Menge von Eigenschaften, und Sie erhalten Benachrichtigungen über jede änderung einer Eigenschaft. Databinding mit WPF ist es sehr einfach, mit diesem Typ.

dynamic _DynInteger = new ExpandoObject();

_DynInteger.Integer = 10;
((INotifyPropertyChanged)_DynInteger).PropertyChanged += (o, e) =>
{
    Console.WriteLine("Property {0} changed", e.PropertyName);
};

Console.WriteLine("value: {0}", _DynInteger.Integer );
_DynInteger.Integer = 20;
 Console.WriteLine("value: {0}", _DynInteger.Integer);

Yours,
Alois Kraus

InformationsquelleAutor der Antwort Alois Kraus

Werde ich um add-on zu Simon Hughes' Antwort. Ich schlage vor, die gleiche Sache, aber fügen Sie einen Weg, um das decorator-Klasse zu aktualisieren, eine Globale IsDirty-flag automatisch. Sie können finden, dass es weniger Komplex sein, es zu tun auf die altmodische Weise, aber es hängt davon ab, wie viele Eigenschaften Sie sind aufzudecken und wie viele Klassen erfordern die gleiche Funktionalität.

public class IsDirtyDecorator<T>
{
    private T _myValue;
    private Action<bool> _changedAction;

    public IsDirtyDecorator<T>(Action<bool> changedAction = null)
    {
        _changedAction = changedAction;
    }

    public bool IsDirty { get; private set; }

    public T Value
    {
        get { return _myValue; }
        set
        {
            _myValue = value;
            IsDirty = true;
            if(_changedAction != null)
                _changedAction(IsDirty);
        }
    }
}

Jetzt können Sie Ihre decorator-Klasse automatisch aktualisieren einige andere IsDirty-Eigenschaft in einer anderen Klasse:

class MyObject
{
    private IsDirtyDecorator<int> _myInt = new IsDirtyDecorator<int>(onValueChanged);
    private IsDirtyDecorator<int> _myOtherInt = new IsDirtyDecorator<int>(onValueChanged);

    public bool IsDirty { get; private set; }

    public int MyInt
    {
        get { return _myInt.Value; }
        set { _myInt.Value = value; }
    }

    public int MyOtherInt
    {
        get { return _myOtherInt.Value; }
        set { _myOtherInt.Value = value; }
    }

    private void onValueChanged(bool dirty)
    {
        IsDirty = true;
    }

}

InformationsquelleAutor der Antwort Phil

1

Habe ich eine benutzerdefinierte Property<T> - Klasse, um gemeinsame Operationen wie das. Ich habe nicht verwendet es gründlich allerdings noch nicht, aber es könnte verwendet werden, in diesem Szenario.

Code finden Sie hier: http://pastebin.com/RWTWNNCU

Könnten Sie es wie folgt:
```
readonly Property<int> _myInt = new Property<int>();
public int MyInt
{
    get { return _myInt.GetValue(); }
    set { _myInt.SetValue( value, SetterCallbackOption.OnNewValue, SetDirty ); }
}

private void SetDirty( int oldValue, int newValue )
{
    IsDirty = true;
}
```
Die Eigenschaft, Klasse verarbeitet nur den Aufruf der übergebenen Delegaten, wenn ein neuer Wert übergeben wird Dank der SetterCallbackOption parameter. Dies ist die Standardeinstellung, damit es gelöscht werden kann.

UPDATE:

Funktioniert es nicht offensichtlich, wenn Sie brauchen, um Unterstützung für mehrere Arten (neben int), weil das delegieren nicht übereinstimmt dann. Sie könnte natürlich immer passen Sie den code an Ihre Bedürfnisse anzupassen.

InformationsquelleAutor der Antwort Steven Jeuris

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.