如何比較具有相似屬性的兩個明顯不同的對象

Question

這是使用.NET 2.0的C＃中的所有內容。

我有對象的兩個列表。它們不是相關的對象，但它們確實有一些共同點，比如基於Guid的獨特標識符。這兩個列表需要 由只包含的GUID另一個列表可能會或可能不會與 匹配過濾的ID的包含在第一個兩個列表。

我曾經想過把每個對象列表轉換爲'對象'並按 排序的想法，但我不確定一旦它被投射就能夠訪問ID屬性， m 認爲排序這兩個列表的方法在知道要排序的列表是什麼時應該有點愚蠢。

什麼是每個對象名單帶來，以便它可以對列表中只用ID的排序的最佳方式？

Answer 1

你應該讓你的每一個對象的不同實現共同的接口。然後爲該接口創建一個IComparer < T>並在您的排序中使用它。

Answer 2

我不知道我完全理解你想要什麼，但你可以使用LINQ選擇了從列表中匹配的項目，以及對它們進行排序。下面是一個簡單的例子，其中一個列表中的值在另一個列表中被過濾並排序。

 List<int> itemList = new List<int>() { 9,6,3,4,5,2,7,8,1 }; 
     List<int> filterList = new List<int>() { 2, 6, 9 }; 

     IEnumerable<int> filtered = itemList.SelectMany(item => filterList.Where(filter => filter == item)).OrderBy(p => p); 

Answer 3

我還沒有機會使用AutoMapper呢，但是從你的描述你希望check it out。從吉米·博加德的帖子：

AutoMapper公約

由於AutoMapper變平，它將 尋找：

匹配屬性名稱

嵌套屬性名（Product.Name 映射到產品名稱，通過假設 PascalCase命名約定）

方法開始W¯¯第i個字「獲取」， 所以GetTotal（）映射到總計

現有的任何類型的地圖已經 配置

基本上，如果你刪除了所有的 「點」和「獲取」，AutoMapper將 比賽屬性名稱。現在， AutoMapper不匹配 類型，但由於其他一些原因不會失敗。

Answer 4

我不能完全確定，但是你想什麼作爲你的最終結果，....

如果你比較兩種不同類型的屬性，你可以投影屬性名稱和相應的數值，兩個字典。並用這些信息做一些排序/差異的財產價值。

 Guid newGuid = Guid.NewGuid(); 
     var classA = new ClassA{Id = newGuid}; 
     var classB = new ClassB{Id = newGuid}; 

     PropertyInfo[] classAProperties = classA.GetType().GetProperties(); 

     Dictionary<string, object> classAPropertyValue = classAProperties.ToDictionary(pName => pName.Name, 
                       pValue => 
                       pValue.GetValue(classA, null)); 

     PropertyInfo[] classBProperties = classB.GetType().GetProperties(); 
     Dictionary<string, object> classBPropetyValue = classBProperties.ToDictionary(pName => pName.Name, 
                       pValue => 
                       pValue.GetValue(classB, null)); 


internal class ClassB 
{ 
    public Guid Id { get; set; } 
} 

internal class ClassA 
{ 
    public Guid Id { get; set; } 
} 

classAPropertyValue 
Count = 1 
    [0]: {[Id, d0093d33-a59b-4537-bde9-67db324cf7f6]} 

classBPropetyValue 
Count = 1 
    [0]: {[Id, d0093d33-a59b-4537-bde9-67db324cf7f6]} 

Answer 5

僅使用.NET 2。0方法：

class Foo 
{ 
    public Guid Guid { get; } 
} 

List<Foo> GetFooSubset(List<Foo> foos, List<Guid> guids) 
{ 
    return foos.FindAll(foo => guids.Contains(foo.Guid)); 
} 

如果你的類沒有實現一個共同的接口，你必須實現GetFooSubset每種類型分別。

Answer 6

編輯方針基本上應該得到你想要的東西 - 但你可能會使用LINQ

class T1 
{ 
    public T1(Guid g, string n) { Guid = g; MyName = n; } 
    public Guid Guid { get; set; } 
    public string MyName { get; set; } 
} 
class T2 
{ 
    public T2(Guid g, string n) { ID = g; Name = n; } 
    public Guid ID { get; set; } 
    public string Name { get; set; } 
} 
class Test 
{ 
    public void Run() 
    { 
     Guid G1 = Guid.NewGuid(); 
     Guid G2 = Guid.NewGuid(); 
     Guid G3 = Guid.NewGuid(); 
     List<T1> t1s = new List<T1>() { 
      new T1(G1, "one"), 
      new T1(G2, "two"), 
      new T1(G3, "three") 
     }; 
     List<Guid> filter = new List<Guid>() { G2, G3}; 

     List<T1> filteredValues1 = t1s.FindAll(delegate(T1 item) 
     { 
      return filter.Contains(item.Guid); 
     }); 

     List<T1> filteredValues2 = t1s.FindAll(o1 => filter.Contains(o1.Guid)); 
    } 
} 

