blocks|key|1220730|text|这实际上是一个简单的过程。使用反射，您可以比较对象上的每个字段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1220731|public+static+Boolean+ObjectMatches(Object+x,+Object+y)
{
++++if+(x+==+null+&&+y+==+null)
++++++++return+true;
++++else+if+((x+==+null+&&+y+!=+null)+%7C%7C+(x+!=+null+&&+y+==+null))
++++++++return+false;+++++++

++++Type+tx+=+x.GetType();
++++Type+ty+=+y.GetType();

++++if+(tx+!=+ty)
++++++++return+false;

++++foreach(FieldInfo+field+in+tx.GetFields(BindingFlags.NonPublic+%7C+BindingFlags.Public+%7C+BindingFlags.Instance+%7C+BindingFlags.DeclaredOnly))
++++{
++++++++if+(field.FieldType.IsValueType+&&+(field.GetValue(x).ToString()+!=+field.GetValue(y).ToString()))
++++++++++++return+false;
++++++++else+if+(field.FieldType.IsClass+&&+!ObjectMatches(field.GetValue(x),+field.GetValue(y)))
++++++++++++return+false;+++++++++++++++
++++}

++++return+true;
}|code-block|syntax|javascript|1220732|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|$]]

This is actually a simple process. Using reflection you can compare each field on the object.

<pre><code>public static Boolean ObjectMatches(Object x, Object y)
{
 if (x == null &amp;&amp; y == null)
 return true;
 else if ((x == null &amp;&amp; y != null) || (x != null &amp;&amp; y == null))
 return false; 

 Type tx = x.GetType();
 Type ty = y.GetType();

 if (tx != ty)
 return false;

 foreach(FieldInfo field in tx.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
 {
 if (field.FieldType.IsValueType &amp;&amp; (field.GetValue(x).ToString() != field.GetValue(y).ToString()))
 return false;
 else if (field.FieldType.IsClass &amp;&amp; !ObjectMatches(field.GetValue(x), field.GetValue(y)))
 return false; 
 }

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

blocks|key|1435865|text|使用Jesse建议的Nuget和这段代码，我成功地比较了两个对象，得到了很好的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435866|using+KellermanSoftware.CompareNetObjects;
using+System;

namespace+MyProgram.UnitTestHelper
{
++public+class+ObjectComparer
++{

++++public+static+bool+ObjectsHaveSameValues(object+first,+object+second)
++++{
++++++CompareLogic+cl+=+new+CompareLogic();
++++++ComparisonResult+result+=+cl.Compare(first,+second);

++++++if+(!result.AreEqual)
++++++++Console.WriteLine(result.DifferencesString);

++++++return+result.AreEqual;
++++}
++}
}|code-block|syntax|javascript|1435867|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|$]]

Using the Nuget suggested by Jesse and this code I managed to compare two objects with great results.

<pre><code>using KellermanSoftware.CompareNetObjects;
using System;

namespace MyProgram.UnitTestHelper
{
 public class ObjectComparer
 {

 public static bool ObjectsHaveSameValues(object first, object second)
 {
 CompareLogic cl = new CompareLogic();
 ComparisonResult result = cl.Compare(first, second);

 if (!result.AreEqual)
 Console.WriteLine(result.DifferencesString);

 return result.AreEqual;
 }
 }
}
</code></pre>

