Is there a C# IN operator?

Question

In SQL, you can use the following syntax:

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

Is there an equivalent in C#? The IDE seems to recognise "in" as a keyword, but I don't seem to be able to find any information on it.

So, is it possible to do something like the following:

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

Instead of

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

Answer 1

List.Contains() is I think what you're looking for. C# has in keyword and not an operator which serves completely different purpose then what you're referring in SQL.

There are two ways you can use in keyword in C#. Assume you have a string[] or List 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);
        }

Referring your edit, I'd put your code this way to do what you need.

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

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

Answer 2

There's no "in" operator in C#, the "in" keyword is used only with "foreach (... in ...)" or "from ... in ...".

The LINQ equivalent of your SQL query would be:

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

Answer 3

Duplicate of : http://stackoverflow.com/questions/3047657/linq-to-sql-in-and-not-in

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

or

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

The equivalent of IN and NOT IN queries in LINQ to SQL would be something like this:

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

and this:

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

Answer 4

You usually usu the Contains method of a collection.

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

Hope it helps

Answer 5

The in keyword in C# is for the foreach statement and for LINQ query expressions. There is no functionality equivalent to SQL's in operator in C# per se, but LINQ offers similar functionality with Contains().

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

Answer 6

For you updated question

make use of switch

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

Answer 7

You can write an extension. I wrote one time ago, for making code like

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

more readable with an extention s.t. one was able to write

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

Here's the 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
        }
    }
}

This is the one specific to my needs at that time, but you may adapt and modify it to match more different types.

Answer 8

There is no in operator that looks for a value in a collection, instead it's a method of the collection, called Contains.

The most scalable solution is to use a HashSet as the collection. Checking for a value in a HashSet is close to an O(1) operation, compared to doing it in a List where it is an O(n) operation. That means that you can pack a lot of values in a HashSet and it's still fast, while looking for a value in a List gets slower the more values you have.

Example:

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

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

Answer 9

If you wanted to write .In then you could create an extension that allows you to do that.

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