Comparing object properties in c

Question

This is what I ve come up with as a method on a class inherited by many of my other classes  The idea is that it allows the simple comparison between properties of Objects of the same Type   Now  this does work - but in the interest of improving the quality of my code I thought I d throw it out for scrutiny  How can it be better more efficient etc         lt summary gt      Compare property values  as strings       lt  summary gt       lt param name  obj  gt  lt  param gt       lt returns gt  lt  returns gt  public bool PropertiesEqual object comparisonObject         Type sourceType   this GetType        Type destinationType   comparisonObject GetType         if  sourceType    destinationType                PropertyInfo   sourceProperties   sourceType GetProperties            foreach  PropertyInfo pi in sourceProperties                        if   sourceType GetProperty pi Name  GetValue this  null     null  amp  amp  destinationType GetProperty pi Name  GetValue comparisonObject  null     null                                    if both are null  don t try to compare   throws exception                            else if    sourceType GetProperty pi Name  GetValue this  null  ToString      destinationType GetProperty pi Name  GetValue comparisonObject  null  ToString                                      only need one property to be different to fail Equals                  return false                                    else               throw new ArgumentException  Comparison object must be of the same type    comparisonObject               return true

User · Answer

Make sure objects aren t null   Having obj1 and obj2   if obj1    null        return false    return obj1 Equals  obj2

User · Answer

I was looking for a snippet of code that would do something similar to help with writing unit test  Here is what I ended up using   public static bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class           if  self    null  amp  amp  to    null                 Type type   typeof T           List lt string gt  ignoreList   new List lt string gt  ignore           foreach  System Reflection PropertyInfo pi in type GetProperties System Reflection BindingFlags Public   System Reflection BindingFlags Instance                        if   ignoreList Contains pi Name                              object selfValue   type GetProperty pi Name  GetValue self  null                 object toValue   type GetProperty pi Name  GetValue to  null                  if  selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue                                     return false                                                 return true              return self    to        EDIT   Same code as above but uses LINQ and Extension methods    public static bool PublicInstancePropertiesEqual lt T gt  this T self  T to  params string   ignore  where T   class       if  self    null  amp  amp  to    null                var type   typeof T           var ignoreList   new List lt string gt  ignore           var unequalProperties               from pi in type GetProperties BindingFlags Public   BindingFlags Instance              where  ignoreList Contains pi Name   amp  amp  pi GetUnderlyingType   IsSimpleType    amp  amp  pi GetIndexParameters   Length    0             let selfValue   type GetProperty pi Name  GetValue self  null              let toValue   type GetProperty pi Name  GetValue to  null              where selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue               select selfValue          return  unequalProperties Any              return self    to     public static class TypeExtensions                 lt summary gt            Determine whether a type is simple  String  Decimal  DateTime  etc             or complex  i e  custom class with public properties and methods              lt  summary gt             lt see cref  http   stackoverflow com questions 2442534 how-to-test-if-type-is-primitive   gt        public static bool IsSimpleType           this Type type                   return             type IsValueType                type IsPrimitive                new                                typeof String                  typeof Decimal                  typeof DateTime                  typeof DateTimeOffset                  typeof TimeSpan                  typeof Guid                Contains type                  Convert GetTypeCode type     TypeCode Object                  public static Type GetUnderlyingType this MemberInfo member                   switch  member MemberType                         case MemberTypes Event                 return   EventInfo member  EventHandlerType              case MemberTypes Field                 return   FieldInfo member  FieldType              case MemberTypes Method                 return   MethodInfo member  ReturnType              case MemberTypes Property                 return   PropertyInfo member  PropertyType              default                 throw new ArgumentException                                     Input MemberInfo must be if type EventInfo  FieldInfo  MethodInfo  or PropertyInfo

User · Answer

Do you override  ToString   on all of your objects that are in the properties   Otherwise  that second comparison could come back with null   Also  in that second comparison  I m on the fence about the construct of    A    B  compared to  A    B   in terms of readability six months two years from now   The line itself is pretty wide  which is ok if you ve got a wide monitor  but might not print out very well   nitpick   Are all of your objects always using properties such that this code will work   Could there be some internal  non-propertied data that could be different from one object to another  but all exposed data is the same   I m thinking of some data which could change over time  like two random number generators that happen to hit the same number at one point  but are going to produce two different sequences of information  or just any data that doesn t get exposed through the property interface

User · Answer

Update on Liviu s answer above - CompareObjects DifferencesString has been deprecated   This works well in a unit test   CompareLogic compareLogic   new CompareLogic    ComparisonResult result   compareLogic Compare object1  object2   Assert IsTrue result AreEqual

User · Answer

sometimes you don t want to compare all public properties and want to compare only the subset of them  so in this case you can just move logic to compare the desired list of properties to abstract class  public abstract class ValueObject lt T gt  where T   ValueObject lt T gt        protected abstract IEnumerable lt object gt  GetAttributesToIncludeInEqualityCheck         public override bool Equals object other                return Equals other as T              public bool Equals T other                if  other    null                        return false                     return GetAttributesToIncludeInEqualityCheck                SequenceEqual other GetAttributesToIncludeInEqualityCheck                public static bool operator    ValueObject lt T gt  left  ValueObject lt T gt  right                return Equals left  right              public static bool operator    ValueObject lt T gt  left  ValueObject lt T gt  right                return   left    right              public override int GetHashCode                 int hash   17          foreach  var obj in this GetAttributesToIncludeInEqualityCheck                hash   hash   31    obj    null   0   obj GetHashCode              return hash            and use this abstract class later to compare the objects  public class Meters   ValueObject lt Meters gt                 protected decimal DistanceInMeters   get  private set                  protected override IEnumerable lt object gt  GetAttributesToIncludeInEqualityCheck                 return new List lt Object gt    DistanceInMeters

User · Answer

I ended up doing this       public static string ToStringNullSafe this object obj                return obj    null   obj ToString     String Empty            public static bool Compare lt T gt  T a  T b                int count   a GetType   GetProperties   Count            string aa  bb          for  int i   0  i  lt  count  i                          aa   a GetType   GetProperties   i  GetValue a  null  ToStringNullSafe                bb   b GetType   GetProperties   i  GetValue b  null  ToStringNullSafe                if  aa    bb                                return false                                  return true          Usage       if  Compare lt ObjectType gt  a  b     Update  If you want to ignore some properties by name        public static string ToStringNullSafe this object obj                return obj    null   obj ToString     String Empty            public static bool Compare lt T gt  T a  T b  params string   ignore                int count   a GetType   GetProperties   Count            string aa  bb          for  int i   0  i  lt  count  i                          aa   a GetType   GetProperties   i  GetValue a  null  ToStringNullSafe                bb   b GetType   GetProperties   i  GetValue b  null  ToStringNullSafe                if  aa    bb  amp  amp  ignore Where x   gt  x    a GetType   GetProperties   i  Name  Count      0                                return false                                  return true          Usage       if  MyFunction Compare lt ObjType gt  a  b   Id   AnotherProp

