如何在类型上使用切换大小写

本文关键字：大小写 类型 | 更新日期: 2023-09-27 18:09:49

可能重复：
还有比这更好的选择吗；开关类型'；？

我需要遍历类的所有属性，并检查它的类型是否为int，如果它的字符串。。然后做点什么。我需要使用开关盒。在这里，我以以下方式使用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(？

如何在类型上使用切换大小写

不能使用开关块测试Type类型的值。编译你的代码应该会给你一个错误，比如说：

开关表达式或大小写标签必须是bool、char、string、，integral、enum或相应的可为null类型

您将需要使用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...
}

实现这一点的一个好的、可扩展的方法是根据您想要对该类型的值执行的操作，制作一个适当类型的类型和委托的字典。

例如：

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中的键和委托值类型正确匹配，也是类型安全的。

在实际操作中查看。

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

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

这个"答案"是对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);
}

打印输出：

动态调用：00:00:03.1959900
直接调用：00:00:00.0735220

这意味着DynamicInvoke(在这个简单的例子中(比直接调用慢42倍。

相关文章：