Array.Exists<T>(T[], Predicate<T>) Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Determina se a matriz especificada contém elementos que correspondem às condições definidas pelo predicado especificado.

C#

public static bool Exists<T> (T[] array, Predicate<T> match);

Parâmetros de tipo

T

O tipo dos elementos da matriz.

Parâmetros

array

T[]

O Array unidimensional, com base em zero, a ser procurado.

match

Predicate<T>

O Predicate<T> que define as condições dos elementos a serem pesquisados.

Retornos

Boolean

true se array contiver um ou mais elementos que correspondem às condições definidas pelo predicado especificado; caso contrário, false.

Exceções

ArgumentNullException

array é null.

- ou -

match é null.

Exemplos

O exemplo a seguir especifica as condições de correspondência para o Exists método que usa expressões lambda para verificar se um planeta começa com uma determinada letra ou se o planeta é encontrado na matriz determinada.

C#

using System;

namespace Example
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] planets = { "Mercury", "Venus",
                "Earth", "Mars", "Jupiter",
                "Saturn", "Uranus", "Neptune" };

            Console.WriteLine("One or more planets begin with 'M': {0}",
                Array.Exists(planets, element => element.StartsWith("M")));

            Console.WriteLine("One or more planets begin with 'T': {0}",
                Array.Exists(planets, element => element.StartsWith("T")));

            Console.WriteLine("Is Pluto one of the planets? {0}",
                Array.Exists(planets, element => element == "Pluto"));
        }
    }
}
// The example displays the following output:
//       One or more planets begin with 'M': True
//       One or more planets begin with 'T': False
//       Is Pluto one of the planets? False

O exemplo a seguir usa o Exists método para indicar se os nomes em uma matriz de cadeia de caracteres começam com um caractere especificado. O exemplo cria uma instância de um StringSearcher objeto passando a cadeia de caracteres para pesquisar em seu construtor de classe. O StringSearcher.StartsWith método tem a mesma assinatura que o Predicate<T> delegado. Quando o Exists método é chamado, cada membro da matriz é passado para o delegado até que ele retorne true ou itera todos os elementos na matriz.

C#

using System;

public class Example
{
   public static void Main()
   {
      String[] names = { "Adam", "Adel", "Bridgette", "Carla",
                         "Charles", "Daniel", "Elaine", "Frances",
                         "George", "Gillian", "Henry", "Irving",
                         "James", "Janae", "Lawrence", "Miguel",
                         "Nicole", "Oliver", "Paula", "Robert",
                         "Stephen", "Thomas", "Vanessa",
                         "Veronica", "Wilberforce" };
      Char[] charsToFind = { 'A', 'K', 'W', 'Z' };

      foreach (var charToFind in charsToFind)
         Console.WriteLine("One or more names begin with '{0}': {1}",
                           charToFind,
                           Array.Exists(names, (new StringSearcher(charToFind)).StartsWith));
   }
}

public class StringSearcher
{
   char firstChar;

   public StringSearcher(char firstChar)
   {
      this.firstChar = char.ToUpper(firstChar);
   }

   public bool StartsWith(string s)
   {
      if (string.IsNullOrEmpty(s)) return false;

      if(s.Substring(0, 1).ToUpper() == firstChar.ToString())
         return true;
      else
         return false;
   }
}
// The example displays the following output:
//       One or more names begin with 'A': True
//       One or more names begin with 'K': False
//       One or more names begin with 'W': True
//       One or more names begin with 'Z': False

Você também pode usar uma expressão lambda em vez de definir explicitamente um método cuja assinatura corresponde à do delegado. O exemplo a seguir substitui a StringSearcher classe e seu StartsWith método por uma expressão lambda.

C#

using System;

public class Example
{
   public static void Main()
   {
      String[] names = { "Adam", "Adel", "Bridgette", "Carla",
                         "Charles", "Daniel", "Elaine", "Frances",
                         "George", "Gillian", "Henry", "Irving",
                         "James", "Janae", "Lawrence", "Miguel",
                         "Nicole", "Oliver", "Paula", "Robert",
                         "Stephen", "Thomas", "Vanessa",
                         "Veronica", "Wilberforce" };
      Char[] charsToFind = { 'A', 'K', 'W', 'Z' };

      foreach (var charToFind in charsToFind)
         Console.WriteLine("One or more names begin with '{0}': {1}",
                           charToFind,
                           Array.Exists(names,
                                        s => { if (string.IsNullOrEmpty(s))
                                                  return false;

                                               if (s.Substring(0, 1).ToUpper() == charToFind.ToString())
                                                  return true;
                                               else
                                                  return false;
                                             } ));
   }
}
// The example displays the following output:
//       One or more names begin with 'A': True
//       One or more names begin with 'K': False
//       One or more names begin with 'W': True
//       One or more names begin with 'Z': False

Comentários

O Predicate<T> é um representante para um método que retorna true caso o objeto passado para ele corresponda às condições definidas no representante. Os elementos são array passados individualmente para o , e o Predicate<T>processamento é interrompido quando uma correspondência é encontrada.

Observação

Em C# e Visual Basic, não é necessário criar o Predicate<T> delegado explicitamente. Essas linguagens inferem o representante correto pelo contexto e criam-no automaticamente. Em F#, as funções e as expressões lambda são convertidas implicitamente.

Este método é uma operação O(n), em que n é o Length de array.

Aplica-se a

Confira também

• Find<T>(T[], Predicate<T>)
• FindLast<T>(T[], Predicate<T>)
• FindAll<T>(T[], Predicate<T>)
• BinarySearch
• IndexOf
• LastIndexOf
• TrueForAll<T>(T[], Predicate<T>)
• Predicate<T>
• Expressões lambda (Guia de Programação em C#)
• Expressões lambda (Visual Basic)