blocks|key|951228|text|实际上，我还没有机会亲自尝试这一点，但下次我要设置一个对INotifyPropertyChanged有很大要求的项目时，我打算编写一个后夏普属性，它将在编译时注入代码。类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|951229|[NotifiesChange]
public+string+FirstName+{+get;+set;+}|code-block|syntax|javascript|951230|将成为：|951231|private+string+_firstName;

public+string+FirstName
{
+++get+{+return+_firstname;+}
+++set
+++{
++++++if+(_firstname+!=+value)
++++++{
++++++++++_firstname+=+value;
++++++++++OnPropertyChanged("FirstName")
++++++}
+++}
}|951232|我不确定这是否会在实践中奏效，我需要坐下来试一试，但我看不出为什么不行。对于需要触发多个OnPropertyChanged的情况，我可能需要让它接受一些参数(例如，如果我在上面的类中有一个FullName属性)|951233|目前，我在Resharper中使用自定义模板，但即便如此，我也厌倦了所有的属性都太长了。|951234|啊，一个快速的谷歌搜索(在我写这篇文章之前我应该这么做)显示，至少有一个人在这里之前做过这样的事情。不完全是我的想法，但足够接近，以表明理论是好的。|951235|entityMap|0|LINK|mutability|MUTABLE|url|http://www.postsharp.org/|1|http://code.google.com/p/propfu/^0|1V|3|0|0|0|0|0|0|0|12|2|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

I haven't actually had a chance to try this myself yet, but next time I'm setting up a project with a big requirement for INotifyPropertyChanged I'm intending on writing a <a href="http://www.postsharp.org/" rel="noreferrer">Postsharp</a> attribute that will inject the code at compile time. Something like:

<pre><code>[NotifiesChange]
public string FirstName { get; set; }
</code></pre>

Will become:

<pre><code>private string _firstName;

public string FirstName
{
 get { return _firstname; }
 set
 {
 if (_firstname != value)
 {
 _firstname = value;
 OnPropertyChanged("FirstName")
 }
 }
}
</code></pre>

I'm not sure if this will work in practice and I need to sit down and try it out, but I don't see why not. I may need to make it accept some parameters for situations where more than one OnPropertyChanged needs to be triggered (if, for example, I had a FullName property in the class above)

Currently I'm using a custom template in Resharper, but even with that I'm getting fed up of all my properties being so long.

<hr>

Ah, a quick Google search (which I should have done before I wrote this) shows that at least one person has done something like this before <a href="http://code.google.com/p/propfu/" rel="noreferrer">here</a>. Not exactly what I had in mind, but close enough to show that the theory is good.

blocks|key|951305|text|我使用的最小版本没有使用postsharp之类的内容，而是使用了如下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951306|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");+}
++++}
}|code-block|syntax|javascript|951307|然后，每个属性都类似于：|951308|private+string+name;
public+string+Name
{
++++get+{+return+name;+}
++++set+{+SetField(ref+name,+value,+"Name");+}
}|951309|这并不大；如果您愿意，它也可以作为基类使用。如果您想应用其他逻辑，从bool返回的SetField会告诉您它是否为非操作。|offset|length|style|CODE|951310|或者更容易使用C#+5：|951311|protected+bool+SetField<T>(ref+T+field,+T+value,
++++[CallerMemberName]+string+propertyName+=+null)
{...}|951312|可以这样称呼：|951313|set+{+SetField(ref+name,+value);+}|951314|编译器将自动添加"Name"。|951315|C#+6.0使实现更容易：|951316|protected+void+OnPropertyChanged([CallerMemberName]+string+propertyName+=+null)
{
++++PropertyChanged?.Invoke(this,+new+PropertyChangedEventArgs(propertyName));
}|951317|...and现在使用C#7：|951318|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);
}|951319|而且，对于C#+8和Nullable引用类型，它应该如下所示：|951320|public+event+PropertyChangedEventHandler?+PropertyChanged;

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

protected+bool+SetField<T>(ref+T+field,+T+value,+[CallerMemberName]+string+propertyName+=+"")
{
++++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);
}|951321|entityMap^0|0|0|0|0|Y|4|15|8|0|0|0|0|0|8|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1I|8|@$M|1J|N|1K|O|P]|$M|1L|N|1M|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1N|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1P|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1R|8|@$M|1S|N|1T|O|P]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1U|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1W|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|1C|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|1D|$]]

Without using something like postsharp, the minimal version I use uses something like:
<pre><code>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&lt;T&gt;(ref T field, T value, string propertyName)
 {
 if (EqualityComparer&lt;T&gt;.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, &quot;Name&quot;); }
 }
}
</code></pre>
Each property is then just something like:
<pre><code>private string name;
public string Name
{
 get { return name; }
 set { SetField(ref name, value, &quot;Name&quot;); }
}
</code></pre>
which isn't huge; it can also be used as a base-class if you want. The <code>bool</code> return from <code>SetField</code> tells you if it was a no-op, in case you want to apply other logic.
<hr />
or even easier with C# 5:
<pre><code>protected bool SetField&lt;T&gt;(ref T field, T value,
 [CallerMemberName] string propertyName = null)
{...}
</code></pre>
which can be called like this:
<pre><code>set { SetField(ref name, value); }
</code></pre>
with which the compiler will add the <code>&quot;Name&quot;</code> automatically.
<hr />
C# 6.0 makes the implementation easier:
<pre><code>protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
</code></pre>
<hr />
...and now with C#7:
<pre><code>protected void OnPropertyChanged(string propertyName)
 =&gt; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

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

private string name;
public string Name
{
 get =&gt; name;
 set =&gt; SetField(ref name, value);
}
</code></pre>
<hr />
And, with C# 8 and Nullable reference types, it would look like this:
<pre><code>public event PropertyChangedEventHandler? PropertyChanged;

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

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

private string name;
public string Name
{
 get =&gt; name;
 set =&gt; SetField(ref name, value);
}
</code></pre>

blocks|key|1007171|text|谈论大规模的过度工程。这比只是用正确的方法要复杂得多，几乎没有什么好处。如果您的IDE支持代码段+(Visual+/MonoDevelop)，那么您可以使实现这一操作变得非常简单。实际上，您只需键入属性的类型和属性名称。额外的三行代码将自动生成。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1007172|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.componentmodel.inotifypropertychanged.aspx|1|http://msdn.microsoft.com/en-us/library/ms165392(VS.80).aspx^0|D|8|0|19|3|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Talk about massive overengineering. This is significantly more complex than <a href="http://msdn.microsoft.com/en-us/library/system.componentmodel.inotifypropertychanged.aspx" rel="nofollow noreferrer">just doing it the right way</a> and gives little to no benefit. If your IDE supports <a href="http://msdn.microsoft.com/en-us/library/ms165392(VS.80).aspx" rel="nofollow noreferrer">code snippets</a> (Visual Studio/MonoDevelop do) then you can make implementing this ridiculously simple. All you'd actually have to type is the type of the property and the property name. The extra three lines of code will be autogenerated.

blocks|key|1007199|text|在实现这类属性时，您可能需要考虑的其他事情是，INotifyPropertyChang+*ed+*ing都使用事件参数类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1007200|如果您有大量正在设置的属性，那么事件参数类实例的数量可能很大，您应该考虑缓存它们，因为它们是可能发生字符串爆炸的区域之一。|1007201|看一看这个实现，并解释一下为什么会想到它。|1007202|乔希·史密斯博客|offset|length|1007203|entityMap|0|LINK|mutability|MUTABLE|url|http://joshsmithonwpf.wordpress.com/2009/07/11/one-way-to-avoid-messy-propertychanged-event-handling/^0|0|0|0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Other things you may want to consider when implementing these sorts of properties is the fact that the INotifyPropertyChang *ed *ing both use event argument classes.

If you have a large number of properties that are being set then the number of event argument class instances can be huge, you should consider caching them as they are one of the areas that a string explosion can occur.

Take a look at this implementation and explanation of why it was conceived.

<a href="http://joshsmithonwpf.wordpress.com/2009/07/11/one-way-to-avoid-messy-propertychanged-event-handling/" rel="nofollow noreferrer">Josh Smiths Blog</a>

