Лучшая альтернатива оператору выбора

Ну, есть бросок в по умолчанию case ... Нет другой конструкции времени редактирования / компиляции, кроме этой.

Однако стратегия, посетитель и другие связанные с ними шаблоны могут быть подходящими, если вы решите сделать это во время выполнения.

Пример кода поможет получить лучший ответ.

РЕДАКТИРОВАТЬ: Спасибо за образец. Я все еще думаю, что это требует некоторой конкретизации, поскольку вы не раскрываете, существуют ли некоторые параметры, которые применяются только к некоторым case и т. Д.

Action часто используется как псевдоним для шаблона Command и Тот факт, что ваше Enum называется LogAction , означает, что каждое значение несет с собой поведение - будь то подразумеваемое (вы вставляете соответствующий код в case ) или явное (в конкретном классе иерархии команд ).

Таким образом, мне кажется, что использование шаблона Command является уместным (хотя ваш образец не доказывает этого) - т.е. иметь класс (потенциально иерархию с использованием перегрузок конструктора или любых других [набор] фабричных механизмов), который сохраняет состояние, связанное с запросом, вместе с конкретным поведением. Затем вместо передачи значения Enum создайте соответствующий экземпляр LogCommand для регистратора, который просто вызывает его (потенциально передавая «приемник» Log Sink, в который может войти команда). В противном случае вы ковыряете случайные подмножества параметров в разных местах.

СМОТРИТЕ ТАКЖЕ связанные сообщения:

• C # - Есть ли лучшая альтернатива, чем эта, для «включения типа»?

• Заменить гигантский оператор switch чем?

Попробуйте использовать отражение.

• Украсить опции перечисления атрибутами, которые содержат связанное значение, и вернуть это значение.
• Создайте статический класс констант и используйте отражение для сопоставления параметра enum-option с константой по имени

надеюсь, что это поможет

Иногда сохранение параметров на карте является хорошим решением, вы также можете перенести конфигурацию в файл, не зная, применимо ли это к вашему приложению.

Пример длинного кода здесь, а окончательный общий код немного тяжелый ( РЕДАКТИРОВАТЬ добавил дополнительный пример, который устраняет необходимость в угловых кронштейнах за счет некоторой конечной гибкости).

Одно из преимуществ этого решения - хорошая производительность - не такая хорошая, как простой оператор switch, но каждый оператор case превращается в поиск по словарю и вызов метода, так что по-прежнему неплохо. Однако при первом вызове будет снижена производительность из-за использования статического обобщения, которое отражается при инициализации.

Создайте атрибут и общий тип следующим образом:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class DynamicSwitchAttribute : Attribute
{
 public DynamicSwitchAttribute(Type enumType, params object[] targets)
 { Targets = new HashSet<object>(targets); EnumType = enumType; }
 public Type EnumType { get; private set; }
 public HashSet<object> Targets { get; private set; }
}

//this builds a cache of methods for a given TTarget type, with a 
//signature equal to TAction,
//keyed by values of the type TEnum.  All methods are expected to 
//be instance methods.
//this code can easily be modified to support static methods instead.
//what would be nice here is if we could enforce a generic constraint 
//on TAction : Delegate, but we can't.
public static class DynamicSwitch<TTarget, TEnum, TAction>
{
 //our lookup of actions against enum values.
 //note: no lock is required on this as it is built when the static 
 //class is initialised.

 private static Dictionary<TEnum, TAction> _actions = 
   new Dictionary<TEnum, TAction>();

 private static MethodInfo _tActionMethod;
 private static MethodInfo TActionMethod
 {
  get
  {
   if (_tActionMethod == null)
   {
    //one criticism of this approach might be that validation exceptions
    //will be thrown inside a TypeInitializationException.
    _tActionMethod = typeof(TAction).GetMethod("Invoke", 
      BindingFlags.Instance | BindingFlags.Public);

    if (_tActionMethod == null)
     throw new ArgumentException(/*elided*/);

    //verify that the first parameter type is compatible with our 
    //TTarget type.
    var methodParams = _tActionMethod.GetParameters();
    if (methodParams.Length == 0)
     throw new ArgumentException(/*elided*/);

    //now check that the first parameter is compatible with our type TTarget
    if (!methodParams[0].ParameterType.IsAssignableFrom(typeof(TTarget)))
     throw new ArgumentException(/*elided*/);
   }
   return _tActionMethod;
  }
 }

 static DynamicSwitch()
 {
  //examine the type TTarget to extract all public instance methods 
  //(you can change this to private instance if need be) which have a
  //DynamicSwitchAttribute defined.
  //we then project the attributes and the method into an anonymous type
  var possibleMatchingMethods = 
     from method in typeof(TTarget).
       GetMethods(BindingFlags.Public | BindingFlags.Instance)
     let attributes = method.GetCustomAttributes(
        typeof(DynamicSwitchAttribute), true).
        Cast<DynamicSwitchAttribute>().ToArray()
     where attributes!= null && attributes.Length == 1 
        && attributes[0].EnumType.Equals(typeof(TEnum))
     select new { Method = method, Attribute = attributes[0] };

  //create linq expression parameter expressions for each of the 
  //delegate type's parameters
  //these can be re-used for each of the dynamic methods we generate.
  ParameterExpression[] paramExprs = TActionMethod.GetParameters().
    Select((pinfo, index) =>
    Expression.Parameter(
      pinfo.ParameterType, pinfo.Name ?? string.Format("arg{0}"))
    ).ToArray();
  //pre-build an array of these parameter expressions that only 
  //include the actual parameters
  //for the method, and not the 'this' parameter.
  ParameterExpression[] realParamExprs = paramExprs.Skip(1).ToArray();

  //this has to be generated for each target method.
  MethodCallExpression methodCall = null;

  foreach (var match in possibleMatchingMethods)
  {
   if (!MethodMatchesAction(match.Method))
    continue;

   //right, now we're going to use System.Linq.Expressions to build 
   //a dynamic expression to invoke this method given an instance of TTarget.
   methodCall = 
     Expression.Call(
       Expression.Convert(
         paramExprs[0], typeof(TTarget)
       ),  
       match.Method, realParamExprs);

   TAction dynamicDelegate = Expression.
     Lambda<TAction>(methodCall, paramExprs).Compile();

   //now we have our method, we simply inject it into the dictionary, using 
   //all the unique TEnum values (from the attribute) as the keys
   foreach (var enumValue in match.Attribute.Targets.OfType<TEnum>())
   {
    if (_actions.ContainsKey(enumValue))
     throw new InvalidOperationException(/*elided*/);

    _actions[enumValue] = dynamicDelegate;
   }
  }
 }

 private static bool MethodMatchesAction(MethodInfo method)
 {
  //so we want to check that the target method matches our desired 
  //delegate type (TAction).
  //The way this is done is to fetch the delegate type's Invoke 
  //method (implicitly invoked when you invoke delegate(args)), and 
  //then we check the return type and parameters types of that
  //against the return type and args of the method we've been passed.

  //if the target method's return type is equal to or derived from the 
  //expected delegate's return type, then all is good.

  if (!_tActionMethod.ReturnType.IsAssignableFrom(method.ReturnType))
   return false;

  //now, the parameter lists of the method will not be equal in length, 
  //as our delegate explicitly includes the 'this' parameter, whereas 
  //instance methods do not.

  var methodParams = method.GetParameters();
  var delegateParams = TActionMethod.GetParameters();

  for (int i = 0; i < methodParams.Length; i++)
  {
   if (!methodParams[i].ParameterType.IsAssignableFrom(
        delegateParams[i + 1].ParameterType))
    return false;
  }
  return true;
 }


