Verifique si un valor está en una matriz (C #)

¿Cómo verifico si un valor está en una matriz en C #?

Quiero crear una matriz con una lista de nombres de impresoras.

Estos se enviarán a un método, que examinará cada cadena a su vez, y si la cadena es igual que un valor en una matriz, realice esa acción.

Por ejemplo:

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

Estos son los nombres de las impresoras, que se alimentan al método PrinterSetup.

PrinterSetup se verá así (un pseudocódigo):

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

¿Cómo puedo formatear if (printer == "jupiter")de una manera que C # pueda reconocer?

Agregar el espacio de nombres necesario

using System.Linq;

Entonces puedes usar el 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) Verdadero 2) Falso 3) Verdadero 4) Falso

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

}  

¿Algo como esto?

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: La pregunta es sobre matrices de cadenas. Las rutinas mencionadas no se deben mezclar con el método .Contains de cadenas individuales.

Me gustaría agregar una respuesta extendida que se refiera a diferentes versiones de C # y por dos razones:

• La respuesta aceptada requiere Linq, que es C # perfectamente idiomático, mientras que no viene sin costos y no está disponible en C # 2.0 o inferior. Cuando se trata de una matriz, el rendimiento puede ser importante, por lo que hay situaciones en las que desea permanecer con los métodos de matriz.

• Ninguna respuesta atiende directamente a la pregunta en la que también se pidió que pusiera esto en una función (como algunas respuestas también mezclan cadenas con matrices de cadenas, esto no es completamente insignificante).

Array.Exists () es un método C # / .NET 2.0 y no necesita Linq. La búsqueda en matrices es O (n). Para un acceso aún más rápido, use HashSet o colecciones similares.

Desde .NET 3.5 también existe un 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");
   }
}

Puede escribir un método de extensión propio (C # 3.0 y superior) para agregar el azúcar sintáctico para obtener el mismo / similar ".Contains" que para las cadenas para todas las matrices sin 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));
}

En este caso ArrayContains()se utiliza este método y no el método Contiene de Linq.

Los métodos .Contains mencionados en otra parte se refieren a List<T>.Contains(desde C # 2.0) o ArrayList.Contains(desde C # 1.1), pero no directamente a las matrices.

Simplemente te falta algo en tu método:

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

Solo agregue stringy estará bien.

No está muy claro cuál es su problema, pero parece que quiere algo como esto:

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

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

Considere usar HashSet<T>Class por el bien del rendimiento de búsqueda:

Este método es una operación O (1).

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

Por ejemplo:

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");
        }
        // ...
    }
}

Busqué ahora durante 2 horas para encontrar una manera agradable de encontrar duplicados en una lista y cómo eliminarlos . Aquí está la respuesta más simple:

//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();

La salida se verá así: ¡Los elementos duplicados se eliminarán en la nueva lista llamada distinta!