blocks|key|1006537|text|我刚刚找到了ActiveSharp+-自动INotifyPropertyChanged，我还没有使用它，但是它看起来很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1006538|引用它的网站..。|1006539|发送属性更改通知，而不将属性名称指定为字符串。|blockquote|1006540|相反，编写这样的属性：|1006541|public+int+Foo
{
++++get+{+return+_foo;+}
++++set+{+SetValue(ref+_foo,+value);+}++//+<--+no+property+name+here
}|code-block|syntax|javascript|1006542|请注意，不需要将属性的名称作为字符串包括在内。ActiveSharp可靠而正确地为自己指出了这一点。它的工作是基于这样一个事实，即属性实现通过ref传递支持字段(_foo)。(ActiveSharp使用"by+ref“调用来标识传递了哪个支持字段，并从字段中标识该属性)。|1006543|entityMap|0|LINK|mutability|MUTABLE|url|http://activesharp.codeplex.com/^0|6|11|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|16|8|@]|9|@]|C|$N|O]]|$1|P|3|Q|5|6|7|17|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

I have just found <a href="http://activesharp.codeplex.com/" rel="nofollow">ActiveSharp - Automatic INotifyPropertyChanged</a>, I have yet to use it, but it looks good.

To quote from it's web site...

<hr>

<blockquote>
 Send property change notifications
 without specifying property name as a
 string.
</blockquote>

Instead, write properties like this:

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

Note that there is no need to include the name of the property as a string. ActiveSharp reliably and correctly figures that out for itself. It works based on the fact that your property implementation passes the backing field (_foo) by ref. (ActiveSharp uses that "by ref" call to identify which backing field was passed, and from the field it identifies the property).

blocks|key|1006581|text|让我介绍一下我自己的方法，称为亚皮。它属于Runtime派生的类生成器，向现有对象或类型添加新功能，比如种姓项目的动态代理。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1006582|它允许在基类中实现一次INotifyPropertyChanged，然后以下面的样式声明派生类，仍然支持新属性的INotifyPropertyChanged：|1006583|public+class+Animal:Concept
{
++++protected+Animal(){}
++++public+virtual+string+Name+{+get;+set;+}
++++public+virtual+int+Age+{+get;+set;+}
}|code-block|syntax|javascript|1006584|派生类或代理构造的复杂性可以隐藏在以下行后面：|1006585|var+animal+=+Concept.Create<Animal>.New();|1006586|所有的INotifyPropertyChanged实现工作都可以这样完成：|1006587|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);
++++++++++++};
++++++++}
++++}
}|1006588|它是完全安全的重构，没有使用后，类型构造和足够快的反射。|1006589|entityMap|0|LINK|mutability|MUTABLE|url|https://archive.codeplex.com/?p=yappi^0|F|2|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1B|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

Let me introduce my own approach called <a href="https://archive.codeplex.com/?p=yappi" rel="nofollow noreferrer">Yappi</a>.
It belongs to Runtime proxy|derived class generators, adding new functionality to an existing object or type, like Caste Project's Dynamic Proxy.

It allows to implement INotifyPropertyChanged once in base class, and then declare derived classes in following style, still supporting INotifyPropertyChanged for new properties:

<pre><code>public class Animal:Concept
{
 protected Animal(){}
 public virtual string Name { get; set; }
 public virtual int Age { get; set; }
}
</code></pre>

Complexity of derived class or proxy construction can be hidden behind the following line:

<pre><code>var animal = Concept.Create&lt;Animal&gt;.New();
</code></pre>

And all INotifyPropertyChanged implementation work can be done like this:

<pre><code>public class Concept:INotifyPropertyChanged
{
 //Hide constructor
 protected Concept(){}

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


 public event PropertyChangedEventHandler PropertyChanged;

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

 //define implementation
 public class Implementation&lt;TConcept&gt; : DefaultImplementation&lt;TConcept&gt; where TConcept:Concept
 {
 public override Func&lt;TBaseType, TResult&gt; OverrideGetter&lt;TBaseType, TDeclaringType, TConstructedType, TResult&gt;(PropertyInfo property)
 {
 return PropertyImplementation&lt;TBaseType, TDeclaringType&gt;.GetGetter&lt;TResult&gt;(property.Name);
 }
 /// &lt;summary&gt;
 /// Overriding property setter implementation.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="TBaseType"&gt;Base type for implementation. TBaseType must be TConcept, and inherits all its constraints. Also TBaseType is TDeclaringType.&lt;/typeparam&gt;
 /// &lt;typeparam name="TDeclaringType"&gt;Type, declaring property.&lt;/typeparam&gt;
 /// &lt;typeparam name="TConstructedType"&gt;Constructed type. TConstructedType is TDeclaringType and TBaseType.&lt;/typeparam&gt;
 /// &lt;typeparam name="TResult"&gt;Type of property.&lt;/typeparam&gt;
 /// &lt;param name="property"&gt;PropertyInfo of property.&lt;/param&gt;
 /// &lt;returns&gt;Delegate, corresponding to property setter implementation.&lt;/returns&gt;
 public override Action&lt;TBaseType, TResult&gt; OverrideSetter&lt;TBaseType, TDeclaringType, TConstructedType, TResult&gt;(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&lt;TBaseType, TResult&gt; setter = PropertyImplementation&lt;TBaseType, TDeclaringType&gt;.GetSetter&lt;TResult&gt;(property.Name);
 Func&lt;TBaseType, TResult&gt; getter = PropertyImplementation&lt;TBaseType, TDeclaringType&gt;.GetGetter&lt;TResult&gt;(property.Name);

 var comparer = EqualityComparer&lt;TResult&gt;.Default;

 return (pthis, value) =&gt;
 {//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);
 };
 }
 }
}
</code></pre>

It is fully safe for refactoring, uses no reflection after type construction and fast enough.

blocks|key|2477429|text|从.Net+4.5开始，终于有了一种简单的方法来做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477430|.Net+4.5引入了一个新的呼叫者信息属性。|2477431|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));
+++++}
}|code-block|syntax|javascript|2477432|在函数中添加一个比较器可能是个好主意。|2477433|EqualityComparer<T>.Default.Equals|2477434|更多示例这里和这里|offset|length|2477435|还请参见呼叫者信息(C#和Visual+)|2477436|entityMap|0|LINK|mutability|MUTABLE|url|https://www.wintellect.com/using-the-new-caller-information-attributes-for-reliable-property-change-notifications/|1|https://www.danrigby.com/2012/04/01/inotifypropertychanged-the-net-4-5-way-revisited/|2|https://msdn.microsoft.com/en-in/library/hh534540.aspx^0|0|0|0|0|0|4|2|0|7|2|1|0|4|H|2|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@$O|1A|P|1B|1|1C]|$O|1D|P|1E|1|1F]]|A|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@$O|1H|P|1I|1|1J]]|A|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]]]

<h2>As of .Net 4.5 there is finally an easy way to do this.</h2>

.Net 4.5 introduces a new Caller Information Attributes.

<pre><code>private void OnPropertyChanged&lt;T&gt;([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));
 }
}
</code></pre>

It's probably a good idea to add a comparer to the function as well.

<pre><code>EqualityComparer&lt;T&gt;.Default.Equals
</code></pre>

More examples <a href="https://www.wintellect.com/using-the-new-caller-information-attributes-for-reliable-property-change-notifications/" rel="noreferrer">here</a> and <a href="https://www.danrigby.com/2012/04/01/inotifypropertychanged-the-net-4-5-way-revisited/" rel="noreferrer">here</a>

Also see <a href="https://msdn.microsoft.com/en-in/library/hh534540.aspx" rel="noreferrer">Caller Information (C# and Visual Basic)</a>

blocks|key|2477438|text|看这里：http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2477439|它是用德语写的，但是你可以下载ViewModelBase.cs。cs-文件中的所有注释都是用英语编写的。|2477440|使用此ViewModelBase类，可以实现类似于众所周知的依赖项属性的可绑定属性：|2477441|public+string+SomeProperty
{
++++get+{+return+GetValue(+()+=>+SomeProperty+);+}
++++set+{+SetValue(+()+=>+SomeProperty,+value+);+}
}|code-block|syntax|javascript|2477442|entityMap|0|LINK|mutability|MUTABLE|url|http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx^0|4|3O|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Look here : <a href="http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx" rel="nofollow">http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx</a>

It's written in German, but you can download the ViewModelBase.cs. All the comments in the cs-File are written in English.

With this ViewModelBase-Class it is possible to implement bindable properties similar to the well known Dependency Properties :

<pre><code>public string SomeProperty
{
 get { return GetValue( () =&gt; SomeProperty ); }
 set { SetValue( () =&gt; SomeProperty, value ); }
}
</code></pre>

blocks|key|2477459|text|使用反射的想法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477460|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|code-block|syntax|javascript|2477461|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An idea using reflection:

<pre><code>class ViewModelBase : INotifyPropertyChanged {

 public event PropertyChangedEventHandler PropertyChanged;

 bool Notify&lt;T&gt;(MethodBase mb, ref T oldValue, T newValue) {

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

 // Detect Change
 bool changed = EqualityComparer&lt;T&gt;.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
</code></pre>

blocks|key|1006605|text|另一个想法..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006606|+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));
++++}
}|code-block|syntax|javascript|1006607|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another Idea...