 public static TAction Resolve(TEnum value)
 {
  TAction result;

  if (!_actions.TryGetValue(value, out result))
   throw new ArgumentException("The value is not mapped");

  return result;
 }
}

Теперь сделайте это в модульном тесте:

[TestMethod]
public void TestMethod1()
{
  Assert.AreEqual(1, 
    DynamicSwitch<UnitTest1, Blah, Func<UnitTest1, int>>.
      Resolve(Blah.BlahBlah)(this));

  Assert.AreEqual(125, 
    DynamicSwitch<UnitTest1, Blah, Func<UnitTest1, int>>.
      Resolve(Blah.Blip)(this));

 Assert.AreEqual(125, 
    DynamicSwitch<UnitTest1, Blah, Func<UnitTest1, int>>.
      Resolve(Blah.Bop)(this));
}

public enum Blah
{
 BlahBlah,
 Bloo,
 Blip,
 Bup,
 Bop
}


[DynamicSwitchAttribute(typeof(Blah), Blah.BlahBlah)]
public int Method()
{
 return 1;
}

[DynamicSwitchAttribute(typeof(Blah), Blah.Blip, Blah.Bop)]
public int Method2()
{
 return 125;
}

Итак, учитывая значение TEnum и ваш предпочтительный тип «действия» (в вашем коде вы бы выглядели как просто ничего не возвращая и изменяя внутреннее состояние класса), вы просто обращаетесь к классу DynamicSwitch <>, просите его разрешить целевой метод, а затем вызываете его в строке (передавая целевой объект, для которого метод будет вызываться как первый параметр).

На самом деле я не жду никаких голосов за это - это решение MAD , если честно (у него есть то преимущество, что его можно применять для любого типа перечисления и даже для скрытых значений типа int / float / double, а также поддерживает любой тип делегата) - так что, возможно, это что-то вроде кувалды!

РЕДАКТИРОВАТЬ

Если у вас есть статический универсальный шаблон, подобный этому, наступает ад угловых скобок - поэтому мы хотим попытаться избавиться от них.В большинстве случаев это делается путем вывода типа для параметров метода и т. Д. - но у нас есть проблема , заключающаяся в том, что мы не можем легко вывести подпись делегата, не повторяя вызов метода , т.е. (args ) => возврат .

Однако вам, похоже, нужен метод, который не принимает параметров и возвращает void, поэтому вы можете закрыть этот гигантский универсальный метод, зафиксировав тип делегата на Action, а также добавить гибкий API в микс (если это ваш вид of thing):

public static class ActionSwitch
{
  public class SwitchOn<TEnum>
  {
    private TEnum Value { get; set; }

    internal SwitchOn(TEnum value)
    {
      Value = value;
    }

    public class Call<TTarget>{
      private TEnum Value { get; set; }
      private TTarget Target { get; set; }

      internal Call(TEnum value, TTarget target)
      {
        Value = value;
        Target = target;
        Invoke();
      }

      internal void Invoke(){
          DynamicSwitch<TTarget, TEnum, Action<TTarget>>.Resolve(Value)(Target);
      }
    }

    public Call<TTarget> On<TTarget>(TTarget target)
    {
      return new Call<TTarget>(Value, target);
    }
  }

  public static SwitchOn<TEnum> Switch<TEnum>(TEnum onValue)
  {
    return new SwitchOn<TEnum>(onValue);
  }
}

Теперь добавьте это в тестовый проект:

[TestMethod]
public void TestMethod2()
{
  //no longer have any angle brackets
  ActionSwitch.Switch(Blah.Bup).On(this);

  Assert.IsTrue(_actionMethod1Called);
}

private bool _actionMethod1Called;

[DynamicSwitch(typeof(Blah), Blah.Bup)]
public void ActionMethod1()
{
  _actionMethod1Called = true;
}