Answer 7

好的更好，如果你有機會到只修改原來的類來添加界面出現，馬修就​​能辨出上。我在這裏變得有點瘋狂，並使用2.0匿名代表定義了一個完整的解決方案。 （我認爲我沉迷於3.0 Lambda;否則，如果我仍然使用2005，我可能會將它寫在foreach循環中）。

基本上，創建一個與公共屬性的接口。讓yoru兩班實現界面。創建一個通用列表作爲界面，將這些值轉換並轉換爲新列表;刪除任何不匹配的項目。

//Program Output: 
List1: 
206aa77c-8259-428b-a4a0-0e005d8b016c 
64f71cc9-596d-4cb8-9eb3-35da3b96f583 

List2: 
10382452-a7fe-4307-ae4c-41580dc69146 
97f3f3f6-6e64-4109-9737-cb72280bc112 
64f71cc9-596d-4cb8-9eb3-35da3b96f583 

Matches: 
64f71cc9-596d-4cb8-9eb3-35da3b96f583 
Press any key to continue . . . 


using System; 
using System.Collections.Generic; 
using System.Text; 

namespace ConsoleApplication8 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      //test initialization 
      List<ClassTypeA> list1 = new List<ClassTypeA>(); 
      List<ClassTypeB> list2 = new List<ClassTypeB>(); 

      ClassTypeA citem = new ClassTypeA(); 
      ClassTypeB citem2 = new ClassTypeB(); 
      citem2.ID = citem.ID; 

      list1.Add(new ClassTypeA()); 
      list1.Add(citem); 
      list2.Add(new ClassTypeB()); 
      list2.Add(new ClassTypeB()); 
      list2.Add(citem2); 


      //new common list. 
      List<ICommonTypeMakeUpYourOwnName> common_list = 
         new List<ICommonTypeMakeUpYourOwnName>(); 

      //in english, give me everything in list 1 
      //and cast it to the interface 
      common_list.AddRange(
       list1.ConvertAll<ICommonTypeMakeUpYourOwnName>(delegate(
        ClassTypeA x) { return (ICommonTypeMakeUpYourOwnName)x; })); 

      //in english, give me all the items in the 
      //common list that don't exist in list2 and remove them. 
      common_list.RemoveAll(delegate(ICommonTypeMakeUpYourOwnName x) 
       { return list2.Find(delegate(ClassTypeB y) 
         {return y.ID == x.ID;}) == null; }); 

      //show list1 
      Console.WriteLine("List1:"); 
      foreach (ClassTypeA item in list1) 
      { 
       Console.WriteLine(item.ID); 
      } 
      //show list2 
      Console.WriteLine("\nList2:"); 
      foreach (ClassTypeB item in list2) 
      { 
       Console.WriteLine(item.ID); 
      } 

      //show the common items 
      Console.WriteLine("\nMatches:"); 
      foreach (ICommonTypeMakeUpYourOwnName item in common_list) 
      { 
       Console.WriteLine(item.ID); 
      } 
     } 

    } 

    interface ICommonTypeMakeUpYourOwnName 
    { 
     Guid ID { get; set; } 
    } 

    class ClassTypeA : ICommonTypeMakeUpYourOwnName 
    { 
     Guid _ID; 
     public Guid ID {get { return _ID; } set { _ID = value;}} 
     int _Stuff1; 
     public int Stuff1 {get { return _Stuff1; } set { _Stuff1 = value;}} 
     string _Stuff2; 
     public string Stuff2 {get { return _Stuff2; } set { _Stuff2 = value;}} 

     public ClassTypeA() 
     { 
      this.ID = Guid.NewGuid(); 
     } 
    } 

    class ClassTypeB : ICommonTypeMakeUpYourOwnName 
    { 
     Guid _ID; 
     public Guid ID {get { return _ID; } set { _ID = value;}} 
     int _Stuff3; 
     public int Stuff3 {get { return _Stuff3; } set { _Stuff3 = value;}} 
     string _Stuff4; 
     public string Stuff4 {get { return _Stuff4; } set { _Stuff4 = value;}} 

     public ClassTypeB() 
     { 
      this.ID = Guid.NewGuid(); 
     } 

    } 
}