User · Answer

my solution inspired from Aras Alenin answer above where I added one level of object comparison and a custom object for comparison results  I am also interested to get property name with object name       public static IEnumerable lt ObjectPropertyChanged gt  GetPublicSimplePropertiesChanged lt T gt  this T previous  T proposedChange       string   namesOfPropertiesToBeIgnored  where T   class               return GetPublicGenericPropertiesChanged previous  proposedChange  namesOfPropertiesToBeIgnored  true  null  null              public static IReadOnlyList lt ObjectPropertyChanged gt  GetPublicGenericPropertiesChanged lt T gt  this T previous  T proposedChange          string   namesOfPropertiesToBeIgnored  where T   class               return GetPublicGenericPropertiesChanged previous  proposedChange  namesOfPropertiesToBeIgnored  false  null  null                   lt summary gt          Gets the names of the public properties which values differs between first and second objects          Considers  simple  properties AND for complex properties without index  get the simple properties of the children objects           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  previous  gt The previous object  lt  param gt           lt param name  proposedChange  gt The second object which should be the new one  lt  param gt           lt param name  namesOfPropertiesToBeIgnored  gt The names of the properties to be ignored  lt  param gt           lt param name  simpleTypeOnly  gt if set to  lt c gt true lt  c gt  consider simple types only  lt  param gt           lt param name  parentTypeString  gt The parent type string  Meant only for recursive call with simpleTypeOnly set to  lt c gt true lt  c gt   lt  param gt           lt param name  secondType  gt when calling recursively  the current type of T must be clearly defined here  as T will be more generic  using base class   lt  param gt           lt returns gt          the names of the properties          lt  returns gt      private static IReadOnlyList lt ObjectPropertyChanged gt  GetPublicGenericPropertiesChanged lt T gt  this T previous  T proposedChange          string   namesOfPropertiesToBeIgnored  bool simpleTypeOnly  string parentTypeString  Type secondType  where T   class               List lt ObjectPropertyChanged gt  propertiesChanged   new List lt ObjectPropertyChanged gt              if  previous    null  amp  amp  proposedChange    null                        var type   secondType    null   typeof T    secondType              string typeStr   parentTypeString   type Name                    var ignoreList   namesOfPropertiesToBeIgnored CreateList                IEnumerable lt IEnumerable lt ObjectPropertyChanged gt  gt  genericPropertiesChanged                   from pi in type GetProperties BindingFlags Public   BindingFlags Instance                  where  ignoreList Contains pi Name   amp  amp  pi GetIndexParameters   Length    0                       amp  amp    simpleTypeOnly    simpleTypeOnly  amp  amp  pi PropertyType IsSimpleType                    let firstValue   type GetProperty pi Name  GetValue previous  null                  let secondValue   type GetProperty pi Name  GetValue proposedChange  null                  where firstValue    secondValue  amp  amp   firstValue    null     firstValue Equals secondValue                   let subPropertiesChanged   simpleTypeOnly    pi PropertyType IsSimpleType                         null                       GetPublicGenericPropertiesChanged firstValue  secondValue  namesOfPropertiesToBeIgnored  true  typeStr  pi PropertyType                  let objectPropertiesChanged   subPropertiesChanged    null  amp  amp  subPropertiesChanged Count    gt  0                       subPropertiesChanged                        new ObjectPropertyChanged proposedChange ToString    typeStr   pi Name  firstValue ToStringOrNull    secondValue ToStringOrNull     CreateList                   select objectPropertiesChanged               if  genericPropertiesChanged    null                     get items from sub lists                 genericPropertiesChanged ForEach a   gt  propertiesChanged AddRange a                                    return propertiesChanged          Using the following class to store comparison results   System Serializable  public class ObjectPropertyChanged       public ObjectPropertyChanged string objectId  string propertyName  string previousValue  string changedValue                ObjectId   objectId          PropertyName   propertyName          PreviousValue   previousValue          ProposedChangedValue   changedValue             public string ObjectId   get  set         public string PropertyName   get  set         public string PreviousValue   get  set         public string ProposedChangedValue   get  set        And a sample unit test        TestMethod        public void GetPublicGenericPropertiesChangedTest1                    Define objects to test         Function func1   new Function   Id   1  Description    func1             Function func2   new Function   Id   2  Description    func2             FunctionAssignment funcAss1   new FunctionAssignment                       Function   func1              Level   1                    FunctionAssignment funcAss2   new FunctionAssignment                       Function   func2              Level   2                        Main test  read properties changed         var propertiesChanged   Utils GetPublicGenericPropertiesChanged funcAss1  funcAss2  null            Assert IsNotNull propertiesChanged           Assert IsTrue propertiesChanged Count    3           Assert IsTrue propertiesChanged 0  PropertyName     FunctionAssignment Function Description            Assert IsTrue propertiesChanged 1  PropertyName     FunctionAssignment Function Id            Assert IsTrue propertiesChanged 2  PropertyName     FunctionAssignment Level

User · Answer

Do you override  ToString   on all of your objects that are in the properties   Otherwise  that second comparison could come back with null   Also  in that second comparison  I m on the fence about the construct of    A    B  compared to  A    B   in terms of readability six months two years from now   The line itself is pretty wide  which is ok if you ve got a wide monitor  but might not print out very well   nitpick   Are all of your objects always using properties such that this code will work   Could there be some internal  non-propertied data that could be different from one object to another  but all exposed data is the same   I m thinking of some data which could change over time  like two random number generators that happen to hit the same number at one point  but are going to produce two different sequences of information  or just any data that doesn t get exposed through the property interface

User · Answer

I think the answer of Big T was quite good but the deep comparison was missing  so I tweaked it a little bit   using System Collections Generic  using System Reflection        lt summary gt Comparison class  lt  summary gt  public static class Compare            lt summary gt Compare the public instance properties  Uses deep comparison  lt  summary gt           lt param name  self  gt The reference object  lt  param gt           lt param name  to  gt The object to compare  lt  param gt           lt param name  ignore  gt Ignore property with name  lt  param gt           lt typeparam name  T  gt Type of objects  lt  typeparam gt           lt returns gt  lt see cref  bool  gt True lt  see gt  if both objects are equal  else  lt see cref  bool  gt false lt  see gt   lt  returns gt      public static bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class               if  self    null  amp  amp  to    null                        var type   self GetType                var ignoreList   new List lt string gt  ignore               foreach  var pi in type GetProperties BindingFlags Public   BindingFlags Instance                                 if  ignoreList Contains pi Name                                         continue                                     var selfValue   type GetProperty pi Name  GetValue self  null                   var toValue   type GetProperty pi Name  GetValue to  null                    if  pi PropertyType IsClass  amp  amp   pi PropertyType Module ScopeName Equals  CommonLanguageRuntimeLibrary                                             Check of  CommonLanguageRuntimeLibrary  is needed because string is also a class                     if  PublicInstancePropertiesEqual selfValue  toValue  ignore                                                 continue                                             return false                                     if  selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue                                          return false                                               return true                     return self    to

