Verifique se um valor está em uma matriz (C #)

Como posso verificar se um valor está em uma matriz em C #?

Tipo, eu quero criar um array com uma lista de nomes de impressoras.

Eles serão alimentados para um método, que examinará cada string por vez, e se a string for igual a um valor em um array, faça essa ação.

Por exemplo:

string[] printer = {"jupiter", "neptune", "pangea", "mercury", "sonic"};
foreach (p in printer)
{
   PrinterSetup(p);     
}

Esses são os nomes das impressoras, eles estão sendo alimentados pelo método PrinterSetup.

PrinterSetup será mais ou menos assim (algum pseudocódigo):

public void PrinterSetup(printer)
{
   if (printer == "jupiter") 
   {
      Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC");
   }
}

Como faço para formatar if (printer == "jupiter")de uma maneira que o C # possa reconhecer?

Adicione o namespace necessário

using System.Linq;

Então você pode usar o Contains()método linq

string[] printer = {"jupiter", "neptune", "pangea", "mercury", "sonic"};
if(printer.Contains("jupiter"))
{
    Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC"");
}

   string[] array = { "cat", "dot", "perls" };

// Use Array.Exists in different ways.
bool a = Array.Exists(array, element => element == "perls");
bool b = Array.Exists(array, element => element == "python");
bool c = Array.Exists(array, element => element.StartsWith("d"));
bool d = Array.Exists(array, element => element.StartsWith("x"));

// Display bools.
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
----------------------------output-----------------------------------

1) Verdadeiro 2) Falso 3) Verdadeiro 4) Falso

if ((new [] {"foo", "bar", "baaz"}).Contains("bar"))
{

}  

Algo assim?

string[] printer = {"jupiter", "neptune", "pangea", "mercury", "sonic"};
PrinterSetup(printer);

// redefine PrinterSetup this way:
public void PrinterSetup(string[] printer)
{
    foreach (p in printer.Where(c => c == "jupiter"))
    {
        Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC"");
    }
}

    public static bool Contains(Array a, object val)
    {
        return Array.IndexOf(a, val) != -1;
    }

Nota: a questão é sobre matrizes de strings. As rotinas mencionadas não devem ser misturadas com o método .Contains de strings únicas.

Eu gostaria de adicionar uma resposta extensa referindo-se a diferentes versões C # e por dois motivos:

• A resposta aceita requer Linq, que é perfeitamente idiomático C #, embora não venha sem custos e não esteja disponível em C # 2.0 ou inferior. Quando um array está envolvido, o desempenho pode ser importante, portanto, há situações em que você deseja permanecer com os métodos Array.

• Nenhuma resposta atende diretamente à pergunta onde foi solicitado também colocar isso em uma função (como algumas respostas também misturam strings com matrizes de strings, isso não é completamente sem importância).

Array.Exists () é um método C # /. NET 2.0 e não precisa de Linq. Pesquisar em matrizes é O (n). Para um acesso ainda mais rápido, use HashSet ou coleções semelhantes.

Desde .NET 3.5 também existe um método genérico Array<T>.Exists():

public void PrinterSetup(string[] printer)
{
   if (Array.Exists(printer, x => x == "jupiter"))
   {
      Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC");
   }
}

Você poderia escrever um método de extensão próprio (C # 3.0 e superior) para adicionar o açúcar sintático para obter o mesmo / semelhante ".Contains" como para strings para todos os arrays sem incluir Linq:

// Using the generic extension method below as requested.
public void PrinterSetup(string[] printer)
{
   if (printer.ArrayContains("jupiter"))
   {
      Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC");
   }
}

public static bool ArrayContains<T>(this T[] thisArray, T searchElement)
{
   // If you want this to find "null" values, you could change the code here
   return Array.Exists<T>(thisArray, x => x.Equals(searchElement));
}

Neste caso, este ArrayContains()método é usado e não o método Contains do Linq.

Os outros métodos mencionados .Contains referem-se a List<T>.Contains(desde C # 2.0) ou ArrayList.Contains(desde C # 1.1), mas não a arrays diretamente.

Você está simplesmente perdendo algo em seu método:

public void PrinterSetup(string printer)
{
   if (printer == "jupiter") 
   {
      Process.Start("BLAH BLAH CODE TO ADD PRINTER VIA WINDOWS EXEC"");
   }
}

Basta adicionar stringe você ficará bem.

Não está muito claro qual é o seu problema, mas parece que você quer algo assim:

    List<string> printer = new List<string>( new [] { "jupiter", "neptune", "pangea", "mercury", "sonic" } );

    if( printer.Exists( p => p.Equals( "jupiter" ) ) )
    {
        ...
    }

Considere o uso de HashSet<T>Class para o desempenho da pesquisa:

Este método é uma operação O (1).

- HashSet<T>.ContainsMétodo (T), MSDN .

Por exemplo:

class PrinterInstaller
{
    private static readonly HashSet<string> PrinterNames = new HashSet<string>
        {
            "jupiter", "neptune", "pangea", "mercury", "sonic"
        };

    public void Setup(string printerName)
    {
        if (!PrinterNames.Contains(printerName))
        {
            throw new ArgumentException("Unknown printer name", "printerName");
        }
        // ...
    }
}

Pesquisei agora por 2h para encontrar uma maneira agradável de encontrar duplicatas em uma lista e como removê-las . Aqui está a resposta mais simples:

//Copy the string array with the filtered data of the analytics db into an list
// a list should be easier to use
List<string> list_filtered_data = new List<string>(analytics_db_filtered_data);

// Get distinct elements and convert into a list again.
List<string> distinct = list_filtered_data.Distinct().ToList();

A saída terá a seguinte aparência: Elementos duplicados serão removidos da nova lista chamada distintos!