blocks|key|1435906|text|这是一个简单的比较器，我们在单元测试中使用它来断言两个对象具有相同的属性。它是在各种文章中找到的想法的混合体，并处理循环引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435907|public+static+class+TestHelper
{
++++public+static+void+AssertAreEqual(Object+expected,+Object+actual,+String+name)
++++{
++++++++//+Start+a+new+check+with+an+empty+list+of+actual+objects+checked
++++++++//+The+list+of+actual+objects+checked+is+used+to+ensure+that+circular+references+don't+result+in+infinite+recursion
++++++++List<Object>+actualObjectsChecked+=+new+List<Object>();
++++++++AssertAreEqual(expected,+actual,+name,+actualObjectsChecked);
++++}

++++private+static+void+AssertAreEqual(Object+expected,+Object+actual,+String+name,+List<Object>+actualObjectsChecked)
++++{
++++++++//+Just+return+if+already+checked+the+actual+object
++++++++if+(actualObjectsChecked.Contains(actual))
++++++++{
++++++++++++return;
++++++++}

++++++++actualObjectsChecked.Add(actual);

++++++++//+If+both+expected+and+actual+are+null,+they+are+considered+equal
++++++++if+(expected+==+null+&&+actual+==+null)
++++++++{
++++++++++++return;
++++++++}

++++++++if+(expected+==+null+&&+actual+!=+null)
++++++++{
++++++++++++Assert.Fail(String.Format("The+actual+value+of+{0}+was+not+null+when+null+was+expected.",+name));
++++++++}

++++++++if+(expected+!=+null+&&+actual+==+null)
++++++++{
++++++++++++Assert.Fail(String.Format("The+actual+value+of+{0}+was+null+when+an+instance+was+expected.",+name));
++++++++}

++++++++//+Get+/+check+type+info
++++++++//+Note:+GetType+always+returns+instantiated+(i.e.+most+derived)+type
++++++++Type+expectedType+=+expected.GetType();
++++++++Type+actualType+=+actual.GetType();
++++++++if+(expectedType+!=+actualType)
++++++++{
++++++++++++Assert.Fail(String.Format("The+actual+type+of+{0}+was+not+the+same+as+the+expected+type.",+name));
++++++++}

++++++++//+If+expected+is+a+Primitive,+Value,+or+IEquatable+type,+assume+Equals+is+sufficient+to+check
++++++++//+Note:+Every+IEquatable+type+should+have+also+overridden+Object.Equals
++++++++if+(expectedType.IsPrimitive+%7C%7C+expectedType.IsValueType+%7C%7C+expectedType.IsIEquatable())
++++++++{
++++++++++++Assert.IsTrue(expected.Equals(actual),+"The+actual+{0}+is+not+equal+to+the+expected.",+name);
++++++++++++return;
++++++++}

++++++++//+If+expected+is+an+IEnumerable+type,+assume+comparing+enumerated+items+is+sufficient+to+check
++++++++IEnumerable<Object>+expectedEnumerable+=+expected+as+IEnumerable<Object>;
++++++++IEnumerable<Object>+actualEnumerable+=+actual+as+IEnumerable<Object>;
++++++++if+((expectedEnumerable+!=+null)+&&+(actualEnumerable+!=+null))
++++++++{
++++++++++++Int32+actualEnumerableCount+=+actualEnumerable.Count();
++++++++++++Int32+expectedEnumerableCount+=+expectedEnumerable.Count();

++++++++++++//+Check+size+first
++++++++++++if+(actualEnumerableCount+!=+expectedEnumerableCount)
++++++++++++{
++++++++++++++++Assert.Fail(String.Format("The+actual+number+of+enumerable+items+in+{0}+did+not+match+the+expected+number.",+name));
++++++++++++}

++++++++++++//+Check+items+in+order,+assuming+order+is+the+same
++++++++++++for+(int+i+=+0;+i+<+actualEnumerableCount;+%2B%2Bi)
++++++++++++{
++++++++++++++++AssertAreEqual(expectedEnumerable.ElementAt(i),+actualEnumerable.ElementAt(i),+String.Format("{0}[{1}]",+name,+i),+actualObjectsChecked);
++++++++++++}

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

++++++++//+If+expected+is+not+a+Primitive,+Value,+IEquatable,+or+Ienumerable+type,+assume+comparing+properties+is+sufficient+to+check
++++++++//+Iterate+through+properties
++++++++foreach+(PropertyInfo+propertyInfo+in+actualType.GetProperties(BindingFlags.Instance+%7C+BindingFlags.Public))
++++++++{
++++++++++++//+Skip+properties+that+can't+be+read+or+require+parameters
++++++++++++if+((!propertyInfo.CanRead)+%7C%7C+(propertyInfo.GetIndexParameters().Length+!=+0))
++++++++++++{
++++++++++++++++continue;
++++++++++++}

++++++++++++//+Get+properties+from+both
++++++++++++Object+actualProperty+=+propertyInfo.GetValue(actual,+null);
++++++++++++Object+expectedProperty+=+propertyInfo.GetValue(expected,+null);

++++++++++++AssertAreEqual(expectedProperty,+actualProperty,+String.Format("{0}.{1}",+name,+propertyInfo.Name),+actualObjectsChecked);
++++++++}
++++}

++++public+static+Boolean+IsIEquatable(this+Type+type)
++++{
++++++++return+type.GetInterfaces().Any(x+=>+x.IsGenericType+&&+x.GetGenericTypeDefinition()+==+typeof(IEquatable<>));
++++}

}|code-block|syntax|javascript|1435908|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|$]]

Here is a simple comparer that we've used with unit testing to assert that two objects have equal properties. It's a mash-up of ideas found in various articles, and handles circular references.

