有 C# IN 运算符吗？

【问题标题】：Is there a C# IN operator?有 C# IN 运算符吗？
【发布时间】：2011-03-11 01:11:38
【问题描述】：

在 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

【问题讨论】：

  • 我已经对此进行了一些编辑以澄清我想要比较的内容
  • 查看我添加的另一个答案
  • 这已经在stackoverflow上被问过多次了...
  • @chiccodoro 如果之前有人问过这个问题，然后将其标记为重复并发布带有原始问题链接的答案，不要只留下负面评论
  • 我仍然很好奇为什么它不是一个内置的语言功能（至少，至少对于字符串）。 SQL 和 Python 等其他语言具有此功能。但通常有一个合理的理由，考虑到这一点的简单性，我怀疑它从未被要求或考虑过。

标签： c# sql operators in-operator


【解决方案1】：

List.Contains() 是我认为您正在寻找的东西。 C# 有 in keyword 而不是 operator，其用途与您在 SQL 中所指的用途完全不同。

有两种方法可以在 C# 中使用 in 关键字。假设您在 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

【讨论】：

  • 人们看到SQL立马跳到LINQ，不过这个简单的功能大概正是他想要的吧
【解决方案2】：

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;

【讨论】：

    【解决方案3】：

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

    【讨论】：

    • 是的 - 抱歉，我已经编辑了我的问题，因为我的问题与 linq 无关
    【解决方案4】：

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

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

    希望对你有帮助。

    【讨论】：

      【解决方案5】：

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

      【讨论】：

        【解决方案6】：

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

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

        【讨论】：

        • 这就是我最终要做的。我想大家的共识是，在 C# 中实际上并没有为此提供任何便利。
        • 我真的不会接受这个，因为它不是对“in”运算符问题的回答。请查看投票最多的答案...
        • 我完全不推荐这种方法！它不可扩展，并且有能力让你的程序员同事的生活变得悲惨！
        • @decyclone：是的，一切都与可维护性有关。编写代码，就好像下一个取代你的程序员是一个连环杀手，并且知道你住在哪里。
        • 我不同意，这个问题没有实际答案（或者答案是“不，在 C# 中不存在”） - 所以这似乎是我最接近的选择。您还必须记住，问题是基于语言功能而不是风格。
        【解决方案7】：

        您可以编写扩展程序。前段时间写的，为了写代码

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

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

        【讨论】：

          【解决方案8】：

          没有在集合中查找值的 in 运算符，而是集合的一个方法，称为 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));

          【讨论】：

            【解决方案9】：

            如果您想编写 .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...
    }
}

            【讨论】：

            • 记得使用 System.Linq 添加；
            • In 比 contains 好读得多... 更容易理解
            • 相同版本不引发异常：return items?.Contains(item) ?? false;
            【解决方案10】：

            我同意实现 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");

            【讨论】：

            • 最好在这个函数中使用参数数组。喜欢public static bool In(this string str, params string[] stringSet) 并称它为bool result = myString.In("Val1", "Val2", "Val3")
            【解决方案11】：

            你可以这样做：

            var x = 99; // searched value

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

            【讨论】：

            • 我更喜欢这个答案而不是投票率更高的答案，因为想要进行 IN 而不是重复的相等检查的全部意义在于降低代码复杂性，这很好，简短而简单！
            【解决方案12】：

            对于从 0 到 9 的数字：

            "123".Contains(myValue)

            对于任何其他的东西：

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

            【讨论】：

              【解决方案13】：

              普通，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;

              【讨论】：

                【解决方案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();

                【讨论】：

                  猜你喜欢
                  • 1970-01-01
                  • 1970-01-01
                  • 2012-07-11
                  • 2022-08-10
                  • 1970-01-01
                  • 2011-03-03
                  • 2018-12-10
                  相关资源
                  最近更新 更多
                  热门标签
                  Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode