INotifyPropertyChanged implementieren - gibt es einen besseren Weg?

Microsoft hätte etwas Bissiges implementieren sollen INotifyPropertyChanged, wie in den automatischen Eigenschaften. Geben {get; set; notify;} Sie einfach an, dass es meiner Meinung nach sehr sinnvoll ist, dies zu tun. Oder gibt es irgendwelche Komplikationen, um es zu tun?

Können wir selbst so etwas wie "Benachrichtigen" in unseren Eigenschaften implementieren? Gibt es eine anmutige Lösung für die Implementierung INotifyPropertyChangedin Ihrer Klasse oder die einzige Möglichkeit, dies zu tun, besteht darin, das PropertyChangedEreignis in jeder Eigenschaft auszulösen.

Wenn nicht, können wir etwas schreiben, um den Code automatisch zu generieren, um das PropertyChanged Ereignis auszulösen ?

Ohne etwas wie Postsharp zu verwenden, verwendet die von mir verwendete Minimalversion Folgendes:

public class Data : INotifyPropertyChanged
{
    // boiler-plate
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
    protected bool SetField<T>(ref T field, T value, string propertyName)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return false;
        field = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    // props
    private string name;
    public string Name
    {
        get { return name; }
        set { SetField(ref name, value, "Name"); }
    }
}

Jede Eigenschaft ist dann nur so etwas wie:

    private string name;
    public string Name
    {
        get { return name; }
        set { SetField(ref name, value, "Name"); }
    }

das ist nicht riesig; Wenn Sie möchten, kann es auch als Basisklasse verwendet werden. Die boolRückgabe von SetFieldgibt an, ob es sich um ein No-Op handelt, falls Sie eine andere Logik anwenden möchten.

oder noch einfacher mit C # 5:

protected bool SetField<T>(ref T field, T value,
    [CallerMemberName] string propertyName = null)
{...}

was so genannt werden kann:

set { SetField(ref name, value); }

mit dem der Compiler das "Name"automatisch hinzufügt .

C # 6.0 erleichtert die Implementierung:

protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

... und jetzt mit C # 7:

protected void OnPropertyChanged(string propertyName)
   => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

protected bool SetField<T>(ref T field, T value,[CallerMemberName] string propertyName =  null)
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return false;
    field = value;
    OnPropertyChanged(propertyName);
    return true;
}

private string name;
public string Name
{
    get => name;
    set => SetField(ref name, value);
}

Ab .Net 4.5 gibt es endlich eine einfache Möglichkeit, dies zu tun.

.Net 4.5 führt neue Anruferinformationsattribute ein.

private void OnPropertyChanged<T>([CallerMemberName]string caller = null) {
     // make sure only to call this if the value actually changes

     var handler = PropertyChanged;
     if (handler != null) {
        handler(this, new PropertyChangedEventArgs(caller));
     }
}

Es ist wahrscheinlich eine gute Idee, der Funktion auch einen Vergleicher hinzuzufügen.

EqualityComparer<T>.Default.Equals

Weitere Beispiele hier und hier

Siehe auch Anruferinformationen (C # und Visual Basic).

Ich mag Marc's Lösung wirklich, aber ich denke, sie kann leicht verbessert werden, um die Verwendung einer "magischen Zeichenfolge" zu vermeiden (die kein Refactoring unterstützt). Anstatt den Eigenschaftsnamen als Zeichenfolge zu verwenden, können Sie ihn einfach zu einem Lambda-Ausdruck machen:

private string name;
public string Name
{
    get { return name; }
    set { SetField(ref name, value, () => Name); }
}

Fügen Sie einfach die folgenden Methoden zu Marc's Code hinzu, es wird den Trick machen:

protected virtual void OnPropertyChanged<T>(Expression<Func<T>> selectorExpression)
{
    if (selectorExpression == null)
        throw new ArgumentNullException("selectorExpression");
    MemberExpression body = selectorExpression.Body as MemberExpression;
    if (body == null)
        throw new ArgumentException("The body must be a member expression");
    OnPropertyChanged(body.Member.Name);
}

protected bool SetField<T>(ref T field, T value, Expression<Func<T>> selectorExpression)
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return false;
    field = value;
    OnPropertyChanged(selectorExpression);
    return true;
}

Übrigens wurde dies von dieser aktualisierten URL des Blogposts inspiriert

Es gibt auch Fody mit einem PropertyChanged- Add-In, mit dem Sie Folgendes schreiben können:

[ImplementPropertyChanged]
public class Person 
{        
    public string GivenNames { get; set; }
    public string FamilyName { get; set; }
}

... und beim Kompilieren werden Benachrichtigungen über geänderte Eigenschaften eingefügt.

Ich denke, die Leute sollten der Leistung etwas mehr Aufmerksamkeit schenken. Dies wirkt sich tatsächlich auf die Benutzeroberfläche aus, wenn viele Objekte gebunden werden müssen (denken Sie an ein Raster mit mehr als 10.000 Zeilen) oder wenn sich der Wert des Objekts häufig ändert (Echtzeitüberwachungs-App).

Ich nahm verschiedene Implementierungen, die hier und anderswo gefunden wurden, und führte einen Vergleich durch. Testen Sie den Leistungsvergleich von INotifyPropertyChanged-Implementierungen .

Hier ist ein Blick auf das Ergebnis

Ich stelle eine verbindliche Klasse in meinem Blog unter http://timoch.com/blog/2013/08/annoyed-with-inotifypropertychange/ vor. Bindable verwendet ein Wörterbuch als Eigenschaftstasche. Es ist einfach genug, die erforderlichen Überladungen für eine Unterklasse hinzuzufügen, um ihr eigenes Sicherungsfeld mithilfe von ref-Parametern zu verwalten.

• Keine magische Schnur
• Keine Reflexion
• Kann verbessert werden, um die Standard-Wörterbuchsuche zu unterdrücken

