Why is this an issue?

Both the List.Exists method and IEnumerable.Any method can be used to find the first element that satisfies a predicate in a collection. However, List.Exists can be faster than IEnumerable.Any for List objects, as well as requires significantly less memory. For small collections, the performance difference may be negligible, but for large collections, it can be noticeable. The same applies to ImmutableList and arrays too.

It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the performance improvements in .NET 9 have brought Any closer to the performance of collection-specific Exists methods in most scenarios.

Applies to

• List
• Array
• ImmutableList

What is the potential impact?

We measured at least 3x improvement in execution time. For more details see the Benchmarks section from the More info tab.

Also, no memory allocations were needed for the Exists method, since the search is done in-place.

Exceptions

Since LINQ to Entities relies a lot on System.Linq for query conversion, this rule won’t raise when used within LINQ to Entities syntaxes.

How to fix it

The Exists method is defined on the collection class, and it has the same signature as Any extension method if a predicate is used. The method can be replaced in place.

Code examples

Noncompliant code example

bool ContainsEven(List<int> data) =>
    data.Any(x => x % 2 == 0);

bool ContainsEven(int[] data) =>
    data.Any(x => x % 2 == 0);

Compliant solution

bool ContainsEven(List<int> data) =>
    data.Exists(x => x % 2 == 0);

bool ContainsEven(int[] data) =>
    Array.Exists(data, x => x % 2 == 0);

Resources

Documentation

• Microsoft Learn - List<T>.Exists(Predicate<T>)
• Microsoft Learn - Array.Exists<T>(T[], Predicate<T>)
• Microsoft Learn - ImmutableList<T>.Exists(Predicate<T>)
• Microsoft Learn - Enumerable.Any(Predicate<T>)
• Microsoft Learn - LINQ to Entities

Benchmarks

Glossary

• Mean
• Standard Deviation
• Allocated

The results were generated by running the following snippet with BenchmarkDotNet:

// Explicitly cache the delegates to avoid allocations inside the benchmark.
private readonly static Func<int, bool> ConditionFunc = static x => x == -1 * Math.Abs(x);
private readonly static Predicate<int> ConditionPredicate = static x => x == -1 * Math.Abs(x);

private List<int> list;
private ImmutableList<int> immutableList;
private int[] array;

[Params(1_000)]
public int N { get; set; }

[GlobalSetup]
public void GlobalSetup()
{
    list = Enumerable.Range(0, N).Select(x => N - x).ToList();
    immutableList = ImmutableList.CreateRange(list);
    array = list.ToArray();
}

[BenchmarkCategory("List<T>"), Benchmark]
public bool ListAny() =>
    list.Any(ConditionFunc);

[BenchmarkCategory("List<T>"), Benchmark(Baseline = true)]
public bool ListExists() =>
    list.Exists(ConditionPredicate);

[BenchmarkCategory("ImmutableList<T>"), Benchmark(Baseline = true)]
public bool ImmutableListAny() =>
    immutableList.Any(ConditionFunc);

[BenchmarkCategory("ImmutableList<T>"), Benchmark]
public bool ImmutableListExists() =>
    immutableList.Exists(ConditionPredicate);

[BenchmarkCategory("Array"), Benchmark(Baseline = true)]
public bool ArrayAny() =>
    array.Any(ConditionFunc);

[BenchmarkCategory("Array"), Benchmark]
public bool ArrayExists() =>
    Array.Exists(array, ConditionPredicate);

Hardware configuration:

BenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)
11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores
  [Host]               : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256
  .NET 8.0             : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
  .NET 9.0             : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI
  .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256