L'Obtention De La Différence Entre Deux Objets Ayant Les Mêmes Propriétés

Je suis en train d'essayer d'obtenir une liste des modifications qui ont été apportées à un Employé modèle (objet 1) à l'aide d'un EmployeeHistory modèle (objet 2). Fondamentalement, il y a un seul enregistrement de l'employé, mais il y a plusieurs EmployeeHistory enregistrements. Chaque fois que quelque chose est changé d'un Employé, un nouvel enregistrement est ajouté à la EmployeeHistory table qui contient les données de l'Employé avant le changement. J'ai besoin d'un moyen de comparer chacun des EmployeeHistory Dossiers et retourner une liste de chaînes de déclaration les modifications qui ont été apportées. Donc, afin d'obtenir la liste des changements que je veux parcourir la liste des EmployeeHistory enregistrements et de comparer chaque EmployeeHistory Enregistrement avec le précédent EmployeeHistory enregistrement. Et le tout dernier EmployeeHistory enregistrement devra être comparé à l'Employé (objet 1) enregistrement qui est très similaire dans les propriétés. Est-il possible de le faire sans avoir une quantité folle de SI les déclarations de comparer les deux propriétés sur chacun de ces dossiers?

C'est le genre de ce que je suis à la recherche d':

 public List<string> GetEmployeeMasterHistory(Models.EmployeeMaster employee,IEnumerable<EmployeeMasterHistory> employeeHistoryCollection)
 {
       foreach (var historyRecord in employeeHistoryCollection)
       {
          //Compare historyRecord to EmployeeCollection[historyRecord.Index() - 1]
       }
       return null;
 }

J'ai déjà une méthode qui ne tous les vérifier pour chacune des propriétés, mais il va y avoir beaucoup plus de propriétés ajoutées dans le futur et j'ai fatigué de devoir ajouter de nouveaux SI les déclarations et il ne semble pas très efficace.

Voici ce qu'un EmployeeMasterHistory Record ressemble:

 public partial class EmployeeMasterHistory
{
public Nullable<int> EmployeeNumber { get; set; }
public Nullable<int> CompanyNumber { get; set; }
public string UserName { get; set; }
public string Initials { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string FullName { get; set; }
public Nullable<bool> StatusFlag { get; set; }
public Nullable<System.DateTime> StartDate { get; set; }
public Nullable<System.DateTime> TerminationDate { get; set; }
public string Branch { get; set; }
public Nullable<int> DepartmentNumber { get; set; }
public string Supervisor { get; set; }
public Nullable<int> Shift { get; set; }
public Nullable<int> UnionNo { get; set; }
public string G2ID { get; set; }
public Nullable<bool> EnterTimeFl { get; set; }
public string Phone { get; set; }
public string Extension { get; set; }
public string CellPhone { get; set; }
public string Email { get; set; }
public Nullable<int> PrimaryJobRole { get; set; }
public Nullable<int> JobLevel { get; set; }
public Nullable<int> JobGroup { get; set; }
public string JobTitle { get; set; }
public string EmployeeType { get; set; }
public string PayType { get; set; }
public Nullable<decimal> Rate { get; set; }
public Nullable<System.DateTime> LastReviewDate { get; set; }
public Nullable<System.DateTime> NextReviewDate { get; set; }
public Nullable<System.DateTime> LastPayChangeDate { get; set; }
public string EmergencyContact { get; set; }
public string EmergencyContactRelationship { get; set; }
public string EmergencyContactPhone { get; set; }
public Nullable<bool> CPComputer { get; set; }
public Nullable<bool> CPPhone { get; set; }
public Nullable<bool> CPCreditCard { get; set; }
public Nullable<bool> CPGasCard { get; set; }
public Nullable<bool> CPKeys { get; set; }
public Nullable<bool> CPSecurityCard { get; set; }
public Nullable<bool> CPVehicle { get; set; }
public Nullable<bool> CPTools { get; set; }
public Nullable<bool> CPUniform { get; set; }
public string ModBy { get; set; }
public Nullable<System.DateTime> ModDate { get; set; }
public int ID { get; set; }
public string SalesRep { get; set; }
public string MiddleName { get; set; }
public Nullable<int> ManagerEmpNo { get; set; }
public Nullable<bool> TempFl { get; set; }
public Nullable<bool> PEWFl { get; set; }
public Nullable<bool> PGTFl { get; set; }
public Nullable<bool> PMPFl { get; set; }
public Nullable<bool> PPGEFl { get; set; }
public Nullable<bool> PPGFl { get; set; }
public Nullable<bool> PRCFl { get; set; }
public Nullable<bool> PTCFl { get; set; }
public Nullable<bool> PPFl { get; set; }
public Nullable<bool> SWPFl { get; set; }
public Nullable<int> PrimaryDivision { get; set; }
public string TechGroupID { get; set; }
public string TechLevelID { get; set; }
public Nullable<bool> TechATD { get; set; }
public Nullable<int> ReviewPeriod { get; set; }
public Nullable<bool> CorpFl { get; set; }
}

Vous en remercie d'avance!

Sonne comme un travail de réflexion sur le dessus de ma tête.
Vous pouvez utiliser la réflexion pour identifier les propriétés de comparer. Ensuite, c'est juste une question de l'utilisation d'une boucle au lieu d'écrire un nouveau paragraphe pour chaque propriété. Si vous ne souhaitez comparer certaines propriétés, vous pouvez définir un Attribut personnalisé, que ce soit à l'opt-dans les propriétés de la comparaison, ou opt-out.
J'ai fait quelques recherches sur la réflexion parce que je suis de nouveau pour elle. Je vais essayer et créer une solution de l'utiliser. Merci les gars, c'est très utile.
utiliser la réflexion et peut-être lu sur IComparable et de comprendre la différence entre == && Object.Equals()
j'ai utilisé cette bibliothèque avec d'excellents résultats: comparenetobjects.codeplex.com

OriginalL'auteur user3788671 | 2014-10-17

