根據2條件選擇使用linq

Question

我有一個集合。我想選擇匹配2個條件的值。

var a; 
var b; 
foreach(SomeObject so in collection) 
{ 
    if(so.Value == something) 
    { 
     a = so; 
     // break if b is not null. 
    } 
    else if(so.Value == somethingElse) 
    { 
     b = so; 
     // break if a is not null 
    } 
} 

是否有可能使用linq迭代集合只做一次？如果我們能夠使用這個事實，那麼只有一種東西的價值和一種東西的價值。

Answer 1

你需要的東西是這樣的：

var a = collection.OfType<YourCollectionElementType>().FirstOrDefault(i=>i.Equals(something)); 
var b = collection.OfType<YourCollectionElementType>().FirstOrDefault(i=>i.Equals(somethingelse)); 

您的集合應實現IEnumerable至少要能夠使用這個代碼。 這取決於你的收藏類型是什麼。如果它實現了通用IEnumerable<T>，說這是List<YourCollectionElementType>或再數組YourCollectionElementType[]你不需要使用OfType<T>，即

var a = collection.FirstOrDefault(i=>i.Equals(something)); 
var b = collection.FirstOrDefault(i=>i.Equals(somethingelse)); 

如果集合不包含該值，a和/或b將獲得null值。

其實你可以在MSDN中閱讀所有這些東西。 LINQ是不是很難學，如果你嘗試 例如：

1. Enumerable.FirstOrDefault Method (IEnumerable)

2. Enumerable.OfType Method

編輯

在您的評論你說那它確信只有一個值目前。你需要兩個單獨的變量是非常重要的嗎？你可以得到的現值，就像這樣：

object thevalue = collection.FirstOrDefault(i => i == something || i == somethingelse); 

編輯

事實上，我會離開你的循環，因爲它是唯一已增加這樣一行：

SomeObject a; 
SomeObject b; 
foreach(SomeObject so in collection) 
{ 
    if(so.Value == something) 
     a = so; 
    else if(so.Value == somethingElse) 
     b = so; 
    if(a!=null && b!=null) 
     break; 
} 

並且如果僅預期其中一個值，則

SomeObject a; 
SomeObject b; 
foreach(SomeObject so in collection) 
{ 
    if(so.Value == something) 
    { 
     a = so; 
     break; 
    } 
    else if(so.Value == somethingElse) 
    { 
     b = so; 
     break; 
    } 
} 

Answer 2

當然可以，但我不會推薦它。現在你已經擁有了你的循環，這將是更清潔的。

如果你真的想知道怎麼了，你可以這樣做：

class SomeObject 
{ 
    public string Value { get; set; } 
} 

var items = new[] 
{ 
    new SomeObject { Value = "foo" }, 
    new SomeObject { Value = "bar" }, 
    new SomeObject { Value = "baz" }, 
}; 

var something = "foo"; 
var somethingElse = "baz"; 
var result = items.Aggregate(
    Tuple.Create(default(SomeObject), default(SomeObject)), 
    (acc, item) => Tuple.Create(
     item.Value == something  ? item : acc.Item1, 
     item.Value == somethingElse ? item : acc.Item2 
    ) 
); 
// result.Item1 <- a == new SomeObject { Value = "foo" } 
// result.Item2 <- b == new SomeObject { Value = "baz" } 

Answer 3

var relevant = 
    from so in l where so.Value == something || so.Value == somethingElse 
    group so by so.Value == something into grp 
    select new {ForA = grp.Key, SO = grp.First()}; 
foreach(var bit in relevant) 
    if(bit.ForA) 
    a = bit.SO; 
    else 
    b = bit.SO; 

它可能獲得你對某些來源的東西，因爲只有兩個項目被檢索到，雖然如果針對內存中的集合，我會保留所有內容，但要添加一個catch，以便一旦設置了a和b，就停止了循環，而不是不必要地檢查集合。

Answer 4

你可以這樣做：

collection 
    .Select(x => x.Value == something 
     ?() => a = x 
     : (x.Value == somethingElse 
      ?() => b = x 
      : (Action)null)) 
    .Where(x => x != null) 
    .ToArray() 
    .ForEach(x => x()); 

我測試此代碼和它的工作一種享受。

如果集合了一個數據庫，然後某處，我建議這樣的：

collection 
    .Where(x => x.Value == something || x.Value == somethingElse) 
    .ToArray() 
    .Select(x => x.Value == something 
     ?() => a = x 
     : (x.Value == somethingElse 
      ?() => b = x 
      : (Action)null)) 
    .Where(x => x != null) 
    .ToArray() 
    .ForEach(x => x()); 

Answer 5

該解決方案將列表範圍縮小到兩個元素，然後從那裏去。使用Take(2)，因此僅在找到兩個值之前才搜索集合。

var matches = collection.Where(x => x.Value == something || x.Value == somethingElse) 
         .Take(2) 
         .ToList(); 
var a = matches.Single(x => x.Value == something); 
var b = matches.Single(x => x.Value == somethingElse); 

Answer 6

不知道如果我理解你的問題，但假設Something和SomethingElse是值類型和運行時間之前已知的，你可以在一個聲明中做如下圖所示。

 var FindItems = new[] 
     { 
      new SomeObject { Value = "SomethingElse" } 
     }; 

     var CollectionItems = new[] 
     { 
      new SomeObject { Value = "Something" }, 
      new SomeObject { Value = "SomethingElse" } 
     }; 

     var qSomeObject = CollectionItems 
          .Where(c => FindItems.Any(x => c.Value == x.Value));