鉴于 C# 无法对类型使用 switch（我了解到这并没有作为特殊情况添加，因为 is 关系意味着可能适用多个不同的 case），是否有更好的方法来模拟在类型上进行切换，而不是使用此方法？
void Foo(object o)
{
if (o is A)
{
((A)o).Hop();
}
else if (o is B)
{
((B)o).Skip();
}
else
{
throw new ArgumentException("Unexpected type: " + o.GetType());
}
}
使用在 Visual Studio 2017（版本 15.*）中发布的 C# 7.0，您可以在 case 语句（模式匹配）中使用类型：
switch(shape)
{
case Circle c:
WriteLine($"circle with radius {c.Radius}");
break;
case Rectangle s when (s.Length == s.Height):
WriteLine($"{s.Length} x {s.Height} square");
break;
case Rectangle r:
WriteLine($"{r.Length} x {r.Height} rectangle");
break;
default:
WriteLine("<unknown shape>");
break;
case null:
throw new ArgumentNullException(nameof(shape));
}
使用C# 6，您可以使用nameof()运算符与switch语句（感谢@Joey Adams）一起使用：
switch(o.GetType().Name) {
case nameof(AType):
break;
case nameof(BType):
break;
}
在C# 5及以前版本中，你可以使用switch语句，但你需要使用包含类型名称的魔术字符串...这不是特别易于重构（感谢@nukefusion）
switch(o.GetType().Name) {
case "AType":
break;
}
case UnauthorizedException _:。 - Assaf S.nameof 比 ToString 更好，因为它具有编译器保护。 - 4thex在C#中，类型开关明显不足(更新：在C#7 / VS 2017中支持类型开关 - 请参见Zachary Yates的答案)。为了避免使用大量的if / else if / else语句，您需要使用不同的结构。我之前写过一篇博客文章，详细介绍如何构建TypeSwitch结构。
https://learn.microsoft.com/archive/blogs/jaredpar/switching-on-types
简短版本：TypeSwitch旨在防止冗余转换，并提供类似于普通switch / case语句的语法。例如，以下是在标准Windows窗体事件上运行TypeSwitch的示例：
TypeSwitch.Do(
sender,
TypeSwitch.Case<Button>(() => textBox1.Text = "Hit a Button"),
TypeSwitch.Case<CheckBox>(x => textBox1.Text = "Checkbox is " + x.Checked),
TypeSwitch.Default(() => textBox1.Text = "Not sure what is hovered over"));
TypeSwitch的代码实际上非常小，可以轻松地放入您的项目中。
static class TypeSwitch {
public class CaseInfo {
public bool IsDefault { get; set; }
public Type Target { get; set; }
public Action<object> Action { get; set; }
}
public static void Do(object source, params CaseInfo[] cases) {
var type = source.GetType();
foreach (var entry in cases) {
if (entry.IsDefault || entry.Target.IsAssignableFrom(type)) {
entry.Action(source);
break;
}
}
}
public static CaseInfo Case<T>(Action action) {
return new CaseInfo() {
Action = x => action(),
Target = typeof(T)
};
}
public static CaseInfo Case<T>(Action<T> action) {
return new CaseInfo() {
Action = (x) => action((T)x),
Target = typeof(T)
};
}
public static CaseInfo Default(Action action) {
return new CaseInfo() {
Action = x => action(),
IsDefault = true
};
}
}
foreach之后进行处理（仅当找不到匹配时才会发生）。 - musefan一个选择是拥有从Type到Action（或其他委托）的字典。根据类型查找动作，然后执行它。我之前曾将其用于工厂。
在参考JaredPar的答案后，我编写了他的TypeSwitch类的变体，该变体使用类型推断来实现更美观的语法:
class A { string Name { get; } }
class B : A { string LongName { get; } }
class C : A { string FullName { get; } }
class X { public string ToString(IFormatProvider provider); }
class Y { public string GetIdentifier(); }
public string GetName(object value)
{
string name = null;
TypeSwitch.On(value)
.Case((C x) => name = x.FullName)
.Case((B x) => name = x.LongName)
.Case((A x) => name = x.Name)
.Case((X x) => name = x.ToString(CultureInfo.CurrentCulture))
.Case((Y x) => name = x.GetIdentifier())
.Default((x) => name = x.ToString());
return name;
}
Case()方法的顺序很重要。
获取我TypeSwitch类的完整注释代码。这是一个可工作的简略版本：
public static class TypeSwitch
{
public static Switch<TSource> On<TSource>(TSource value)
{
return new Switch<TSource>(value);
}
public sealed class Switch<TSource>
{
private readonly TSource value;
private bool handled = false;
internal Switch(TSource value)
{
this.value = value;
}
public Switch<TSource> Case<TTarget>(Action<TTarget> action)
where TTarget : TSource
{
if (!this.handled && this.value is TTarget)
{
action((TTarget) this.value);
this.handled = true;
}
return this;
}
public void Default(Action<TSource> action)
{
if (!this.handled)
action(this.value);
}
}
}
this.value 只读，对您的要点进行了小幅修改。 - Cœurpublic static Switch<TSource> Case<TSource, TTarget>(this TSource value, Action<TTarget> action) where TTarget : TSource。这样，你就可以说 value.Case((C x) ...。 - Joey Adamsvalue.TypeSwitch().Case((C x) ...），但这并不是什么大问题。 - Joey Adams您可以在C# 7及以上版本中使用模式匹配：
switch (foo.GetType())
{
case var type when type == typeof(Player):
break;
case var type when type == typeof(Address):
break;
case var type when type == typeof(Department):
break;
case var type when type == typeof(ContactType):
break;
default:
break;
}
public Animal Animal { get; set; }
var animalName = Animal switch
{
Cat cat => "Tom",
Mouse mouse => "Jerry",
_ => "unknown"
};
创建一个超类（S），并让 A 和 B 继承它。然后在 S 上声明一个抽象方法，每个子类都需要实现该方法。
这样做，“foo”方法也可以更改其签名为 Foo(S o)，使其类型安全，并且您不需要抛出那个丑陋的异常。
是的，多亏了 C# 7 的支持，这可以实现。下面是具体步骤（使用表达式模式）：
switch (o)
{
case A a:
a.Hop();
break;
case B b:
b.Skip();
break;
case C _:
return new ArgumentException("Type C will be supported in the next version");
default:
return new ArgumentException("Unexpected type: " + o.GetType());
}
class Thing
{
void Foo(A a)
{
a.Hop();
}
void Foo(B b)
{
b.Skip();
}
}
用法：
object aOrB = Get_AOrB();
Thing t = GetThing();
((dynamic)t).Foo(aorB);
- 这是关于在C#中使用字符串类型或者elseif语句进行条件判断哪种方法更快的问题。
- 这是关于如何在运行时根据对象类型使用C# switch语句的问题。
- 这个问题探讨了为什么在C#中使用switch语句判断类型容易引起混淆。
- 这是有关如何在C#中切换对象可能的类型的问题。
- 这是关于基于类型切换行为的最佳方法的问题。
- 这是关于在C#中使用哪种最佳替代方案来替换switch语句的问题。
- Mikhail Poda