LINQ：ありませんvsすべてありません

多くの場合、提供された値がリスト内の値と一致するかどうかを確認したい（たとえば、検証するとき）：

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

最近、ReSharperがこれらのクエリを簡略化して次のことを要求することに気づきました。

if (acceptedValues.All(v => v != someValue))
{
    // exception logic
}

明らかに、これは論理的に同一で、おそらく少し読みやすくなります（多くの数学を実行した場合）、私の質問は次のとおりです。これはパフォーマンスに影響を与えますか？

それはあるべきように感じます（すなわち.Any()、それは短絡.All()するように聞こえますが、そうではないように聞こえます）が、私はこれを実証するものは何もありません。クエリが同じように解決されるかどうか、またはReSharperが私を迷わせているかどうかについて、より深い知識を持っている人はいますか？

AllILSpyによる実装（実際に行ったところ、「まあ、その方法は少し似ています...」ではなく、影響についてではなく理論について話していたのでした）。

public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource current in source)
    {
        if (!predicate(current))
        {
            return false;
        }
    }
    return true;
}

AnyILSpyによる実装：

public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource current in source)
    {
        if (predicate(current))
        {
            return true;
        }
    }
    return false;
}

もちろん、生成されたILには微妙な違いがある可能性があります。しかし、いいえ、ありません。ILはほとんど同じですが、述語の一致でtrueを返すのと、述語の不一致でfalseを返すという明らかな逆の違いがあります。

もちろんこれはlinq-for-objectsだけです。他の一部のlinqプロバイダーが他のlinqプロバイダーをより適切に処理することは可能ですが、そうである場合、どちらがより最適な実装を得たかはかなりランダムです。

ルールif(determineSomethingTrue)は、に比べてシンプルで読みやすいと感じている人にのみ適用されるようですif(!determineSomethingFalse)。公平にif(!someTest)言えば、私たちが行動したい条件に対してtrueを返す同等の冗長性と複雑さの代替テストがある場合、私はしばしば混乱*するという点で少しポイントがあると思います。しかし、実際には、私が個人的に、あなたが与える2つの選択肢のどちらかを優先することは何もないので、述語がより複雑である場合は、前者にわずかに傾くでしょう。

*私が理解していないように混乱しないが、私が理解していない決定にいくつかの微妙な理由があることを心配しているように混乱している。そうすれば、このコードをもう一度見て何を待っていたのか...」

これらの拡張メソッドにより、コードが読みやすくなる場合があります。

public static bool None<TSource>(this IEnumerable<TSource> source)
{
    return !source.Any();
}

public static bool None<TSource>(this IEnumerable<TSource> source, 
                                 Func<TSource, bool> predicate)
{
    return !source.Any(predicate);
}

元の代わりに

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

あなたは言えた

if (acceptedValues.None(v => v == someValue))
{
    // exception logic
}

結果を決定することができる後の両方は、両方のストップ列挙ので、同じ性能を有するであろう- Any()最初のアイテムに渡される述語評価するのにtrue及びAll()述語評価する最初の項目にしますfalse。

All 最初の不一致での短絡のため、問題ありません。

微妙な分野の1つは、

 bool allEven = Enumerable.Empty<int>().All(i => i % 2 == 0); 

本当です。シーケンス内のすべてのアイテムが偶数です。

このメソッドの詳細については、Enumerable.Allのドキュメントを参照してください。

All()シーケンスのすべての要素が条件を満たすかどうかを決定します。
Any()シーケンスの要素が条件を満たすかどうかを決定します。

var numbers = new[]{1,2,3};

numbers.All(n => n % 2 == 0); // returns false
numbers.Any(n => n % 2 == 0); // returns true

このリンクによると

任意–少なくとも1つの一致をチェックします

すべて–すべてが一致することを確認します

他の回答が十分にカバーしているので、これはパフォーマンスに関するものではなく、明確さに関するものです。

両方のオプションが幅広くサポートされています。

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

if (acceptedValues.All(v => v != someValue))
{
    // exception logic
}

しかし、これにより幅広いサポートが得られると思います。

var isValueAccepted = acceptedValues.Any(v => v == someValue);
if (!isValueAccepted)
{
    // exception logic
}

何かを否定する前にブール値を計算する（そして名前を付ける）だけで、これは私の頭の中ではっきりとわかります。

あなたが見て取れば可算ソース、あなたはの実装がわかりますAnyし、All非常に近いです。

public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
    if (source == null) throw Error.ArgumentNull("source");
    if (predicate == null) throw Error.ArgumentNull("predicate");
    foreach (TSource element in source) {
        if (predicate(element)) return true;
    }
    return false;
}

public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
    if (source == null) throw Error.ArgumentNull("source");
    if (predicate == null) throw Error.ArgumentNull("predicate");
    foreach (TSource element in source) {
        if (!predicate(element)) return false;
    }
    return true;
}

唯一の違いはブール値の否定であるため、1つの方法が他の方法よりも大幅に高速になる方法はありません。