User · Answer

Make sure objects aren t null   Having obj1 and obj2   if obj1    null        return false    return obj1 Equals  obj2

User · Answer

I think it would be best to follow the pattern for Override Object Equals   For a better description  Read Bill Wagner s Effective C  - Item 9 I think  public override Equals object obOther      if  null    obOther      return false    if  object ReferenceEquals this  obOther      return true    if  this GetType      obOther GetType        return false      private method to compare members    return CompareMembers this  obOther as ThisClass        Also in methods that check for equality  you should return either true or false  either they are equal or they are not   instead of throwing an exception  return false   I d consider overriding Object Equals  Even though you must have considered this  using Reflection to compare properties is supposedly slow  I dont have numbers to back this up   This is the default behavior for valueType Equals in C  and it is recommended that you override Equals for value types and do a member wise compare for performance   Earlier I speed-read this as you have a collection of custom Property objects    my bad      Update-Dec 2011     Of course  if the type already has a production Equals   then you need another approach  If you re using this to compare immutable data structures exclusively for test purposes  you shouldn t add an Equals to production classes  Someone might hose the tests by chainging the Equals implementation or you may prevent creation of a production-required Equals implementation

User · Answer

To expand on  nawfal s answer  I use this to test objects of different types in my unit tests to compare equal property names  In my case database entity and DTO    Used like this in my test   Assert IsTrue resultDto PublicInstancePropertiesEqual expectedEntity       public static bool PublicInstancePropertiesEqual lt T  Z gt  this T self  Z to  params string   ignore  where T   class       if  self    null  amp  amp  to    null                var type   typeof T           var type2   typeof Z           var ignoreList   new List lt string gt  ignore           var unequalProperties              from pi in type GetProperties BindingFlags Public   BindingFlags Instance             where  ignoreList Contains pi Name             let selfValue   type GetProperty pi Name  GetValue self  null             let toValue   type2 GetProperty pi Name  GetValue to  null             where selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue              select selfValue             return  unequalProperties Any              return self    null  amp  amp  to    null

User · Answer

UPDATE  The latest version of Compare-Net-Objects is located on GitHub    has NuGet package and Tutorial  It can be called like     This is the comparison class CompareLogic compareLogic   new CompareLogic     ComparisonResult result   compareLogic Compare person1  person2      These will be different  write out the differences if   result AreEqual      Console WriteLine result DifferencesString     Or if you need to change some configuration  use   CompareLogic basicComparison   new CompareLogic      Config   new ComparisonConfig        MaxDifferences   propertyCount         add other configurations           Full list of configurable parameters is in ComparisonConfig cs  Original answer   The limitations I see in your code     The biggest one is that it doesn t do a deep object comparison   It doesn t do an element by element comparison in case properties are lists or contain lists as elements  this can go n-levels    It doesn t take into account that some type of properties should not be compared  e g  a Func property used for filtering purposes  like the one in the PagedCollectionView class   It doesn t keep track of what properties actually were different  so you can show in your assertions     I was looking today for some solution for unit-testing purposes to do property by property deep comparison and I ended up using  http   comparenetobjects codeplex com   It is a free library with just one class which you can simply use like this   var compareObjects   new CompareObjects         CompareChildren   true    this turns deep compare one  otherwise it s shallow     CompareFields   false      CompareReadOnly   true      ComparePrivateFields   false      ComparePrivateProperties   false      CompareProperties   true      MaxDifferences   1      ElementsToIgnore   new List lt string gt       Filter        Assert IsTrue      compareObjects Compare objectA  objectB        compareObjects DifferencesString      Also  it can be easily re-compiled for Silverlight  Just copy the one class into a Silverlight project and remove one or two lines of code for comparisons that are not available in Silverlight  like private members comparison

User · Answer

I would add the following line to the PublicInstancePropertiesEqual method to avoid copy  amp  paste errors   Assert AreNotSame self  to

User · Answer

Make sure objects aren t null   Having obj1 and obj2   if obj1    null        return false    return obj1 Equals  obj2

User · Answer

You can optimize your code by calling GetProperties only once per type   public static string ToStringNullSafe this object obj        return obj    null   obj ToString     String Empty    public static bool Compare lt T gt  T a  T b  params string   ignore        var aProps   a GetType   GetProperties        var bProps   b GetType   GetProperties        int count   aProps Count        string aa  bb      for  int i   0  i  lt  count  i                  aa   aProps i  GetValue a  null  ToStringNullSafe            bb   bProps i  GetValue b  null  ToStringNullSafe            if  aa    bb  amp  amp  ignore Where x   gt  x    aProps i  Name  Count      0                        return false                      return true

User · Answer

If performance doesn t matter  you could serialize them and compare the results   var serializer   new XmlSerializer typeof TheObjectType    StringWriter serialized1   new StringWriter    serialized2   new StringWriter    serializer Serialize serialized1  obj1   serializer Serialize serialized2  obj2   bool areEqual   serialized1 ToString      serialized2 ToString

User · Answer

The first thing I would suggest would be to split up the actual comparison so that it s a bit more readable  I ve also taken out the ToString   - is that needed     else       object originalProperty   sourceType GetProperty pi Name  GetValue this  null       object comparisonProperty   destinationType GetProperty pi Name  GetValue comparisonObject  null        if  originalProperty    comparisonProperty          return false    The next suggestion would be to minimise the use of reflection as much as possible - it s really slow  I mean  really slow  If you are going to do this  I would suggest caching the property references  I m not intimately familiar with the Reflection API  so if this is a bit off  just adjust to make it compile      elsewhere Dictionary lt object  Property   gt  lookupDictionary   new Dictionary lt object  Property   gt    Property   objectProperties   null  if  lookupDictionary ContainsKey sourceType       objectProperties   lookupProperties sourceType     else        build array of Property references   PropertyInfo   sourcePropertyInfos   sourceType GetProperties      Property   sourceProperties   new Property sourcePropertyInfos length     for  int i 0  i  lt  sourcePropertyInfos length  i          sourceProperties i    sourceType GetProperty pi Name            add to cache   objectProperties   sourceProperties    lookupDictionary object    sourceProperties        loop through and compare against the instances   However  I have to say that I agree with the other posters  This smells lazy and inefficient  You should be implementing IComparable instead  -

User · Answer