<pre><code> public class ViewModelBase : INotifyPropertyChanged
{
 private Dictionary&lt;string, object&gt; _propertyStore = new Dictionary&lt;string, object&gt;();
 protected virtual void SetValue&lt;T&gt;(T value, [CallerMemberName] string propertyName="") {
 _propertyStore[propertyName] = value;
 OnPropertyChanged(propertyName);
 }
 protected virtual T GetValue&lt;T&gt;([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&lt;string&gt;(); }
 // set { SetValue(value); }
 //}

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

blocks|key|951530|text|如果您使用的是.NET+4.5中的dynamics，则不需要担心INotifyPropertyChanged。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|951531|dynamic+obj+=+new+ExpandoObject();
obj.Name+=+"John";|code-block|syntax|javascript|951532|如果名称被绑定到某个控件，它就能正常工作。|951533|entityMap^0|W|M|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

If you are using dynamics in .NET 4.5 you don't need to worry about <code>INotifyPropertyChanged</code>. 

<pre><code>dynamic obj = new ExpandoObject();
obj.Name = "John";
</code></pre>

if Name is bound to some control it just works fine.

blocks|key|2477520|text|所有这些答案都很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477521|我的解决方案是使用代码片段来完成这项工作。|2477522|这使用了对PropertyChanged事件的最简单调用。|2477523|保存这个片段并使用它，就像您使用“完全螺旋桨”片段一样。|2477524|该位置可在“Tools\Code代码段管理器.”找到。菜单在。|blockquote|2477525|<?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>|code-block|syntax|javascript|2477526|您可以随意修改调用(以使用上述解决方案)。|2477527|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|Y|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|Z|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|S|$]]

All these answer are very nice.

My solution is using the code snippets to do the job.

This uses the simplest call to PropertyChanged event.

Save this snippet and use it as you use 'fullprop' snippet.

<blockquote>
 the location can be found at 'Tools\Code Snippet Manager...' menu at Visual Studio.
</blockquote>

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

You can modify the call as you like (to use the above solutions)

blocks|key|1006628|text|另一种组合解决方案是使用StackFrame：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006629|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));
++++++++}
++++}
}|code-block|syntax|javascript|1006630|用法：|1006631|public+class+TempVM+:+BaseViewModel
{
++++private+int+_intP;
++++public+int+IntP
++++{
++++++++get+{+return+_intP;+}
++++++++set+{+Set<int>(ref+_intP,+value);+}
++++}
}|1006632|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another combined solution is using StackFrame:

<pre><code>public class BaseViewModel : INotifyPropertyChanged
{
 public event PropertyChangedEventHandler PropertyChanged;

 protected void Set&lt;T&gt;(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));
 }
 }
}
</code></pre>

Usage:

<pre><code>public class TempVM : BaseViewModel
{
 private int _intP;
 public int IntP
 {
 get { return _intP; }
 set { Set&lt;int&gt;(ref _intP, value); }
 }
}
</code></pre>

blocks|key|1006639|text|具有以下特性的=>+这里+my解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1006640|+public+ResourceStatus+Status
+{
+++++get+{+return+_status;+}
+++++set
+++++{
+++++++++_status+=+value;
+++++++++Notify(Npcea.Status,Npcea.Comments);
+++++}
+}|code-block|syntax|javascript|1006641|无折射|ordered-list-item|1006642|短表示法|1006643|在您的业务代码中没有魔术字符串|1006644|PropertyChangedEventArgs跨应用程序的可重用性|1006645|在一条语句中通知多个属性的可能性|1006646|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/15088225/mvvm-inotifypropertychanged-with-automatic-property-name-implementation/15504461#15504461^0|A|2|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|K|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|K|7|17|8|@]|9|@]|C|$]]|$1|N|3|O|5|K|7|18|8|@]|9|@]|C|$]]|$1|P|3|Q|5|K|7|19|8|@]|9|@]|C|$]]|$1|R|3|S|5|K|7|1A|8|@]|9|@]|C|$]]|$1|T|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|U|$V|$5|W|X|Y|C|$Z|10]]]]

=> <a href="https://stackoverflow.com/questions/15088225/mvvm-inotifypropertychanged-with-automatic-property-name-implementation/15504461#15504461">here</a> my solution with the following features

<pre><code> public ResourceStatus Status
 {
 get { return _status; }
 set
 {
 _status = value;
 Notify(Npcea.Status,Npcea.Comments);
 }
 }
</code></pre>

<ol>
<li>no refelction</li>
<li>short notation</li>
<li>no magic string in your business code</li>
<li>Reusability of PropertyChangedEventArgs across application</li>
<li>Possibility to notify multiple properties in one statement</li>
</ol>

blocks|key|2477615|text|还有一个福迪，它有一个AddINotifyPropertyChangedInterface外接程序，它允许您编写以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2477616|[AddINotifyPropertyChangedInterface]
public+class+Person+
{++++++++
++++public+string+GivenNames+{+get;+set;+}
++++public+string+FamilyName+{+get;+set;+}
}|code-block|syntax|javascript|2477617|...and在编译时注入属性更改通知。|2477618|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/Fody/Fody|1|https://github.com/Fody/PropertyChanged^0|4|2|0|B|Y|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

There's also <a href="https://github.com/Fody/Fody" rel="noreferrer">Fody</a> which has a <a href="https://github.com/Fody/PropertyChanged" rel="noreferrer">AddINotifyPropertyChangedInterface</a> add-in, which lets you write this:
<pre><code>[AddINotifyPropertyChangedInterface]
public class Person 
{ 
 public string GivenNames { get; set; }
 public string FamilyName { get; set; }
}
</code></pre>
...and at compile time injects property changed notifications.

blocks|key|951698|text|是的，更好的方式肯定存在。下面是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951699|一步一步地缩小我的教程，基于这个有用物品。|offset|length|951700|创建新项目|unordered-list-item|951701|将城堡核心组件安装到项目中|951702|安装包Castle.Core|blockquote|951703|只安装mvvm灯光库|951704|安装包MvvmLightLibs|951705|在项目中添加两个类：|951706|NotifierInterceptor|style|BOLD|951707|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;
++++++++}
++++}|code-block|syntax|javascript|951708|ProxyCreator|951709|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;
++++}
}|951710|创建视图模型，例如：|951711|-|CODE|951712|+public+class+MainViewModel
++++{
++++++++public+virtual+string+MainTextBox+{+get;+set;+}

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

++++++++public+void+TestAction()
++++++++{
++++++++++++Trace.WriteLine(MainTextBox);
++++++++}
++++}|951713|将绑定放到xaml中：
测试|951714|将代码行放入代码隐藏文件MainWindow.xaml.cs中，如下所示：|951715|DataContext+=+ProxyCreator.MakeINotifyPropertyChanged<MainViewModel>();|951716|好好享受吧。|951717|​|951718|📷|atomic|951719|951720|注意！所有有界的属性都应该用关键字虚拟来修饰，因为它们被城堡代理用来重写。|951721|entityMap|0|LINK|mutability|MUTABLE|url|https://www.codeproject.com/Articles/65178/MVVM-Creating-ViewModel-create-dynamic-proxies-wit|1|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/67aee512e01efc672c9770ef0f02486d.png|imageAlt^0|0|G|4|0|0|0|0|0|0|0|0|0|J|0|0|0|C|0|0|0|0|1|0|0|0|0|0|1Z|0|0|0|0|1|1|0|0|0^^$0|@$1|2|3|4|5|6|7|27|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|28|8|@]|9|@$D|29|E|2A|1|2B]]|A|$]]|$1|F|3|G|5|H|7|2C|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|2D|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|2E|8|@]|9|@]|A|$]]|$1|N|3|O|5|H|7|2F|8|@]|9|@]|A|$]]|$1|P|3|Q|5|M|7|2G|8|@]|9|@]|A|$]]|$1|R|3|S|5|H|7|2H|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|2I|8|@$D|2J|E|2K|V|W]]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|2L|8|@]|9|@]|A|$10|11]]|$1|12|3|13|5|6|7|2M|8|@$D|2N|E|2O|V|W]]|9|@]|A|$]]|$1|14|3|15|5|Z|7|2P|8|@]|9|@]|A|$10|11]]|$1|16|3|17|5|H|7|2Q|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2R|8|@$D|2S|E|2T|V|1A]]|9|@]|A|$]]|$1|1B|3|1C|5|Z|7|2U|8|@]|9|@]|A|$10|11]]|$1|1D|3|1E|5|H|7|2V|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|H|7|2W|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2X|8|@$D|2Y|E|2Z|V|1A]]|9|@]|A|$]]|$1|1J|3|1K|5|H|7|30|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|31|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|1P|7|32|8|@]|9|@$D|33|E|34|1|35]]|A|$]]|$1|1Q|3|1M|5|6|7|36|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|37|8|@]|9|@]|A|$]]|$1|1T|3|-4|5|6|7|38|8|@]|9|@]|A|$]]]|1U|$1V|$5|1W|1X|1Y|A|$1Z|20]]|21|$5|22|1X|23|A|$24|25|26|-4]]]]

