如何使 switch 语句更加面向对象？ [复制]

Question

我正在尝试重构这样的 switch 语句：

private void Validate(DataTypeEnum dataType, string value, ...)
{
    switch(dataType)
    {
        case DataTypeEnum.Number:
            var typedValue = int.Parse(value);
            //Validation of typedValue
            break;
        case DataTypeEnum.Decimal:
            var typedValue = Decimal.Parse(value);
            //Validation of typedValue
            break;
        case DataTypeEnum.DateTime:
            var typedValue = DateTime.Parse(value);
            //Validation of typedValue
            break;
    }
}

我想摆脱 switch 语句并以某种方式将其替换为更面向对象的构造。有什么建议吗？

我的理想是这样的：

private void Validate(DataTypeEnum dataType, string value, ...)
{
    Validate(value);
}
private void (Decimal value)
{
    //Validate
}
private void (DateTime value)
{
    //Validate
}

有什么优雅的方法可以解决这个问题吗？

Answer 1

使用多态性。

例子：

public class DataType
{
    public virtual void Validate()
    {
        Console.WriteLine("Performing base class validation tasks");
    }
}

class Foo : DataType
{
    public override void Validate()
    {
        // Code to validate a foo...
        Console.WriteLine("Validating a foo");
    }
}
class Bar : DataType
{
    public override void Validate()
    {
        // Code to validate a bar...
        Console.WriteLine("Validating a bar");
    }
}


List<DataType> datatypes = new List<DataType>();
datatypes.Add(new Foo());
datatypes.Add(new Barr());

foreach (DataType s in datatypes)
{
    s.Validate();
}

Answer 2

此外，虽然有些人可能认为这根本不是 OOP，但您可以使用 dynamic 重载来处理此问题：

public bool ValidateAny(dynamic val)
{
  return Validate(val);
}

private bool Validate(string val) { ... }
private bool Validate(int val) { ... }
private bool Validate(decimal val) { ... }

private bool Validate(object val) { ... } // This is the fallback

基本上，这与通常的重载解析相同，但它在运行时执行，具体取决于ValidateAny 中val 的运行时类型。

例如：

ValidateAny(3); // Uses the int overload
ValidateAny((object)3); // Uses the int overload as well - dynamic handles the unboxing
ValidateAny(3M); // Uses the decimal overload
ValidateAny(3.ToString()); // Uses the string overload
ValidateAny(3f); // Uses the object overload, since there's no better match

这非常强大，只要您只需要对不同的类型进行不同的验证。如果您还有其他考虑，这必须在某种程度上回到if/switch。即便如此，它也可以为您节省大量时间。

Answer 3

首先我要实现简单的验证接口：

public interface IValidator
{
    bool Validate(object value);
}

那么数字验证器可能如下所示：

public class NumberValidator : IValidator
{
    public bool Validate(object value)
    {
        return (int) value > 0;
    }
}

最后一步用字典替换你的开关：

 var _validators = new Dictionary<DataTypeEnum, IValidator> // injected via DI
 {
     { DataTypeEnum.Number, new NumberValidator() },
     { DataTypeEnum.DateTime, new DateTimeValidator() },
     { DataTypeEnum.String, new StringValidator() }
 };

 ......

 private bool Validate(DataTypeEnum dataType, object value, ...)
 {
     if (_validators.ContainsKey(dataType))
     {
        return _validators[dataType].Validate(value);
     }

     return false;
 }

Answer 4

    public interface IValidator
    {
        void Validate(object value);
    }

    public class NumberValidator : IValidator
    {
        public void Validate(object value)
        {
            //implementation
        }
    }

    public class DecimalValidator : IValidator
    {
        public void Validate(object value)
        {
            //implementation
        }
    }

    public class DatetimeValidator : IValidator
    {
        public void Validate(object value)
        {
            //implementation
        }
    }

    private void Validate(IValidator validator, object value)
    {
        validator.Validate(value);
    }

Answer 5

创建一个字典，其中 DataTypeEnum 作为 Key，Action 作为 Value。然后通过键从字典中获取值并调用操作。

private readonly Dictionary<DataTypeEnum , Action > Validator = new Dictionary<DataTypeEnum , Action >
        {
            { DataTypeEnum.Number, () => Validate(Convert.ToDouble((string)value)) },
            { DataTypeEnum.Decimal, () => Validate(Convert.ToDecimal((string)value)) },
            { DataTypeEnum.DateTime, () => Validate(Convert.ToDateTime((string)value)) },
            // ...
        }

private void Validate(DataTypeEnum dataType, object value, ...)
{
    Validator[dataType](); // Gets the Action and Invokes it
}

private void Validate (Decimal value)
{
    //Validate
}
private void Validate (DateTime value)
{
    //Validate
}
//...

这里的 Action 是不带参数的 Void 委托。它将值转换为合适的格式并调用验证方法。

Answer 6

private void Validate<T>(T value) where T : IComparable
{
    if(value is Number)
    {

    }
    if(value is Decimal)
    {

    }
    if(value is DateTime)
    {

    }
}

Answer 7

这样的事情怎么样：

private void Validate(object value, ...)
{
    if(Reference.Equals(null, value)
        return;

    if(value is Number)
    {

    }
    else if(value is Decimal)
    {

    }
    else if (value is DateTime)
    {

    }
    else return;
}

如果传入的值是 Number、Decimal 或 DateTime，它将运行适当的方法，否则它将简单地返回。