<pre><code>public static class TestHelper
{
 public static void AssertAreEqual(Object expected, Object actual, String name)
 {
 // Start a new check with an empty list of actual objects checked
 // The list of actual objects checked is used to ensure that circular references don't result in infinite recursion
 List&lt;Object&gt; actualObjectsChecked = new List&lt;Object&gt;();
 AssertAreEqual(expected, actual, name, actualObjectsChecked);
 }

 private static void AssertAreEqual(Object expected, Object actual, String name, List&lt;Object&gt; actualObjectsChecked)
 {
 // Just return if already checked the actual object
 if (actualObjectsChecked.Contains(actual))
 {
 return;
 }

 actualObjectsChecked.Add(actual);

 // If both expected and actual are null, they are considered equal
 if (expected == null &amp;&amp; actual == null)
 {
 return;
 }

 if (expected == null &amp;&amp; actual != null)
 {
 Assert.Fail(String.Format("The actual value of {0} was not null when null was expected.", name));
 }

 if (expected != null &amp;&amp; actual == null)
 {
 Assert.Fail(String.Format("The actual value of {0} was null when an instance was expected.", name));
 }

 // Get / check type info
 // Note: GetType always returns instantiated (i.e. most derived) type
 Type expectedType = expected.GetType();
 Type actualType = actual.GetType();
 if (expectedType != actualType)
 {
 Assert.Fail(String.Format("The actual type of {0} was not the same as the expected type.", name));
 }

 // If expected is a Primitive, Value, or IEquatable type, assume Equals is sufficient to check
 // Note: Every IEquatable type should have also overridden Object.Equals
 if (expectedType.IsPrimitive || expectedType.IsValueType || expectedType.IsIEquatable())
 {
 Assert.IsTrue(expected.Equals(actual), "The actual {0} is not equal to the expected.", name);
 return;
 }

 // If expected is an IEnumerable type, assume comparing enumerated items is sufficient to check
 IEnumerable&lt;Object&gt; expectedEnumerable = expected as IEnumerable&lt;Object&gt;;
 IEnumerable&lt;Object&gt; actualEnumerable = actual as IEnumerable&lt;Object&gt;;
 if ((expectedEnumerable != null) &amp;&amp; (actualEnumerable != null))
 {
 Int32 actualEnumerableCount = actualEnumerable.Count();
 Int32 expectedEnumerableCount = expectedEnumerable.Count();

 // Check size first
 if (actualEnumerableCount != expectedEnumerableCount)
 {
 Assert.Fail(String.Format("The actual number of enumerable items in {0} did not match the expected number.", name));
 }

 // Check items in order, assuming order is the same
 for (int i = 0; i &lt; actualEnumerableCount; ++i)
 {
 AssertAreEqual(expectedEnumerable.ElementAt(i), actualEnumerable.ElementAt(i), String.Format("{0}[{1}]", name, i), actualObjectsChecked);
 }

 return;
 }

 // If expected is not a Primitive, Value, IEquatable, or Ienumerable type, assume comparing properties is sufficient to check
 // Iterate through properties
 foreach (PropertyInfo propertyInfo in actualType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
 {
 // Skip properties that can't be read or require parameters
 if ((!propertyInfo.CanRead) || (propertyInfo.GetIndexParameters().Length != 0))
 {
 continue;
 }

 // Get properties from both
 Object actualProperty = propertyInfo.GetValue(actual, null);
 Object expectedProperty = propertyInfo.GetValue(expected, null);

 AssertAreEqual(expectedProperty, actualProperty, String.Format("{0}.{1}", name, propertyInfo.Name), actualObjectsChecked);
 }
 }

 public static Boolean IsIEquatable(this Type type)
 {
 return type.GetInterfaces().Any(x =&gt; x.IsGenericType &amp;&amp; x.GetGenericTypeDefinition() == typeof(IEquatable&lt;&gt;));
 }

}
</code></pre>

I am looking for a C# specific , open source (or source code available) implementation of recursive, or deep, object comparison.

I currently have two graphs of live objects that I am looking to compare to each other, with the result of the comparison being a set of discrepancies in the graphs. The objects are instantiations of a set of classes that are known at run time (but not necessarily at compile time).

There is a specific requirement to be able to map from the discrepancies in the graphs, back to the objects containing the discrepancies.

C# implementation of deep/recursive object comparison in .net 3.5

单元测试

我正在寻找一个特定于C#的，开源(或源代码可用)的递归或深度对象比较的实现。我目前有两个活动对象的图形，我希望将它们相互比较，比较的结果是图形中的一组差异。这些对象是在运行时(但不一定在编译时)已知的一组类的实例化。有一个特定的要求，就是能够从图中的差异映射回包含差异的对象。

问.net 3.5中深度/递归对象比较的C#实现
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.net 3.5中深度/递归对象比较的C#实现EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.net 3.5中深度/递归对象比较的C#实现
EN