The first thing I would suggest would be to split up the actual comparison so that it s a bit more readable  I ve also taken out the ToString   - is that needed     else       object originalProperty   sourceType GetProperty pi Name  GetValue this  null       object comparisonProperty   destinationType GetProperty pi Name  GetValue comparisonObject  null        if  originalProperty    comparisonProperty          return false    The next suggestion would be to minimise the use of reflection as much as possible - it s really slow  I mean  really slow  If you are going to do this  I would suggest caching the property references  I m not intimately familiar with the Reflection API  so if this is a bit off  just adjust to make it compile      elsewhere Dictionary lt object  Property   gt  lookupDictionary   new Dictionary lt object  Property   gt    Property   objectProperties   null  if  lookupDictionary ContainsKey sourceType       objectProperties   lookupProperties sourceType     else        build array of Property references   PropertyInfo   sourcePropertyInfos   sourceType GetProperties      Property   sourceProperties   new Property sourcePropertyInfos length     for  int i 0  i  lt  sourcePropertyInfos length  i          sourceProperties i    sourceType GetProperty pi Name            add to cache   objectProperties   sourceProperties    lookupDictionary object    sourceProperties        loop through and compare against the instances   However  I have to say that I agree with the other posters  This smells lazy and inefficient  You should be implementing IComparable instead  -

User · Answer

I think the answer of Big T was quite good but the deep comparison was missing  so I tweaked it a little bit   using System Collections Generic  using System Reflection        lt summary gt Comparison class  lt  summary gt  public static class Compare            lt summary gt Compare the public instance properties  Uses deep comparison  lt  summary gt           lt param name  self  gt The reference object  lt  param gt           lt param name  to  gt The object to compare  lt  param gt           lt param name  ignore  gt Ignore property with name  lt  param gt           lt typeparam name  T  gt Type of objects  lt  typeparam gt           lt returns gt  lt see cref  bool  gt True lt  see gt  if both objects are equal  else  lt see cref  bool  gt false lt  see gt   lt  returns gt      public static bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class               if  self    null  amp  amp  to    null                        var type   self GetType                var ignoreList   new List lt string gt  ignore               foreach  var pi in type GetProperties BindingFlags Public   BindingFlags Instance                                 if  ignoreList Contains pi Name                                         continue                                     var selfValue   type GetProperty pi Name  GetValue self  null                   var toValue   type GetProperty pi Name  GetValue to  null                    if  pi PropertyType IsClass  amp  amp   pi PropertyType Module ScopeName Equals  CommonLanguageRuntimeLibrary                                             Check of  CommonLanguageRuntimeLibrary  is needed because string is also a class                     if  PublicInstancePropertiesEqual selfValue  toValue  ignore                                                 continue                                             return false                                     if  selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue                                          return false                                               return true                     return self    to

User · Answer

I ended up doing this       public static string ToStringNullSafe this object obj                return obj    null   obj ToString     String Empty            public static bool Compare lt T gt  T a  T b                int count   a GetType   GetProperties   Count            string aa  bb          for  int i   0  i  lt  count  i                          aa   a GetType   GetProperties   i  GetValue a  null  ToStringNullSafe                bb   b GetType   GetProperties   i  GetValue b  null  ToStringNullSafe                if  aa    bb                                return false                                  return true          Usage       if  Compare lt ObjectType gt  a  b     Update  If you want to ignore some properties by name        public static string ToStringNullSafe this object obj                return obj    null   obj ToString     String Empty            public static bool Compare lt T gt  T a  T b  params string   ignore                int count   a GetType   GetProperties   Count            string aa  bb          for  int i   0  i  lt  count  i                          aa   a GetType   GetProperties   i  GetValue a  null  ToStringNullSafe                bb   b GetType   GetProperties   i  GetValue b  null  ToStringNullSafe                if  aa    bb  amp  amp  ignore Where x   gt  x    a GetType   GetProperties   i  Name  Count      0                                return false                                  return true          Usage       if  MyFunction Compare lt ObjType gt  a  b   Id   AnotherProp

User · Answer

here is revised one to treat  null   null  as equal   private bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class                       if  self    null  amp  amp  to    null                                Type type   typeof T                   List lt string gt  ignoreList   new List lt string gt  ignore                   foreach  PropertyInfo pi in type GetProperties BindingFlags Public   BindingFlags Instance                                         if   ignoreList Contains pi Name                                                 object selfValue   type GetProperty pi Name  GetValue self  null                           object toValue   type GetProperty pi Name  GetValue to  null                           if  selfValue    null                                                        if   selfValue Equals toValue                                   return false                                                    else if  toValue    null                              return false                                                          return true                            return self    to

User · Answer

If you are only comparing objects of the same type or further down the inheritance chain  why not specify the parameter as your base type  rather than object    Also do null checks on the parameter as well   Furthermore I d make use of  var  just to make the code more readable  if its c 3 code   Also  if the object has reference types as properties then you are just calling ToString   on them which doesn t really compare values  If ToString isn t overwridden then its just going to return the type name as a string which could return false-positives

User · Answer

This works even if the objects are different  you could customize the methods in the utilities class maybe you want to compare private properties as well      using System  using System Collections Generic  using System Linq  using System Text   class ObjectA       public string PropertyA   get  set        public string PropertyB   get  set        public string PropertyC   get  set        public DateTime PropertyD   get  set         public string FieldA      public DateTime FieldB     class ObjectB       public string PropertyA   get  set        public string PropertyB   get  set        public string PropertyC   get  set        public DateTime PropertyD   get  set          public string FieldA      public DateTime FieldB       class Program       static void Main string   args                   create two objects with same properties         ObjectA a   new ObjectA     PropertyA    test   PropertyB    test2   PropertyC    test3             ObjectB b   new ObjectB     PropertyA    test   PropertyB    test2   PropertyC    test3                 add fields to those objects         a FieldA    hello           b FieldA    Something differnt            if  a ComparePropertiesTo b                         Console WriteLine  objects have the same properties                      else                       Console WriteLine  objects have diferent properties                         if  a CompareFieldsTo b                         Console WriteLine  objects have the same Fields                      else                       Console WriteLine  objects have diferent Fields                        Console Read             public static class Utilities       public static bool ComparePropertiesTo this Object a  Object b                System Reflection PropertyInfo   properties   a GetType   GetProperties       get all the properties of object a          foreach  var property in properties                        var propertyName   property Name               var aValue   a GetType   GetProperty propertyName  GetValue a  null               object bValue               try    try to get the same property from object b  maybe that property does                    not exist                                 bValue   b GetType   GetProperty propertyName  GetValue b  null                             catch                               return false                             if  aValue    null  amp  amp  bValue    null                  continue               if  aValue    null  amp  amp  bValue    null                  return false               if  aValue    null  amp  amp  bValue    null                 return false                  if properties do not match return false             if  aValue GetHashCode      bValue GetHashCode                                  return false                                   return true               public static bool CompareFieldsTo this Object a  Object b                System Reflection FieldInfo   fields   a GetType   GetFields       get all the properties of object a          foreach  var field in fields                        var fieldName   field Name               var aValue   a GetType   GetField fieldName  GetValue a                object bValue               try    try to get the same property from object b  maybe that property does                not exist                                 bValue   b GetType   GetField fieldName  GetValue b                             catch                               return false                             if  aValue    null  amp  amp  bValue    null                 continue               if  aValue    null  amp  amp  bValue    null                 return false               if  aValue    null  amp  amp  bValue    null                 return false                   if properties do not match return false             if  aValue GetHashCode      bValue GetHashCode                                  return false                                   return true