Der Code:

public class Bindable : INotifyPropertyChanged {
    private Dictionary<string, object> _properties = new Dictionary<string, object>();

    /// <summary>
    /// Gets the value of a property
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="name"></param>
    /// <returns></returns>
    protected T Get<T>([CallerMemberName] string name = null) {
        Debug.Assert(name != null, "name != null");
        object value = null;
        if (_properties.TryGetValue(name, out value))
            return value == null ? default(T) : (T)value;
        return default(T);
    }

    /// <summary>
    /// Sets the value of a property
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <param name="name"></param>
    /// <remarks>Use this overload when implicitly naming the property</remarks>
    protected void Set<T>(T value, [CallerMemberName] string name = null) {
        Debug.Assert(name != null, "name != null");
        if (Equals(value, Get<T>(name)))
            return;
        _properties[name] = value;
        OnPropertyChanged(name);
    }

    public event PropertyChangedEventHandler PropertyChanged;

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

Es kann folgendermaßen verwendet werden:

public class Contact : Bindable {
    public string FirstName {
        get { return Get<string>(); }
        set { Set(value); }
    }
}

Ich hatte noch keine Gelegenheit, dies selbst zu versuchen, aber wenn ich das nächste Mal ein Projekt mit einer großen Anforderung für INotifyPropertyChanged einrichte, beabsichtige ich, ein Postsharp- Attribut zu schreiben, das den Code beim Kompilieren einfügt . Etwas wie:

[NotifiesChange]
public string FirstName { get; set; }

Wird werden:

private string _firstName;

public string FirstName
{
   get { return _firstname; }
   set
   {
      if (_firstname != value)
      {
          _firstname = value;
          OnPropertyChanged("FirstName")
      }
   }
}

Ich bin mir nicht sicher, ob dies in der Praxis funktionieren wird und ich muss mich hinsetzen und es ausprobieren, aber ich verstehe nicht, warum nicht. Möglicherweise muss es einige Parameter für Situationen akzeptieren, in denen mehr als ein OnPropertyChanged ausgelöst werden muss (wenn ich beispielsweise eine FullName-Eigenschaft in der obigen Klasse hatte).

Momentan verwende ich eine benutzerdefinierte Vorlage in Resharper, aber trotzdem habe ich es satt, dass alle meine Eigenschaften so lang sind.

Ah, eine schnelle Google-Suche (die ich hätte machen sollen, bevor ich das geschrieben habe) zeigt, dass mindestens eine Person hier schon einmal so etwas gemacht hat . Nicht genau das, was ich mir vorgestellt hatte, aber nah genug, um zu zeigen, dass die Theorie gut ist.

Ja, es gibt sicherlich einen besseren Weg. Hier ist es:

Schritt für Schritt Tutorial von mir geschrumpft, basierend auf diesem nützlichen Artikel .

• Neues Projekt erstellen
• Installieren Sie das Castle Core-Paket im Projekt

Installationspaket Castle.Core

• Installieren Sie nur mvvm light-Bibliotheken

Install-Package MvvmLightLibs

• Fügen Sie dem Projekt zwei Klassen hinzu:

NotifierInterceptor

public class NotifierInterceptor : IInterceptor
    {
        private PropertyChangedEventHandler handler;
        public static Dictionary<String, PropertyChangedEventArgs> _cache =
          new Dictionary<string, PropertyChangedEventArgs>();

        public void Intercept(IInvocation invocation)
        {
            switch (invocation.Method.Name)
            {
                case "add_PropertyChanged":
                    handler = (PropertyChangedEventHandler)
                              Delegate.Combine(handler, (Delegate)invocation.Arguments[0]);
                    invocation.ReturnValue = handler;
                    break;
                case "remove_PropertyChanged":
                    handler = (PropertyChangedEventHandler)
                              Delegate.Remove(handler, (Delegate)invocation.Arguments[0]);
                    invocation.ReturnValue = handler;
                    break;
                default:
                    if (invocation.Method.Name.StartsWith("set_"))
                    {
                        invocation.Proceed();
                        if (handler != null)
                        {
                            var arg = retrievePropertyChangedArg(invocation.Method.Name);
                            handler(invocation.Proxy, arg);
                        }
                    }
                    else invocation.Proceed();
                    break;
            }
        }

        private static PropertyChangedEventArgs retrievePropertyChangedArg(String methodName)
        {
            PropertyChangedEventArgs arg = null;
            _cache.TryGetValue(methodName, out arg);
            if (arg == null)
            {
                arg = new PropertyChangedEventArgs(methodName.Substring(4));
                _cache.Add(methodName, arg);
            }
            return arg;
        }
    }

ProxyCreator

public class ProxyCreator
{
    public static T MakeINotifyPropertyChanged<T>() where T : class, new()
    {
        var proxyGen = new ProxyGenerator();
        var proxy = proxyGen.CreateClassProxy(
          typeof(T),
          new[] { typeof(INotifyPropertyChanged) },
          ProxyGenerationOptions.Default,
          new NotifierInterceptor()
          );
        return proxy as T;
    }
}

• Erstellen Sie Ihr Ansichtsmodell, zum Beispiel:

-

 public class MainViewModel
    {
        public virtual string MainTextBox { get; set; }

        public RelayCommand TestActionCommand
        {
            get { return new RelayCommand(TestAction); }
        }

        public void TestAction()
        {
            Trace.WriteLine(MainTextBox);
        }
    }

• Binden Sie Bindungen in xaml:

