Controlla se un valore è in una matrice (C #)

Come posso verificare se un valore è in una matrice in C #?

Ad esempio, voglio creare un array con un elenco di nomi di stampanti.

Questi verranno inviati a un metodo, che esaminerà ciascuna stringa a turno e, se la stringa è uguale a un valore in un array, eseguire tale azione.

Per esempio:

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

Questi sono i nomi delle stampanti, vengono inviati al metodo PrinterSetup.

PrinterSetup avrà un aspetto simile a questo (alcuni pseudocodici):

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

Come faccio a formattare if (printer == "jupiter")in modo che C # possa riconoscere?

Aggiungi lo spazio dei nomi necessario

using System.Linq;

Quindi puoi usare il Contains()metodo 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) Vero 2) Falso 3) Vero 4) Falso

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

}  

Qualcosa come questo?

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 domanda riguarda gli array di stringhe. Le routine menzionate non devono essere mescolate con il metodo .Contains di singole stringhe.

Vorrei aggiungere una risposta estesa che fa riferimento a diverse versioni C # e per due motivi:

• La risposta accettata richiede Linq che è perfettamente idiomatico C # mentre non è senza costi e non è disponibile in C # 2.0 o inferiore. Quando è coinvolto un array, le prestazioni possono essere importanti, quindi ci sono situazioni in cui si desidera rimanere con i metodi Array.

• Nessuna risposta risponde direttamente alla domanda in cui è stato chiesto anche di mettere questo in una funzione (poiché alcune risposte stanno anche mescolando stringhe con array di stringhe, questo non è del tutto irrilevante).

Array.Exists () è un metodo C # /. NET 2.0 e non necessita di Linq. La ricerca negli array è O (n). Per un accesso ancora più veloce usa HashSet o raccolte simili.

A partire da .NET 3.5 esiste anche un metodo generico 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");
   }
}

È possibile scrivere un metodo di estensione personalizzato (C # 3.0 e versioni successive) per aggiungere lo zucchero sintattico per ottenere lo stesso / simile ".Contains" delle stringhe per tutti gli array senza includere 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));
}

In questo caso ArrayContains()viene utilizzato questo metodo e non il metodo Contains di Linq.

I metodi .Contains menzionati altrove fanno riferimento a List<T>.Contains(da C # 2.0) o ArrayList.Contains(a partire da C # 1.1), ma non direttamente agli array.

Ti manca solo qualcosa nel tuo metodo:

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

Basta aggiungere stringe starai bene.

Non è molto chiaro quale sia il tuo problema, ma sembra che tu voglia qualcosa del genere:

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

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

Prendi in considerazione l'utilizzo di HashSet<T>Class per motivi di prestazioni di ricerca:

Questo metodo è un'operazione O (1).

- HashSet<T>.ContainsMetodo (T), MSDN .

Per esempio:

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

Ho cercato ora più di 2 ore per trovare un modo carino su come trovare i duplicati in un elenco e su come rimuoverli . Ecco la risposta più semplice:

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

L'output sarà simile a questo: gli elementi duplicati verranno rimossi nel nuovo elenco chiamato distinto!