  1. 21

    Ici est une approche très simple à l'aide de la réflexion:

            var oOldRecord = new EmployeeMasterHistory();
oOldRecord.EmployeeNumber = 1;
var oNewRecord = new EmployeeMasterHistory();
oNewRecord.EmployeeNumber = 2;
oNewRecord.CompanyNumber = 3;
var oType = oOldRecord.GetType();
foreach (var oProperty in oType.GetProperties())
{
var oOldValue = oProperty.GetValue(oOldRecord, null);
var oNewValue = oProperty.GetValue(oNewRecord, null);
//this will handle the scenario where either value is null
if (!object.Equals(oOldValue, oNewValue))
{
//Handle the display values when the underlying value is null
var sOldValue = oOldValue == null ? "null" : oOldValue.ToString();
var sNewValue = oNewValue == null ? "null" : oNewValue.ToString();
System.Diagnostics.Debug.WriteLine("Property " + oProperty.Name + " was: " + sOldValue + "; is: " + sNewValue);
}
}

    La sortie de cet exemple est la suivante:

    Property EmployeeNumber was: 1; is: 2
Property CompanyNumber was: null; is: 3

    C'est sans doute ce besoin de nettoyage, mais devrait vous aider à démarrer sur la voie de droite.

    Peut-être !object.Equals(oOldValue, oNewValue)?
    excellente suggestion! Toujours avoir à traiter avec des valeurs null lors de l'enregistrement de l'différences, mais qui devrait être un peu plus facile à traiter.
    Merci beaucoup

    OriginalL'auteur competent_tech

  2. 15

    L'autre réponse est un bon début. Mais je suis allé de l'avant et a écrit ce plus étoffé exemple, j'ai donc pensé que je pourrais aussi bien le poster aussi. Ce on manipule des valeurs nulles et offre une façon d'opt-out propriétés de la comparaison. Il reste basique, mais doit aller plus loin, en supposant que mentionnées précédemment bibliothèque, ce n'est pas ce que vous voulez utiliser.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace TestCompareProperties
{
class Program
{
class IgnorePropertyCompareAttribute : Attribute { }
class A
{
public int Property1 { get; private set; }
public string Property2 { get; private set; }
[IgnorePropertyCompare]
public bool Property3 { get; private set; }
public A(int property1, string property2, bool property3)
{
Property1 = property1;
Property2 = property2;
Property3 = property3;
}
}
class PropertyCompareResult
{
public string Name { get; private set; }
public object OldValue { get; private set; }
public object NewValue { get; private set; }
public PropertyCompareResult(string name, object oldValue, object newValue)
{
Name = name;
OldValue = oldValue;
NewValue = newValue;
}
}
private static List<PropertyCompareResult> Compare<T>(T oldObject, T newObject)
{
PropertyInfo[] properties = typeof(T).GetProperties();
List<PropertyCompareResult> result = new List<PropertyCompareResult>();
foreach (PropertyInfo pi in properties)
{
if (pi.CustomAttributes.Any(ca => ca.AttributeType == typeof(IgnorePropertyCompareAttribute)))
{
continue;
}
object oldValue = pi.GetValue(oldObject), newValue = pi.GetValue(newObject);
if (!object.Equals(oldValue, newValue))
{
result.Add(new PropertyCompareResult(pi.Name, oldValue, newValue));
}
}
return result;
}
static void Main(string[] args)
{
A[] rga = { new A(1, "1", false), new A(2, "1", true), new A(2, null, false) };
for (int i = 0; i < rga.Length - 1; i++)
{
Console.WriteLine("Comparing {0} and {1}:", i, i + 1);
foreach (PropertyCompareResult resultItem in Compare(rga[i], rga[i+1]))
{
Console.WriteLine("  Property name: {0} -- old: {1}, new: {2}",
resultItem.Name, resultItem.OldValue ?? "<null>", resultItem.NewValue ?? "<null>");
}
}
}
}
}
    Merci Pierre, je suis toujours ouvert aux suggestions. Je suis plus récente de ce genre de choses donc il est intéressant de voir toutes les différentes façons d'aller à ce sujet.

    OriginalL'auteur Peter Duniho