過濾器的LINQ除了在性能

Question

這可能看起來很傻，但所有的例子，我發現在使用LINQ使用Except兩個列表或僅字符串或整數數組和過濾他們根據比賽，例如：

var excludes = users.Except(matches); 

我想用排除，以保持我的代碼短而簡單，但似乎無法找出如何做到以下幾點：

class AppMeta 
{ 
    public int Id { get; set; } 
} 

var excludedAppIds = new List<int> {2, 3, 5, 6}; 
var unfilteredApps = new List<AppMeta> 
         { 
          new AppMeta {Id = 1}, 
          new AppMeta {Id = 2}, 
          new AppMeta {Id = 3}, 
          new AppMeta {Id = 4}, 
          new AppMeta {Id = 5} 
         } 

我怎樣可以過濾對AppMeta回列表excludedAppIds？

Answer 1

嘗試一個簡單的地方查詢

var filtered = unfilteredApps.Where(i => !excludedAppIds.Contains(i.Id)); 

的只是方法使用平等，你的列表中包含不同類型的對象，所以沒有一個項目所包含將等於！

Answer 2

從排除列表構造一個List<AppMeta>並使用Except Linq運算符。

var ex = excludedAppIds.Select(x => new AppMeta{Id = x}).ToList();       
var result = ex.Except(unfilteredApps).ToList(); 

Answer 3

ColinE的回答簡單而優雅。如果您的列表較大，並且排除了排除的應用程序列表，則BinarySearch<T>可能會比Contains更快。

例：

unfilteredApps.Where(i => excludedAppIds.BinarySearch(i.Id) < 0); 

Answer 4

我使用除擴展方法，它允許你用橙子，只要它們都具有共同的東西，可以用來對它們進行比較比較蘋果，像一個標識或鑰匙。

public static class ExtensionMethods 
{ 
    public static IEnumerable<TA> Except<TA, TB, TK>(
     this IEnumerable<TA> a, 
     IEnumerable<TB> b, 
     Func<TA, TK> selectKeyA, 
     Func<TB, TK> selectKeyB, 
     IEqualityComparer<TK> comparer = null) 
    { 
     return a.Where(aItem => !b.Select(bItem => selectKeyB(bItem)).Contains(selectKeyA(aItem), comparer)); 
    } 
} 

然後使用它是這樣的：

var filteredApps = unfilteredApps.Except(excludedAppIds, a => a.Id, b => b); 

擴展非常相似，可啉的答案，它只是打包成一個整齊的擴展，它可以在不太多的精神開銷被重用。

Answer 5

這是LINQ需要

public static IEnumerable<T> Except<T, TKey>(this IEnumerable<T> items, IEnumerable<T> other, Func<T, TKey> getKey) 
{ 
    return from item in items 
      join otherItem in other on getKey(item) 
      equals getKey(otherItem) into tempItems 
      from temp in tempItems.DefaultIfEmpty() 
      where ReferenceEquals(null, temp) || temp.Equals(default(T)) 
      select item; 
} 

Answer 6

public static class ExceptByProperty 
{ 
    public static List<T> ExceptBYProperty<T, TProperty>(this List<T> list, List<T> list2, Expression<Func<T, TProperty>> propertyLambda) 
    { 
     Type type = typeof(T); 

     MemberExpression member = propertyLambda.Body as MemberExpression; 

     if (member == null) 
      throw new ArgumentException(string.Format(
       "Expression '{0}' refers to a method, not a property.", 
       propertyLambda.ToString())); 

     PropertyInfo propInfo = member.Member as PropertyInfo; 
     if (propInfo == null) 
      throw new ArgumentException(string.Format(
       "Expression '{0}' refers to a field, not a property.", 
       propertyLambda.ToString())); 

     if (type != propInfo.ReflectedType && 
      !type.IsSubclassOf(propInfo.ReflectedType)) 
      throw new ArgumentException(string.Format(
       "Expresion '{0}' refers to a property that is not from type {1}.", 
       propertyLambda.ToString(), 
       type)); 
     Func<T, TProperty> func = propertyLambda.Compile(); 
     var ids = list2.Select<T, TProperty>(x => func(x)).ToArray(); 
     return list.Where(i => !ids.Contains(((TProperty)propInfo.GetValue(i, null)))).ToList(); 
    } 
} 

public class testClass 
{ 
    public int ID { get; set; } 
    public string Name { get; set; } 
} 

爲了測試此：

 List<testClass> a = new List<testClass>(); 
     List<testClass> b = new List<testClass>(); 
     a.Add(new testClass() { ID = 1 }); 
     a.Add(new testClass() { ID = 2 }); 
     a.Add(new testClass() { ID = 3 }); 
     a.Add(new testClass() { ID = 4 }); 
     a.Add(new testClass() { ID = 5 }); 

     b.Add(new testClass() { ID = 3 }); 
     b.Add(new testClass() { ID = 5 }); 
     a.Select<testClass, int>(x => x.ID); 

     var items = a.ExceptBYProperty(b, u => u.ID); 

Answer 7

我喜歡的除了擴展方法，但原來的問題沒有對稱密鑰訪問和I更喜歡包含（或任何變體）加入，所以所有功勞azuneca's answer：

public static IEnumerable<T> Except<T, TKey>(this IEnumerable<TKey> items, 
    IEnumerable<T> other, Func<T, TKey> getKey) { 

    return from item in items 
     where !other.Contains(getKey(item)) 
     select item; 
} 

然後可以像使用：

var filteredApps = unfilteredApps.Except(excludedAppIds, ua => ua.Id); 

此外，這個版本允許需要對異常的映射IEnumerable的使用選擇：

var filteredApps = unfilteredApps.Except(excludedApps.Select(a => a.Id), ua => ua.Id);