Yes, better way certainly exists.
Here it is:

Step by step tutorial shrank by me, based on this <a href="https://www.codeproject.com/Articles/65178/MVVM-Creating-ViewModel-create-dynamic-proxies-wit" rel="nofollow noreferrer">useful article</a>.

<ul>
<li>Create new project</li>
<li>Install castle core package into the project </li>
</ul>

<blockquote>
 Install-Package Castle.Core
</blockquote>

<ul>
<li>Install mvvm light libraries only</li>
</ul>

<blockquote>
 Install-Package MvvmLightLibs
</blockquote>

<ul>
<li>Add two classes in project:</li>
</ul>

NotifierInterceptor

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

 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;
 }
 }
</code></pre>

ProxyCreator

<pre><code>public class ProxyCreator
{
 public static T MakeINotifyPropertyChanged&lt;T&gt;() 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;
 }
}
</code></pre>

<ul>
<li>Create your view model, for example:</li>
</ul>

<code>-</code>

<pre><code> public class MainViewModel
 {
 public virtual string MainTextBox { get; set; }

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

 public void TestAction()
 {
 Trace.WriteLine(MainTextBox);
 }
 }
</code></pre>

<ul>
<li>Put bindings into xaml:

<pre><code>&lt;TextBox Text="{Binding MainTextBox}" &gt;&lt;/TextBox&gt;
&lt;Button Command="{Binding TestActionCommand}" &gt;Test&lt;/Button&gt;
</code></pre></li>
<li>Put line of code in code-behind file MainWindow.xaml.cs like this:</li>
</ul>

<code>DataContext = ProxyCreator.MakeINotifyPropertyChanged&lt;MainViewModel&gt;();</code>

<ul>
<li>Enjoy.</li>
</ul>

<img src="https://i.stack.imgur.com/vYtMz.png" alt="enter image description here">

Attention!!! All bounded properties should be decorated with
keyword virtual because they used by castle proxy for overriding.

blocks|key|2477752|text|我在http://timoch.com/blog/2013/08/annoyed-with-inotifypropertychange/+Bindable的博客中介绍了一个Bindable类，它使用字典作为属性包。很容易为子类添加必要的重载，以便使用ref参数管理自己的支持字段。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2477753|无魔法绳|unordered-list-item|2477754|无反射|2477755|可以改进以抑制默认字典查找。|2477756|守则：|2477757|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));
++++++++}
++++}
}|code-block|syntax|javascript|2477758|它可以这样使用：|2477759|public+class+Contact+:+Bindable+{
++++public+string+FirstName+{
++++++++get+{+return+Get<string>();+}
++++++++set+{+Set(value);+}
++++}
}|2477760|entityMap|0|LINK|mutability|MUTABLE|url|http://timoch.com/blog/2013/08/annoyed-with-inotifypropertychange/^0|2|1U|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$]]|$1|G|3|H|5|F|7|18|8|@]|9|@]|C|$]]|$1|I|3|J|5|F|7|19|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1B|8|@]|9|@]|C|$P|Q]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|C|$]]|$1|T|3|U|5|O|7|1D|8|@]|9|@]|C|$P|Q]]|$1|V|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]]]

I introduce a Bindable class in my blog at <a href="http://timoch.com/blog/2013/08/annoyed-with-inotifypropertychange/">http://timoch.com/blog/2013/08/annoyed-with-inotifypropertychange/</a>
Bindable uses a dictionary as a property bag. It's easy enough to add the necessary overloads for a subclass to manage its own backing field using ref parameters.

<ul>
<li>No magic string</li>
<li>No reflection</li>
<li>Can be improved to suppress the default dictionary lookup</li>
</ul>

The code: 

<pre><code>public class Bindable : INotifyPropertyChanged {
 private Dictionary&lt;string, object&gt; _properties = new Dictionary&lt;string, object&gt;();

 /// &lt;summary&gt;
 /// Gets the value of a property
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="name"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 protected T Get&lt;T&gt;([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);
 }

 /// &lt;summary&gt;
 /// Sets the value of a property
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="value"&gt;&lt;/param&gt;
 /// &lt;param name="name"&gt;&lt;/param&gt;
 /// &lt;remarks&gt;Use this overload when implicitly naming the property&lt;/remarks&gt;
 protected void Set&lt;T&gt;(T value, [CallerMemberName] string name = null) {
 Debug.Assert(name != null, "name != null");
 if (Equals(value, Get&lt;T&gt;(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));
 }
 }
}
</code></pre>

It can be used like this:

<pre><code>public class Contact : Bindable {
 public string FirstName {
 get { return Get&lt;string&gt;(); }
 set { Set(value); }
 }
}
</code></pre>

blocks|key|2477816|text|我认为人们应该更多地关注性能；当有很多对象要绑定时，它确实会影响UI+(比如带有10,000%2B行的网格)，或者对象的值经常变化(实时监控应用程序)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477817|我使用了这里和其他地方找到的各种实现，并进行了比较；查看一下INotifyPropertyChanged实现的性能比较。|offset|length|2477818|下面是对结果的一个窥探|2477819|📷|atomic|2477820|​|2477821|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.amusedia.com/2013/06/inotifypropertychanged-implementation.html|1|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/cf140f7e3c5a955728242a447ae8df46.png|imageAlt^0|0|U|T|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@$D|17|E|18|1|19]]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|V|Q|W|A|$X|Y|Z|-4]]]]

I think people should pay a little more attention to performance; it really does impact the UI when there are a lot of objects to be bound (think of a grid with 10,000+ rows), or if the object's value changes frequently (real-time monitoring app).

I took various implementation found here and elsewhere and did a comparison; check it out <a href="http://blog.amusedia.com/2013/06/inotifypropertychanged-implementation.html" rel="noreferrer">perfomance comparison of INotifyPropertyChanged implementations</a>.

<hr>

Here is a peek at the result
<img src="https://i.stack.imgur.com/g6doK.png" alt="Implemenation vs Runtime">

blocks|key|1006767|text|我在基本库中创建了一个扩展方法以供重用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006768|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;
++++}
}|code-block|syntax|javascript|1006769|这适用于.Net+4.5，因为CallerMemberNameAttribute的缘故。如果您想将它与早期的.Net版本一起使用，则必须将方法声明从：...,[CallerMemberName]+string+propertyName+=+"",+...更改为...,string+propertyName,+...|offset|length|style|CODE|1006770|用法：|1006771|public+class+Dog+:+INotifyPropertyChanged
{
++++public+event+PropertyChangedEventHandler+PropertyChanged;
++++string+_name;

++++public+string+Name
++++{
++++++++get+{+return+_name;+}
++++++++set
++++++++{
++++++++++++this.SetPropertyAndNotify(PropertyChanged,+ref+_name,+value);
++++++++}
++++}
}|1006772|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.callermembernameattribute%2528v=vs.110%2529.aspx^0|0|0|23|1G|3M|S|F|P|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@$I|15|J|16|1|17]]|A|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

