Question

在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

Answer 1

如果你想写。那么你可以创建一个允许你这样做的扩展。

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

Answer 2

List.Contains()我认为你在寻找什么。 C＃有in keyword，而不是operator，它的用途完全不同于您在SQL中引用的内容。

有两种方法可以在C＃中使用in关键字。假设你在C＃中有一个字符串[]或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

Answer 3

你可以这样做：

var x = 99; // searched value

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

Answer 4

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;

Answer 5

您通常使用集合的Contains方法。

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

我希望它有所帮助。

Answer 6

重复：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;

Answer 7

我同意实现In运算符的最佳方法是使用Extension方法。我做的有点不同：

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

Answer 8

对于您更新的问题，您还可以使用switch语句。

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

Answer 9

你可以写一个扩展名。我在一段时间前写过，用于编写像

这样的代码

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

更具可读性与扩展s.t.一个人能够写

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

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

这是我当时特定的需求，但您可以调整和修改它以匹配更多不同的类型。

Answer 10

运算符中没有查找集合中的值，而是集合的方法，称为Contains。

最具扩展性的解决方案是使用HashSet作为集合。检查HashSet中的值是否接近于O（1）操作，与在List中进行O（n）操作相比。这意味着您可以在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));

Answer 11

对于0到9之间的数字：

"123".Contains(myValue)

对于任何其他东西：

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

Answer 12

常用的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;

Answer 13

C＃中的in关键字用于foreach语句和LINQ查询表达式。 C＃本身没有与SQL in运算符等效的功能，但LINQ提供与Contains()类似的功能。

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

Answer 14

我做这样的事情：

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

有C＃IN运算符吗？

14 个答案: