重構代碼到一個通用的方法

Question

我在我的EntityFramework支持的存儲庫中有一個重新啓動的代碼塊，我想以某種方式通用化並作爲方法調用，因此重複使用代碼而不是重複它。

當前碼塊看起來像這樣：

 // Archive deleted MyItems sections 
     _t.MyItems.Where(x => x.ValidTo == null && !team.MyItems.Contains(x)).ToList().ForEach(x => x.ValidTo = DateTime.Now); 

     // Add or update MyItems sections 
     foreach (var MyItemsSection in team.MyItems) 
     { 
      if (MyItemsSection.Id == default(int)) 
      { 
       MyItemsSection.ValidFrom = DateTime.Now; 
       _t.MyItems.Add(MyItemsSection); 
      } 
      else 
      { 
       var _MyItemsSection = _t.MyItems.FirstOrDefault(x => x.Id == MyItemsSection.Id); 
       context.Entry(_MyItemsSection).CurrentValues.SetValues(MyItemsSection); 
      } 
     } 

_t是的EntityFramework連接對象圖，而team是已被斷開，並可能從外部更新的對象圖的相同類型。這裏的目標是同步兩個對象圖，以便更改得以持續。

我需要_t.MyItems和team.MyItems，其中MyItems要genericised通過使同樣的方法適用於MyOtherItems和MySocks，MyUnderPants等

這是在所有可能的？

Answer 1

在回答我自己的問題，這裏就是答案 - 我錯過了什麼，你可以要求傳入類型爲實現特定的接口，而且還有它可作爲事實鍵入想要的。

所以，這裏是我想出了：

public void UpdateEntities<TEntity>(ICollection<TEntity> pocoCollection, ICollection<TEntity> dbCollection) 
     where TEntity : class, IEntity 
    { 
     // Archive deleted entities 
     dbCollection.Where(x => x.ValidTo == null && !pocoCollection.Contains(x)).ToList().ForEach(x => x.ValidTo = DateTime.Now); 

     // Add or update entities 
     foreach (var entity in pocoCollection) 
     { 
      if (entity.Id == default(int)) 
      { 
       entity.ValidFrom = DateTime.Now; 
       dbCollection.Add(entity); 
      } 
      else 
      { 
       var _entity = dbCollection.FirstOrDefault(x => x.Id == entity.Id); 
       context.Entry(_entity).CurrentValues.SetValues(entity); 
      } 
     } 
    } 

的一部分，我一直在尋找的是where TEntity : class, IEntity

在這個解決方案，我必須確保我的實體實現接口IEntity，它僅僅是：

public interface IEntity 
{ 
    int Id { get; set;} 
    DateTime ValidFrom { get; set; } 
    DateTime? ValidTo { get; set; } 
} 

這允許編譯器退出抱怨使用這些屬性的，而我仍然可以使用的實際類型所以實體框架也很滿意，並且對發生的事情不再感到困惑。

希望這可以幫助別人。

Answer 2

有兩種選擇：您可以將對象限制爲包含要在泛型方法中訪問的屬性和方法的已知基本類型，也可以使用謂詞執行選擇。

約束：

// base type 
interface IFoo { 
    int ID { get; set; } 
} 

    // generic method 
    public List<T> Update<T>(List<T> graph1, List<T> graph2) where T : IFoo { 
    var update = graph1.Intersect(graph2, (g1, g2) => { g1.ID == g2.ID }).ToList(); 
    return update; 
    } 

謂詞：

public void Update<T, U>(T _t, T team, Func<T, IList<U>> selector) 
{ 
    var _tItems = selector(_t); 
    var teamItems = selector(team); 

    // Archive deleted MyItems sections 
    _tItems.Where(x => x.ValidTo == null && !teamItems.Contains(x)).ToList().ForEach(x => x.ValidTo = DateTime.Now); 

    // Add or update MyItems sections 
    foreach (var MyItemsSection in teamItems) 
    { 
     if (MyItemsSection.Id == default(int)) 
     { 
      MyItemsSection.ValidFrom = DateTime.Now; 
      _tItems.Add(MyItemsSection); 
     } 
     else 
     { 
      var _MyItemsSection = _tItems.FirstOrDefault(x => x.Id == MyItemsSection.Id); 
      context.Entry(_MyItemsSection).CurrentValues.SetValues(MyItemsSection); 
     } 
    } 
} 

    //Usage: 
    Update(_t, team, (t => t.MyItems)); 

不過話又說回來，是什麼讓你寫它接受列表作爲參數的方法？

如public void Update<T>(IList<T> _tItems, IList<T> teamItems)