User · Answer

For completeness I want to add reference to  http   www cyotek com blog comparing-the-properties-of-two-objects-via-reflection It has more complete logic than most of others answers on this page   However I prefer Compare-Net-Objects library https   github com GregFinzer Compare-Net-Objects  referred by Liviu Trifoi s answer  The library has NuGet package http   www nuget org packages CompareNETObjects and multiple options to configure

User · Answer

my solution inspired from Aras Alenin answer above where I added one level of object comparison and a custom object for comparison results  I am also interested to get property name with object name       public static IEnumerable lt ObjectPropertyChanged gt  GetPublicSimplePropertiesChanged lt T gt  this T previous  T proposedChange       string   namesOfPropertiesToBeIgnored  where T   class               return GetPublicGenericPropertiesChanged previous  proposedChange  namesOfPropertiesToBeIgnored  true  null  null              public static IReadOnlyList lt ObjectPropertyChanged gt  GetPublicGenericPropertiesChanged lt T gt  this T previous  T proposedChange          string   namesOfPropertiesToBeIgnored  where T   class               return GetPublicGenericPropertiesChanged previous  proposedChange  namesOfPropertiesToBeIgnored  false  null  null                   lt summary gt          Gets the names of the public properties which values differs between first and second objects          Considers  simple  properties AND for complex properties without index  get the simple properties of the children objects           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  previous  gt The previous object  lt  param gt           lt param name  proposedChange  gt The second object which should be the new one  lt  param gt           lt param name  namesOfPropertiesToBeIgnored  gt The names of the properties to be ignored  lt  param gt           lt param name  simpleTypeOnly  gt if set to  lt c gt true lt  c gt  consider simple types only  lt  param gt           lt param name  parentTypeString  gt The parent type string  Meant only for recursive call with simpleTypeOnly set to  lt c gt true lt  c gt   lt  param gt           lt param name  secondType  gt when calling recursively  the current type of T must be clearly defined here  as T will be more generic  using base class   lt  param gt           lt returns gt          the names of the properties          lt  returns gt      private static IReadOnlyList lt ObjectPropertyChanged gt  GetPublicGenericPropertiesChanged lt T gt  this T previous  T proposedChange          string   namesOfPropertiesToBeIgnored  bool simpleTypeOnly  string parentTypeString  Type secondType  where T   class               List lt ObjectPropertyChanged gt  propertiesChanged   new List lt ObjectPropertyChanged gt              if  previous    null  amp  amp  proposedChange    null                        var type   secondType    null   typeof T    secondType              string typeStr   parentTypeString   type Name                    var ignoreList   namesOfPropertiesToBeIgnored CreateList                IEnumerable lt IEnumerable lt ObjectPropertyChanged gt  gt  genericPropertiesChanged                   from pi in type GetProperties BindingFlags Public   BindingFlags Instance                  where  ignoreList Contains pi Name   amp  amp  pi GetIndexParameters   Length    0                       amp  amp    simpleTypeOnly    simpleTypeOnly  amp  amp  pi PropertyType IsSimpleType                    let firstValue   type GetProperty pi Name  GetValue previous  null                  let secondValue   type GetProperty pi Name  GetValue proposedChange  null                  where firstValue    secondValue  amp  amp   firstValue    null     firstValue Equals secondValue                   let subPropertiesChanged   simpleTypeOnly    pi PropertyType IsSimpleType                         null                       GetPublicGenericPropertiesChanged firstValue  secondValue  namesOfPropertiesToBeIgnored  true  typeStr  pi PropertyType                  let objectPropertiesChanged   subPropertiesChanged    null  amp  amp  subPropertiesChanged Count    gt  0                       subPropertiesChanged                        new ObjectPropertyChanged proposedChange ToString    typeStr   pi Name  firstValue ToStringOrNull    secondValue ToStringOrNull     CreateList                   select objectPropertiesChanged               if  genericPropertiesChanged    null                     get items from sub lists                 genericPropertiesChanged ForEach a   gt  propertiesChanged AddRange a                                    return propertiesChanged          Using the following class to store comparison results   System Serializable  public class ObjectPropertyChanged       public ObjectPropertyChanged string objectId  string propertyName  string previousValue  string changedValue                ObjectId   objectId          PropertyName   propertyName          PreviousValue   previousValue          ProposedChangedValue   changedValue             public string ObjectId   get  set         public string PropertyName   get  set         public string PreviousValue   get  set         public string ProposedChangedValue   get  set        And a sample unit test        TestMethod        public void GetPublicGenericPropertiesChangedTest1                    Define objects to test         Function func1   new Function   Id   1  Description    func1             Function func2   new Function   Id   2  Description    func2             FunctionAssignment funcAss1   new FunctionAssignment                       Function   func1              Level   1                    FunctionAssignment funcAss2   new FunctionAssignment                       Function   func2              Level   2                        Main test  read properties changed         var propertiesChanged   Utils GetPublicGenericPropertiesChanged funcAss1  funcAss2  null            Assert IsNotNull propertiesChanged           Assert IsTrue propertiesChanged Count    3           Assert IsTrue propertiesChanged 0  PropertyName     FunctionAssignment Function Description            Assert IsTrue propertiesChanged 1  PropertyName     FunctionAssignment Function Id            Assert IsTrue propertiesChanged 2  PropertyName     FunctionAssignment Level

User · Answer

Make sure objects aren t null   Having obj1 and obj2   if obj1    null        return false    return obj1 Equals  obj2

User · Answer

sometimes you don t want to compare all public properties and want to compare only the subset of them  so in this case you can just move logic to compare the desired list of properties to abstract class  public abstract class ValueObject lt T gt  where T   ValueObject lt T gt        protected abstract IEnumerable lt object gt  GetAttributesToIncludeInEqualityCheck         public override bool Equals object other                return Equals other as T              public bool Equals T other                if  other    null                        return false                     return GetAttributesToIncludeInEqualityCheck                SequenceEqual other GetAttributesToIncludeInEqualityCheck                public static bool operator    ValueObject lt T gt  left  ValueObject lt T gt  right                return Equals left  right              public static bool operator    ValueObject lt T gt  left  ValueObject lt T gt  right                return   left    right              public override int GetHashCode                 int hash   17          foreach  var obj in this GetAttributesToIncludeInEqualityCheck                hash   hash   31    obj    null   0   obj GetHashCode              return hash            and use this abstract class later to compare the objects  public class Meters   ValueObject lt Meters gt                 protected decimal DistanceInMeters   get  private set                  protected override IEnumerable lt object gt  GetAttributesToIncludeInEqualityCheck                 return new List lt Object gt    DistanceInMeters

