myCars.Select((v, i) => new {car = v, index = i}).First(myCondition).index;

O el ligeramente más corto

myCars.Select((car, index) => new {car, index}).First(myCondition).index;

Simplemente haga:

int index = List.FindIndex(your condition);

Por ejemplo

int index = cars.FindIndex(c => c.ID == 150);

myCars.TakeWhile(car => !myCondition(car)).Count();

Funciona! Piénsalo. El índice del primer elemento coincidente es igual al número de elemento anterior (no coincidente).

Tiempo de la historia

A mí también me disgusta la horrible solución estándar que ya sugeriste en tu pregunta. Al igual que la respuesta aceptada, opté por un simple bucle antiguo, aunque con una ligera modificación:

public static int FindIndex<T>(this IEnumerable<T> items, Predicate<T> predicate) {
    int index = 0;
    foreach (var item in items) {
        if (predicate(item)) break;
        index++;
    }
    return index;
}

Tenga en cuenta que devolverá el número de elementos en lugar de -1 cuando no haya coincidencia. Pero vamos a ignorar esta molestia menor para ahora. De hecho, la horrible solución estándar se bloquea en ese caso y considero devolver un índice que está fuera de límites superior .

Lo que pasa ahora es que ReSharper me dice Que el bucle se puede convertir en expresión LINQ. Si bien la mayoría de las veces la función empeora la legibilidad, esta vez el resultado fue impresionante. Así que felicitaciones a los JetBrains.

Análisis

Pros

• Conciso
• Combinable con otros LINQ
• Evita new ing objetos anónimos
• Solo evalúa el enumerable hasta que el predicado coincida por primera vez

Por lo tanto, lo considero óptimo en el tiempo y el espacio sin dejar de ser legible.

Cons

• No es muy obvio al principio
• No devuelve -1 cuando no hay coincidencia

Por supuesto, siempre se puede ocultar detrás de un método de extensión. Y qué hacer mejor cuando no hay partido depende en gran medida de contexto.

Haré mi contribución aquí... ¿Por qué? solo porque: p es una implementación diferente, basada en la extensión Any LINQ, y un delegado. Aquí está:

public static class Extensions
{
    public static int IndexOf<T>(
            this IEnumerable<T> list, 
            Predicate<T> condition) {               
        int i = -1;
        return list.Any(x => { i++; return condition(x); }) ? i : -1;
    }
}

void Main()
{
    TestGetsFirstItem();
    TestGetsLastItem();
    TestGetsMinusOneOnNotFound();
    TestGetsMiddleItem();   
    TestGetsMinusOneOnEmptyList();
}

void TestGetsFirstItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("a"));

    // Assert
    if(index != 0)
    {
        throw new Exception("Index should be 0 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsLastItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("d"));

    // Assert
    if(index != 3)
    {
        throw new Exception("Index should be 3 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMinusOneOnNotFound()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("e"));

    // Assert
    if(index != -1)
    {
        throw new Exception("Index should be -1 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMinusOneOnEmptyList()
{
    // Arrange
    var list = new string[] {  };

    // Act
    int index = list.IndexOf(item => item.Equals("e"));

    // Assert
    if(index != -1)
    {
        throw new Exception("Index should be -1 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMiddleItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d", "e" };

    // Act
    int index = list.IndexOf(item => item.Equals("c"));

    // Assert
    if(index != 2)
    {
        throw new Exception("Index should be 2 but is: " + index);
    }

    "Test Successful".Dump();
}        

Aquí hay una pequeña extensión que acabo de armar.

public static class PositionsExtension
{
    public static Int32 Position<TSource>(this IEnumerable<TSource> source,
                                          Func<TSource, bool> predicate)
    {
        return Positions<TSource>(source, predicate).FirstOrDefault();
    }
    public static IEnumerable<Int32> Positions<TSource>(this IEnumerable<TSource> source, 
                                                        Func<TSource, bool> predicate)
    {
        if (typeof(TSource) is IDictionary)
        {
            throw new Exception("Dictionaries aren't supported");
        }

        if (source == null)
        {
            throw new ArgumentOutOfRangeException("source is null");
        }
        if (predicate == null)
        {
            throw new ArgumentOutOfRangeException("predicate is null");
        }
        var found = source.Where(predicate).First();
        var query = source.Select((item, index) => new
            {
                Found = ReferenceEquals(item, found),
                Index = index

            }).Where( it => it.Found).Select( it => it.Index);
        return query;
    }
}

Entonces puedes llamarlo así.

IEnumerable<Int32> indicesWhereConditionIsMet = 
      ListItems.Positions(item => item == this);

Int32 firstWelcomeMessage ListItems.Position(msg =>               
      msg.WelcomeMessage.Contains("Hello"));

Aquí hay una implementación de la respuesta más votada que devuelve -1 cuando el elemento no se encuentra:

public static int FindIndex<T>(this IEnumerable<T> items, Func<T, bool> predicate)
{
    var itemsWithIndices = items.Select((item, index) => new { Item = item, Index = index });
    var matchingIndices =
        from itemWithIndex in itemsWithIndices
        where predicate(itemWithIndex.Item)
        select (int?)itemWithIndex.Index;

    return matchingIndices.FirstOrDefault() ?? -1;
}