в операторе в C #

Question

Я думаю, что в Commodore 128 Basic был оператор in .
Есть ли оператор в C # тоже?

Я имею в виду, есть ли оператор вида

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

Edit1: В настоящее время мне нужно решить, находится ли значение перечисления в диапазоне некоторых значений перечисления.

Edit2: Спасибо всем за решения Contains (). Я буду использовать это в будущем. Но в настоящее время у меня есть потребность в перечислении значений. Могу ли я заменить следующий оператор на Contains () или другие методы?

public enum MyEnum { A, B, C }

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

Edit3: Извините, это не было Basic. Я просто погуглил некоторое время и нашел Turbo Pascal в качестве кандидата, где я мог видеть это. Смотри http://en.wikipedia.org/wiki/Pascal_%28programming_language%29#Set_types

Edit4: Лучшие ответы на данный момент (конец 15 февраля 2012 г.):

• Для списков и массивов: принятый ответ и все остальные ответы с Содержит () решения
• Для Enums: TheKaneda ответ с хорошим списком плюсов / минусов для различные методы расширения

Answer 1

Попробуйте это:

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

Для поиска в массиве aString.

используется метод Contains.

Answer 2

Благодаря моим дням в Delphi я также привык к его ключевому слову в .Для общего случая в 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");

Answer 3

Вы можете использовать метод расширения, если вы хотите немного более свободный способ работы, поэтому для этого примера клиента и статуса клиента:

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 4

Эквивалент в C # будет 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 5

Нет.Вы можете подойти ближе:

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

Answer 6

Попробуйте это:

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

Answer 7

Чтобы ответить на дополнительный вопрос об ответе Эндрю Хэра, да, можно ограничить метод расширения In одним перечислением.Не принимайте этот ответ, так как Эндрю и Тревор ответили на пересмотренный вопрос (и большинство ответили на оригинал ... в любом случае).

Напомним, это то, что я считаю наиболее полезным: https://stackoverflow.com/a/5320727/1169696

Но если вы действительно хотите ограничить его, это просто вопрос использования типа Enum в качестве параметра вместо универсального (или Enum):

// 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));
    }

}

Я считаю его менее полезным, чем универсальныйЯ связал - или подход Тревора - но вы идете.

Обновление

Разница между подходами:

• Использование Тревораметод, все три смеси врага и друга в приведенном выше коде будут приняты компилятором (выходные данные будут «True», «False», «False», «False», «True»).

• При использовании универсального подхода будет принят последний (и «True»), поскольку универсальные шаблоны гарантируют, что все параметры (включая this) имеют одинаковый тип.То есть он не будет принимать смешивание различных перечислений в одном вызове.

• Приведенный выше, опять же, будет принимать только одно перечисление, для которого вы разработали метод расширения.

Answer 8

Ключевое слово 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 9

Используйте метод содержимого:

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 10

На основании вашего кода вы посмотрите, равно ли 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'"); 
}