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
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...
}
}
List.Contains()
est ce que vous recherchez, je pense. C # a in
keyword
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
Tu peux le faire:
var x = 99; // searched value
if (new[] {1,2,3,99}.Contains(x))
{
// do something
}
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;
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.
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");
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;
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.
Pour les chiffres de 0 à 9:
"123".Contains(myValue)
Pour toute autre chose:
"|1|2|3|".Contains("|" + myValue + "|")
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;
}
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));
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;
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().