Efficiency of List<T>.IndexOf() versus List<T>.FindIndex()

Question

Which one of the methods

• List<T>.IndexOf() and
• List<T>.FindIndex()

is more efficient in terms of processing time?

The type of T in this instance is String.

Answer 1

IndexOf performs a for-loop, using the Equals implementation of the objects being searched to look for a match. FindIndex also peforms a for-loop but evaluates a Predicate to check for a match instead.

They each boil down to a for-loop. While they both technically have an O(n) design, the use of a delegate in FindIndex will have some overhead. The difference in performance can be seen in Denis19901's answer. Here are some MSDN excerpts:

List<T>.IndexOf Method (T):

This method performs a linear search; therefore, this method is an O(n) operation, where n is Count.

List<T>.FindIndex Method (Predicate<T>):

This method performs a linear search; therefore, this method is an O(n) operation, where n is Count.

That said, the two functions would be used quite differently. The former assumes you have an object from the list, and you just need to know at what index it exists at (if any) in the list.

The latter assumes you know some criteria about an object, and you want to find the first index where an object in the list matches that criteria. There could be multiple matches, but the method returns the first match.

Answer 2

Cᴏʀʏ suggested that the difference in performance would be negligible, if any at all. And since my intuition said that using a delegate is always going to be slower, I decided to put it to the test.

Using DotNetBenchMark and the following code to test:

[MemoryDiagnoser]
public class Bench
{
    byte[] buffer;

    public Bench()
    {
        buffer = new byte[1024];
    }

    [Benchmark]
    public void FindIndex()
    {
        int index = Array.FindIndex(buffer, x => x == byte.MaxValue);
    }

    [Benchmark]
    public void IndexOf()
    {
        int index = Array.IndexOf(buffer, byte.MaxValue);
    }
}

• FindIndex had a mean runtime of 1,986.2 ns
• IndexOf had a mean runtime of 178.4 ns

Doesn't seem like the difference in performance is negligible, as it is more than 10 times slower.

And even in a case where the 16th element of the array matches, IndexOf is still more than twice as fast as FindIndex