I created an Extension Method in my base Library for reuse:

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

This works with .Net 4.5 because of <a href="http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.callermembernameattribute%28v=vs.110%29.aspx" rel="nofollow">CallerMemberNameAttribute</a>.
If you want to use it with an earlier .Net version you have to change the method declaration from: <code>...,[CallerMemberName] string propertyName = "", ...</code> to <code>...,string propertyName, ...</code>

Usage:

<pre><code>public class Dog : INotifyPropertyChanged
{
 public event PropertyChangedEventHandler PropertyChanged;
 string _name;

 public string Name
 {
 get { return _name; }
 set
 {
 this.SetPropertyAndNotify(PropertyChanged, ref _name, value);
 }
 }
}
</code></pre>

blocks|key|951870|text|使用这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951871|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"+%7C%7C+methodCall.MethodName+==+"remove_PropertyChanged"%7C%7C
++++++++++++++++methodCall.MethodName+==+"add_PropertyChanging"+%7C%7C+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+%2B+".dll");

++++++++var+typeBuilder+=+moduleBuilder.DefineType(
++++++++++++objectType.FullName,+TypeAttributes.Public+%7C+TypeAttributes.Interface+%7C+TypeAttributes.Abstract);

++++++++typeBuilder.AddInterfaceImplementation(objectType);
++++++++typeBuilder.AddInterfaceImplementation(typeof(INotifyPropertyChanged));
++++++++typeBuilder.AddInterfaceImplementation(typeof(INotifyPropertyChanging));
++++++++var+newType+=+typeBuilder.CreateType();
++++++++return+newType;
++++}
}|code-block|syntax|javascript|951872|}|951873|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Use this

<pre><code>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&lt;T&gt;(T target)
 {
 if (!typeof(T).IsInterface)
 throw new ArgumentException("Target should be an interface", "target");

 var proxy = new Observable&lt;T&gt;(target);
 return (T)proxy.GetTransparentProxy();
 }
}

internal class Observable&lt;T&gt; : 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;
 }
}
</code></pre>

}

blocks|key|951900|text|我用这种方式解决了问题(这有点费劲，但在运行时肯定更快)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951901|在VB中(对不起，但我认为在C#中翻译它并不难)，我用RE做了这个替换：|951902|(?<Attr><(.*ComponentModel\.)Bindable$True$>)(+%7C\r\n)*(?<Def>(Public%7CPrivate%7CFriend%7CProtected)+.*Property+)(?<Name>[%5E+]*)+As+(?<Type>.*?)[+%7C\r\n](?![+%7C\r\n]*Get)|code-block|syntax|javascript|951903|通过以下方式：|951904|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|951905|这个转换程序都是这样的代码：|951906|<Bindable(True)>
Protected+Friend+Property+StartDate+As+DateTime?|951907|在……里面|951908|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|951909|如果我想要一个更具可读性的代码，我可能会相反，只需做以下替换：|951910|Private+_(?<Name>.*)+As+(?<Type>.*)[\r\n+]*(?<Attr><(.*ComponentModel\.)Bindable$True$>)[\r\n+]*(?<Def>(Public%7CPrivate%7CFriend%7CProtected)+.*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|951911|使用|951912|${Attr}+${Def}+${Name}+As+${Type}|951913|我抛出以替换set方法的IL代码，但是我不能用IL.如果有一天我写了，我会说你！|951914|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

I resolved in This Way (it's a little bit laboriouse, but it's surely the faster in runtime).

In VB (sorry, but I think it's not hard translate it in C#), I make this substitution with RE:

<pre><code>(?&lt;Attr&gt;&lt;(.*ComponentModel\.)Bindable$True$&gt;)( |\r\n)*(?&lt;Def&gt;(Public|Private|Friend|Protected) .*Property )(?&lt;Name&gt;[^ ]*) As (?&lt;Type&gt;.*?)[ |\r\n](?![ |\r\n]*Get)
</code></pre>

with:

<pre><code>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} &lt;&gt; 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
</code></pre>

This transofrm all code like this:

<pre><code>&lt;Bindable(True)&gt;
Protected Friend Property StartDate As DateTime?
</code></pre>

In

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

And If I want to have a more readable code, I can be the opposite just making the following substitution:

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

With

<pre><code>${Attr} ${Def} ${Name} As ${Type}
</code></pre>

I throw to replace the IL code of the set method, but I can't write a lot of compiled code in IL... If a day I write it, I'll say you!

blocks|key|951947|text|基于Thomas的回答，它是根据Marc的一个答案改编的，我已经将代码转换为一个基类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951948|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);
++++}
}|code-block|syntax|javascript|951949|用法与Thomas的答案相同，只是可以传递要通知的其他属性。这对于处理需要在网格中刷新的计算列是必要的。|951950|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;+}+}|951951|我通过一个BindingList公开了一个存储在DataGridView中的项目集合。它消除了我对网格执行手动Refresh()调用的需要。|951952|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Based on the answer by Thomas which was adapted from an answer by Marc I've turned the reflecting property changed code into a base class:

<pre><code>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&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; 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&lt;T&gt;(ref T field, T value, Expression&lt;Func&lt;T&gt;&gt; selectorExpression, params Expression&lt;Func&lt;object&gt;&gt;[] additonal)
 {
 if (EqualityComparer&lt;T&gt;.Default.Equals(field, value)) return;
 field = value;
 OnPropertyChanged(selectorExpression);
 foreach (var item in additonal)
 OnPropertyChanged(item);
 }
}
</code></pre>

Usage is the same as Thomas' answer except that you can pass additional properties to notify for. This was necessary to handle calculated columns which need to be refreshed in a grid.

<pre><code>private int _quantity;
private int _price;

public int Quantity 
{ 
 get { return _quantity; } 
 set { SetField(ref _quantity, value, () =&gt; Quantity, () =&gt; Total); } 
}
public int Price 
{ 
 get { return _price; } 
 set { SetField(ref _price, value, () =&gt; Price, () =&gt; Total); } 
}
public int Total { get { return _price * _quantity; } }
</code></pre>

I have this driving a collection of items stored in a BindingList exposed via a DataGridView. It has eliminated the need for me to do manual Refresh() calls to the grid.

blocks|key|2477938|text|我把这当成一个小片段。C#+6为调用处理程序添加了一些很好的语法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477939|//+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));
++++}
}|code-block|syntax|javascript|2477940|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I keep this around as a snippet. C# 6 adds some nice syntax for invoking the handler.

<pre><code>// INotifyPropertyChanged

public event PropertyChangedEventHandler PropertyChanged;

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

blocks|key|2477962|text|我使用以下扩展方法(使用C#+6.0)使INPC的实现尽可能简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2477963|public+static+bool+ChangeProperty<T>(this+PropertyChangedEventHandler+propertyChanged,+ref+T+field,+T+value,+object+sender,
++++IEqualityComparer<T>+comparer+=+null,+[CallerMemberName]+string+propertyName+=+null)
{
++++if+(comparer+==+null)
++++++++comparer+=+EqualityComparer<T>.Default;

++++if+(comparer.Equals(field,+value))
++++{
++++++++return+false;
++++}
++++else
++++{
++++++++field+=+value;
++++++++propertyChanged?.Invoke(sender,+new+PropertyChangedEventArgs(propertyName));
++++++++return+true;
++++}
}|code-block|syntax|javascript|2477964|INPC实现归结为(您可以每次实现这个或创建一个基类)：|2477965|public+class+INPCBaseClass:+INotifyPropertyChanged
{
++++public+event+PropertyChangedEventHandler+PropertyChanged;

++++protected+bool+changeProperty<T>(ref+T+field,+T+value,
++++++++IEqualityComparer<T>+comparer+=+null,+[CallerMemberName]+string+propertyName+=+null)
++++{
++++++++return+PropertyChanged.ChangeProperty(ref+field,+value,+this,+comparer,+propertyName);
++++}
}|2477966|然后这样写你的属性：|2477967|private+string+testProperty;
public+string+TestProperty
{
++++get+{+return+testProperty;+}
++++set+{+changeProperty(ref+testProperty,+value);+}
}|2477968|注意:如果需要，可以在扩展方法中省略[CallerMemberName]声明，但我希望保持它的灵活性。|offset|length|style|CODE|2477969|如果您的属性没有后备字段，则可以重载changeProperty。|2477970|protected+bool+changeProperty<T>(T+property,+Action<T>+set,+T+value,
++++IEqualityComparer<T>+comparer+=+null,+[CallerMemberName]+string+propertyName+=+null)
{
++++bool+ret+=+changeProperty(ref+property,+value,+comparer,+propertyName);
++++if+(ret)
++++++++set(property);
++++return+ret;
}|2477971|一个例子是：|2477972|public+string+MyTestProperty
{
++++get+{+return+base.TestProperty;+}
++++set+{+changeProperty(base.TestProperty,+(x)+=>+{+base.TestProperty+=+x;+},+value);+}
}|2477973|entityMap^0|0|0|0|0|0|0|I|I|0|I|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1A|8|@$Q|1B|R|1C|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@$Q|1E|R|1F|S|T]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|13|$]]

