Sintaxis LINQ: Any, All y Contains

Any

El operador Any se utiliza para determinar si existe un elemento dentro de una secuencia que cumpla una condición expecífica. Las signaturas del método son las siguientes:

   1:  public static bool Any<TSource>(
   2:      this IEnumerable<TSource> source)
   3:  
   4:  public static bool Any<TSource>(
   5:      this IEnumerable<TSource> source,
   6:      Func<TSource, bool> predicate)

Como se puede ver en las signaturas el método devuelve true si algún elemento cumple con la condición y false si no encuentra nada. En el siguiente ejemplo queremos comprobar si existe algún desarrollador que se llame Jorge dentro de nuestra colección.

   1:  var list = (from d in developers
   2:              select d).Any(d => d.Name == "Jorge");

El ejemplo anterior devolverá true ya que existe un desarrollador que se llame Jorge. Para el siguiente ejemplo, en el cual utilizamos una lista vacía, el método Any devolverá false ya que no existe ningún elemento en la colección.

   1:  var list = Enumerable.Empty<Developer>()
   2:                          .Any(d => d.Name == "Jorge");

All

El operador All se utiliza para determinar si todos los elementos de una colección cumplen con una condición específica. La signatura del método es la siguiente:

   1:  public static bool All<TSource>(
   2:      this IEnumerable<TSource> source,
   3:      Func<TSource, bool> predicate)

Este método devolvera true, si todos los elementos cumplen con la condición indicata y false, si hay algún elemento que no cumpla con la condición. En el siguiente ejemplo queremos comprobar que todos los desarroladores haya estado por lo menos en un cliente.

   1:  var list = (from d in developers
   2:              select d).All(d => d.Customers.Count() >= 1);

Si aplicamos este método sobre una colección vacía, este devolverá true. Esto es debido aque el método devuelve false encuanto encuentra un elemento que no coincide con la condición seleccionada y evidentemente en una colección vacía no va ha encontrar ningún elemento.

   1:  var list = Enumerable.Empty<Developer>()
   2:                 .All(d => d.Customers.Count() >= 1);

Contains

El método Contains determina si un determinado elemento se encuentra en la colección. Las signaturas del método son las siguientes:

   1:  public static bool Contains<TSource>(
   2:      this IEnumerable<TSource> source,
   3:      TSource value)
   4:  
   5:  public static bool Contains<TSource>(
   6:      this IEnumerable<TSource> source,
   7:      TSource value,
   8:      IEqualityComparer<TSource> comparer)

En la segunda signatura nos permite personalidar la forma en la que las comparaciones son realizas. Este método devolverá true si en cuentra el elemento y false sino existe el elemento en la colección.

En el siguiente ejemplo, queremos comprobar que en la colección exista el desarrollador, Jorge. Como veréis en el código ,hemos aprovechado la segunda signatura de este método para que se busque por el nombre simplemente.

   1:  Developer d = new Developer{ Name="Jorge", Language="C#", Age=18};
   2:  
   3:  var list = developers.Contains(d, new DeveloperComparer());
   4:  
   5:  public class DeveloperComparer : IEqualityComparer<Developer>
   6:  {
   7:      public bool Equals(Developer x, Developer y)
   8:      {
   9:          if (x.Name == y.Name)
  10:          {
  11:              return true;
  12:          }
  13:  
  14:          return false;
  15:      }
  16:  
  17:      public int GetHashCode(Developer obj)
  18:      {
  19:          return obj.Name.ToString().GetHashCode();
  20:      }
  21:  }

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *