blocks|key|1322533|text|当然，您可以使用反射。下面是从给定类型获取属性的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1322534|var+info+=+typeof(SomeType).GetProperties();|code-block|syntax|javascript|1322535|如果你能提供更多关于属性比较的信息，我们可以得到一个基本的差分算法。intstance的这段代码在名称上会有所不同|1322536|public+bool+AreDifferent(Type+t1,+Type+t2)+{
++var+list1+=+t1.GetProperties().OrderBy(x+=>+x.Name).Select(x+=>+x.Name);
++var+list2+=+t2.GetProperties().OrderBy(x+=>+x.Name).Select(x+=>+x.Name);
++return+list1.SequenceEqual(list2);
}|1322537|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|$]]

Sure you can with reflection. Here is the code to grab the properties off of a given type.

<pre><code>var info = typeof(SomeType).GetProperties();
</code></pre>

If you can give more info on what you're comparing about the properties we can get together a basic diffing algorithmn. This code for intstance will diff on names

<pre><code>public bool AreDifferent(Type t1, Type t2) {
 var list1 = t1.GetProperties().OrderBy(x =&gt; x.Name).Select(x =&gt; x.Name);
 var list2 = t2.GetProperties().OrderBy(x =&gt; x.Name).Select(x =&gt; x.Name);
 return list1.SequenceEqual(list2);
}
</code></pre>

blocks|key|1537868|text|是。使用Reflection。使用反射，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1537869|//given+object+of+some+type
object+myObjectFromSomewhere;
Type+myObjOriginalType+=+myObjectFromSomewhere.GetType();
PropertyInfo[]+myProps+=+myObjOriginalType.GetProperties();|code-block|syntax|javascript|1537870|然后，您可以使用生成的PropertyInfo类来比较各种情况。|1537871|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.reflection.propertyinfo.aspx^0|4|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Yes. Use <a href="http://msdn.microsoft.com/en-us/library/system.reflection.propertyinfo.aspx" rel="noreferrer">Reflection</a>. With Reflection, you can do things like:

<pre><code>//given object of some type
object myObjectFromSomewhere;
Type myObjOriginalType = myObjectFromSomewhere.GetType();
PropertyInfo[] myProps = myObjOriginalType.GetProperties();
</code></pre>

And then you can use the resulting PropertyInfo classes to compare all manner of things.

blocks|key|1322599|text|Type.GetProperties将列出给定类型的每个属性。然后使用PropertyInfo.GetValue检查这些值。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1322600|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.type.getproperties.aspx|1|http://msdn.microsoft.com/en-us/library/b05d59ty.aspx^0|0|I|0|Z|L|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]]]]

<a href="http://msdn.microsoft.com/en-us/library/system.type.getproperties.aspx" rel="nofollow noreferrer">Type.GetProperties</a> will list each of the properties of a given type. Then use <a href="http://msdn.microsoft.com/en-us/library/b05d59ty.aspx" rel="nofollow noreferrer">PropertyInfo.GetValue</a> to check the values.