User · Answer

I think it would be best to follow the pattern for Override Object Equals   For a better description  Read Bill Wagner s Effective C  - Item 9 I think  public override Equals object obOther      if  null    obOther      return false    if  object ReferenceEquals this  obOther      return true    if  this GetType      obOther GetType        return false      private method to compare members    return CompareMembers this  obOther as ThisClass        Also in methods that check for equality  you should return either true or false  either they are equal or they are not   instead of throwing an exception  return false   I d consider overriding Object Equals  Even though you must have considered this  using Reflection to compare properties is supposedly slow  I dont have numbers to back this up   This is the default behavior for valueType Equals in C  and it is recommended that you override Equals for value types and do a member wise compare for performance   Earlier I speed-read this as you have a collection of custom Property objects    my bad      Update-Dec 2011     Of course  if the type already has a production Equals   then you need another approach  If you re using this to compare immutable data structures exclusively for test purposes  you shouldn t add an Equals to production classes  Someone might hose the tests by chainging the Equals implementation or you may prevent creation of a production-required Equals implementation

User · Answer

The first thing I would suggest would be to split up the actual comparison so that it s a bit more readable  I ve also taken out the ToString   - is that needed     else       object originalProperty   sourceType GetProperty pi Name  GetValue this  null       object comparisonProperty   destinationType GetProperty pi Name  GetValue comparisonObject  null        if  originalProperty    comparisonProperty          return false    The next suggestion would be to minimise the use of reflection as much as possible - it s really slow  I mean  really slow  If you are going to do this  I would suggest caching the property references  I m not intimately familiar with the Reflection API  so if this is a bit off  just adjust to make it compile      elsewhere Dictionary lt object  Property   gt  lookupDictionary   new Dictionary lt object  Property   gt    Property   objectProperties   null  if  lookupDictionary ContainsKey sourceType       objectProperties   lookupProperties sourceType     else        build array of Property references   PropertyInfo   sourcePropertyInfos   sourceType GetProperties      Property   sourceProperties   new Property sourcePropertyInfos length     for  int i 0  i  lt  sourcePropertyInfos length  i          sourceProperties i    sourceType GetProperty pi Name            add to cache   objectProperties   sourceProperties    lookupDictionary object    sourceProperties        loop through and compare against the instances   However  I have to say that I agree with the other posters  This smells lazy and inefficient  You should be implementing IComparable instead  -

User · Answer

You can optimize your code by calling GetProperties only once per type   public static string ToStringNullSafe this object obj        return obj    null   obj ToString     String Empty    public static bool Compare lt T gt  T a  T b  params string   ignore        var aProps   a GetType   GetProperties        var bProps   b GetType   GetProperties        int count   aProps Count        string aa  bb      for  int i   0  i  lt  count  i                  aa   aProps i  GetValue a  null  ToStringNullSafe            bb   bProps i  GetValue b  null  ToStringNullSafe            if  aa    bb  amp  amp  ignore Where x   gt  x    aProps i  Name  Count      0                        return false                      return true

User · Answer

If you are only comparing objects of the same type or further down the inheritance chain  why not specify the parameter as your base type  rather than object    Also do null checks on the parameter as well   Furthermore I d make use of  var  just to make the code more readable  if its c 3 code   Also  if the object has reference types as properties then you are just calling ToString   on them which doesn t really compare values  If ToString isn t overwridden then its just going to return the type name as a string which could return false-positives

User · Answer

UPDATE  The latest version of Compare-Net-Objects is located on GitHub    has NuGet package and Tutorial  It can be called like     This is the comparison class CompareLogic compareLogic   new CompareLogic     ComparisonResult result   compareLogic Compare person1  person2      These will be different  write out the differences if   result AreEqual      Console WriteLine result DifferencesString     Or if you need to change some configuration  use   CompareLogic basicComparison   new CompareLogic      Config   new ComparisonConfig        MaxDifferences   propertyCount         add other configurations           Full list of configurable parameters is in ComparisonConfig cs  Original answer   The limitations I see in your code     The biggest one is that it doesn t do a deep object comparison   It doesn t do an element by element comparison in case properties are lists or contain lists as elements  this can go n-levels    It doesn t take into account that some type of properties should not be compared  e g  a Func property used for filtering purposes  like the one in the PagedCollectionView class   It doesn t keep track of what properties actually were different  so you can show in your assertions     I was looking today for some solution for unit-testing purposes to do property by property deep comparison and I ended up using  http   comparenetobjects codeplex com   It is a free library with just one class which you can simply use like this   var compareObjects   new CompareObjects         CompareChildren   true    this turns deep compare one  otherwise it s shallow     CompareFields   false      CompareReadOnly   true      ComparePrivateFields   false      ComparePrivateProperties   false      CompareProperties   true      MaxDifferences   1      ElementsToIgnore   new List lt string gt       Filter        Assert IsTrue      compareObjects Compare objectA  objectB        compareObjects DifferencesString      Also  it can be easily re-compiled for Silverlight  Just copy the one class into a Silverlight project and remove one or two lines of code for comparisons that are not available in Silverlight  like private members comparison

User · Answer

This method will get properties of the class and compare the values for each property  If any of the values are different  it will return false  else it will return true   public static bool Compare lt T gt  T Object1  T object2          Get the type of the object     Type type   typeof T          return false if any of the object is false     if  Object1    null    object2    null          return false         Loop through each properties inside class and get values for the property from both the objects and compare     foreach  System Reflection PropertyInfo property in type GetProperties                  if  property Name     ExtensionData                         string Object1Value   string Empty              string Object2Value   string Empty              if  type GetProperty property Name  GetValue Object1  null     null                  Object1Value   type GetProperty property Name  GetValue Object1  null  ToString                if  type GetProperty property Name  GetValue object2  null     null                  Object2Value   type GetProperty property Name  GetValue object2  null  ToString                if  Object1Value Trim      Object2Value Trim                                  return false                                    return true      Usage   bool isEqual   Compare lt Employee gt  Object1  Object2

User · Answer

This works even if the objects are different  you could customize the methods in the utilities class maybe you want to compare private properties as well      using System  using System Collections Generic  using System Linq  using System Text   class ObjectA       public string PropertyA   get  set        public string PropertyB   get  set        public string PropertyC   get  set        public DateTime PropertyD   get  set         public string FieldA      public DateTime FieldB     class ObjectB       public string PropertyA   get  set        public string PropertyB   get  set        public string PropertyC   get  set        public DateTime PropertyD   get  set          public string FieldA      public DateTime FieldB       class Program       static void Main string   args                   create two objects with same properties         ObjectA a   new ObjectA     PropertyA    test   PropertyB    test2   PropertyC    test3             ObjectB b   new ObjectB     PropertyA    test   PropertyB    test2   PropertyC    test3                 add fields to those objects         a FieldA    hello           b FieldA    Something differnt            if  a ComparePropertiesTo b                         Console WriteLine  objects have the same properties                      else                       Console WriteLine  objects have diferent properties                         if  a CompareFieldsTo b                         Console WriteLine  objects have the same Fields                      else                       Console WriteLine  objects have diferent Fields                        Console Read             public static class Utilities       public static bool ComparePropertiesTo this Object a  Object b                System Reflection PropertyInfo   properties   a GetType   GetProperties       get all the properties of object a          foreach  var property in properties                        var propertyName   property Name               var aValue   a GetType   GetProperty propertyName  GetValue a  null               object bValue               try    try to get the same property from object b  maybe that property does                    not exist                                 bValue   b GetType   GetProperty propertyName  GetValue b  null                             catch                               return false                             if  aValue    null  amp  amp  bValue    null                  continue               if  aValue    null  amp  amp  bValue    null                  return false               if  aValue    null  amp  amp  bValue    null                 return false                  if properties do not match return false             if  aValue GetHashCode      bValue GetHashCode                                  return false                                   return true               public static bool CompareFieldsTo this Object a  Object b                System Reflection FieldInfo   fields   a GetType   GetFields       get all the properties of object a          foreach  var field in fields                        var fieldName   field Name               var aValue   a GetType   GetField fieldName  GetValue a                object bValue               try    try to get the same property from object b  maybe that property does                not exist                                 bValue   b GetType   GetField fieldName  GetValue b                             catch                               return false                             if  aValue    null  amp  amp  bValue    null                 continue               if  aValue    null  amp  amp  bValue    null                 return false               if  aValue    null  amp  amp  bValue    null                 return false                   if properties do not match return false             if  aValue GetHashCode      bValue GetHashCode                                  return false                                   return true

User · Answer

Do you override  ToString   on all of your objects that are in the properties   Otherwise  that second comparison could come back with null   Also  in that second comparison  I m on the fence about the construct of    A    B  compared to  A    B   in terms of readability six months two years from now   The line itself is pretty wide  which is ok if you ve got a wide monitor  but might not print out very well   nitpick   Are all of your objects always using properties such that this code will work   Could there be some internal  non-propertied data that could be different from one object to another  but all exposed data is the same   I m thinking of some data which could change over time  like two random number generators that happen to hit the same number at one point  but are going to produce two different sequences of information  or just any data that doesn t get exposed through the property interface

User · Answer

Do you override  ToString   on all of your objects that are in the properties   Otherwise  that second comparison could come back with null   Also  in that second comparison  I m on the fence about the construct of    A    B  compared to  A    B   in terms of readability six months two years from now   The line itself is pretty wide  which is ok if you ve got a wide monitor  but might not print out very well   nitpick   Are all of your objects always using properties such that this code will work   Could there be some internal  non-propertied data that could be different from one object to another  but all exposed data is the same   I m thinking of some data which could change over time  like two random number generators that happen to hit the same number at one point  but are going to produce two different sequences of information  or just any data that doesn t get exposed through the property interface

User · Answer

I was looking for a snippet of code that would do something similar to help with writing unit test  Here is what I ended up using   public static bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class           if  self    null  amp  amp  to    null                 Type type   typeof T           List lt string gt  ignoreList   new List lt string gt  ignore           foreach  System Reflection PropertyInfo pi in type GetProperties System Reflection BindingFlags Public   System Reflection BindingFlags Instance                        if   ignoreList Contains pi Name                              object selfValue   type GetProperty pi Name  GetValue self  null                 object toValue   type GetProperty pi Name  GetValue to  null                  if  selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue                                     return false                                                 return true              return self    to        EDIT   Same code as above but uses LINQ and Extension methods    public static bool PublicInstancePropertiesEqual lt T gt  this T self  T to  params string   ignore  where T   class       if  self    null  amp  amp  to    null                var type   typeof T           var ignoreList   new List lt string gt  ignore           var unequalProperties               from pi in type GetProperties BindingFlags Public   BindingFlags Instance              where  ignoreList Contains pi Name   amp  amp  pi GetUnderlyingType   IsSimpleType    amp  amp  pi GetIndexParameters   Length    0             let selfValue   type GetProperty pi Name  GetValue self  null              let toValue   type GetProperty pi Name  GetValue to  null              where selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue               select selfValue          return  unequalProperties Any              return self    to     public static class TypeExtensions                 lt summary gt            Determine whether a type is simple  String  Decimal  DateTime  etc             or complex  i e  custom class with public properties and methods              lt  summary gt             lt see cref  http   stackoverflow com questions 2442534 how-to-test-if-type-is-primitive   gt        public static bool IsSimpleType           this Type type                   return             type IsValueType                type IsPrimitive                new                                typeof String                  typeof Decimal                  typeof DateTime                  typeof DateTimeOffset                  typeof TimeSpan                  typeof Guid                Contains type                  Convert GetTypeCode type     TypeCode Object                  public static Type GetUnderlyingType this MemberInfo member                   switch  member MemberType                         case MemberTypes Event                 return   EventInfo member  EventHandlerType              case MemberTypes Field                 return   FieldInfo member  FieldType              case MemberTypes Method                 return   MethodInfo member  ReturnType              case MemberTypes Property                 return   PropertyInfo member  PropertyType              default                 throw new ArgumentException                                     Input MemberInfo must be if type EventInfo  FieldInfo  MethodInfo  or PropertyInfo

User · Answer

For completeness I want to add reference to  http   www cyotek com blog comparing-the-properties-of-two-objects-via-reflection It has more complete logic than most of others answers on this page   However I prefer Compare-Net-Objects library https   github com GregFinzer Compare-Net-Objects  referred by Liviu Trifoi s answer  The library has NuGet package http   www nuget org packages CompareNETObjects and multiple options to configure

User · Answer

I would add the following line to the PublicInstancePropertiesEqual method to avoid copy  amp  paste errors   Assert AreNotSame self  to

User · Answer

I think it would be best to follow the pattern for Override Object Equals   For a better description  Read Bill Wagner s Effective C  - Item 9 I think  public override Equals object obOther      if  null    obOther      return false    if  object ReferenceEquals this  obOther      return true    if  this GetType      obOther GetType        return false      private method to compare members    return CompareMembers this  obOther as ThisClass        Also in methods that check for equality  you should return either true or false  either they are equal or they are not   instead of throwing an exception  return false   I d consider overriding Object Equals  Even though you must have considered this  using Reflection to compare properties is supposedly slow  I dont have numbers to back this up   This is the default behavior for valueType Equals in C  and it is recommended that you override Equals for value types and do a member wise compare for performance   Earlier I speed-read this as you have a collection of custom Property objects    my bad      Update-Dec 2011     Of course  if the type already has a production Equals   then you need another approach  If you re using this to compare immutable data structures exclusively for test purposes  you shouldn t add an Equals to production classes  Someone might hose the tests by chainging the Equals implementation or you may prevent creation of a production-required Equals implementation