  <TextBox Text="{Binding MainTextBox}" ></TextBox>
  <Button Command="{Binding TestActionCommand}" >Test</Button>

• Fügen Sie die Codezeile wie folgt in die CodeBehind-Datei MainWindow.xaml.cs ein:

DataContext = ProxyCreator.MakeINotifyPropertyChanged<MainViewModel>();

• Genießen.

Beachtung!!! Alle begrenzten Eigenschaften sollten mit dem virtuellen Schlüsselwort dekoriert werden, da sie vom Castle-Proxy zum Überschreiben verwendet werden.

Ein sehr AOP-ähnlicher Ansatz besteht darin, das INotifyPropertyChanged-Material im laufenden Betrieb auf ein bereits instanziiertes Objekt zu injizieren. Sie können dies mit etwas wie Castle DynamicProxy tun. Hier ist ein Artikel, der die Technik erklärt:

Hinzufügen von INotifyPropertyChanged zu einem vorhandenen Objekt

Schauen Sie hier: http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx

Es ist in deutscher Sprache geschrieben, aber Sie können die ViewModelBase.cs herunterladen. Alle Kommentare in der cs-Datei sind in englischer Sprache verfasst.

Mit dieser ViewModelBase-Klasse können bindbare Eigenschaften implementiert werden, die den bekannten Abhängigkeitseigenschaften ähneln:

public string SomeProperty
{
    get { return GetValue( () => SomeProperty ); }
    set { SetValue( () => SomeProperty, value ); }
}

Basierend auf der Antwort von Thomas, die aus einer Antwort von Marc übernommen wurde, habe ich den Code der reflektierten Eigenschaft in eine Basisklasse umgewandelt:

public abstract class PropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) 
            handler(this, new PropertyChangedEventArgs(propertyName));
    }

    protected void OnPropertyChanged<T>(Expression<Func<T>> selectorExpression)
    {
        if (selectorExpression == null)
            throw new ArgumentNullException("selectorExpression");
        var me = selectorExpression.Body as MemberExpression;

        // Nullable properties can be nested inside of a convert function
        if (me == null)
        {
            var ue = selectorExpression.Body as UnaryExpression;
            if (ue != null)
                me = ue.Operand as MemberExpression;
        }

        if (me == null)
            throw new ArgumentException("The body must be a member expression");

        OnPropertyChanged(me.Member.Name);
    }

    protected void SetField<T>(ref T field, T value, Expression<Func<T>> selectorExpression, params Expression<Func<object>>[] additonal)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return;
        field = value;
        OnPropertyChanged(selectorExpression);
        foreach (var item in additonal)
            OnPropertyChanged(item);
    }
}

Die Verwendung entspricht der Antwort von Thomas, außer dass Sie zusätzliche Eigenschaften übergeben können, für die Sie benachrichtigen möchten. Dies war erforderlich, um berechnete Spalten zu verarbeiten, die in einem Raster aktualisiert werden müssen.

private int _quantity;
private int _price;

public int Quantity 
{ 
    get { return _quantity; } 
    set { SetField(ref _quantity, value, () => Quantity, () => Total); } 
}
public int Price 
{ 
    get { return _price; } 
    set { SetField(ref _price, value, () => Price, () => Total); } 
}
public int Total { get { return _price * _quantity; } }

Ich habe dies eine Sammlung von Elementen steuern, die in einer BindingList gespeichert sind, die über eine DataGridView verfügbar gemacht wird. Ich muss keine manuellen Refresh () -Aufrufe mehr an das Grid senden.

Lassen Sie mich meinen eigenen Ansatz namens Yappi vorstellen . Es gehört zu den vom Runtime-Proxy abgeleiteten Klassengeneratoren und fügt einem vorhandenen Objekt oder Typ wie dem dynamischen Proxy von Caste Project neue Funktionen hinzu.

Es ermöglicht die einmalige Implementierung von INotifyPropertyChanged in der Basisklasse und die Deklaration abgeleiteter Klassen im folgenden Stil, wobei INotifyPropertyChanged weiterhin für neue Eigenschaften unterstützt wird:

public class Animal:Concept
{
    protected Animal(){}
    public virtual string Name { get; set; }
    public virtual int Age { get; set; }
}

Die Komplexität der abgeleiteten Klassen- oder Proxy-Konstruktion kann hinter der folgenden Zeile verborgen werden:

var animal = Concept.Create<Animal>.New();

Alle Implementierungsarbeiten von INotifyPropertyChanged können folgendermaßen ausgeführt werden:

public class Concept:INotifyPropertyChanged
{
    //Hide constructor
    protected Concept(){}

    public static class Create<TConcept> where TConcept:Concept
    {
        //Construct derived Type calling PropertyProxy.ConstructType
        public static readonly Type Type = PropertyProxy.ConstructType<TConcept, Implementation<TConcept>>(new Type[0], true);
        //Create constructing delegate calling Constructor.Compile
        public static Func<TConcept> New = Constructor.Compile<Func<TConcept>>(Type);
    }


    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(PropertyChangedEventArgs eventArgs)
    {
        var caller = PropertyChanged;
        if(caller!=null)
        {
            caller(this, eventArgs);
        }
    }

