Vérifier si une valeur est dans un tableau (C #)

Comment vérifier si une valeur est dans un tableau en C #?

Comme, je veux créer un tableau avec une liste de noms d'imprimantes.

Celles-ci seront transmises à une méthode, qui examinera chaque chaîne tour à tour, et si la chaîne est identique à une valeur dans un tableau, effectuez cette action.

Par exemple:

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

Ce sont les noms des imprimantes, ils sont alimentés par la méthode PrinterSetup.

PrinterSetup ressemblera à ceci (un pseudocode):

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

Comment formater if (printer == "jupiter")d'une manière que C # peut reconnaître?

Ajouter l'espace de noms nécessaire

using System.Linq;

Ensuite, vous pouvez utiliser la Contains()méthode 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) Vrai 2) Faux 3) Vrai 4) Faux

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

}  

Quelque chose comme ça?

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;
    }

Remarque: la question concerne les tableaux de chaînes. Les routines mentionnées ne doivent pas être mélangées avec la méthode .Contains des chaînes simples.

Je voudrais ajouter une réponse étendue faisant référence à différentes versions de C # et pour deux raisons:

• La réponse acceptée nécessite Linq qui est parfaitement idiomatique C # alors qu'il n'est pas gratuit et n'est pas disponible en C # 2.0 ou inférieur. Lorsqu'un tableau est impliqué, les performances peuvent être importantes, il existe donc des situations dans lesquelles vous souhaitez rester avec les méthodes Array.

• Aucune réponse ne répond directement à la question où il a également été demandé de mettre cela dans une fonction (comme certaines réponses mélangent également des chaînes avec des tableaux de chaînes, ce n'est pas complètement sans importance).

Array.Exists () est une méthode C # /. NET 2.0 et n'a pas besoin de Linq. La recherche dans les tableaux est O (n). Pour un accès encore plus rapide, utilisez HashSet ou des collections similaires.

Depuis .NET 3.5, il existe également une méthode générique 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");
   }
}

Vous pouvez écrire une propre méthode d'extension (C # 3.0 et supérieur) pour ajouter le sucre syntaxique pour obtenir le même / similaire ".Contains" que pour les chaînes de tous les tableaux sans inclure 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));
}

Dans ce cas, cette ArrayContains()méthode est utilisée et non la méthode Contains de Linq.

Les méthodes .Contains mentionnées ailleurs font référence à List<T>.Contains(depuis C # 2.0) ou ArrayList.Contains(depuis C # 1.1), mais pas aux tableaux lui-même directement.

Il vous manque juste quelque chose dans votre méthode:

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

Ajoutez simplement stringet tout ira bien.

Le problème n'est pas très clair, mais il semble que vous vouliez quelque chose comme ceci:

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

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

Envisagez d'utiliser HashSet<T>Class pour des raisons de performances de recherche:

Cette méthode est une opération O (1).

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

Par exemple:

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

J'ai cherché maintenant plus de 2h pour trouver un bon moyen de trouver des doublons dans une liste et comment les supprimer . Voici la réponse la plus 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 sortie ressemblera à ceci: Les éléments dupliqués seront supprimés dans la nouvelle liste appelée distinct!