web-dev-qa-db-fra.com

Y a-t-il un opérateur C # IN?

En SQL, vous pouvez utiliser la syntaxe suivante:

SELECT *
FROM MY_TABLE
WHERE VALUE_1 IN (1, 2, 3)

Existe-t-il un équivalent en C #? Le IDE semble reconnaître "dans" comme mot clé, mais je ne semble pas pouvoir trouver aucune information à ce sujet.

Alors, est-il possible de faire quelque chose comme ce qui suit:

int myValue = 1;
if (myValue in (1, 2, 3))
    // Do something

Au lieu de

int myValue = 1;
if (myValue == 1 || myValue == 2 || myValue == 3)
    // Do something
c#sqloperatorsin-operator
75
Paul Michaels

Si vous voulez écrire .In, vous pouvez créer une extension vous permettant de le faire. 

static class Extensions
{

    public static bool In<T>(this T item, params T[] items)
    {
        if (items == null)
            throw new ArgumentNullException("items");

        return items.Contains(item);
    }

}


class Program
{

    static void Main()
    {


        int myValue = 1;

        if (myValue.In(1, 2, 3))
            // Do Somthing...

        string ds = "Bob";

        if (ds.In("andy", "joel", "matt")) 
        // Do Someting...
    }
}
104
Andy Robinson

List.Contains() est ce que vous recherchez, je pense. C # a inkeyword et non une operator qui sert à un but complètement différent de ce que vous faites référence en SQL.

Vous pouvez utiliser le mot clé in de deux manières différentes en C #. Supposons que vous avez une chaîne [] ou une liste en C #.

        string[] names; //assume there are some names;

        //find all names that start with "a"
        var results = from str in names
                      where str.StartsWith("a")
                      select str;

        //iterate through all names in results and print
        foreach (string name in results)
        {
            Console.WriteLine(name);
        }

En référant votre modification, je mettrais votre code de cette façon pour faire ce dont vous avez besoin.

        int myValue = 1;
        List<int> checkValues = new List<int> { 1, 2, 3 };

        if (checkValues.Contains(myValue))
            // Do something
77
this. __curious_geek

Tu peux le faire:

var x = 99; // searched value

if (new[] {1,2,3,99}.Contains(x))
{
   // do something
}
20
JwJosefy

Il n'y a pas d'opérateur "in" en C #, le mot-clé "in" est utilisé uniquement avec "foreach (... in ...)" ou "from ... in ...".

L'équivalent LINQ de votre requête SQL serait:

List<int> list = new List<int> { 1, 2, 3 };
var query = from row in my_table
            where list.Contains(row.value1)
            select row;
6
Daniel

Vous utilisez généralement la méthode Contains d'une collection.

myCollection.Where(p => Enumerable.Range(1,3).Contains(p));

J'espère que ça aide.

6
luckyluke

Je conviens que le meilleur moyen d'implémenter l'opérateur In est d'utiliser une méthode d'extension. Je l'ai fait un peu différemment:

public static bool In(this string str, string CommaDelimintedStringSet)
{
    string[] Values = CommaDelimintedStringSet.Split(new char[] { ',' });
    foreach (string V in Values)
    {
       if (str == V)
         return true;
    }
    return false;
}

La différence est qu'il n'est pas nécessaire de mettre des guillemets autour de chaque valeur, mais uniquement l'ensemble des valeurs délimitées par des virgules, ce qui est plus facile à saisir:

bool result = MyString.In("Val1,Val2,Val3");
4
Chuck Bevitt

Duplicate of: LINQ to SQL dans et non dans

select * from table where fieldname in ('val1', 'val2')

ou 

select * from table where fieldname not in (1, 2)

L'équivalent des requêtes IN et NOT IN dans LINQ to SQL ressemblerait à ceci:

List<string> validValues = new List<string>() { "val1", "val2"}; 
var qry = from item in dataContext.TableName 
          where validValues.Contains(item.FieldName) 
          select item;

et ça:

List<int> validValues = new List<int>() { 1, 2}; 
var qry = from item in dataContext.TableName 
          where !validValues.Contains(item.FieldName) 
          select item;
4
Pranay Rana

Vous pouvez écrire une extension. J'ai écrit il y a un moment, pour faire du code comme

if(someObject.stringPropertyX.Equals("abc") || someObject.stringPropertyX.Equals("def") || ....){
    //do something
    ...
}else{
   //do something other...
   ....
}

plus lisible avec une extension à la on était capable d'écrire

if(someObject.stringPropertyX.In("abc", "def",...,"xyz"){
   //do something
   ...
}else{
  //do something other...
  ....
}

Voici le code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Some.Namespace.Extenders
{
    public static class StringExtender
    {
        /// <summary>
        /// Evaluates whether the String is contained in AT LEAST one of the passed values (i.e. similar to the "in" SQL clause)
        /// </summary>
        /// <param name="thisString"></param>
        /// <param name="values">list of strings used for comparison</param>
        /// <returns><c>true</c> if the string is contained in AT LEAST one of the passed values</returns>
        public static bool In(this String thisString, params string[] values)
        {
            foreach (string val in values)
            {
                if (thisString.Equals(val, StringComparison.InvariantCultureIgnoreCase))
                    return true;
            }

            return false; //no occurence found
        }
    }
}

C’est celui qui correspond à mes besoins à ce moment-là, mais vous pouvez l’adapter et le modifier pour correspondre à plusieurs types.

2
Juri

Pour les chiffres de 0 à 9:

"123".Contains(myValue)

Pour toute autre chose:

"|1|2|3|".Contains("|" + myValue + "|")
1
user3354025

Pour votre question mise à jour, vous pouvez également utiliser une instruction switch.

switch (myvalue)
{
   case 1:
   case 2:
   case 3: 
      // your code goes here
  break;
}
1
Pranay Rana

Il n'y a pas d'opérateur in qui cherche une valeur dans une collection, il s'agit plutôt d'une méthode de la collection, appelée Contains.

La solution la plus évolutive consiste à utiliser HashSet en tant que collection. La vérification d'une valeur dans HashSet est proche d'une opération O(1), par rapport à l'opération dans une List où il s'agit d'une opération O(n). Cela signifie que vous pouvez insérer beaucoup de valeurs dans un HashSet et que cela reste rapide, tandis que rechercher une valeur dans un List devient plus lent si vous avez plus de valeurs.

Exemple:

var set = new HashSet<int>();
set.Add(1);
set.Add(2);
set.Add(3);

var result = items.Select(i => set.Contains(i.value));
1
Guffa

Commun, LINQ beaucoup plus puissant:

var list = new List<string> { "Tomato", "Orange", "Mango"};
var query = from i in my_table
            from v in list
            where i.Name.StartsWith(v)
            select i;
0
bjolfr

Le mot clé in en C # concerne l'instruction foreach et les expressions de requête LINQ. Il n'y a pas de fonctionnalité équivalente à l'opérateur in de SQL en C # en tant que tel, mais LINQ offre une fonctionnalité similaire avec Contains().

var list = {1, 2, 3}
var filtered = (
    from item in items
    where list.Contains(item)
    select item).ToArray().
0
P Daddy