Gibt es einen C # IN-Operator?

List.Contains() ist, denke ich, wonach du suchst. C # hat inkeyword und keine operator, die einen völlig anderen Zweck erfüllt als das, worauf Sie in SQL verweisen.

Es gibt zwei Möglichkeiten, das in-Schlüsselwort in C # zu verwenden. Angenommen, Sie haben eine Zeichenfolge [] oder eine Liste in 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);
        }

In Bezug auf Ihre Bearbeitung würde ich Ihren Code so einstellen, dass er das tut, was Sie brauchen.

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

        if (checkValues.Contains(myValue))
            // Do something 

Du kannst das:

var x = 99; // searched value

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

In C # gibt es keinen Operator "in", das Schlüsselwort "in" wird nur mit "foreach (... in ...)" oder "from ... in ..." verwendet.

Das LINQ-Äquivalent Ihrer SQL-Abfrage wäre:

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

Sie verwenden normalerweise die Contains-Methode einer Collection.

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

Ich hoffe, es hilft.

Ich stimme zu, der beste Weg zur Implementierung des In-Operators besteht in einer Erweiterungsmethode. Ich habe es etwas anders gemacht:

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

Der Unterschied ist, dass Sie nicht um jeden Wert Anführungszeichen setzen müssen, sondern nur den gesamten Satz von durch Kommas getrennten Werten.

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

Duplikat von: LINQ zu SQL in und nicht in

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

oder 

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

Das Äquivalent von IN- und NOT-IN-Abfragen in LINQ to SQL lautet etwa so:

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

und das:

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

Sie können eine Erweiterung schreiben. Ich habe vor einer Zeit geschrieben, um Code zu schreiben

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

besser lesbar mit einer erweiterung an t. man konnte schreiben

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

Hier ist der 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
        }
    }
}

Dies ist derjenige, der für meine damaligen Bedürfnisse spezifisch ist, aber Sie können ihn anpassen und an andere Typen anpassen.

Für Ziffern von 0 bis 9:

"123".Contains(myValue)

Für alle anderen Sachen:

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

Für Ihre aktualisierte Frage können Sie auch eine switch-Anweisung verwenden.

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

Es gibt keinen in-Operator, der in einer Sammlung nach einem Wert sucht, sondern eine Methode der Sammlung mit dem Namen Contains.

Die skalierbarste Lösung ist die Verwendung von HashSet als Auflistung. Das Prüfen auf einen Wert in einer HashSet -Operation liegt in der Nähe einer O(1) - Operation, im Vergleich zu einer List -Operation, bei der es sich um eine O(n) -Operation handelt. Das bedeutet, dass Sie viele Werte in ein HashSet packen können und es ist immer noch schnell, während die Suche nach einem Wert in einem List langsamer wird, je mehr Werte Sie haben.

Beispiel:

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

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

Häufigere, LINQ Weise leistungsstärker:

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;

Das Schlüsselwort in in C # gilt für die Anweisung foreach und für LINQ-Abfrageausdrücke. Es gibt keine Funktionalität, die dem in-Operator von SQL in C # an sich entspricht. LINQ bietet jedoch ähnliche Funktionen wie Contains().

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