I use the following extension method (using C# 6.0) to make the INPC implemenation as easy as possible:

<pre><code>public static bool ChangeProperty&lt;T&gt;(this PropertyChangedEventHandler propertyChanged, ref T field, T value, object sender,
 IEqualityComparer&lt;T&gt; comparer = null, [CallerMemberName] string propertyName = null)
{
 if (comparer == null)
 comparer = EqualityComparer&lt;T&gt;.Default;

 if (comparer.Equals(field, value))
 {
 return false;
 }
 else
 {
 field = value;
 propertyChanged?.Invoke(sender, new PropertyChangedEventArgs(propertyName));
 return true;
 }
}
</code></pre>

The INPC implementation boils down to (you can either implement this every time or create a base class):

<pre><code>public class INPCBaseClass: INotifyPropertyChanged
{
 public event PropertyChangedEventHandler PropertyChanged;

 protected bool changeProperty&lt;T&gt;(ref T field, T value,
 IEqualityComparer&lt;T&gt; comparer = null, [CallerMemberName] string propertyName = null)
 {
 return PropertyChanged.ChangeProperty(ref field, value, this, comparer, propertyName);
 }
}
</code></pre>

Then write your properties like this:

<pre><code>private string testProperty;
public string TestProperty
{
 get { return testProperty; }
 set { changeProperty(ref testProperty, value); }
}
</code></pre>

NOTE: You can omit the <code>[CallerMemberName]</code> declaration in the extension method, if you want, but I wanted to keep it flexible.

If you have properties without a backing field you can overload <code>changeProperty</code>:

<pre><code>protected bool changeProperty&lt;T&gt;(T property, Action&lt;T&gt; set, T value,
 IEqualityComparer&lt;T&gt; comparer = null, [CallerMemberName] string propertyName = null)
{
 bool ret = changeProperty(ref property, value, comparer, propertyName);
 if (ret)
 set(property);
 return ret;
}
</code></pre>

An example use would be:

<pre><code>public string MyTestProperty
{
 get { return base.TestProperty; }
 set { changeProperty(base.TestProperty, (x) =&gt; { base.TestProperty = x; }, value); }
}
</code></pre>

blocks|key|2478017|text|棱镜5执行情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2478018|public+abstract+class+BindableBase+:+INotifyPropertyChanged
{
++++public+event+PropertyChangedEventHandler+PropertyChanged;

++++protected+virtual+bool+SetProperty<T>(ref+T+storage,
++++++++++++++++++++++++++++++++++++++++++T+value,
++++++++++++++++++++++++++++++++++++++++++[CallerMemberName]+string+propertyName+=+null)
++++{
++++++++if+(object.Equals(storage,+value))+return+false;

++++++++storage+=+value;
++++++++this.OnPropertyChanged(propertyName);

++++++++return+true;
++++}

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

++++protected+void+OnPropertyChanged<T>(Expression<Func<T>>+propertyExpression)
++++{
++++++++var+propertyName+=+PropertySupport.ExtractPropertyName(propertyExpression);
++++++++this.OnPropertyChanged(propertyName);
++++}
}

public+static+class+PropertySupport
{
++++public+static+string+ExtractPropertyName<T>(Expression<Func<T>>+propertyExpression)
++++{
++++++++if+(propertyExpression+==+null)
++++++++{
++++++++++++throw+new+ArgumentNullException("propertyExpression");
++++++++}

++++++++var+memberExpression+=+propertyExpression.Body+as+MemberExpression;
++++++++if+(memberExpression+==+null)
++++++++{
++++++++++++throw+new+ArgumentException("The+expression+is+not+a+member+access+expression.",+"propertyExpression");
++++++++}

++++++++var+property+=+memberExpression.Member+as+PropertyInfo;
++++++++if+(property+==+null)
++++++++{
++++++++++++throw+new+ArgumentException("The+member+access+expression+does+not+access+a+property.",+"propertyExpression");
++++++++}

++++++++var+getMethod+=+property.GetMethod;
++++++++if+(getMethod.IsStatic)
++++++++{
++++++++++++throw+new+ArgumentException("The+referenced+property+is+a+static+property.",+"propertyExpression");
++++++++}

++++++++return+memberExpression.Member.Name;
++++}
}|code-block|syntax|javascript|2478019|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Prism 5 implementation:

<pre><code>public abstract class BindableBase : INotifyPropertyChanged
{
 public event PropertyChangedEventHandler PropertyChanged;

 protected virtual bool SetProperty&lt;T&gt;(ref T storage,
 T value,
 [CallerMemberName] string propertyName = null)
 {
 if (object.Equals(storage, value)) return false;

 storage = value;
 this.OnPropertyChanged(propertyName);

 return true;
 }

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

 protected void OnPropertyChanged&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; propertyExpression)
 {
 var propertyName = PropertySupport.ExtractPropertyName(propertyExpression);
 this.OnPropertyChanged(propertyName);
 }
}

public static class PropertySupport
{
 public static string ExtractPropertyName&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; propertyExpression)
 {
 if (propertyExpression == null)
 {
 throw new ArgumentNullException("propertyExpression");
 }

 var memberExpression = propertyExpression.Body as MemberExpression;
 if (memberExpression == null)
 {
 throw new ArgumentException("The expression is not a member access expression.", "propertyExpression");
 }

 var property = memberExpression.Member as PropertyInfo;
 if (property == null)
 {
 throw new ArgumentException("The member access expression does not access a property.", "propertyExpression");
 }

 var getMethod = property.GetMethod;
 if (getMethod.IsStatic)
 {
 throw new ArgumentException("The referenced property is a static property.", "propertyExpression");
 }

 return memberExpression.Member.Name;
 }
}
</code></pre>

blocks|key|952045|text|这里是一个Unity3D或非缓存名的NotifyPropertyChanged版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|952046|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
}|code-block|syntax|javascript|952047|此代码使您能够编写如下所示的属性支持字段：|952048|++public+string+Text
++++{
++++++++get+{+return+Get<string>();+}
++++++++set+{+Set(value);+}
++++}|952049|此外，在resharper中，如果您创建了模式/搜索片段，那么您也可以通过将简单的支柱字段转换为上面的支持来自动化您的工作流。|952050|搜索模式：|offset|length|style|BOLD|952051|public+$type$+$fname$+{+get;+set;+}|952052|替换模式：|952053|public+$type$+$fname$
{
++++get+{+return+Get<$type$>();+}
++++set+{+Set(value);+}
}|952054|entityMap^0|0|0|0|0|0|0|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@$O|16|P|17|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Here is a Unity3D or non-CallerMemberName version of NotifyPropertyChanged

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

 /// &lt;summary&gt;
 /// Resolves a Property's name from a Lambda Expression passed in.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
 /// &lt;param name="property"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 internal string GetPropertyName&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; 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

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

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

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

 #endregion

 #region Getters

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

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

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

 #endregion

 #region Setters

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

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

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

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

 if (Equals(value, Get&lt;T&gt;(propertyName)))
 return;
 _properties[propertyName] = value;
 NotifyOfPropertyChange(propertyName);
 }

 #endregion
}
</code></pre>

This code enables you to write property backing fields like this:

<pre><code> public string Text
 {
 get { return Get&lt;string&gt;(); }
 set { Set(value); }
 }
</code></pre>

Furthermore, in resharper if you create a pattern/search snippet you can then also automate you're workflow by converting simple prop fields into the above backing.

Search Pattern:

<pre><code>public $type$ $fname$ { get; set; }
</code></pre>

Replace Pattern:

<pre><code>public $type$ $fname$
{
 get { return Get&lt;$type$&gt;(); }
 set { Set(value); }
}
</code></pre>

blocks|key|2478087|text|我写了一篇文章来帮助解决这个问题(https://msdn.microsoft.com/magazine/mt736453)。您可以使用SolSoft.DataBinding+NuGet包。然后您可以编写如下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2478088|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)
}|code-block|syntax|javascript|2478089|好处：|2478090|基类是可选的。|ordered-list-item|2478091|不对每一个“设定值”进行反思|2478092|可以具有依赖于其他属性的属性，并且它们都会自动引发适当的事件(本文有此示例)|2478093|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/magazine/mt736453^0|H|18|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|15|8|@]|9|@]|C|$]]|$1|N|3|O|5|M|7|16|8|@]|9|@]|C|$]]|$1|P|3|Q|5|M|7|17|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

I have written an article that helps with this (<a href="https://msdn.microsoft.com/magazine/mt736453" rel="nofollow">https://msdn.microsoft.com/magazine/mt736453</a>). You can use the SolSoft.DataBinding NuGet package. Then you can write code like this:

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

 private readonly NotifyProperty&lt;string&gt; m_nameProperty;
 public string Name
 {
 get
 {
 return m_nameProperty.Value;
 }
 set
 {
 m_nameProperty.SetValue(value);
 }
 }

 // Plus implement IRaisePropertyChanged (or extend BaseViewModel)
}
</code></pre>

Benefits:

<ol>
<li>base class is optional</li>
<li>no reflection on every 'set value'</li>
<li>can have properties that depend on other properties, and they all automatically raise the appropriate events (article has an example of this)</li>
</ol>

blocks|key|2478124|text|我意识到这个问题已经有了无数的答案，但没有一个对我来说是正确的。我的问题是，我不想要任何性能上的成功，我愿意忍受一些细节，仅仅因为这个原因。我也不太关心汽车属性，这导致我找到了以下解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2478125|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()
++++{
++++}
}|code-block|syntax|javascript|2478126|换句话说，如果您不介意这样做的话，以上解决方案是方便的：|2478127|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()
++++{
++++}
}|2478128|Pros|offset|length|style|BOLD|2478129|无反射|unordered-list-item|2478130|只通知旧值!=新值|2478131|一次通知多个属性|2478132|Cons|2478133|没有自动属性(但是可以添加对两者的支持！)|2478134|一些冗长的|2478135|拳击(小表演赛？)|2478136|唉，还是比这么做好，|2478137|set
{
++++if+(!someProperty.Equals(value))
++++{
++++++++someProperty+=+value;
++++++++OnPropertyChanged("SomeProperty");
++++++++OnPropertyChanged("AnotherProperty");
++++}
}|2478138|对于每一个属性，这将成为一个恶梦和额外的详细;-(|2478139|注意，我并不认为这个解决方案比其他解决方案具有更好的性能，只是对于那些不喜欢其他解决方案的人来说，这是一个可行的解决方案。|2478140|entityMap^0|0|0|0|0|0|4|0|0|0|0|0|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1H|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1J|8|@$M|1K|N|1L|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1M|8|@]|9|@]|A|$]]|$1|T|3|U|5|S|7|1N|8|@]|9|@]|A|$]]|$1|V|3|W|5|S|7|1O|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1P|8|@$M|1Q|N|1R|O|P]]|9|@]|A|$]]|$1|Z|3|10|5|S|7|1S|8|@]|9|@]|A|$]]|$1|11|3|12|5|S|7|1T|8|@]|9|@]|A|$]]|$1|13|3|14|5|S|7|1U|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|1V|8|@]|9|@]|A|$]]|$1|17|3|18|5|D|7|1W|8|@]|9|@]|A|$E|F]]|$1|19|3|1A|5|6|7|1X|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|1E|$]]

I realize this question already has a gazillion answers, but none of them felt quite right for me. My issue is I don't want any performance hits and am willing to put up with a little verbosity for that reason alone. I also don't care too much for auto properties either, which led me to the following solution:

<pre><code>public abstract class AbstractObject : INotifyPropertyChanged
{
 public event PropertyChangedEventHandler PropertyChanged;

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

 protected virtual bool SetValue&lt;TKind&gt;(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()
 {
 }
}
</code></pre>

In other words, the above solution is convenient if you don't mind doing this:

<pre><code>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()
 {
 }
}
</code></pre>

Pros

<ul>
<li>No reflection</li>
<li>Only notifies if old value != new value</li>
<li>Notify multiple properties at once</li>
</ul>

Cons

<ul>
<li>No auto properties (you can add support for both, though!)</li>
<li>Some verbosity</li>
<li>Boxing (small performance hit?)</li>
</ul>

Alas, it is still better than doing this,

<pre><code>set
{
 if (!someProperty.Equals(value))
 {
 someProperty = value;
 OnPropertyChanged("SomeProperty");
 OnPropertyChanged("AnotherProperty");
 }
}
</code></pre>

For every single property, which becomes a nightmare with the additional verbosity ;-(

Note, I do not claim this solution is better performance-wise compared to the others, just that it is a viable solution for those who don't like the other solutions presented.

blocks|key|952162|text|我想出了这个基类来实现可观察到的模式，基本上可以满足您的需要(“自动”实现set和get)。我花了一个小时在这个原型上，所以它没有太多的单元测试，但是证明了这个概念。注意，它使用Dictionary<string,+ObservablePropertyContext>来消除对私有字段的需求。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|952163|++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+%7C+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();
++}|code-block|syntax|javascript|952164|这是用法|952165|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);+}
++++}
++}|952166|entityMap^0|2H|19|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I came up with this base class to implement the observable pattern, pretty much does what you need ("automatically" implementing the set and get). I spent line an hour on this as prototype, so it doesn't have many unit tests, but proves the concept. Note it uses the <code>Dictionary&lt;string, ObservablePropertyContext&gt;</code> to remove the need for private fields.

