wake-up-neo.net

Gibt es einen C # IN-Operator?

In SQL können Sie die folgende Syntax verwenden:

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

Gibt es ein Äquivalent in C #? Die IDE scheint "in" als Schlüsselwort zu erkennen, aber ich scheine keine Informationen darüber zu finden.

Ist es möglich, etwas wie das Folgende zu tun:

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

Anstatt

int myValue = 1;
if (myValue == 1 || myValue == 2 || myValue == 3)
    // Do something
75
Paul Michaels

Wenn Sie .In schreiben wollten, könnten Sie eine Erweiterung erstellen, mit der Sie das tun können. 

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() 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 
77

Du kannst das:

var x = 99; // searched value

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

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;
6
Daniel

Sie verwenden normalerweise die Contains-Methode einer Collection.

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

Ich hoffe, es hilft.

6
luckyluke

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");
4
Chuck Bevitt

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; 
4
Pranay Rana

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.

2
Juri

Für Ziffern von 0 bis 9:

"123".Contains(myValue)

Für alle anderen Sachen:

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

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;
}
1
Pranay Rana

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));
1
Guffa

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;
0
bjolfr

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().
0
P Daddy