我喜欢Virtlink使用隐式类型，使切换更具可读性，但我不喜欢不可能进行early-out，而且我们正在进行分配。让我们把性能提高一点。

public static class TypeSwitch
{
    public static void On<TV, T1>(TV value, Action<T1> action1)
        where T1 : TV
    {
        if (value is T1) action1((T1)value);
    }

    public static void On<TV, T1, T2>(TV value, Action<T1> action1, Action<T2> action2)
        where T1 : TV where T2 : TV
    {
        if (value is T1) action1((T1)value);
        else if (value is T2) action2((T2)value);
    }

    public static void On<TV, T1, T2, T3>(TV value, Action<T1> action1, Action<T2> action2, Action<T3> action3)
        where T1 : TV where T2 : TV where T3 : TV
    {
        if (value is T1) action1((T1)value);
        else if (value is T2) action2((T2)value);
        else if (value is T3) action3((T3)value);
    }

    // ... etc.
}

我的手指都疼了。我们在T4做一下:

<#@ template debug="false" hostSpecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ import namespace="System.Linq" #> 
<#@ import namespace="System.IO" #> 
<#
    string GenWarning = "// THIS FILE IS GENERATED FROM " + Path.GetFileName(Host.TemplateFile) + " - ANY HAND EDITS WILL BE LOST!";
    const int MaxCases = 15;
#>
<#=GenWarning#>

using System;

public static class TypeSwitch
{
<# for(int icase = 1; icase <= MaxCases; ++icase) {
    var types = string.Join(", ", Enumerable.Range(1, icase).Select(i => "T" + i));
    var actions = string.Join(", ", Enumerable.Range(1, icase).Select(i => string.Format("Action<T{0}> action{0}", i)));
    var wheres = string.Join(" ", Enumerable.Range(1, icase).Select(i => string.Format("where T{0} : TV", i)));
#>
    <#=GenWarning#>

    public static void On<TV, <#=types#>>(TV value, <#=actions#>)
        <#=wheres#>
    {
        if (value is T1) action1((T1)value);
<# for(int i = 2; i <= icase; ++i) { #>
        else if (value is T<#=i#>) action<#=i#>((T<#=i#>)value);
<#}#>
    }

<#}#>
    <#=GenWarning#>
}

稍微调整一下Virtlink的例子:

TypeSwitch.On(operand,
    (C x) => name = x.FullName,
    (B x) => name = x.LongName,
    (A x) => name = x.Name,
    (X x) => name = x.ToString(CultureInfo.CurrentCulture),
    (Y x) => name = x.GetIdentifier(),
    (object x) => name = x.ToString());

可读且快速。现在，正如每个人在他们的答案中不断指出的那样，考虑到这个问题的性质，顺序在类型匹配中很重要。因此:

先放叶类型，再放基类型。 对于对等类型，将可能性更大的匹配放在前面，以最大化性能。 这意味着不需要特殊的默认情况。相反，只需使用lambda中的base-most类型，并将其放在最后。

应该与

case type _:

如:

int i = 1;
bool b = true;
double d = 1.1;
object o = i; // whatever you want

switch (o)
{
    case int _:
        Answer.Content = "You got the int";
        break;
    case double _:
        Answer.Content = "You got the double";
        break;
    case bool _:
        Answer.Content = "You got the bool";
        break;
}

根据c# 7.0规范，你可以在开关的情况下声明一个局部变量的作用域:

object a = "Hello world";
switch (a)
{
    case string myString:
        // The variable 'a' is a string!
        break;
    case int myInt:
        // The variable 'a' is an int!
        break;
    case Foo myFoo:
        // The variable 'a' is of type Foo!
        break;
}

这是做这件事的最佳方式，因为它只涉及强制转换和栈上推操作，这是解释器可以运行的最快的操作之一，只是在位操作和布尔条件之前。

与使用Dictionary<K, V>相比，这里占用的内存更少，计算量基本为零。

另一方面，这应该和使用if语句链一样快(如果不是更快的话):

object a = "Hello world";
if (a is string)
{
    // The variable 'a' is a string!
} else if (a is int)
{
    // The variable 'a' is an int!
} // etc.

在比较了这里提供的f#特性的选项后，我发现f#对基于类型的切换有更好的支持(尽管我仍然坚持使用c#)。 你可能想看看这里和这里。

一种选择是使用一个从Type到Action(或其他委托)的字典。根据类型查找操作，然后执行它。我以前在工厂用过这个。

创建一个超类(S)，并使a和B从它继承。然后在S上声明一个每个子类都需要实现的抽象方法。

这样做，"foo"方法还可以将其签名更改为foo (S o)，使其类型安全，并且不需要抛出那个丑陋的异常。