Réflexion - comparaison d'objets et valeurs par défaut

Question

J'essaie de comparer deux objets complexes en C#, et de produire un dictionnaire contenant les différences entre les deux.

Si j'ai une classe comme ceci:

public class Product 
{ 
    public int Id {get; set;} 
    public bool IsWhatever {get; set;} 
    public string Something {get; set;} 
    public int SomeOtherId {get; set;} 
} 

Et un exemple, ainsi:

var p = new Product 
        { 
         Id = 1, 
         IsWhatever = false, 
         Something = "Pony", 
         SomeOtherId = 5 
        }; 

et un autre:

var newP = new Product 
    { 
     Id = 1, 
     IsWhatever = true 
    }; 

Pour obtenir les différences entre ceux-ci, i fais des choses qui comprend ceci:

var oldProps = p.GetType().GetProperties(); 
var newProps = newP.GetType().GetProperties(); 

// snip 
foreach(var newInfo in newProps) 
{ 
    var oldVal = oldInfo.GetValue(oldVersion, null); 
    var newVal = newInfo.GetValue(newVersion,null); 
} 

// snip - some ifs & thens & other stuff 

et il est cette ligne qui est d'intérêt

var newVal = newInfo.GetValue(newVersion,null); 

En utilisant l'exemple des objets ci-dessus, cette ligne me donnerait une valeur par défaut de 0 pour SomeOtherId (même histoire pour bools & DateTimes & whathaveyou).

Qu'est-ce que je cherche est d'avoir newProps inclure uniquement les propriétés qui sont explicitement spécifiées dans l'objet, donc dans l'exemple ci-dessus, Id et . J'ai joué environ avec BindingFlags en vain.

Est-ce possible? Y a-t-il une façon plus propre/meilleure de le faire, ou un outil qui est là pour me sauver la peine?

Merci.

Answer 1

J'ai fini par corriger le problème sans utiliser de réflexion (ou, ne l'utilisant pas au moins de cette façon).

Il va, plus ou moins, comme ceci:

public class Comparable 
{ 
    private IDictionary<string, object> _cache; 

    public Comparable() 
    { 
     _cache = new Dictionary<string, object>(); 
    } 

    public IDictionary<string, object> Cache { get { return _cache; } } 

    protected void Add(string name, object val) 
    { 
     _cache.Add(name, val); 
    } 
} 

Et la mise en œuvre du produit va à ceci:

public class Product : Comparable 
{ 
    private int _id; 
    private bool _isWhatever; 
    private string _something; 
    private int _someOtherId; 

    public int Id {get { return _id; } set{ _id = value; Add("Id", value); } } 
    public bool IsWhatever { get { return _isWhatever; } set{ _isWhatever = value; Add("IsWhatever ", value); } } 
    public string Something {get { return _something; } set{ _something = value; Add("Something ", value); } } 
    public int SomeOtherId {get { return _someOtherId; } set{ _someOtherId = value; Add("SomeOtherId", value); } } 
} 

Et la comparaison est alors assez simple

var dic = new Dictionary<string, object>(); 

foreach(var obj in version1.Cache) 
{ 
    foreach(var newObj in version2.Cache) 
    { 
     //snip -- do stuff to check equality 
     dic.Add(....); 
    } 
} 

Ne salit pas énormément le modèle, et fonctionne bien.

Answer 2

Il n'y a pas d'indicateur à indiquer si une propriété a été explicitement définie. Ce que vous pouvez faire est de déclarer vos propriétés en tant que types nullable et comparer la valeur à null.

Answer 3

Si je vous comprends bien, c'est ce que Microsoft a fait avec les classes d'emballage xml, générés avec l'utilitaire xsd, où vous avez eu un XIsSpecified, ou quelque chose comme ça, pour chaque propriété X.

Donc, c'est ce que vous pouvez faire aussi bien - au lieu de public int ID{get;set;}, ajouter un membre privé _id, ou tout ce que vous choisissez de l'appeler, et une propriété booléenne IDSpecified qui sera défini sur true chaque fois poseur de Id est appelé