in operator in C＃

Question

我想在Commodore 128 Basic中運算符中有。
在c＃中是否還有一個in運算符？

我的意思是有樣

if(aString in ["a", "b", "c"]) 
    Console.Out.WriteLine("aString is 'a', 'b' or 'c'"); 

EDIT1操作：目前我需要它來決定，如果一個枚舉值在一定範圍內枚舉值。

編輯2：謝謝大家的Contains（）解決方案。我將來會使用它。但目前我需要枚舉值。我可以使用Contains（）或其他方法替換以下語句嗎？

public enum MyEnum { A, B, C } 

class MyEnumHelper 
{ 
    void IsSpecialSet(MyEnum e) 
    { 
    return e in [MyEnum.A, MyEnum.C] 
    } 
} 

編輯3：對不起，它不是基本的。我剛剛搜索了一下，發現Turbo Pascal是我可以看到的候選人。見http://en.wikipedia.org/wiki/Pascal_%28programming_language%29#Set_types

Edit4：最佳答案到現在爲止（到2005年底2012年2月15日）：

• 對於列表和數組：接受的答案和所有其他的答案與 載有（）解決方案
• For Enums：TheKaneda的答案與優點/利弊列表 不同的擴展方法

Answer 1

嘗試此：

if(new [] {"a", "b", "c"}.Contains(aString)) 
    Console.Out.WriteLine("aString is 'a', 'b' or 'c'"); 

這使用Contains方法來搜索該陣列爲aString。

Answer 2

大多數集合都有一個.Contains方法，LINQ也有一個Contains方法，所以任何可枚舉的，沒有自己包含方法的東西都可以從LINQ中獲得。

Answer 3

號你可以接近：

if (new [] { "a", "b", "c" }.Contains(aString)) 
    Console.Out.WriteLine("aString is 'a', 'b' or 'c'"); 

Answer 4

基於您的代碼，你看看是否ASTRING等於「A」，「B」或「C」，而不是它是否包含「a」，「b」或「c」。如果我在看問題的權利，那麼：

號相反，你會使用一個switch語句

switch(aString) 
{ 
    case "a:": 
    case "b:": 
    case "b:": 
     Console.Out.WriteLine("aString is 'a', 'b' or 'c'"); 
    default: 
     Console.Out.WriteLine("aString is NOT 'a', 'b' or 'c'"); 
} 

Answer 5

C＃中的equivelent將Contains()（假設你有一個列表或數據的陣列）

var myStuff = new List<string> { "a", "b", "c" }; 
var aString = "a"; 

if(myStuff.Contains(aString)) { 
    //Do Stuff 
} 

至於in關鍵字，它具有不同的用途：

var myStuff = new List<string> { "a", "b", "c" }; 
var aString = "a"; 

foreach(string str in myStuff) { 
    //Iteration 0 = a, 1 = b, 2 = c 
} 

Answer 6

使用包含方法：

string[] values = { "A", "B", "C" }; 

if (values.Contains("A"))   //True 
    MessageBox.Show("A is there"); 

if (values.Contains("b"))    //false, strings are case sensitive 
    MessageBox.Show("b is there"); 

Answer 7

in關鍵字僅用於foreach。 不，沒有這樣的操作員專門用於此目的。但是你可以使用數組類型或列表類型的內置方法，如下面所示：

 string aString = "a"; 
     string[] strings = new string[] { "a", "b", "c" }; 
     if (strings.Contains(aString)) //Contains here is a Linq extension 
      Console.WriteLine("aString is either a, b, or c"); 

     List<string> stringList = new List<string>() { "a", "b", "c" }; 
     if(stringList.Contains(aString)) //Contains here is a member method 
      Console.WriteLine("aString is either a, b, or c"); 

     if(stringList.IndexOf(aString) != -1) 
      Console.WriteLine("aString is either a, b, or c"); 

Answer 8

