C# - Generische Methode zur Objektüberwachung mit verschachtelten komplexen Eigenschaften wie Liste und iEnumeable

Question

Ich versuche eine generische Methode zu erstellen, die zwei Objekte als Parameter akzeptiert und jede Eigenschaft innerhalb der Objekte vergleicht und die Unterschiede zurückgibt. Jetzt implementiere ich dies mit Reflektion und das funktioniert gut für die einfachen Eigenschaften (int, string ....).

Aber wenn es um komplexe Datentypen wie eine Liste, Array usw. geht, muss ich die Anzahl der Elemente in diesen Listen hinzugefügt oder entfernt verfolgen. Ich versuche, das gleiche unter Verwendung von Code herauszufinden, bin aber irgendwie für komplexe Typen fest.

In für jede Schleife gibt es mir newItem und OldItem des Objekttyps. Kann andere Operationen nicht ausführen.

Ich brauche eine Lösung, um die hinzugefügten und entfernten Elemente aus IEnumerable Typ Eigenschaften zu finden.

Alle Vorschläge, um fortzufahren, werden geschätzt.

Danke !!

private static string GenerateAuditLogMessage<T>(T oldObject, T newObject) 
    { 
     PropertyInfo[] properties = typeof(T).GetProperties(); 
     foreach (PropertyInfo pi in properties) 
     { 
      object oldValue = pi.GetValue(oldObject), newValue = pi.GetValue(newObject); 

      if (pi.PropertyType.IsGenericType && typeof(IEnumerable).IsAssignableFrom(pi.PropertyType)) 
      { 
       Type type = oldValue.GetType().GetGenericArguments()[0]; 
       foreach (var oldItem in (IEnumerable)oldValue) 
       { 
        foreach (var newItem in (IEnumerable)newValue) 
        { 
         var propertyResult = GenerateAuditLogMessage<object>(oldObject, newObject); 
         if (string.IsNullOrEmpty(propertyResult)) 
         { 
          // newItem. 
         } 
        } 
       } 
       /* Need something like below commented line.*/ 
       // var added = newValue.Except(oldValue) 
       // var removed = oldValue.Except(newValue); 
      } 
      else 
      { 
       if (!object.Equals(oldValue, newValue)) 
       { 
        //.... 
       } 
      } 
     } 

     return string.Empty; 
    } 

Answer 1

Dies ist eine Sache, die alten pre-generic System.Collections.* Schnittstellen für noch verwendet werden: Mit Reflexion über generische Sammlungen.

können Sie werfen jede generische System.Collections.Generic.IEnumerable<T>-System.Collections.IEnumerable, jede System.Collections.Generic.IList<T> zu System.Collections.IList usw. Dann können Sie eine Schleife durch sie in irgendeiner Weise sie unterstützen.

Sie rufen bereits o.GetType().GetGenericArguments() an, um sicherzustellen, dass es sich um Sammlungen desselben Typs handelt. Wenn dies der Fall ist, können Sie die Objekte in den Sammlungen über die nicht generischen Auflistungsschnittstellen abrufen. Sobald Sie die Objekte haben, natürlich, einfach rekursiv.