blocks|key|1537965|text|我知道这可能有点夸大其词，但下面是我的ObjectComparer类，我将其用于此目的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1537966|///+<summary>
///+Utility+class+for+comparing+objects.
///+</summary>
public+static+class+ObjectComparer
{
++++///+<summary>
++++///+Compares+the+public+properties+of+any+2+objects+and+determines+if+the+properties+of+each
++++///+all+contain+the+same+value.
++++///+<para>+
++++///+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++///+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++///+completed+on+COMMON+properties.
++++///+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++///+both+objects+will+be+cast+to+Foo+for+comparison)
++++///+</para>
++++///+</summary>
++++///+<typeparam+name="T">Any+class+with+public+properties.</typeparam>
++++///+<param+name="object1">Object+to+compare+to+object2.</param>
++++///+<param+name="object2">Object+to+compare+to+object1.</param>
++++///+<param+name="propertyInfoList">A+List+of+<see+cref="PropertyInfo"/>+objects+that+contain+data+on+the+properties
++++///+from+object1+that+are+not+equal+to+the+corresponding+properties+of+object2.</param>
++++///+<returns>A+boolean+value+indicating+whether+or+not+the+properties+of+each+object+match.</returns>
++++public+static+bool+GetDifferentProperties<T>+(+T+object1+,+T+object2+,+out+List<PropertyInfo>+propertyInfoList+)
++++++++where+T+:+class
++++{
++++++++return+GetDifferentProperties<T>(+object1+,+object2+,+null+,+out+propertyInfoList+);
++++}

++++///+<summary>
++++///+Compares+the+public+properties+of+any+2+objects+and+determines+if+the+properties+of+each
++++///+all+contain+the+same+value.
++++///+<para>+
++++///+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++///+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++///+completed+on+COMMON+properties.
++++///+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++///+both+objects+will+be+cast+to+Foo+for+comparison)
++++///+</para>
++++///+</summary>
++++///+<typeparam+name="T">Any+class+with+public+properties.</typeparam>
++++///+<param+name="object1">Object+to+compare+to+object2.</param>
++++///+<param+name="object2">Object+to+compare+to+object1.</param>
++++///+<param+name="ignoredProperties">A+list+of+<see+cref="PropertyInfo"/>+objects
++++///+to+ignore+when+completing+the+comparison.</param>
++++///+<param+name="propertyInfoList">A+List+of+<see+cref="PropertyInfo"/>+objects+that+contain+data+on+the+properties
++++///+from+object1+that+are+not+equal+to+the+corresponding+properties+of+object2.</param>
++++///+<returns>A+boolean+value+indicating+whether+or+not+the+properties+of+each+object+match.</returns>
++++public+static+bool+GetDifferentProperties<T>+(+T+object1+,+T+object2+,+List<PropertyInfo>+ignoredProperties+,+out+List<PropertyInfo>+propertyInfoList+)
++++++++where+T+:+class
++++{
++++++++propertyInfoList+=+new+List<PropertyInfo>();

++++++++//+If+either+object+is+null,+we+can't+compare+anything
++++++++if+(+object1+==+null+%7C%7C+object2+==+null+)
++++++++{
++++++++++++return+false;
++++++++}

++++++++Type+object1Type+=+object1.GetType();
++++++++Type+object2Type+=+object2.GetType();

++++++++//+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++++++//+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++++++//+completed+on+COMMON+properties.
++++++++//+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++++++//+both+objects+will+be+cast+to+Foo+for+comparison)
++++++++if+(+object1Type+!=+object2Type+)
++++++++{
++++++++++++object1Type+=+typeof+(+T+);
++++++++++++object2Type+=+typeof+(+T+);
++++++++}

++++++++//+Remove+any+properties+to+be+ignored
++++++++List<PropertyInfo>+comparisonProps+=
++++++++++++RemoveProperties(+object1Type.GetProperties()+,+ignoredProperties+);

++++++++foreach+(+PropertyInfo+object1Prop+in+comparisonProps+)
++++++++{
++++++++++++Type+propertyType+=+null;
++++++++++++object+object1PropValue+=+null;
++++++++++++object+object2PropValue+=+null;

++++++++++++//+Rule+out+an+attempt+to+check+against+a+property+which+requires
++++++++++++//+an+index,+such+as+one+accessed+via+this[]
++++++++++++if+(+object1Prop.GetIndexParameters().GetLength(+0+)+==+0+)
++++++++++++{
++++++++++++++++//+Get+the+value+of+each+property
++++++++++++++++object1PropValue+=+object1Prop.GetValue(+object1+,+null+);
++++++++++++++++object2PropValue+=+object2Type.GetProperty(+object1Prop.Name+).GetValue(+object2+,+null+);

++++++++++++++++//+As+we+are+comparing+2+objects+of+the+same+type+we+know
++++++++++++++++//+that+they+both+have+the+same+properties,+so+grab+the
++++++++++++++++//+first+non-null+value
++++++++++++++++if+(+object1PropValue+!=+null+)
++++++++++++++++++++propertyType+=+object1PropValue.GetType().GetInterface(+"IComparable"+);

++++++++++++++++if+(+propertyType+==+null+)
++++++++++++++++++++if+(+object2PropValue+!=+null+)
++++++++++++++++++++++++propertyType+=+object2PropValue.GetType().GetInterface(+"IComparable"+);
++++++++++++}

++++++++++++//+If+both+objects+have+null+values+or+were+indexed+properties,+don't+continue
++++++++++++if+(+propertyType+!=+null+)
++++++++++++{
++++++++++++++++//+If+one+property+value+is+null+and+the+other+is+not+null,+
++++++++++++++++//+they+aren't+equal;+this+is+done+here+as+a+native+CompareTo
++++++++++++++++//+won't+work+with+a+null+value+as+the+target
++++++++++++++++if+(+object1PropValue+==+null+%7C%7C+object2PropValue+==+null+)
++++++++++++++++{
++++++++++++++++++++propertyInfoList.Add(+object1Prop+);
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++//+Use+the+native+CompareTo+method
++++++++++++++++++++MethodInfo+nativeCompare+=+propertyType.GetMethod(+"CompareTo"+);

++++++++++++++++++++//+Sanity+Check:
++++++++++++++++++++//+If+we+don't+have+a+native+CompareTo+OR+both+values+are+null,+we+can't+compare;
++++++++++++++++++++//+hence,+we+can't+confirm+the+values+differ...+just+go+to+the+next+property
++++++++++++++++++++if+(+nativeCompare+!=+null+)
++++++++++++++++++++{
++++++++++++++++++++++++//+Return+the+native+CompareTo+result
++++++++++++++++++++++++bool+equal+=+(+0+==+(int)+(+nativeCompare.Invoke(+object1PropValue+,+new+object[]+{object2PropValue}+)+)+);

++++++++++++++++++++++++if+(+!equal+)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++propertyInfoList.Add(+object1Prop+);
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+propertyInfoList.Count+==+0;
++++}

++++///+<summary>
++++///+Compares+the+public+properties+of+any+2+objects+and+determines+if+the+properties+of+each
++++///+all+contain+the+same+value.
++++///+<para>+
++++///+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++///+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++///+completed+on+COMMON+properties.
++++///+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++///+both+objects+will+be+cast+to+Foo+for+comparison)
++++///+</para>
++++///+</summary>
++++///+<typeparam+name="T">Any+class+with+public+properties.</typeparam>
++++///+<param+name="object1">Object+to+compare+to+object2.</param>
++++///+<param+name="object2">Object+to+compare+to+object1.</param>
++++///+<returns>A+boolean+value+indicating+whether+or+not+the+properties+of+each+object+match.</returns>
++++public+static+bool+HasSamePropertyValues<T>+(+T+object1+,+T+object2+)
++++++++where+T+:+class
++++{
++++++++return+HasSamePropertyValues<T>(+object1+,+object2+,+null+);
++++}

++++///+<summary>
++++///+Compares+the+public+properties+of+any+2+objects+and+determines+if+the+properties+of+each
++++///+all+contain+the+same+value.
++++///+<para>+
++++///+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++///+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++///+completed+on+COMMON+properties.
++++///+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++///+both+objects+will+be+cast+to+Foo+for+comparison)
++++///+</para>
++++///+</summary>
++++///+<typeparam+name="T">Any+class+with+public+properties.</typeparam>
++++///+<param+name="object1">Object+to+compare+to+object2.</param>
++++///+<param+name="object2">Object+to+compare+to+object1.</param>
++++///+<param+name="ignoredProperties">A+list+of+<see+cref="PropertyInfo"/>+objects
++++///+to+ignore+when+completing+the+comparison.</param>
++++///+<returns>A+boolean+value+indicating+whether+or+not+the+properties+of+each+object+match.</returns>
++++public+static+bool+HasSamePropertyValues<T>+(+T+object1+,+T+object2+,+List<PropertyInfo>+ignoredProperties+)
++++++++where+T+:+class
++++{

++++++++//+If+either+object+is+null,+we+can't+compare+anything
++++++++if+(+object1+==+null+%7C%7C+object2+==+null+)
++++++++{
++++++++++++return+false;
++++++++}

++++++++Type+object1Type+=+object1.GetType();
++++++++Type+object2Type+=+object2.GetType();

++++++++//+In+cases+where+object1+and+object2+are+of+different+Types+(both+being+derived+from+Type+T)+
++++++++//+we+will+cast+both+objects+down+to+the+base+Type+T+to+ensure+the+property+comparison+is+only+
++++++++//+completed+on+COMMON+properties.
++++++++//+(ex.+Type+T+is+Foo,+object1+is+GoodFoo+and+object2+is+BadFoo+--+both+being+inherited+from+Foo+--
++++++++//+both+objects+will+be+cast+to+Foo+for+comparison)
++++++++if+(+object1Type+!=+object2Type+)
++++++++{
++++++++++++object1Type+=+typeof+(+T+);
++++++++++++object2Type+=+typeof+(+T+);
++++++++}

++++++++//+Remove+any+properties+to+be+ignored
++++++++List<PropertyInfo>+comparisonProps+=
++++++++++++RemoveProperties(+object1Type.GetProperties()+,+ignoredProperties+);

++++++++foreach+(+PropertyInfo+object1Prop+in+comparisonProps+)
++++++++{
++++++++++++Type+propertyType+=+null;
++++++++++++object+object1PropValue+=+null;
++++++++++++object+object2PropValue+=+null;

++++++++++++//+Rule+out+an+attempt+to+check+against+a+property+which+requires
++++++++++++//+an+index,+such+as+one+accessed+via+this[]
++++++++++++if+(+object1Prop.GetIndexParameters().GetLength(+0+)+==+0+)
++++++++++++{
++++++++++++++++//+Get+the+value+of+each+property
++++++++++++++++object1PropValue+=+object1Prop.GetValue(+object1+,+null+);
++++++++++++++++object2PropValue+=+object2Type.GetProperty(+object1Prop.Name+).GetValue(+object2+,+null+);

++++++++++++++++//+As+we+are+comparing+2+objects+of+the+same+type+we+know
++++++++++++++++//+that+they+both+have+the+same+properties,+so+grab+the
++++++++++++++++//+first+non-null+value
++++++++++++++++if+(+object1PropValue+!=+null+)
++++++++++++++++++++propertyType+=+object1PropValue.GetType().GetInterface(+"IComparable"+);

++++++++++++++++if+(+propertyType+==+null+)
++++++++++++++++++++if+(+object2PropValue+!=+null+)
++++++++++++++++++++++++propertyType+=+object2PropValue.GetType().GetInterface(+"IComparable"+);
++++++++++++}

++++++++++++//+If+both+objects+have+null+values+or+were+indexed+properties,+don't+continue
++++++++++++if+(+propertyType+!=+null+)
++++++++++++{
++++++++++++++++//+If+one+property+value+is+null+and+the+other+is+not+null,+
++++++++++++++++//+they+aren't+equal;+this+is+done+here+as+a+native+CompareTo
++++++++++++++++//+won't+work+with+a+null+value+as+the+target
++++++++++++++++if+(+object1PropValue+==+null+%7C%7C+object2PropValue+==+null+)
++++++++++++++++{
++++++++++++++++++++return+false;
++++++++++++++++}

++++++++++++++++//+Use+the+native+CompareTo+method
++++++++++++++++MethodInfo+nativeCompare+=+propertyType.GetMethod(+"CompareTo"+);

++++++++++++++++//+Sanity+Check:
++++++++++++++++//+If+we+don't+have+a+native+CompareTo+OR+both+values+are+null,+we+can't+compare;
++++++++++++++++//+hence,+we+can't+confirm+the+values+differ...+just+go+to+the+next+property
++++++++++++++++if+(+nativeCompare+!=+null+)
++++++++++++++++{
++++++++++++++++++++//+Return+the+native+CompareTo+result
++++++++++++++++++++bool+equal+=+(+0+==+(int)+(+nativeCompare.Invoke(+object1PropValue+,+new+object[]+{object2PropValue}+)+)+);

++++++++++++++++++++if+(+!equal+)
++++++++++++++++++++{
++++++++++++++++++++++++return+false;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+true;
++++}

++++///+<summary>
++++///+Removes+any+<see+cref="PropertyInfo"/>+object+in+the+supplied+List+of+
++++///+properties+from+the+supplied+Array+of+properties.
++++///+</summary>
++++///+<param+name="allProperties">Array+containing+master+list+of+
++++///+<see+cref="PropertyInfo"/>+objects.</param>
++++///+<param+name="propertiesToRemove">List+of+<see+cref="PropertyInfo"/>+objects+to
++++///+remove+from+the+supplied+array+of+properties.</param>
++++///+<returns>A+List+of+<see+cref="PropertyInfo"/>+objects.</returns>
++++private+static+List<PropertyInfo>+RemoveProperties+(
++++++++IEnumerable<PropertyInfo>+allProperties+,+IEnumerable<PropertyInfo>+propertiesToRemove+)
++++{
++++++++List<PropertyInfo>+innerPropertyList+=+new+List<PropertyInfo>();

++++++++//+Add+all+properties+to+a+list+for+easy+manipulation
++++++++foreach+(+PropertyInfo+prop+in+allProperties+)
++++++++{
++++++++++++innerPropertyList.Add(+prop+);
++++++++}

++++++++//+Sanity+check
++++++++if+(+propertiesToRemove+!=+null+)
++++++++{
++++++++++++//+Iterate+through+the+properties+to+ignore+and+remove+them+from+the+list+of+
++++++++++++//+all+properties,+if+they+exist
++++++++++++foreach+(+PropertyInfo+ignoredProp+in+propertiesToRemove+)
++++++++++++{
++++++++++++++++if+(+innerPropertyList.Contains(+ignoredProp+)+)
++++++++++++++++{
++++++++++++++++++++innerPropertyList.Remove(+ignoredProp+);
++++++++++++++++}
++++++++++++}
++++++++}

++++++++return+innerPropertyList;
++++}
}|code-block|syntax|javascript|1537967|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 know this is probably overkill, but here's my ObjectComparer class I use for this very purpose:

<pre><code>/// &lt;summary&gt;
/// Utility class for comparing objects.
/// &lt;/summary&gt;
public static class ObjectComparer
{
 /// &lt;summary&gt;
 /// Compares the public properties of any 2 objects and determines if the properties of each
 /// all contain the same value.
 /// &lt;para&gt; 
 /// In cases where object1 and object2 are of different Types (both being derived from Type T) 
 /// we will cast both objects down to the base Type T to ensure the property comparison is only 
 /// completed on COMMON properties.
 /// (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 /// both objects will be cast to Foo for comparison)
 /// &lt;/para&gt;
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Any class with public properties.&lt;/typeparam&gt;
 /// &lt;param name="object1"&gt;Object to compare to object2.&lt;/param&gt;
 /// &lt;param name="object2"&gt;Object to compare to object1.&lt;/param&gt;
 /// &lt;param name="propertyInfoList"&gt;A List of &lt;see cref="PropertyInfo"/&gt; objects that contain data on the properties
 /// from object1 that are not equal to the corresponding properties of object2.&lt;/param&gt;
 /// &lt;returns&gt;A boolean value indicating whether or not the properties of each object match.&lt;/returns&gt;
 public static bool GetDifferentProperties&lt;T&gt; ( T object1 , T object2 , out List&lt;PropertyInfo&gt; propertyInfoList )
 where T : class
 {
 return GetDifferentProperties&lt;T&gt;( object1 , object2 , null , out propertyInfoList );
 }

 /// &lt;summary&gt;
 /// Compares the public properties of any 2 objects and determines if the properties of each
 /// all contain the same value.
 /// &lt;para&gt; 
 /// In cases where object1 and object2 are of different Types (both being derived from Type T) 
 /// we will cast both objects down to the base Type T to ensure the property comparison is only 
 /// completed on COMMON properties.
 /// (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 /// both objects will be cast to Foo for comparison)
 /// &lt;/para&gt;
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Any class with public properties.&lt;/typeparam&gt;
 /// &lt;param name="object1"&gt;Object to compare to object2.&lt;/param&gt;
 /// &lt;param name="object2"&gt;Object to compare to object1.&lt;/param&gt;
 /// &lt;param name="ignoredProperties"&gt;A list of &lt;see cref="PropertyInfo"/&gt; objects
 /// to ignore when completing the comparison.&lt;/param&gt;
 /// &lt;param name="propertyInfoList"&gt;A List of &lt;see cref="PropertyInfo"/&gt; objects that contain data on the properties
 /// from object1 that are not equal to the corresponding properties of object2.&lt;/param&gt;
 /// &lt;returns&gt;A boolean value indicating whether or not the properties of each object match.&lt;/returns&gt;
 public static bool GetDifferentProperties&lt;T&gt; ( T object1 , T object2 , List&lt;PropertyInfo&gt; ignoredProperties , out List&lt;PropertyInfo&gt; propertyInfoList )
 where T : class
 {
 propertyInfoList = new List&lt;PropertyInfo&gt;();

 // If either object is null, we can't compare anything
 if ( object1 == null || object2 == null )
 {
 return false;
 }

 Type object1Type = object1.GetType();
 Type object2Type = object2.GetType();

 // In cases where object1 and object2 are of different Types (both being derived from Type T) 
 // we will cast both objects down to the base Type T to ensure the property comparison is only 
 // completed on COMMON properties.
 // (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 // both objects will be cast to Foo for comparison)
 if ( object1Type != object2Type )
 {
 object1Type = typeof ( T );
 object2Type = typeof ( T );
 }

 // Remove any properties to be ignored
 List&lt;PropertyInfo&gt; comparisonProps =
 RemoveProperties( object1Type.GetProperties() , ignoredProperties );

 foreach ( PropertyInfo object1Prop in comparisonProps )
 {
 Type propertyType = null;
 object object1PropValue = null;
 object object2PropValue = null;

 // Rule out an attempt to check against a property which requires
 // an index, such as one accessed via this[]
 if ( object1Prop.GetIndexParameters().GetLength( 0 ) == 0 )
 {
 // Get the value of each property
 object1PropValue = object1Prop.GetValue( object1 , null );
 object2PropValue = object2Type.GetProperty( object1Prop.Name ).GetValue( object2 , null );

 // As we are comparing 2 objects of the same type we know
 // that they both have the same properties, so grab the
 // first non-null value
 if ( object1PropValue != null )
 propertyType = object1PropValue.GetType().GetInterface( "IComparable" );

 if ( propertyType == null )
 if ( object2PropValue != null )
 propertyType = object2PropValue.GetType().GetInterface( "IComparable" );
 }

 // If both objects have null values or were indexed properties, don't continue
 if ( propertyType != null )
 {
 // If one property value is null and the other is not null, 
 // they aren't equal; this is done here as a native CompareTo
 // won't work with a null value as the target
 if ( object1PropValue == null || object2PropValue == null )
 {
 propertyInfoList.Add( object1Prop );
 }
 else
 {
 // Use the native CompareTo method
 MethodInfo nativeCompare = propertyType.GetMethod( "CompareTo" );

 // Sanity Check:
 // If we don't have a native CompareTo OR both values are null, we can't compare;
 // hence, we can't confirm the values differ... just go to the next property
 if ( nativeCompare != null )
 {
 // Return the native CompareTo result
 bool equal = ( 0 == (int) ( nativeCompare.Invoke( object1PropValue , new object[] {object2PropValue} ) ) );

 if ( !equal )
 {
 propertyInfoList.Add( object1Prop );
 }
 }
 }
 }
 }
 return propertyInfoList.Count == 0;
 }

 /// &lt;summary&gt;
 /// Compares the public properties of any 2 objects and determines if the properties of each
 /// all contain the same value.
 /// &lt;para&gt; 
 /// In cases where object1 and object2 are of different Types (both being derived from Type T) 
 /// we will cast both objects down to the base Type T to ensure the property comparison is only 
 /// completed on COMMON properties.
 /// (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 /// both objects will be cast to Foo for comparison)
 /// &lt;/para&gt;
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Any class with public properties.&lt;/typeparam&gt;
 /// &lt;param name="object1"&gt;Object to compare to object2.&lt;/param&gt;
 /// &lt;param name="object2"&gt;Object to compare to object1.&lt;/param&gt;
 /// &lt;returns&gt;A boolean value indicating whether or not the properties of each object match.&lt;/returns&gt;
 public static bool HasSamePropertyValues&lt;T&gt; ( T object1 , T object2 )
 where T : class
 {
 return HasSamePropertyValues&lt;T&gt;( object1 , object2 , null );
 }

 /// &lt;summary&gt;
 /// Compares the public properties of any 2 objects and determines if the properties of each
 /// all contain the same value.
 /// &lt;para&gt; 
 /// In cases where object1 and object2 are of different Types (both being derived from Type T) 
 /// we will cast both objects down to the base Type T to ensure the property comparison is only 
 /// completed on COMMON properties.
 /// (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 /// both objects will be cast to Foo for comparison)
 /// &lt;/para&gt;
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Any class with public properties.&lt;/typeparam&gt;
 /// &lt;param name="object1"&gt;Object to compare to object2.&lt;/param&gt;
 /// &lt;param name="object2"&gt;Object to compare to object1.&lt;/param&gt;
 /// &lt;param name="ignoredProperties"&gt;A list of &lt;see cref="PropertyInfo"/&gt; objects
 /// to ignore when completing the comparison.&lt;/param&gt;
 /// &lt;returns&gt;A boolean value indicating whether or not the properties of each object match.&lt;/returns&gt;
 public static bool HasSamePropertyValues&lt;T&gt; ( T object1 , T object2 , List&lt;PropertyInfo&gt; ignoredProperties )
 where T : class
 {

 // If either object is null, we can't compare anything
 if ( object1 == null || object2 == null )
 {
 return false;
 }

 Type object1Type = object1.GetType();
 Type object2Type = object2.GetType();

 // In cases where object1 and object2 are of different Types (both being derived from Type T) 
 // we will cast both objects down to the base Type T to ensure the property comparison is only 
 // completed on COMMON properties.
 // (ex. Type T is Foo, object1 is GoodFoo and object2 is BadFoo -- both being inherited from Foo --
 // both objects will be cast to Foo for comparison)
 if ( object1Type != object2Type )
 {
 object1Type = typeof ( T );
 object2Type = typeof ( T );
 }

 // Remove any properties to be ignored
 List&lt;PropertyInfo&gt; comparisonProps =
 RemoveProperties( object1Type.GetProperties() , ignoredProperties );

 foreach ( PropertyInfo object1Prop in comparisonProps )
 {
 Type propertyType = null;
 object object1PropValue = null;
 object object2PropValue = null;

 // Rule out an attempt to check against a property which requires
 // an index, such as one accessed via this[]
 if ( object1Prop.GetIndexParameters().GetLength( 0 ) == 0 )
 {
 // Get the value of each property
 object1PropValue = object1Prop.GetValue( object1 , null );
 object2PropValue = object2Type.GetProperty( object1Prop.Name ).GetValue( object2 , null );

 // As we are comparing 2 objects of the same type we know
 // that they both have the same properties, so grab the
 // first non-null value
 if ( object1PropValue != null )
 propertyType = object1PropValue.GetType().GetInterface( "IComparable" );

 if ( propertyType == null )
 if ( object2PropValue != null )
 propertyType = object2PropValue.GetType().GetInterface( "IComparable" );
 }

 // If both objects have null values or were indexed properties, don't continue
 if ( propertyType != null )
 {
 // If one property value is null and the other is not null, 
 // they aren't equal; this is done here as a native CompareTo
 // won't work with a null value as the target
 if ( object1PropValue == null || object2PropValue == null )
 {
 return false;
 }

 // Use the native CompareTo method
 MethodInfo nativeCompare = propertyType.GetMethod( "CompareTo" );

 // Sanity Check:
 // If we don't have a native CompareTo OR both values are null, we can't compare;
 // hence, we can't confirm the values differ... just go to the next property
 if ( nativeCompare != null )
 {
 // Return the native CompareTo result
 bool equal = ( 0 == (int) ( nativeCompare.Invoke( object1PropValue , new object[] {object2PropValue} ) ) );

 if ( !equal )
 {
 return false;
 }
 }
 }
 }
 return true;
 }

 /// &lt;summary&gt;
 /// Removes any &lt;see cref="PropertyInfo"/&gt; object in the supplied List of 
 /// properties from the supplied Array of properties.
 /// &lt;/summary&gt;
 /// &lt;param name="allProperties"&gt;Array containing master list of 
 /// &lt;see cref="PropertyInfo"/&gt; objects.&lt;/param&gt;
 /// &lt;param name="propertiesToRemove"&gt;List of &lt;see cref="PropertyInfo"/&gt; objects to
 /// remove from the supplied array of properties.&lt;/param&gt;
 /// &lt;returns&gt;A List of &lt;see cref="PropertyInfo"/&gt; objects.&lt;/returns&gt;
 private static List&lt;PropertyInfo&gt; RemoveProperties (
 IEnumerable&lt;PropertyInfo&gt; allProperties , IEnumerable&lt;PropertyInfo&gt; propertiesToRemove )
 {
 List&lt;PropertyInfo&gt; innerPropertyList = new List&lt;PropertyInfo&gt;();

 // Add all properties to a list for easy manipulation
 foreach ( PropertyInfo prop in allProperties )
 {
 innerPropertyList.Add( prop );
 }

 // Sanity check
 if ( propertiesToRemove != null )
 {
 // Iterate through the properties to ignore and remove them from the list of 
 // all properties, if they exist
 foreach ( PropertyInfo ignoredProp in propertiesToRemove )
 {
 if ( innerPropertyList.Contains( ignoredProp ) )
 {
 innerPropertyList.Remove( ignoredProp );
 }
 }
 }

 return innerPropertyList;
 }
}
</code></pre>

blocks|key|1538038|text|是的，使用反射-假设每个属性类型都适当地实现了Equals。另一种方法是递归地对除某些已知类型之外的所有类型使用ReflectiveEquals，但这会变得很棘手。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1538039|public+bool+ReflectiveEquals(object+first,+object+second)
{
++++if+(first+==+null+&&+second+==+null)
++++{
++++++++return+true;
++++}
++++if+(first+==+null+%7C%7C+second+==+null)
++++{
++++++++return+false;
++++}
++++Type+firstType+=+first.GetType();
++++if+(second.GetType()+!=+firstType)
++++{
++++++++return+false;+//+Or+throw+an+exception
++++}
++++//+This+will+only+use+public+properties.+Is+that+enough?
++++foreach+(PropertyInfo+propertyInfo+in+firstType.GetProperties())
++++{
++++++++if+(propertyInfo.CanRead)
++++++++{
++++++++++++object+firstValue+=+propertyInfo.GetValue(first,+null);
++++++++++++object+secondValue+=+propertyInfo.GetValue(second,+null);
++++++++++++if+(!object.Equals(firstValue,+secondValue))
++++++++++++{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|1538040|entityMap^0|N|6|1K|G|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Yes, with reflection - assuming each property type implements <code>Equals</code> appropriately. An alternative would be to use <code>ReflectiveEquals</code> recursively for all but some known types, but that gets tricky.

<pre><code>public bool ReflectiveEquals(object first, object second)
{
 if (first == null &amp;&amp; second == null)
 {
 return true;
 }
 if (first == null || second == null)
 {
 return false;
 }
 Type firstType = first.GetType();
 if (second.GetType() != firstType)
 {
 return false; // Or throw an exception
 }
 // This will only use public properties. Is that enough?
 foreach (PropertyInfo propertyInfo in firstType.GetProperties())
 {
 if (propertyInfo.CanRead)
 {
 object firstValue = propertyInfo.GetValue(first, null);
 object secondValue = propertyInfo.GetValue(second, null);
 if (!object.Equals(firstValue, secondValue))
 {
 return false;
 }
 }
 }
 return true;
}
</code></pre>

blocks|key|1322796|text|真正的问题是:如何得到两个集合的差异？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1322797|我找到的最快的方法是先把集合转换成字典，然后再比较它们。|1322798|static+IEnumerable<T>+DictionaryDiff<K,+T>(Dictionary<K,+T>+d1,+Dictionary<K,+T>+d2)
{
++++return+from+x+in+d1+where+!d2.ContainsKey(x.Key)+select+x.Value;
}|code-block|syntax|javascript|1322799|然后你可以这样做：|1322800|static+public+IEnumerable<PropertyInfo>+PropertyDiff(Type+t1,+Type+t2)
{
++++var+d1+=+t1.GetProperties().ToDictionary(x+=>+x.Name);
++++var+d2+=+t2.GetProperties().ToDictionary(x+=>+x.Name);
++++return+DictionaryDiff(d1,+d2);
}|1322801|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The real problem: How to get the difference of two sets? 

The fastest way I've found is to convert the sets to dictionaries first, then diff 'em. Here's a generic approach:

<pre><code>static IEnumerable&lt;T&gt; DictionaryDiff&lt;K, T&gt;(Dictionary&lt;K, T&gt; d1, Dictionary&lt;K, T&gt; d2)
{
 return from x in d1 where !d2.ContainsKey(x.Key) select x.Value;
}
</code></pre>

Then you can do something like this:

<pre><code>static public IEnumerable&lt;PropertyInfo&gt; PropertyDiff(Type t1, Type t2)
{
 var d1 = t1.GetProperties().ToDictionary(x =&gt; x.Name);
 var d2 = t2.GetProperties().ToDictionary(x =&gt; x.Name);
 return DictionaryDiff(d1, d2);
}
</code></pre>

blocks|key|1322862|text|使用LINQ和反射比较两个相同类型的对象。注意！这基本上是Jon+Skeet的解决方案的重写，但具有更紧凑和现代的语法。它还应该生成稍微更有效的IL。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1322863|它是这样的：|1322864|public+bool+ReflectiveEquals(LocalHdTicket+serverTicket,+LocalHdTicket+localTicket)
++{
+++++if+(serverTicket+==+null+&&+localTicket+==+null)+return+true;
+++++if+(serverTicket+==+null+%7C%7C+localTicket+==+null)+return+false;

+++++var+firstType+=+serverTicket.GetType();
+++++//+Handle+type+mismatch+anyway+you+please:
+++++if(localTicket.GetType()+!=+firstType)+throw+new+Exception("Trying+to+compare+two+different+object+types!");

+++++return+!(from+propertyInfo+in+firstType.GetProperties()+
++++++++++++++where+propertyInfo.CanRead+
++++++++++++++let+serverValue+=+propertyInfo.GetValue(serverTicket,+null)+
++++++++++++++let+localValue+=+propertyInfo.GetValue(localTicket,+null)+
++++++++++++++where+!Equals(serverValue,+localValue)+
++++++++++++++select+serverValue).Any();
++}|code-block|syntax|javascript|1322865|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Comparing two objects of the same type using LINQ and Reflection.
NB! This is basically a rewrite of the solution from Jon Skeet, but with a more compact and modern syntax. It should also generate slightly more effecticve IL.

It goes something like this:

<pre><code>public bool ReflectiveEquals(LocalHdTicket serverTicket, LocalHdTicket localTicket)
 {
 if (serverTicket == null &amp;&amp; localTicket == null) return true;
 if (serverTicket == null || localTicket == null) return false;

 var firstType = serverTicket.GetType();
 // Handle type mismatch anyway you please:
 if(localTicket.GetType() != firstType) throw new Exception("Trying to compare two different object types!");

 return !(from propertyInfo in firstType.GetProperties() 
 where propertyInfo.CanRead 
 let serverValue = propertyInfo.GetValue(serverTicket, null) 
 let localValue = propertyInfo.GetValue(localTicket, null) 
 where !Equals(serverValue, localValue) 
 select serverValue).Any();
 }
</code></pre>

blocks|key|1322911|text|正如许多人提到的递归方法，这是一个函数，您可以将搜索到的名称和属性传递给：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1322912|++++public+static+void+loopAttributes(PropertyInfo+prop,+string+targetAttribute,+object+tempObject)
++++{
++++++++foreach+(PropertyInfo+nestedProp+in+prop.PropertyType.GetProperties())
++++++++{
++++++++++++if(nestedProp.Name+==+targetAttribute)
++++++++++++{
++++++++++++++++//found+the+matching+attribute
++++++++++++}
++++++++++++loopAttributes(nestedProp,+targetAttribute,+prop.GetValue(tempObject);
++++++++}
++++}

//in+the+main+function
foreach+(PropertyInfo+prop+in+rootObject.GetType().GetProperties())
{
++++loopAttributes(prop,+targetAttribute,+rootObject);
}|code-block|syntax|javascript|1322913|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|$]]

As many mentioned the recursive approach, this is the function you can pass the searched name and the property to begin with to:

<pre><code> public static void loopAttributes(PropertyInfo prop, string targetAttribute, object tempObject)
 {
 foreach (PropertyInfo nestedProp in prop.PropertyType.GetProperties())
 {
 if(nestedProp.Name == targetAttribute)
 {
 //found the matching attribute
 }
 loopAttributes(nestedProp, targetAttribute, prop.GetValue(tempObject);
 }
 }

//in the main function
foreach (PropertyInfo prop in rootObject.GetType().GetProperties())
{
 loopAttributes(prop, targetAttribute, rootObject);
}
</code></pre>

blocks|key|1538232|text|Compare+NET+Objects可以帮助您！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1538233|CompareLogic+logic+=+new+CompareLogic();
var+compare+=+logic.Compare(obj1,+obj2);
comparacao.Differences.ForEach(diff+=>+Debug.Write(diff.PropertyName));
//+Or+formatted+summary
Debug.Write(comparacao.DifferencesString);|code-block|syntax|javascript|1538234|entityMap|0|LINK|mutability|MUTABLE|url|https://www.nuget.org/packages/CompareNETObjects/^0|0|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="https://www.nuget.org/packages/CompareNETObjects/" rel="nofollow noreferrer">Compare NET Objects</a> can help you!
<pre><code>CompareLogic logic = new CompareLogic();
var compare = logic.Compare(obj1, obj2);
comparacao.Differences.ForEach(diff =&gt; Debug.Write(diff.PropertyName));
// Or formatted summary
Debug.Write(comparacao.DifferencesString);
</code></pre>

I have two objects of the same type, and I want to loop through the public properties on each of them and alert the user about which properties don't match.

Is it possible to do this without knowing what properties the object contains?

Compare two objects' properties to find differences?

我有两个相同类型的对象，我希望遍历每个对象上的公共属性，并警告用户哪些属性不匹配。有没有可能在不知道对象包含什么属性的情况下执行此操作？

问比较两个对象的属性以找出差异？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问比较两个对象的属性以找出差异？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问比较两个对象的属性以找出差异？
EN