User · Answer

Update on Liviu s answer above - CompareObjects DifferencesString has been deprecated   This works well in a unit test   CompareLogic compareLogic   new CompareLogic    ComparisonResult result   compareLogic Compare object1  object2   Assert IsTrue result AreEqual

User · Answer

I think it would be best to follow the pattern for Override Object Equals   For a better description  Read Bill Wagner s Effective C  - Item 9 I think  public override Equals object obOther      if  null    obOther      return false    if  object ReferenceEquals this  obOther      return true    if  this GetType      obOther GetType        return false      private method to compare members    return CompareMembers this  obOther as ThisClass        Also in methods that check for equality  you should return either true or false  either they are equal or they are not   instead of throwing an exception  return false   I d consider overriding Object Equals  Even though you must have considered this  using Reflection to compare properties is supposedly slow  I dont have numbers to back this up   This is the default behavior for valueType Equals in C  and it is recommended that you override Equals for value types and do a member wise compare for performance   Earlier I speed-read this as you have a collection of custom Property objects    my bad      Update-Dec 2011     Of course  if the type already has a production Equals   then you need another approach  If you re using this to compare immutable data structures exclusively for test purposes  you shouldn t add an Equals to production classes  Someone might hose the tests by chainging the Equals implementation or you may prevent creation of a production-required Equals implementation

User · Answer

The first thing I would suggest would be to split up the actual comparison so that it s a bit more readable  I ve also taken out the ToString   - is that needed     else       object originalProperty   sourceType GetProperty pi Name  GetValue this  null       object comparisonProperty   destinationType GetProperty pi Name  GetValue comparisonObject  null        if  originalProperty    comparisonProperty          return false    The next suggestion would be to minimise the use of reflection as much as possible - it s really slow  I mean  really slow  If you are going to do this  I would suggest caching the property references  I m not intimately familiar with the Reflection API  so if this is a bit off  just adjust to make it compile      elsewhere Dictionary lt object  Property   gt  lookupDictionary   new Dictionary lt object  Property   gt    Property   objectProperties   null  if  lookupDictionary ContainsKey sourceType       objectProperties   lookupProperties sourceType     else        build array of Property references   PropertyInfo   sourcePropertyInfos   sourceType GetProperties      Property   sourceProperties   new Property sourcePropertyInfos length     for  int i 0  i  lt  sourcePropertyInfos length  i          sourceProperties i    sourceType GetProperty pi Name            add to cache   objectProperties   sourceProperties    lookupDictionary object    sourceProperties        loop through and compare against the instances   However  I have to say that I agree with the other posters  This smells lazy and inefficient  You should be implementing IComparable instead  -

User · Answer

This method will get properties of the class and compare the values for each property  If any of the values are different  it will return false  else it will return true   public static bool Compare lt T gt  T Object1  T object2          Get the type of the object     Type type   typeof T          return false if any of the object is false     if  Object1    null    object2    null          return false         Loop through each properties inside class and get values for the property from both the objects and compare     foreach  System Reflection PropertyInfo property in type GetProperties                  if  property Name     ExtensionData                         string Object1Value   string Empty              string Object2Value   string Empty              if  type GetProperty property Name  GetValue Object1  null     null                  Object1Value   type GetProperty property Name  GetValue Object1  null  ToString                if  type GetProperty property Name  GetValue object2  null     null                  Object2Value   type GetProperty property Name  GetValue object2  null  ToString                if  Object1Value Trim      Object2Value Trim                                  return false                                    return true      Usage   bool isEqual   Compare lt Employee gt  Object1  Object2

User · Answer

here is revised one to treat  null   null  as equal   private bool PublicInstancePropertiesEqual lt T gt  T self  T to  params string   ignore  where T   class                       if  self    null  amp  amp  to    null                                Type type   typeof T                   List lt string gt  ignoreList   new List lt string gt  ignore                   foreach  PropertyInfo pi in type GetProperties BindingFlags Public   BindingFlags Instance                                         if   ignoreList Contains pi Name                                                 object selfValue   type GetProperty pi Name  GetValue self  null                           object toValue   type GetProperty pi Name  GetValue to  null                           if  selfValue    null                                                        if   selfValue Equals toValue                                   return false                                                    else if  toValue    null                              return false                                                          return true                            return self    to

User · Answer

To expand on  nawfal s answer  I use this to test objects of different types in my unit tests to compare equal property names  In my case database entity and DTO    Used like this in my test   Assert IsTrue resultDto PublicInstancePropertiesEqual expectedEntity       public static bool PublicInstancePropertiesEqual lt T  Z gt  this T self  Z to  params string   ignore  where T   class       if  self    null  amp  amp  to    null                var type   typeof T           var type2   typeof Z           var ignoreList   new List lt string gt  ignore           var unequalProperties              from pi in type GetProperties BindingFlags Public   BindingFlags Instance             where  ignoreList Contains pi Name             let selfValue   type GetProperty pi Name  GetValue self  null             let toValue   type2 GetProperty pi Name  GetValue to  null             where selfValue    toValue  amp  amp   selfValue    null     selfValue Equals toValue              select selfValue             return  unequalProperties Any              return self    null  amp  amp  to    null

User · Answer

If performance doesn t matter  you could serialize them and compare the results   var serializer   new XmlSerializer typeof TheObjectType    StringWriter serialized1   new StringWriter    serialized2   new StringWriter    serializer Serialize serialized1  obj1   serializer Serialize serialized2  obj2   bool areEqual   serialized1 ToString      serialized2 ToString

User · Answer

If you are only comparing objects of the same type or further down the inheritance chain  why not specify the parameter as your base type  rather than object    Also do null checks on the parameter as well   Furthermore I d make use of  var  just to make the code more readable  if its c 3 code   Also  if the object has reference types as properties then you are just calling ToString   on them which doesn t really compare values  If ToString isn t overwridden then its just going to return the type name as a string which could return false-positives

User · Answer

If you are only comparing objects of the same type or further down the inheritance chain  why not specify the parameter as your base type  rather than object    Also do null checks on the parameter as well   Furthermore I d make use of  var  just to make the code more readable  if its c 3 code   Also  if the object has reference types as properties then you are just calling ToString   on them which doesn t really compare values  If ToString isn t overwridden then its just going to return the type name as a string which could return false-positives

[c#] Comparing object properties in c#

Examples related to c#

Examples related to object

Examples related to properties

Examples related to comparison