通過EF更新底層查找的更好方法？

Question

這裏是我的情況 - 我有這有一個名爲食譜，成分和recipes_ingredients一些表的DB。

食譜是由1+成分組成。

的recipes_ingredients具有食譜和成分表之間FKS。

是那些獲得生成的類是recipe和ingredient和recipe有一個看起來像這樣的導航屬性：

public virtual ICollection<ingredients> ingredients { get; set; }

太好了，我明白，我得到一個產生recipe類和生成的ingredient類recipes_ingredients表不會獲得一個類，因爲EF將其視爲一個導航屬性。現在

，我有一個叫做SetIngredientsForRecipe功能，看起來像這樣（減去在try-catch代碼爲簡潔起見：

public void SetIngredientsForRecipe(long recipeId, List<string> ingredients) 
{ 
    using (var db = new FoodEntities(ConnectionString, null, null)) 
    { 
     var existing = GetCurrentIngredients(recipeId); 
     var toRemove = existing.Except(ingredients); 
     var toAdd = ingredients.Except(existing); 
     var recipe = db.recipes.Where(r => r.Id == recipeId).FirstOrDefault(); 
     foreach (var name in toRemove) 
     { 
     var entry = recipe.ingredients.Where(i => i.Name == name).FirstOrDefault(); 
     recipe.ingredients.Remove(entry); 
     } 
     foreach (var name in toAdd) 
     { 
     var entry = db.ingredients.Where(i => i.Name == name).FirstOrDefault(); 
     recipe.ingredients.Add(entry); 
     } 
     db.SaveChanges(); 
    } 
} 

這樣做的目的，顧名思義，是更新成分表對於給定的食譜只能無論是在列表中。我仍然獲得舒適與EF和想知道是否有一個更好的（更有效？）的方式來完成我想要做的事。

---

後續：

繼ntziolis下面的建議，我選擇使用

recipe.ingredients.Clear()以清除任何在配方/成分映射，然後用它提到了對快速添加新的嘲諷。類似這樣的：

foreach (var name in ingredients) 
{ 
    // Mock an ingredient since we just need the FK that is referenced 
    // by the mapping table - the other properties don't matter since we're 
    // just doing the mapping not inserting anything 

    recipe.ingredients.Add(new Ingredient() 
    { 
    Name = name 
    }); 
} 

並且這個工作非常好。

Answer 1

一般性能準則是：

• 嘗試處理ID唯一
• 模擬實體只要有可能，而不是從數據庫
• 使用EF4的新功能，如Contains爲了簡化檢索它們並加快您的代碼

基於這些原則，這裏是一個優化（雖然不簡單）解決您的問題：

public void SetIngredientsForRecipe(long recipeId, List<string> ingredients) 
{ 
    using (var db = new FoodEntities(ConnectionString, null, null)) 
    { 
     var recipe = db.recipe.Single(r => r.ID == recipeId); 

     // make an array since EF4 supports the contains keyword for arrays 
     var ingrArr = ingredients.ToArray(); 

     // get the ids (and only the ids) of the new ingredients 
     var ingrNew = new HasSet<int>(db.ingrediants 
     .Where(i => ingrArr.Contains(i.Name)) 
     .Select(i => I.Id)); 

     // get the ids (again only the ids) of the current receipe 
     var curIngr = new HasSet<int>(db.receipes 
     .Where(r => r.Id == recipeId) 
     .SelectMany(r => r.ingredients) 
     .Select(i => I.Id));   

     // use the build in hash set functions to get the ingredients to add/remove    
     var toAdd = ingrNew.ExpectWith(curIngr); 
     var toRemove = curIngr.ExpectWith(ingrNew); 

     foreach (var id in toAdd) 
     { 
     // mock the ingredients rather than fetching them, for relations only the id needs to be there 
     recipe.ingredients.Add(new Ingredient() 
     { 
      Id = id 
     }); 
     } 

     foreach (var id in toRemove) 
     { 
     // again mock only 
     recipe.ingredients.Remove(new Ingredient() 
     { 
      Id = id 
     }); 
     } 

     db.SaveChanges(); 
    } 
} 

如果你想更簡單，你可以只清除所有成分，並重新在必要時添加它們，EF甚至可能是足夠聰明弄清楚，關係沒有發生變化，不知道這件事，但：

public void SetIngredientsForRecipe(long recipeId, List<string> ingredients) 
{ 
    using (var db = new FoodEntities(ConnectionString, null, null)) 
    {  
    var recipe = db.recipe.Single(r => r.ID == recipeId); 

    // clear all ingredients first 
    recipe.ingredients.Clear() 

    var ingrArr = ingredients.ToArray(); 
    var ingrIds = new HasSet<int>(db.ingrediants 
     .Where(i => ingrArr.Contains(i.Name)) 
     .Select(i => I.Id)); 

    foreach (var id in ingrIds) 
    { 
     // mock the ingredients rather than fetching them, for relations only the id needs to be there 
     recipe.ingredients.Add(new Ingredient() 
     { 
     Id = id 
     }); 
    } 

    db.SaveChanges(); 
    } 
} 

UPDATE
一些編碼錯誤已經被修正。

Answer 2

您可以用FirstOrDefault電話凝結在Where條款：

recipe.ingredients.FirstOrDefault(i => i.Name == name); 

雖然我個人更喜歡使用SingleOrDefault，雖然我不知道的區別到底是什麼：

recipe.ingredients.SingleOrDefault(i => i.Name == name); 

而且，因爲傳入的成分列表是List<string>（與成分ID列表相對），這意味着也可以創建新成分作爲此過程的一部分，而不是處理（雖然可能爲了簡潔而被忽略）。