<pre><code> public class ObservableByTracking&lt;T&gt; : IObservable&lt;T&gt;
 {
 private readonly Dictionary&lt;string, ObservablePropertyContext&gt; _expando;
 private bool _isDirty;

 public ObservableByTracking()
 {
 _expando = new Dictionary&lt;string, ObservablePropertyContext&gt;();

 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&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; 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&lt;T&gt;.Default.Equals(originalValue, value))
 {
 return;
 }

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

 protected T GetValue&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; 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&lt;T&gt;(Expression&lt;Func&lt;T&gt;&gt; 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&lt;T&gt;
 {
 bool IsDirty();
 void SetPristine();
 }
</code></pre>

Here's the usage

<pre><code>public class ObservableByTrackingTestClass : ObservableByTracking&lt;ObservableByTrackingTestClass&gt;
 {
 public ObservableByTrackingTestClass()
 {
 StringList = new List&lt;string&gt;();
 StringIList = new List&lt;string&gt;();
 NestedCollection = new List&lt;ObservableByTrackingTestClass&gt;();
 }

 public IEnumerable&lt;string&gt; StringList
 {
 get { return GetValue(() =&gt; StringList); }
 set { SetValue(() =&gt; StringIList, value); }
 }

 public IList&lt;string&gt; StringIList
 {
 get { return GetValue(() =&gt; StringIList); }
 set { SetValue(() =&gt; StringIList, value); }
 }

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

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

 public IList&lt;ObservableByTrackingTestClass&gt; NestedCollection
 {
 get { return GetValue(() =&gt; NestedCollection); }
 set { SetValue(() =&gt; NestedCollection, value); }
 }

 public string StringProperty
 {
 get { return GetValue(() =&gt; StringProperty); }
 set { SetValue(() =&gt; StringProperty, value); }
 }
 }
</code></pre>

blocks|key|2478242|text|我建议使用ReactiveProperty。除了Fody，这是最短的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2478243|public+class+Data+:+INotifyPropertyChanged
{
++++//+boiler-plate
++++...
++++//+props
++++private+string+name;
++++public+string+Name
++++{
++++++++get+{+return+name;+}
++++++++set+{+SetField(ref+name,+value,+"Name");+}
++++}
}|code-block|syntax|javascript|2478244|相反，|2478245|public+class+Data
{
++++//+Don't+need+boiler-plate+and+INotifyPropertyChanged

++++//+props
++++public+ReactiveProperty<string>+Name+{+get;+}+=+new+ReactiveProperty<string>();
}|2478246|(文档)|offset|length|2478247|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/runceel/ReactiveProperty^0|0|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I suggest to use ReactiveProperty.
This is the shortest method except Fody.

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

instead

<pre><code>public class Data
{
 // Don't need boiler-plate and INotifyPropertyChanged

 // props
 public ReactiveProperty&lt;string&gt; Name { get; } = new ReactiveProperty&lt;string&gt;();
}
</code></pre>

(<a href="https://github.com/runceel/ReactiveProperty" rel="nofollow noreferrer">DOCS</a>)

blocks|key|2478307|text|虽然显然有很多方法可以做到这一点，但除了AOP魔术答案之外，似乎没有一个答案是直接从视图模型中设置一个模型的属性，而没有一个本地字段可以引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2478308|问题是你不能引用一个属性。但是，可以使用Action设置该属性。|2478309|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;
}|code-block|syntax|javascript|2478310|这可以像下面的代码提取一样使用。|2478311|public+int+Prop+{
++++get+=>+model.Prop;
++++set+=>+TrySetProperty(x+=>+model.Prop+=+x,+value,+model.Prop);
}|2478312|查看此BitBucket回购以获得该方法的完整实现和实现相同结果的几种不同方法，包括使用LINQ的方法和使用反射的方法。请注意，这些方法的性能比较慢。|offset|length|2478313|entityMap|0|LINK|mutability|MUTABLE|url|https://bitbucket.org/DanJBower/wpf-binder^0|0|0|0|0|0|3|B|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Whilst there are obviously lots of ways to do this, with the exception of the AOP magic answers, none of the answers seem to look at setting a Model's property directly from the view model without having a local field to reference.
The issue is you can't reference a property. However, you can use an Action to set that property.
<pre><code>protected bool TrySetProperty&lt;T&gt;(Action&lt;T&gt; property, T newValue, T oldValue, [CallerMemberName] string propertyName = null)
{
 if (EqualityComparer&lt;T&gt;.Default.Equals(oldValue, newValue))
 {
 return false;
 }

 property(newValue);
 RaisePropertyChanged(propertyName);
 return true;
}
</code></pre>
This can be used like the following code extract.
<pre><code>public int Prop {
 get =&gt; model.Prop;
 set =&gt; TrySetProperty(x =&gt; model.Prop = x, value, model.Prop);
}
</code></pre>
Check out this <a href="https://bitbucket.org/DanJBower/wpf-binder" rel="nofollow noreferrer">BitBucket repo</a> for a full implementation of the method and a few different ways of achieving the same result, including a method that uses LINQ and a method that uses reflection. Do note that these methods are slower performance wise.

blocks|key|1007653|text|我正在编写一个处理INotifyPropertyChanged的库，主要思想是使用动态代理通知更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1007654|回购程序在这里：CaulyKan/NoMorePropertyChanged|offset|length|1007655|有了这个库，您可以写：|1007656|++++public+dynamic+Test1Binding+{+get;+set;+}
++++public+TestDTO+Test1
++++{
++++++++get+{+return+(TestDTO)Test1Binding;+}
++++++++set+{+SetBinding(nameof(Test1Binding),+value);+}
++++}|code-block|syntax|javascript|1007657|然后让所有绑定和修改都转到Test1Binding，不管TestDTO有多复杂，它都会自动通知PropertyChange和CollectionChanged。|1007658|它还可以处理依赖项。|1007659|++++[DependsOn("Test1Binding.TestString")]
++++public+string+Test2
++++{
++++++++get+{+return+Test1Binding.TestString;+}
++++}|1007660|请给我一些建议。|1007661|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/CaulyKan/NoMorePropertyChanged^0|0|8|U|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

I'm writing a library that deals with INotifyPropertyChanged, and the main idea is using a dynamic proxy to notify changes.

the repo is here: <a href="https://github.com/CaulyKan/NoMorePropertyChanged" rel="nofollow noreferrer">CaulyKan/NoMorePropertyChanged</a>

with this library, you can write:

<pre><code> public dynamic Test1Binding { get; set; }
 public TestDTO Test1
 {
 get { return (TestDTO)Test1Binding; }
 set { SetBinding(nameof(Test1Binding), value); }
 }
</code></pre>

Then make all bindings and modifications go to Test1Binding, which will notify PropertyChange and CollectionChanged automatically no matter how complex TestDTO is.

it can also handle dependencies.

<pre><code> [DependsOn("Test1Binding.TestString")]
 public string Test2
 {
 get { return Test1Binding.TestString; }
 }
</code></pre>

Please give me some suggestions.

blocks|key|2478381|text|是2022年。现在有了一个正式的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2478382|使用Microsoft工具包中的MVVM源发生器。|offset|length|2478383|这|2478384|[ObservableProperty]
private+string?+name;|code-block|syntax|javascript|2478385|将产生：|2478386|private+string?+name;

public+string?+Name
{
++++get+=>+name;
++++set
++++{
++++++++if+(!EqualityComparer<string?>.Default.Equals(name,+value))
++++++++{
++++++++++++OnNameChanging(value);
++++++++++++OnPropertyChanging();
++++++++++++name+=+value;
++++++++++++OnNameChanged(value);
++++++++++++OnPropertyChanged();
++++++++}
++++}
}

//+Property+changing+/+changed+listener
partial+void+OnNameChanging(string?+value);
partial+void+OnNameChanged(string?+value);

protected+void+OnPropertyChanging([CallerMemberName]+string?+propertyName+=+null)
{
++++PropertyChanging?.Invoke(this,+new+PropertyChangingEventArgs(propertyName));
}

protected+void+OnPropertyChanged([CallerMemberName]+string?+propertyName+=+null)
{
++++PropertyChanged?.Invoke(this,+new+PropertyChangedEventArgs(propertyName));
}|2478387|它支持.NET标准2.0和.NET+>=+5.0。|2478388|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/overview^0|0|G|8|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

It's 2022. Now there's an official solution.
Use the <a href="https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/overview" rel="nofollow noreferrer">MVVM source generators</a> in Microsoft MVVM Toolkit.
This
<pre class="lang-cs prettyprint-override"><code>[ObservableProperty]
private string? name;
</code></pre>
will generate:
<pre class="lang-cs prettyprint-override"><code>private string? name;

public string? Name
{
 get =&gt; name;
 set
 {
 if (!EqualityComparer&lt;string?&gt;.Default.Equals(name, value))
 {
 OnNameChanging(value);
 OnPropertyChanging();
 name = value;
 OnNameChanged(value);
 OnPropertyChanged();
 }
 }
}

// Property changing / changed listener
partial void OnNameChanging(string? value);
partial void OnNameChanged(string? value);

protected void OnPropertyChanging([CallerMemberName] string? propertyName = null)
{
 PropertyChanging?.Invoke(this, new PropertyChangingEventArgs(propertyName));
}

protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
{
 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
</code></pre>
It supports .NET standard 2.0 and .NET &gt;= 5.0.

Microsoft should have implemented something snappy for <code>INotifyPropertyChanged</code>, like in the automatic properties, just specify <code>{get; set; notify;}</code>
I think it makes a lot of sense to do it. Or are there any complications to do it? 

Can we ourselves implement something like 'notify' in our properties. Is there a graceful solution for implementing <code>INotifyPropertyChanged</code> in your class or the only way to do it is by raising the <code>PropertyChanged</code> event in each property.

If not can we write something to auto-generate the piece of code to raise <code>PropertyChanged</code> event?

Implementing INotifyPropertyChanged - does a better way exist?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

微软应该为INotifyPropertyChanged实现一些快速的东西，比如在自动属性中，只需指定{get; set; notify;} --我认为这样做很有意义。或者有什么复杂的事情要做吗？我们自己能在属性中实现类似“通知”之类的东西吗？是否有一个在类中实现INotifyPropertyChanged的优雅解决方案...

问实现INotifyPropertyChanged --是否存在更好的方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问实现INotifyPropertyChanged --是否存在更好的方法？EN