Единственная проблема с этим (помимо сложности решения :)) заключается в том, что вам придется перестраивать этот тип статической оболочки всякий раз, когда вы хотите использовать новый тип целевого делегата для динамического переключения в другом месте. Вы можете сгенерировать общую версию на основе делегатов Action <...> и Func <...>, которая включает TArg1, TArg ( n ) и TReturn (если Func <>) - но вы бы в конечном итоге писать намного больше кода.

Возможно, я превращу это в статью в своем блоге и сделаю все это - если у меня будет время!

Одно из возможных решений - использовать SortedDictionary:

delegate void EnumHandler (args);
SortedDictionary <Enum, EnumHandler> handlers;

constructor
{
   handlers = new SortedDictionary <Enum, EnumHandler> ();
   fill in handlers
}

void SomeFunction (Enum enum)
{
  EnumHandler handler;

  if (handlers.TryGetValue (enum, out handler))
  {
     handler (args);
  }
  else
  {
    // not handled, report an error
  }
}

Этот метод действительно позволяет вам динамически заменять обработчики. Вы также можете использовать список как часть значения словаря и иметь несколько обработчиков для каждого перечисления.

РЕДАКТИРОВАТЬ

Я подумал еще раз, просмотрел связанные вопросы в SO и написал код. Я создал класс с именем AdvancedSwitch , который позволяет добавлять случаи и предоставляет метод для оценки значения, а также позволяет указывать значения, которые он должен проверять на наличие.

Вот что я придумал:

public class AdvancedSwitch<T> where T : struct
{
    protected Dictionary<T, Action> handlers = new Dictionary<T, Action>();

    public void AddHandler(T caseValue, Action action)
    {
        handlers.Add(caseValue, action);
    }

    public void RemoveHandler(T caseValue)
    {
        handlers.Remove(caseValue);
    }

    public void ExecuteHandler(T actualValue)
    {
        ExecuteHandler(actualValue, Enumerable.Empty<T>());
    }

    public void ExecuteHandler(T actualValue, IEnumerable<T> ensureExistence)
    {
        foreach (var val in ensureExistence)
            if (!handlers.ContainsKey(val))
                throw new InvalidOperationException("The case " + val.ToString() + " is not handled.");

        handlers[actualValue]();
    }
}

Вы можете использовать класс следующим образом:

public enum TrafficColor { Red, Yellow, Green }

public static void Main()
{
    Console.WriteLine("Choose a traffic color: red, yellow, green?");
    var color = (TrafficColor)Enum.Parse(typeof(TrafficColor), Console.ReadLine());
    var result = string.Empty;

    // Creating the "switch"
    var mySwitch = new AdvancedSwitch<TrafficColor>();

    // Adding a single case
    mySwitch.AddHandler(TrafficColor.Green, delegate
    {
        result = "You may pass.";
    });

    // Adding multiple cases with the same action
    Action redAndYellowDelegate = delegate
    {
        result = "You may not pass.";
    };
    mySwitch.AddHandler(TrafficColor.Red, redAndYellowDelegate);
    mySwitch.AddHandler(TrafficColor.Yellow, redAndYellowDelegate);

    // Evaluating it
    mySwitch.ExecuteHandler(color, (TrafficColor[])Enum.GetValues(typeof(TrafficColor)));

    Console.WriteLine(result);
}

Творчески используя анонимные делегаты, вы можете легко добавлять новые случаи в свой «блок переключения». :)
Не то чтобы вы также могли использовать лямбда-выражения и лямбда-блоки, например () => {...} вместо делегат {...} .

Вы можете легко использовать этот класс вместо длинных блоков переключения.

Исходное сообщение:

Если вы используете Visual Studio, всегда создавайте операторы swich с помощью фрагмента кода switch . Введите переключатель нажмите вкладку дважды, и он автоматически сгенерирует все возможности для вас.

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

Я имею в виду что-то вроде этого:

switch (something)
{
    ...
    case YourEnum.SomeValue:
        ...
        break;
    default:
        throw new InvalidOperationException("Default case reached.");
}