Est-il un C# À l'opérateur?

List.Contains() est je crois ce que vous cherchez. C# a in keyword et pas un operator qui sert le but complètement différent que ce que vous faites référence dans SQL.

Il y a deux façons vous pouvez utiliser in mot-clé en C#. Supposons que vous disposez d'un string[] ou de la Liste en 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);
        }

Se référant à vos modifier, je mettrais votre code de cette façon de faire ce que vous avez besoin.

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

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

Vous utilisez habituellement la Contains méthode de une collection.

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

J'espère que cela aide.

Doublon de : LINQ to SQL et non pas dans

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

ou

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

L'équivalent de DANS et PAS DANS les requêtes LINQ to SQL serait quelque chose comme ceci:

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

et ce:

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

Vous pouvez écrire une extension. J'ai écrit une seule fois auparavant, pour faire un code comme

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

plus lisible avec une extension s.t. on a pu écrire

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

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

C'est l'une de mes besoins pour le moment, mais vous pouvez l'adapter et modifier pour qu'il corresponde plus de types différents.

Pour la mise à jour de votre question, vous pouvez également utiliser un interrupteur d'instruction.

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

Commun, LINQ façon de plus en plus puissants:

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;

- Je faire quelque chose comme ceci:

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