C# 匹配多个值的if语句

写这个if语句有没有更简单的方法

if（value==1 | | value==2）

例如。。。在SQL中，您可以在（1,2）中说

where value，而不是
where value=1或value=2

我要找的东西，将与任何基本类型的工作。。。字符串、int等。
如果您有一个列表，您可以使用.Contains（您的对象），如果您只是寻找它的存在（比如where）。否则，请查看Linq.Any（）扩展方法。
如果您有一个列表，您可以使用.Contains（您的对象），如果您只是查找它是否存在（如where）。否则，请查看Linq.Any（）扩展方法。
通常，否

是的，在某些情况下，列表位于
数组中或
列表中，但这不是一般情况。
通常，否

是的，在某些情况下，列表位于
数组中或
列表中，但这不是一般情况。
这就是您要查找的吗

if (new int[] { 1, 2, 3, 4, 5 }.Contains(value))

这就是你要找的吗

if (new int[] { 1, 2, 3, 4, 5 }.Contains(value))

使用Linq

if（新的int[]{1，2}.Contains（value））

但是我不得不认为您的原始if更快。
使用Linq

if（新的int[]{1，2}.Contains（value））

但我不得不认为你的原始if更快。
怎么样：

if (new[] {1, 2}.Contains(value))

不过这是一种黑客行为：）

或者，如果您不介意创建自己的扩展方法，可以创建以下内容：

public static bool In<T>(this T obj, params T[] args)
{
    return args.Contains(obj);
}

：）
怎么样：

if (new[] {1, 2}.Contains(value))

不过这是一种黑客行为：）

或者，如果您不介意创建自己的扩展方法，可以创建以下内容：

public static bool In<T>(this T obj, params T[] args)
{
    return args.Contains(obj);
}

：）
一种更复杂的方法：）模拟SQL的“IN”：

public static class Ext {    
    public static bool In<T>(this T t,params T[] values){
        foreach (T value in values) {
            if (t.Equals(value)) {
                return true;
            }
        }
        return false;
    }
}

if (value.In(1,2)) {
    // ...
}

公共静态类Ext{
公共静态布尔输入（此T，参数T[]值）{
foreach（值中的T值）{
如果（t等于（值））{
返回true；
}
}
返回false；
}
}
if（在（1,2）中的值）{
// ...
}

但是按照标准的方式，它更具可读性

编辑：根据@Kobi的建议，一个更好的解决方案：

public static class Ext {    
    public static bool In<T>(this T t,params T[] values){
        return values.Contains(t);
    }
}

公共静态类Ext{
公共静态布尔输入（此T，参数T[]值）{
返回值。包含（t）；
}
}
一种更复杂的方法：）模拟SQL的“IN”：

public static class Ext {    
    public static bool In<T>(this T t,params T[] values){
        foreach (T value in values) {
            if (t.Equals(value)) {
                return true;
            }
        }
        return false;
    }
}

if (value.In(1,2)) {
    // ...
}

公共静态类Ext{
公共静态布尔输入（此T，参数T[]值）{
foreach（值中的T值）{
如果（t等于（值））{
返回true；
}
}
返回false；
}
}
if（在（1,2）中的值）{
// ...
}

但是按照标准的方式，它更具可读性

编辑：根据@Kobi的建议，一个更好的解决方案：

public static class Ext {    
    public static bool In<T>(this T t,params T[] values){
        return values.Contains(t);
    }
}

公共静态类Ext{
公共静态布尔输入（此T，参数T[]值）{
返回值。包含（t）；
}
}
使用扩展方法：

public static class ObjectExtension
{
    public static bool In(this object obj, params object[] objects)
    {
        if (objects == null || obj == null)
            return false;
        object found = objects.FirstOrDefault(o => o.GetType().Equals(obj.GetType()) && o.Equals(obj));
        return (found != null);
    }
}

现在您可以执行以下操作：

string role= "Admin";
if (role.In("Admin", "Director"))
{ 
    ...
} 

使用扩展方法：

public static class ObjectExtension
{
    public static bool In(this object obj, params object[] objects)
    {
        if (objects == null || obj == null)
            return false;
        object found = objects.FirstOrDefault(o => o.GetType().Equals(obj.GetType()) && o.Equals(obj));
        return (found != null);
    }
}

现在您可以执行以下操作：

string role= "Admin";
if (role.In("Admin", "Director"))
{ 
    ...
} 

public static bool EqualsAny（可调值，参数T[]可能匹配）{
foreach（可能匹配中的T）{
if（值等于（t））
返回true；
}
返回false；
}
公共静态布尔等式（IEquatable值，IEnumerable可能匹配）{
foreach（可能匹配中的T）{
if（值等于（t））
返回true；
}
返回false；
}
公共静态bool EqualsAny（相等值，参数T[]可能匹配）{
foreach（可能匹配中的T）{
if（值等于（t））
返回true；
}
返回false；
}
公共静态布尔等式（IEquatable值，IEnumerable可能匹配）{
foreach（可能匹配中的T）{
if（值等于（t））
返回true；
}
返回false；
}
或者，如果将来测试除1或2以外的值时使用switch语句，这将为您提供更大的灵活性

switch(value)
{
case 1:
case 2:
   return true;
default:
   return false
}

或者，如果将来测试1或2以外的值时使用switch语句，这将为您提供更大的灵活性

switch(value)
{
case 1:
case 2:
   return true;
default:
   return false
}

更容易是主观的，但是switch语句可能更容易？您不必重复变量，因此行上可以容纳更多的值，并且具有许多比较的行比使用if语句的对应行更清晰。
更容易是主观的，但是switch语句可能更容易？您不必重复该变量，因此该行可以容纳更多的值，并且具有许多比较的行比使用if语句的对应行更清晰。
像这样的扩展方法可以做到这一点

public static bool In<T>(this T item, params T[] items)
{
    return items.Contains(item);
}

像这样的扩展方法可以做到这一点

public static bool In<T>(this T item, params T[] items)
{
    return items.Contains(item);
}

在vb.net或C#中，我认为将一个变量与任何合理数量的单独命名对象（例如，与集合中的所有对象相反）进行比较的最快通用方法是将每个对象与比较对象进行比较，就像您所做的那样。当然可以创建集合的实例并查看它是否包含对象，这样做可能比单独将对象与所有项进行比较更具表现力，但除非使用编译器可以明确识别的构造，这样的代码几乎肯定比简单地进行单独比较要慢得多。如果代码本质上每秒最多运行几百次，我不会担心速度，但我会担心代码会被重新调整用途，使其运行的频率远远超过最初的预期

如果变量类似于枚举类型，另一种方法是选择两个枚举值的幂，以允许使用位掩码。如果枚举类型具有32个或更少的有效值（例如，开始Harry=1、Ron=2、Hermine=4、Ginny=8、Neville=16），则可以将它们存储在整数中，并在单个操作中一次检查多个位（（如果（（thisOne&（Harry | Ron | Neville | Beatrix））！=0）/*执行某些操作