Comprobación simple para ver si al menos un objeto en un conjunto tiene un valor de propiedad TRUE

Question

Tengo un conjunto de objetos modelo que tienen una propiedad pública IsVisible booleana. Todo lo que tengo que hacer es encontrar si al menos uno del conjunto tiene ese valor establecido en TRUE. En otras palabras, si tengo 10.000 objetos, pero el segundo es true, no necesito pasar por los otros 9.998. Ya tengo mi respuesta.

Ahora sé que podría escribir mi propia función iterativa y partir al primer valor 'True', pero espero que eso sea algo que LINQ puede hacer. En realidad, ni siquiera necesita ser LINQ. Cualquier sugerencia es bienvenida.

Por cierto, el idioma de elección es C#.

Actualización:

Ver mi último post aquí. He agregado algunos códigos de prueba y tiempos. Parece que LINQ es bastante pobre en cuanto a rendimiento comparado con solo hacer la prueba yo mismo. Claro que es más fácil escribir, pero en tiempos críticos, ya no estoy seguro.

Lo que más me sorprendió es la mayoría de las veces que corrí esto, la enumeración fue ganada y un buen clip, pero por alguna razón, cuando envolví la prueba en múltiples pases, parece haber cambiado a indexación con un el conteo en caché es el más rápido.

También noté que si no reinicio todo a 'falso', todas las pruebas restantes/repetidas parecen MUCHO más rápidas. De alguna manera, volver a establecer todo en FALSE (que fue intencionalmente exagerado para probar exactamente esto ...) cambia las cosas.

Interesante. No estoy seguro de qué camino tomaré ahora. Este no es un sistema de misión crítica así que tal vez voy a ir por la legibilidad, pero aún así. Interesante.

Answer 1

El método que está buscando es Enumerable.Any.

bool anyObjectsVisible = myObjects.Any(myObject => myObject.IsVisible); 

Tiene la semántica exacta de cortocircuito que está buscando; el código de ejemplo es similar a:

static bool AreAnyObjectsVisible(IEnumerable<MyObject> myObjects) 
{ 
    foreach (var myObject in myObjects) 
    { 
     if (myObject.IsVisible) return true; 
    } 

    return false; 
} 

Answer 2

Si necesita encontrar realmente un objeto, basta con utilizar el método .First o .FirstOrDefault:

var myObject = myCollection.First(x=>x.IsVisible); 

o

var myObject = myCollection.FirstOrDefault(x=>x.IsVisible); 

El único La diferencia entre ellos es que el método .First lanzará una excepción si no hay tal objeto en la colección cuando el segundo devuelve el valor predeterminado (nulo en este ejemplo).

Si sólo tiene que comprobar si hay algún objeto con este conjunto de propiedades, utilice

var thereIsVisibleObject = myCollection.Any(x=>x.IsVisible); 

Todos estos métodos dejan de iteración a través de la colección una vez que se encuentra el objeto correspondiente.

O, en caso de que compruebe si todos los objetos son visibles/invisibles, es posible hacer esto:

var allTheObjectsAreVisible = myCollection.All(x=>x.IsVisible); 
var allTheObjectsAreInvisible = myCollection.All(x=>!x.IsVisible); 

Pero el método .Todas se enumerar todos los elementos (que es obvio por su nombre)

Answer 3

Aquí es un ".Cualquier()" aplicación:

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 local in source) 
    { 
     if (predicate(local)) 
     { 
      return true; 
     } 
    } 
    return false; 
} 

Así que aquí está ella, nada "especial" con .Any(), que es sólo una envoltura alrededor de "foreach". Nada especial para probar allí y nada que culpar en términos de optimización micro-micro-micro.