我需要检查一系列项是否有任何一项满足某个条件，但同时又不是所有项都满足相同的条件。
例如，对于一个包含10个项的序列，如果该序列至少有一个满足条件但不全部满足，则结果为TRUE：
我知道可以这样做：
mySequence.Any (item => item.SomeStatus == SomeConst) && !mySequence.All (item => item.SomeStatus == SomeConst)
但这并不是最优解。
有更好的方法吗？
你会喜欢这个。
var anyButNotAll = mySequence
.Select(item => item.SomeStatus == SomeConst)
.Distinct()
.Take(2)
.Count() == 2;
Take(2) 方法可以阻止它迭代比所需更多的元素。
SomeButNotAll，仅出于清晰起见，因为这段代码本身并没有很好地自我记录。 - ServyEnumerable.Count()需要完全求值，而Enumerable.Take()可以快速截断执行。 - user57508Any 和 All 就会立即短路。mySequence.Any (item => item.SomeStatus == SomeConst)
!mySequence.All (item => item.SomeStatus == SomeConst)
只要有一个元素不符合条件，此语句就会返回true。
由于这两个条件是互斥的，一个语句保证在第一个元素后返回，而另一个语句保证在找到第一个元素后立即返回。
正如其他人指出的那样，这个解决方案需要开始两次遍历集合。如果获得集合的成本很高（例如在数据库访问中），或者对集合进行迭代不能每次产生相同的结果，则这不是一个适合的解决方案。
如果数据源是数据库，那么这可能是一个相当优化的解决方案。根据您的数据源，这个扩展方法可能更好（我只是随意编写的代码，可能有很多错误，请将其视为伪代码）。 这里的好处是它只枚举一次，并在读取足够量的数据以确定结果后立即执行短路操作:
static bool SomeButNotAll<TSource>(this IEnumerable<TSource> source,
Func<TSource, bool> predicate)
{
using(var iter=source.GetEnumerator())
{
if (iter.MoveNext())
{
bool initialValue=predicate(iter.Current);
while (iter.MoveNext())
if (predicate(iter.Current)!=initialValue)
return true;
}
}
return false; /* All */
}
Func 而不是 Expression，因为你打算调用它，并且由于你只计划迭代 source 并且不做其他操作，所以你应该接受一个 IEnumerable 而不是 IQueryable。 - Servy您可以定义自己的扩展方法。这个版本更冗长，但仍然易读，并且它只枚举了一次IEnumerable：
bool AnyButNotAll<ItemT>(this IEnumerable<ItemT> sequence, Func<ItemT, bool> predicate)
{
bool seenTrue = false;
bool seenFalse = false;
foreach (ItemT item in sequence)
{
bool predResult = predicate(item);
if (predResult)
seenTrue = true;
if (!predResult)
seenFalse = true;
if (seenTrue && seenFalse)
return true;
}
return false;
}
代码更加简短，但是会两次枚举 IEnumerable：
bool AnyButNotAll<ItemT>(this IEnumerable<ItemT> sequence, Func<ItemT, bool> predicate)
{
return sequence.Any(predicate) && !sequence.All(predicate);
}
if (!predResult) 替换为 else。 - romanozaif语句是相对独立的。 - Tanner Swett你可以尝试这个:
var result = mySequence.Select(item => item.SomeStatus == SomeConst)
.Distinct().Count() > 1 ? false : true;
基本上我为每个值选择true或false，使用distinct仅获取其中一个，然后计算它们的数量。
Func<MyItemType, bool> myPredicate = item => item.SomeStatus == SomeConst;
if (mySequence.Any(myPredicate) && !mySequence.All(myPredicate))
...
IEnumerable<T>和IQueryable<T>扩展方法。这样可以自动选择最佳方法：public static bool SomeButNotAll<T>(this IQueryable<T> source, Expression<Func<T, bool>> predicate)
{
if(source == null)
throw new ArgumentNullException("source");
if(predicate == null)
throw new ArgumentNullException("predicate");
return source.
Select(predicate)
.Distinct()
.Take(2)
.Count() == 2;
}
public static bool SomeButNotAll<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
if(source == null)
throw new ArgumentNullException("source");
if(predicate == null)
throw new ArgumentNullException("predicate");
using(var en = source.GetEnumerator())
if(en.MoveNext())
{
bool first = predicate(en.Current);
while(en.MoveNext())
if(predicate(en.Current) != first)
return true;
}
return false;
}
CountAsync的其他提供程序），您也可以轻松提供异步版本：public static async Task<bool> SomeButNotAllAsync<T>(this IQueryable<T> source, Expression<Func<T, bool>> predicate, CancellationToken cancel)
{
if(source == null)
throw new ArgumentNullException("source");
if(predicate == null)
throw new ArgumentNullException("predicate");
cancel.ThrowIfCancellationRequested();
return await source.
Select(predicate)
.Distinct()
.Take(2)
.CountAsync(cancel)
.ConfigureAwait(false) == 2;
}
public static Task<bool> SomeButNotAllAsync<T>(this IQueryable<T> source, Expression<Func<T, bool>> predicate)
{
return source.SomeButNotAllAsync(predicate, CancellationToken.None);
}
.Aggregate和一个自定义类型，该类型包含所需信息的属性 - 只是一个输入... - user57508.Count(item => item.SomeStatus == SomeConst)可能更便宜。如果该值大于0且小于集合大小，则返回true。如果序列是IEnumerable<T>，则由于短路，您的实现可能更优。 - Dmitry S.