，如果你想爲一個客戶的這個例子中工作，所以一個稍微更流暢的方式你可以使用一個擴展方法和客戶狀態：

public enum CustomerStatus 
{ 
    Active, 
    Inactive, 
    Deleted 
} 

public class Customer 
{ 
    public CustomerStatus Status { get; set; } 
} 

使用下面的擴展方法：

public static class EnumExtensions 
{ 
    public static bool In(this Enum value, params Enum[] values) 
    { 
     return values.Contains(value); 
    } 
} 

，讓你寫這樣的代碼：

private void DoSomething() 
{ 
     var customer = new Customer 
     { 
      Status = CustomerStatus.Active 
     }; 

     if (customer.Status.In(CustomerStatus.Active, CustomerStatus.Inactive)) 
     { 
      // Do something. 
     } 
} 

Answer 9

要回答關於Andrew Hare回答的後續問題，是的，可以將In擴展方法限制爲單個枚舉。不要接受這個答案，因爲安德魯和特雷弗回答了修改後的問題（無論如何，大多數人都回答了原來的問題）。

要回顧一下，這是我覺得最有用：https://stackoverflow.com/a/5320727/1169696

但如果你真的想限制它，這只是一個使用枚舉的類型作爲參數，而不是一個普通的（或枚舉）的事情：

// This is the one we want to use our In extension method on: 
public enum FriendlyEnum 
{ 
    A, 
    B, 
    C 
} 

public enum EnemyEnum 
{ 
    A, 
    B, 
    C 
} 

// The extension method: 
public static class FriendlyEnumExtensions 
{ 
    public static bool In(this FriendlyEnum value, params FriendlyEnum[] list) 
    { 
     return list.Contains(value); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     FriendlyEnum friendlyValue = FriendlyEnum.A; 
     EnemyEnum enemyValue  = EnemyEnum.A; 

     // Outputs "True": 
     Console.WriteLine(friendlyValue.In(FriendlyEnum.A, FriendlyEnum.C)); 

     // Outputs "False": 
     Console.WriteLine(friendlyValue.In(FriendlyEnum.B, FriendlyEnum.C)); 

     // All of these will result in compiler errors, 
     // because EnemyEnum is invading some way or another: 
     Console.WriteLine(friendlyValue.In(EnemyEnum.A, EnemyEnum.B)); 
     Console.WriteLine(enemyValue.In(FriendlyEnum.A, FriendlyEnum.B)); 
     Console.WriteLine(enemyValue.In(EnemyEnum.A, EnemyEnum.B)); 
    } 

} 

我覺得它比一般一個我聯繫不太有用 - 或Trevor的做法 - 但你去那裏。該方法之間

更新

差異：

• 使用特雷弗的方法，在代碼中的敵人和朋友的所有三種混合物上面會被編譯器所接受（輸出將是「真「，」假「，」假「，」假「，」真「）。

• 使用通用方法，最後一個將被接受（和「真」），因爲泛型只確保所有參數（包括this）具有相同的類型。也就是說，它不會接受在同一個調用中混合不同的枚舉。

• 上面的一個將再次只接受您設計擴展方法的一個枚舉。

Answer 10

我很驚訝，沒有人提出switch：

class MyEnumHelper 
{ 
    void IsSpecialSet(MyEnum e) 
    { 
     return e in [MyEnum.A, MyEnum.C] 
     switch (e) 
     { 
      case MyEnum.A: 
      case MyEnum.C: 
       return true; 
      default: 
       return false; 
     } 
    } 
} 

Answer 11

試試這個：

if ("abc".Contains(aString[0])) 
    Console.WriteLine("aString is 'a', 'b' or 'c'"); 

Answer 12

感謝我的德爾福天，我也用它在關鍵詞。對於C＃泛型的情況下，我使用的是：

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

可以利用如下：

var color = Color.Aqua; 
    var b = color.In(Color.Black, Color.Blue); 
    b = "hello".In("hello", "world");