    //define implementation
    public class Implementation<TConcept> : DefaultImplementation<TConcept> where TConcept:Concept
    {
        public override Func<TBaseType, TResult> OverrideGetter<TBaseType, TDeclaringType, TConstructedType, TResult>(PropertyInfo property)
        {
            return PropertyImplementation<TBaseType, TDeclaringType>.GetGetter<TResult>(property.Name);
        }
        /// <summary>
        /// Overriding property setter implementation.
        /// </summary>
        /// <typeparam name="TBaseType">Base type for implementation. TBaseType must be TConcept, and inherits all its constraints. Also TBaseType is TDeclaringType.</typeparam>
        /// <typeparam name="TDeclaringType">Type, declaring property.</typeparam>
        /// <typeparam name="TConstructedType">Constructed type. TConstructedType is TDeclaringType and TBaseType.</typeparam>
        /// <typeparam name="TResult">Type of property.</typeparam>
        /// <param name="property">PropertyInfo of property.</param>
        /// <returns>Delegate, corresponding to property setter implementation.</returns>
        public override Action<TBaseType, TResult> OverrideSetter<TBaseType, TDeclaringType, TConstructedType, TResult>(PropertyInfo property)
        {
            //This code called once for each declared property on derived type's initialization.
            //EventArgs instance is shared between all events for each concrete property.
            var eventArgs = new PropertyChangedEventArgs(property.Name);
            //get delegates for base calls.
            Action<TBaseType, TResult> setter = PropertyImplementation<TBaseType, TDeclaringType>.GetSetter<TResult>(property.Name);
            Func<TBaseType, TResult> getter = PropertyImplementation<TBaseType, TDeclaringType>.GetGetter<TResult>(property.Name);

            var comparer = EqualityComparer<TResult>.Default;

            return (pthis, value) =>
            {//This code executes each time property setter is called.
                if (comparer.Equals(value, getter(pthis))) return;
                //base. call
                setter(pthis, value);
                //Directly accessing Concept's protected method.
                pthis.OnPropertyChanged(eventArgs);
            };
        }
    }
}

Es ist völlig sicher für das Refactoring, verwendet keine Reflexion nach der Typkonstruktion und ist schnell genug.

Alle diese Antworten sind sehr nett.

Meine Lösung besteht darin, die Codefragmente zu verwenden, um die Arbeit zu erledigen.

Dies verwendet den einfachsten Aufruf des PropertyChanged-Ereignisses.

Speichern Sie dieses Snippet und verwenden Sie es, während Sie das 'fullprop'-Snippet verwenden.

Der Speicherort befindet sich im Menü "Tools \ Code Snippet Manager ..." in Visual Studio.

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>inotifypropfull</Title>
            <Shortcut>inotifypropfull</Shortcut>
            <HelpUrl>http://ofirzeitoun.wordpress.com/</HelpUrl>
            <Description>Code snippet for property and backing field with notification</Description>
            <Author>Ofir Zeitoun</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>The variable backing this property</ToolTip>
                    <Default>myVar</Default>
                </Literal>
            </Declarations>
            <Code Language="csharp">
                <![CDATA[private $type$ $field$;

    public $type$ $property$
    {
        get { return $field$;}
        set { 
            $field$ = value;
            var temp = PropertyChanged;
            if (temp != null)
            {
                temp(this, new PropertyChangedEventArgs("$property$"));
            }
        }
    }
    $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

Sie können den Anruf nach Belieben ändern (um die oben genannten Lösungen zu verwenden).

Wenn Sie in .NET 4.5 Dynamik verwenden, müssen Sie sich keine Sorgen machen INotifyPropertyChanged.

dynamic obj = new ExpandoObject();
obj.Name = "John";

Wenn Name an ein Steuerelement gebunden ist, funktioniert es einwandfrei.

Eine andere kombinierte Lösung verwendet StackFrame:

public class BaseViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void Set<T>(ref T field, T value)
    {
        MethodBase method = new StackFrame(1).GetMethod();
        field = value;
        Raise(method.Name.Substring(4));
    }

    protected void Raise(string propertyName)
    {
        var temp = PropertyChanged;
        if (temp != null)
        {
            temp(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Verwendungszweck:

public class TempVM : BaseViewModel
{
    private int _intP;
    public int IntP
    {
        get { return _intP; }
        set { Set<int>(ref _intP, value); }
    }
}

Ich habe in meiner Basisbibliothek eine Erweiterungsmethode zur Wiederverwendung erstellt:

public static class INotifyPropertyChangedExtensions
{
    public static bool SetPropertyAndNotify<T>(this INotifyPropertyChanged sender,
               PropertyChangedEventHandler handler, ref T field, T value, 
               [CallerMemberName] string propertyName = "",
               EqualityComparer<T> equalityComparer = null)
    {
        bool rtn = false;
        var eqComp = equalityComparer ?? EqualityComparer<T>.Default;
        if (!eqComp.Equals(field,value))
        {
            field = value;
            rtn = true;
            if (handler != null)
            {
                var args = new PropertyChangedEventArgs(propertyName);
                handler(sender, args);
            }
        }
        return rtn;
    }
}

Dies funktioniert mit .Net 4.5 aufgrund von CallerMemberNameAttribute . Wenn Sie es mit einer früheren .NET-Version verwenden möchten, müssen Sie die Methodendeklaration von: ...,[CallerMemberName] string propertyName = "", ...in ändern...,string propertyName, ...

Verwendungszweck:

public class Dog : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    string _name;

    public string Name
    {
        get { return _name; }
        set
        {
            this.SetPropertyAndNotify(PropertyChanged, ref _name, value);
        }
    }
}

Ich habe auf diese Weise gelöst (es ist ein bisschen mühsam, aber es ist sicherlich das schnellere in der Laufzeit).

In VB (sorry, aber ich denke, es ist nicht schwer, es in C # zu übersetzen) mache ich diese Ersetzung durch RE:

(?<Attr><(.*ComponentModel\.)Bindable\(True\)>)( |\r\n)*(?<Def>(Public|Private|Friend|Protected) .*Property )(?<Name>[^ ]*) As (?<Type>.*?)[ |\r\n](?![ |\r\n]*Get)

mit:

Private _${Name} As ${Type}\r\n${Attr}\r\n${Def}${Name} As ${Type}\r\nGet\r\nReturn _${Name}\r\nEnd Get\r\nSet (Value As ${Type})\r\nIf _${Name} <> Value Then \r\n_${Name} = Value\r\nRaiseEvent PropertyChanged(Me, New ComponentModel.PropertyChangedEventArgs("${Name}"))\r\nEnd If\r\nEnd Set\r\nEnd Property\r\n

Diese Transofrm alle Code wie folgt:

<Bindable(True)>
Protected Friend Property StartDate As DateTime?

Im

Private _StartDate As DateTime?
<Bindable(True)>
Protected Friend Property StartDate As DateTime?
    Get
        Return _StartDate
    End Get
    Set(Value As DateTime?)
        If _StartDate <> Value Then
            _StartDate = Value
            RaiseEvent PropertyChange(Me, New ComponentModel.PropertyChangedEventArgs("StartDate"))
        End If
    End Set
End Property

Und wenn ich einen besser lesbaren Code haben möchte, kann ich das Gegenteil sein, indem ich nur die folgende Ersetzung vornehme:

Private _(?<Name>.*) As (?<Type>.*)[\r\n ]*(?<Attr><(.*ComponentModel\.)Bindable\(True\)>)[\r\n ]*(?<Def>(Public|Private|Friend|Protected) .*Property )\k<Name> As \k<Type>[\r\n ]*Get[\r\n ]*Return _\k<Name>[\r\n ]*End Get[\r\n ]*Set\(Value As \k<Type>\)[\r\n ]*If _\k<Name> <> Value Then[\r\n ]*_\k<Name> = Value[\r\n ]*RaiseEvent PropertyChanged\(Me, New (.*ComponentModel\.)PropertyChangedEventArgs\("\k<Name>"\)\)[\r\n ]*End If[\r\n ]*End Set[\r\n ]*End Property

Mit

${Attr} ${Def} ${Name} As ${Type}

Ich werfe, um den IL-Code der set-Methode zu ersetzen, aber ich kann nicht viel kompilierten Code in IL schreiben ... Wenn ich ihn eines Tages schreibe, sage ich es Ihnen!

Ich behalte das als Ausschnitt. C # 6 fügt eine nette Syntax zum Aufrufen des Handlers hinzu.

// INotifyPropertyChanged

public event PropertyChangedEventHandler PropertyChanged;

private void Set<T>(ref T property, T value, [CallerMemberName] string propertyName = null)
{
    if (EqualityComparer<T>.Default.Equals(property, value) == false)
    {
        property = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Hier ist eine Unity3D- oder Nicht-CallerMemberName-Version von NotifyPropertyChanged

public abstract class Bindable : MonoBehaviour, INotifyPropertyChanged
{
    private readonly Dictionary<string, object> _properties = new Dictionary<string, object>();
    private static readonly StackTrace stackTrace = new StackTrace();
    public event PropertyChangedEventHandler PropertyChanged;

    /// <summary>
    ///     Resolves a Property's name from a Lambda Expression passed in.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="property"></param>
    /// <returns></returns>
    internal string GetPropertyName<T>(Expression<Func<T>> property)
    {
        var expression = (MemberExpression) property.Body;
        var propertyName = expression.Member.Name;

        Debug.AssertFormat(propertyName != null, "Bindable Property shouldn't be null!");
        return propertyName;
    }

    #region Notification Handlers

    /// <summary>
    ///     Notify's all other objects listening that a value has changed for nominated propertyName
    /// </summary>
    /// <param name="propertyName"></param>
    internal void NotifyOfPropertyChange(string propertyName)
    {
        OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
    }

    /// <summary>
    ///     Notifies subscribers of the property change.
    /// </summary>
    /// <typeparam name="TProperty">The type of the property.</typeparam>
    /// <param name="property">The property expression.</param>
    internal void NotifyOfPropertyChange<TProperty>(Expression<Func<TProperty>> property)
    {
        var propertyName = GetPropertyName(property);
        NotifyOfPropertyChange(propertyName);
    }

    /// <summary>
    ///     Raises the <see cref="PropertyChanged" /> event directly.
    /// </summary>
    /// <param name="e">The <see cref="PropertyChangedEventArgs" /> instance containing the event data.</param>
    internal void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        var handler = PropertyChanged;
        if (handler != null)
        {
            handler(this, e);
        }
    }

    #endregion

    #region Getters

    /// <summary>
    ///     Gets the value of a property
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="name"></param>
    /// <returns></returns>
    internal T Get<T>(Expression<Func<T>> property)
    {
        var propertyName = GetPropertyName(property);
        return Get<T>(GetPropertyName(property));
    }

    /// <summary>
    ///     Gets the value of a property automatically based on its caller.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    internal T Get<T>()
    {
        var name = stackTrace.GetFrame(1).GetMethod().Name.Substring(4); // strips the set_ from name;
        return Get<T>(name);
    }

    /// <summary>
    ///     Gets the name of a property based on a string.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="name"></param>
    /// <returns></returns>
    internal T Get<T>(string name)
    {
        object value = null;
        if (_properties.TryGetValue(name, out value))
            return value == null ? default(T) : (T) value;
        return default(T);
    }

    #endregion

    #region Setters

    /// <summary>
    ///     Sets the value of a property whilst automatically looking up its caller name.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    internal void Set<T>(T value)
    {
        var propertyName = stackTrace.GetFrame(1).GetMethod().Name.Substring(4); // strips the set_ from name;
        Set(value, propertyName);
    }

    /// <summary>
    ///     Sets the value of a property
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <param name="name"></param>
    internal void Set<T>(T value, string propertyName)
    {
        Debug.Assert(propertyName != null, "name != null");
        if (Equals(value, Get<T>(propertyName)))
            return;
        _properties[propertyName] = value;
        NotifyOfPropertyChange(propertyName);
    }

    /// <summary>
    ///     Sets the value of a property based off an Expression (()=>FieldName)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <param name="property"></param>
    internal void Set<T>(T value, Expression<Func<T>> property)
    {
        var propertyName = GetPropertyName(property);

        Debug.Assert(propertyName != null, "name != null");

        if (Equals(value, Get<T>(propertyName)))
            return;
        _properties[propertyName] = value;
        NotifyOfPropertyChange(propertyName);
    }

    #endregion
}

Mit diesem Code können Sie Eigenschaftsunterstützungsfelder wie folgt schreiben:

  public string Text
    {
        get { return Get<string>(); }
        set { Set(value); }
    }

Wenn Sie in Resharper ein Muster- / Such-Snippet erstellen, können Sie Ihren Workflow auch automatisieren, indem Sie einfache Requisitenfelder in den obigen Hintergrund konvertieren.

Suchmuster:

public $type$ $fname$ { get; set; }

Muster ersetzen:

public $type$ $fname$
{
    get { return Get<$type$>(); }
    set { Set(value); }
}

Ich habe einen Artikel geschrieben, der dabei hilft ( https://msdn.microsoft.com/magazine/mt736453) ). Sie können das SolSoft.DataBinding NuGet-Paket verwenden. Dann können Sie Code wie folgt schreiben:

public class TestViewModel : IRaisePropertyChanged
{
  public TestViewModel()
  {
    this.m_nameProperty = new NotifyProperty<string>(this, nameof(Name), null);
  }

  private readonly NotifyProperty<string> m_nameProperty;
  public string Name
  {
    get
    {
      return m_nameProperty.Value;
    }
    set
    {
      m_nameProperty.SetValue(value);
    }
  }

  // Plus implement IRaisePropertyChanged (or extend BaseViewModel)
}

Leistungen:

1. Basisklasse ist optional
2. keine Reflexion über jeden 'eingestellten Wert'
3. kann Eigenschaften haben, die von anderen Eigenschaften abhängen, und alle lösen automatisch die entsprechenden Ereignisse aus (Artikel enthält ein Beispiel dafür)

Obwohl es offensichtlich viele Möglichkeiten gibt, dies zu tun, mit Ausnahme der magischen AOP-Antworten, scheint keine der Antworten das Festlegen der Eigenschaft eines Modells direkt aus dem Ansichtsmodell zu betrachten, ohne dass ein lokales Feld zum Verweisen vorhanden ist.

Das Problem ist, dass Sie nicht auf eine Eigenschaft verweisen können. Sie können diese Eigenschaft jedoch mit einer Aktion festlegen.

protected bool TrySetProperty<T>(Action<T> property, T newValue, T oldValue, [CallerMemberName] string propertyName = null)
{
    if (EqualityComparer<T>.Default.Equals(oldValue, newValue))
    {
        return false;
    }

    property(newValue);
    RaisePropertyChanged(propertyName);
    return true;
}

Dies kann wie der folgende Code-Extrakt verwendet werden.

public int Prop {
    get => model.Prop;
    set => TrySetProperty(x => model.Prop = x, value, model.Prop);
}

In diesem BitBucket-Repo finden Sie eine vollständige Implementierung der Methode und einige verschiedene Möglichkeiten, um dasselbe Ergebnis zu erzielen, einschließlich einer Methode, die LINQ verwendet, und einer Methode, die Reflektion verwendet. Beachten Sie, dass diese Methoden in Bezug auf die Leistung langsamer sind.

Andere Dinge, die Sie bei der Implementierung dieser Art von Eigenschaften berücksichtigen sollten, sind die Tatsache, dass INotifyPropertyChang * ed * beide Ereignisargumentklassen verwenden.

Wenn Sie eine große Anzahl von Eigenschaften haben, die festgelegt werden, kann die Anzahl der Instanzen von Ereignisargumentklassen sehr groß sein. Sie sollten in Betracht ziehen, sie zwischenzuspeichern, da sie einer der Bereiche sind, in denen eine Zeichenfolgenexplosion auftreten kann.

Schauen Sie sich diese Implementierung an und erklären Sie, warum sie konzipiert wurde.

Josh Smiths Blog

Ich habe gerade ActiveSharp - Automatic INotifyPropertyChanged gefunden . Ich habe es noch nicht verwendet, aber es sieht gut aus.

Um von seiner Website zu zitieren ...

Senden Sie Benachrichtigungen über Eigenschaftsänderungen, ohne den Eigenschaftsnamen als Zeichenfolge anzugeben.

Schreiben Sie stattdessen folgende Eigenschaften:

public int Foo
{
    get { return _foo; }
    set { SetValue(ref _foo, value); }  // <-- no property name here
}

Beachten Sie, dass der Name der Eigenschaft nicht als Zeichenfolge angegeben werden muss. ActiveSharp findet das zuverlässig und korrekt heraus. Es funktioniert basierend auf der Tatsache, dass Ihre Eigenschaftsimplementierung das Hintergrundfeld (_foo) durch ref übergibt. (ActiveSharp verwendet diesen Aufruf "by ref", um zu identifizieren, welches Sicherungsfeld übergeben wurde, und anhand des Felds die Eigenschaft zu identifizieren.)

Eine Idee mit Reflexion:

class ViewModelBase : INotifyPropertyChanged {

    public event PropertyChangedEventHandler PropertyChanged;

    bool Notify<T>(MethodBase mb, ref T oldValue, T newValue) {

        // Get Name of Property
        string name = mb.Name.Substring(4);

        // Detect Change
        bool changed = EqualityComparer<T>.Default.Equals(oldValue, newValue);

        // Return if no change
        if (!changed) return false;

        // Update value
        oldValue = newValue;

        // Raise Event
        if (PropertyChanged != null) {
            PropertyChanged(this, new PropertyChangedEventArgs(name));
        }//if

        // Notify caller of change
        return true;

    }//method

    string name;

    public string Name {
        get { return name; }
        set {
            Notify(MethodInfo.GetCurrentMethod(), ref this.name, value);
        }
    }//method

}//class

Mir ist klar, dass diese Frage bereits unzählige Antworten hat, aber keine davon fühlte sich für mich richtig an. Mein Problem ist, dass ich keine Performance-Hits will und bereit bin, allein aus diesem Grund ein wenig Ausführlichkeit zu ertragen. Ich interessiere mich auch nicht allzu sehr für Auto-Eigenschaften, was mich zu der folgenden Lösung führte:

public abstract class AbstractObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected virtual bool SetValue<TKind>(ref TKind Source, TKind NewValue, params string[] Notify)
    {
        //Set value if the new value is different from the old
        if (!Source.Equals(NewValue))
        {
            Source = NewValue;

            //Notify all applicable properties
            foreach (var i in Notify)
                OnPropertyChanged(i);

            return true;
        }

        return false;
    }

    public AbstractObject()
    {
    }
}

Mit anderen Worten, die obige Lösung ist praktisch, wenn Sie nichts dagegen haben:

public class SomeObject : AbstractObject
{
    public string AnotherProperty
    {
        get
        {
            return someProperty ? "Car" : "Plane";
        }
    }

    bool someProperty = false;
    public bool SomeProperty
    {
        get
        {
            return someProperty;
        }
        set
        {
            SetValue(ref someProperty, value, "SomeProperty", "AnotherProperty");
        }
    }

    public SomeObject() : base()
    {
    }
}

Vorteile

• Keine Reflexion
• Benachrichtigt nur, wenn alter Wert! = Neuer Wert
• Benachrichtigen Sie mehrere Eigenschaften gleichzeitig

Nachteile

• Keine automatischen Eigenschaften (Sie können jedoch Unterstützung für beide hinzufügen!)
• Etwas Ausführlichkeit
• Boxen (kleiner Leistungstreffer?)

Leider ist es immer noch besser als dies zu tun,

set
{
    if (!someProperty.Equals(value))
    {
        someProperty = value;
        OnPropertyChanged("SomeProperty");
        OnPropertyChanged("AnotherProperty");
    }
}

Für jede einzelne Eigenschaft, die mit der zusätzlichen Ausführlichkeit zum Albtraum wird ;-(

Hinweis: Ich behaupte nicht, dass diese Lösung im Vergleich zu den anderen leistungsmäßig besser ist, nur dass sie eine praktikable Lösung für diejenigen ist, die die anderen vorgestellten Lösungen nicht mögen.

Ich habe mir diese Basisklasse ausgedacht, um das beobachtbare Muster zu implementieren. Sie macht so ziemlich das, was Sie brauchen ( "automatisch" das Set implementieren und abrufen). Ich habe eine Stunde als Prototyp damit verbracht, daher gibt es nicht viele Unit-Tests, aber es beweist das Konzept. Beachten Sie, dass das verwendet wird Dictionary<string, ObservablePropertyContext>, um die Notwendigkeit für private Felder zu beseitigen.

  public class ObservableByTracking<T> : IObservable<T>
  {
    private readonly Dictionary<string, ObservablePropertyContext> _expando;
    private bool _isDirty;

    public ObservableByTracking()
    {
      _expando = new Dictionary<string, ObservablePropertyContext>();

      var properties = this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).ToList();
      foreach (var property in properties)
      {
        var valueContext = new ObservablePropertyContext(property.Name, property.PropertyType)
        {
          Value = GetDefault(property.PropertyType)
        };

        _expando[BuildKey(valueContext)] = valueContext;
      }
    }

    protected void SetValue<T>(Expression<Func<T>> expression, T value)
    {
      var keyContext = GetKeyContext(expression);
      var key = BuildKey(keyContext.PropertyName, keyContext.PropertyType);

      if (!_expando.ContainsKey(key))
      {
        throw new Exception($"Object doesn't contain {keyContext.PropertyName} property.");
      }

      var originalValue = (T)_expando[key].Value;
      if (EqualityComparer<T>.Default.Equals(originalValue, value))
      {
        return;
      }

      _expando[key].Value = value;
      _isDirty = true;
    }

    protected T GetValue<T>(Expression<Func<T>> expression)
    {
      var keyContext = GetKeyContext(expression);
      var key = BuildKey(keyContext.PropertyName, keyContext.PropertyType);

      if (!_expando.ContainsKey(key))
      {
        throw new Exception($"Object doesn't contain {keyContext.PropertyName} property.");
      }

      var value = _expando[key].Value;
      return (T)value;
    }

    private KeyContext GetKeyContext<T>(Expression<Func<T>> expression)
    {
      var castedExpression = expression.Body as MemberExpression;
      if (castedExpression == null)
      {
        throw new Exception($"Invalid expression.");
      }

      var parameterName = castedExpression.Member.Name;

      var propertyInfo = castedExpression.Member as PropertyInfo;
      if (propertyInfo == null)
      {
        throw new Exception($"Invalid expression.");
      }

      return new KeyContext {PropertyType = propertyInfo.PropertyType, PropertyName = parameterName};
    }

    private static string BuildKey(ObservablePropertyContext observablePropertyContext)
    {
      return $"{observablePropertyContext.Type.Name}.{observablePropertyContext.Name}";
    }

    private static string BuildKey(string parameterName, Type type)
    {
      return $"{type.Name}.{parameterName}";
    }

    private static object GetDefault(Type type)
    {
      if (type.IsValueType)
      {
        return Activator.CreateInstance(type);
      }
      return null;
    }

    public bool IsDirty()
    {
      return _isDirty;
    }

    public void SetPristine()
    {
      _isDirty = false;
    }

    private class KeyContext
    {
      public string PropertyName { get; set; }
      public Type PropertyType { get; set; }
    }
  }

  public interface IObservable<T>
  {
    bool IsDirty();
    void SetPristine();
  }

Hier ist die Verwendung

public class ObservableByTrackingTestClass : ObservableByTracking<ObservableByTrackingTestClass>
  {
    public ObservableByTrackingTestClass()
    {
      StringList = new List<string>();
      StringIList = new List<string>();
      NestedCollection = new List<ObservableByTrackingTestClass>();
    }

    public IEnumerable<string> StringList
    {
      get { return GetValue(() => StringList); }
      set { SetValue(() => StringIList, value); }
    }

    public IList<string> StringIList
    {
      get { return GetValue(() => StringIList); }
      set { SetValue(() => StringIList, value); }
    }

    public int IntProperty
    {
      get { return GetValue(() => IntProperty); }
      set { SetValue(() => IntProperty, value); }
    }

    public ObservableByTrackingTestClass NestedChild
    {
      get { return GetValue(() => NestedChild); }
      set { SetValue(() => NestedChild, value); }
    }

    public IList<ObservableByTrackingTestClass> NestedCollection
    {
      get { return GetValue(() => NestedCollection); }
      set { SetValue(() => NestedCollection, value); }
    }

    public string StringProperty
    {
      get { return GetValue(() => StringProperty); }
      set { SetValue(() => StringProperty, value); }
    }
  }

Ich schlage vor, ReactiveProperty zu verwenden. Dies ist die kürzeste Methode außer Fody.

public class Data : INotifyPropertyChanged
{
    // boiler-plate
    ...
    // props
    private string name;
    public string Name
    {
        get { return name; }
        set { SetField(ref name, value, "Name"); }
    }
}

stattdessen

public class Data
{
    // Don't need boiler-plate and INotifyPropertyChanged

    // props
    public ReactiveProperty<string> Name { get; } = new ReactiveProperty<string>();
}

( DOCS )

Eine andere Idee...

 public class ViewModelBase : INotifyPropertyChanged
{
    private Dictionary<string, object> _propertyStore = new Dictionary<string, object>();
    protected virtual void SetValue<T>(T value, [CallerMemberName] string propertyName="") {
        _propertyStore[propertyName] = value;
        OnPropertyChanged(propertyName);
    }
    protected virtual T GetValue<T>([CallerMemberName] string propertyName = "")
    {
        object ret;
        if (_propertyStore.TryGetValue(propertyName, out ret))
        {
            return (T)ret;
        }
        else
        {
            return default(T);
        }
    }

    //Usage
    //public string SomeProperty {
    //    get { return GetValue<string>();  }
    //    set { SetValue(value); }
    //}

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        var temp = PropertyChanged;
        if (temp != null)
            temp.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

=> hier meine Lösung mit folgenden Funktionen

 public ResourceStatus Status
 {
     get { return _status; }
     set
     {
         _status = value;
         Notify(Npcea.Status,Npcea.Comments);
     }
 }

1. keine Reflexion
2. kurze Notation
3. Keine magische Zeichenfolge in Ihrem Geschäftscode
4. Wiederverwendbarkeit von PropertyChangedEventArgs für alle Anwendungen
5. Möglichkeit, mehrere Eigenschaften in einer Anweisung zu benachrichtigen

Benutze das

using System;
using System.ComponentModel;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;


public static class ObservableFactory
{
    public static T Create<T>(T target)
    {
        if (!typeof(T).IsInterface)
            throw new ArgumentException("Target should be an interface", "target");

        var proxy = new Observable<T>(target);
        return (T)proxy.GetTransparentProxy();
    }
}

internal class Observable<T> : RealProxy, INotifyPropertyChanged, INotifyPropertyChanging
{
    private readonly T target;

    internal Observable(T target)
        : base(ImplementINotify(typeof(T)))
    {
        this.target = target;
    }

    public override IMessage Invoke(IMessage msg)
    {
        var methodCall = msg as IMethodCallMessage;

        if (methodCall != null)
        {
            return HandleMethodCall(methodCall);
        }

        return null;
    }

    public event PropertyChangingEventHandler PropertyChanging;
    public event PropertyChangedEventHandler PropertyChanged;



    IMessage HandleMethodCall(IMethodCallMessage methodCall)
    {
        var isPropertySetterCall = methodCall.MethodName.StartsWith("set_");
        var propertyName = isPropertySetterCall ? methodCall.MethodName.Substring(4) : null;

        if (isPropertySetterCall)
        {
            OnPropertyChanging(propertyName);
        }

        try
        {
            object methodCalltarget = target;

            if (methodCall.MethodName == "add_PropertyChanged" || methodCall.MethodName == "remove_PropertyChanged"||
                methodCall.MethodName == "add_PropertyChanging" || methodCall.MethodName == "remove_PropertyChanging")
            {
                methodCalltarget = this;
            }

            var result = methodCall.MethodBase.Invoke(methodCalltarget, methodCall.InArgs);

            if (isPropertySetterCall)
            {
                OnPropertyChanged(methodCall.MethodName.Substring(4));
            }

            return new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall);
        }
        catch (TargetInvocationException invocationException)
        {
            var exception = invocationException.InnerException;
            return new ReturnMessage(exception, methodCall);
        }
    }

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

    protected virtual void OnPropertyChanging(string propertyName)
    {
        var handler = PropertyChanging;
        if (handler != null) handler(this, new PropertyChangingEventArgs(propertyName));
    }

    public static Type ImplementINotify(Type objectType)
    {
        var tempAssemblyName = new AssemblyName(Guid.NewGuid().ToString());

        var dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
            tempAssemblyName, AssemblyBuilderAccess.RunAndCollect);

        var moduleBuilder = dynamicAssembly.DefineDynamicModule(
            tempAssemblyName.Name,
            tempAssemblyName + ".dll");

        var typeBuilder = moduleBuilder.DefineType(
            objectType.FullName, TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);

        typeBuilder.AddInterfaceImplementation(objectType);
        typeBuilder.AddInterfaceImplementation(typeof(INotifyPropertyChanged));
        typeBuilder.AddInterfaceImplementation(typeof(INotifyPropertyChanging));
        var newType = typeBuilder.CreateType();
        return newType;
    }
}