C # IN 연산자가 있습니까?

SQL에서 다음 구문을 사용할 수 있습니다.

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

C #에 상응하는 것이 있습니까? IDE는 "in"을 키워드로 인식하는 것 같지만 그것에 대한 정보를 찾을 수없는 것 같습니다.

따라서 다음과 같은 작업을 수행 할 수 있습니까?

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

대신에

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

.In을 작성하고 싶다면 그렇게 할 수있는 확장을 만들 수 있습니다.

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()나는 당신이 찾고있는 것을 생각합니다. C #은이 in keyword아닌operator 당신이 SQL에서 참조하는지 다음 완전히 다른 목적을 제공하는합니다.

inC #에서 키워드를 사용하는 방법에는 두 가지가 있습니다 . C #에 string [] 또는 List가 있다고 가정합니다.

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

편집 내용을 참조하면 필요한 작업을 수행하기 위해이 방법으로 코드를 입력합니다.

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

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

다음과 같이 할 수 있습니다.

var x = 99; // searched value

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

일반적으로 Contains수집 방법을 사용합니다 .

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

도움이되기를 바랍니다.

C #에는 "in"연산자가 없습니다. "in"키워드는 "foreach (... in ...)"또는 "from ... in ..."에만 사용됩니다.

SQL 쿼리에 해당하는 LINQ는 다음과 같습니다.

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

중복 : LINQ to SQL in and not in

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

또는

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

LINQ to SQL의 IN 및 NOT IN 쿼리에 해당하는 것은 다음과 같습니다.

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

이:

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

In 연산자를 구현하는 가장 좋은 방법은 확장 메서드를 사용하는 것에 동의합니다. 나는 그것을 조금 다르게했다.

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

차이점은 각 값 주위에 따옴표를 넣을 필요가없고 쉼표로 구분 된 전체 값 집합 만 입력 할 수 있다는 것입니다.

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

확장을 작성할 수 있습니다. 나는 다음과 같은 코드를 만들기 위해 한 번 썼다.

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

확장명으로 더 읽기 쉬웠습니다.

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

코드 는 다음과 같습니다 .

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

이것은 그 당시 제 요구에 맞는 것이지만 더 다양한 유형에 맞게 조정하고 수정할 수 있습니다.

0에서 9 사이의 숫자 :

"123".Contains(myValue)

기타 항목 :

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

업데이트 된 질문의 경우 switch-statement를 사용할 수도 있습니다.

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

컬렉션에서 값을 찾는 in 연산자는 없습니다. 대신라는 컬렉션의 메서드입니다 Contains.

가장 확장 가능한 솔루션은 a HashSet를 컬렉션 으로 사용하는 것입니다. a에서 값을 확인하는 것은 a에서 HashSet수행하는 것과 비교하여 O (1) 작업에 가깝습니다.List O (n) 연산 인 . 즉, a에 많은 값을 담을 수 있으며 HashSet여전히 빠르며List 려면 값이 많을수록 속도가 느려집니다.

예:

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

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

일반적인 LINQ 방식보다 강력합니다.

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;

inC # 의 키워드는 foreach문 및 LINQ 쿼리 식용입니다. inC # 자체에서 SQL 연산자와 동일한 기능은 없지만 LINQ는 Contains().

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

다음과 같이합니다.

var shippingAddress = checkoutContext.Addresses.Where(a => (new HashSet<AddressType> { AddressType.SHIPPING_ONLY, AddressType.BILLING_AND_SHIPPING }).Contains(a.AddressType) && a.Id == long.Parse(orderDto.ShippingAddressId)).FirstOrDefault();