Question

可能重复：
Is there a better alternative than this to 'switch on type'?

我需要遍历我的类的所有属性，并检查它的类型是否需要做什么，如果它的字符串...然后做一些事情。我需要使用开关盒。这里我以下面的方式使用switch，但它要求一些常量。请参阅以下代码：

 public static bool ValidateProperties(object o)
{
    if(o !=null)
    {
        var sourceType = o.GetType();
        var properties = sourceType.GetProperties(BindingFlags.Public | BindingFlags.Static);
        foreach (var property in properties)
        {
            var type = property.GetType();
            switch (type)
            {
                *case typeof(int):* getting error here
                    // d
            }
        }
    }
}

另外我想知道，我应该使用什么检查，typeof（int）或typeof（Int32）？

Answer 1

您不能使用开关块来测试Type类型的值。编译代码应该会给出错误，例如：

switch表达式或case标签必须是bool，char，string，积分，枚举或相应的可空类型

您需要使用if - else语句。

另外：typeof(int)和typeof(Int32)是等效的。 int是关键字，Int32是类型名称。

<强>更新

如果您希望大多数类型都是固有类型，则可以使用带Type.GetTypeCode(...)的开关块来提高性能。

例如：

switch (Type.GetTypeCode(type))
{
    case TypeCode.Int32:
        // It's an int
        break;

    case TypeCode.String:
        // It's a string
        break;

    // Other type code cases here...

    default:
        // Fallback to using if-else statements...
        if (type == typeof(MyCoolType))
        {
            // ...
        }
        else if (type == typeof(MyOtherType))
        {
            // ...
        } // etc...
}

Answer 2

这样做的一种好的，可扩展的方法是根据你想要对那种类型的值做什么来制作一个适当类型的类型和委托的字典。

例如：

var typeProcessorMap = new Dictionary<Type, Delegate>
{
    { typeof(int), new Action<int>(i => { /* do something with i */ }) },
    { typeof(string), new Action<string>(s => { /* do something with s */ }) },
};

然后：

void ValidateProperties(object o)
{
    var t = o.GetType();
    typeProcessorMap[t].DynamicInvoke(o); // invoke appropriate delegate
}

此解决方案是可扩展的，即使在运行时也是可配置的，只要您保持typeProcessorMap中正确匹配的委托值的键和类型也是类型安全的。

<强> See it in action

Answer 3

这个“答案”是对Jon的回答的详细阐述。（标记CW）

为了记录，DynamicInvoke有点慢。为了说明这一点，请考虑以下程序：

void Main()
{
    Func<int, string> myFunc = i => i.ToString();
    myFunc.DynamicInvoke(1);   // Invoke once so initial run costs are not considered
    myFunc(1);

    Stopwatch stopwatch = new Stopwatch();

    stopwatch.Start();
    for (int i = 0; i < 1000000; i++)
        myFunc.DynamicInvoke(1);
    stopwatch.Stop();

    var elapsed = stopwatch.Elapsed;

    stopwatch.Restart();
    for (int i = 0; i < 1000000; i++)
        myFunc(1);
    stopwatch.Stop();

    var elapsed2 = stopwatch.Elapsed;

    Console.WriteLine("DynamicInvoke: " + elapsed);
    Console.WriteLine("Direct Invocation: " + elapsed2);
}

打印出来：

DynamicInvoke：00：00：03.1959900
直接调用：00：00：00.0735220

这意味着DynamicInvoke（在这个简单的情况下）比直接调用慢42倍。

Answer 4

通常，最简单的解决方案是打开类型名称：

switch (type.Name)
{
    case "Int32":
    ...
}

如何在Type上使用switch-case？

4 个答案: