鉴于c#不能切换类型(我收集到没有作为特殊情况添加，因为关系意味着可能应用多个不同的情况)，有没有更好的方法来模拟类型切换?
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());
}
}
当前回答
正如Pablo所建议的，界面方法几乎总是处理这个问题的正确方法。要真正利用switch，另一种方法是在类中使用自定义枚举来表示类型。
enum ObjectType { A, B, Default }
interface IIdentifiable
{
ObjectType Type { get; };
}
class A : IIdentifiable
{
public ObjectType Type { get { return ObjectType.A; } }
}
class B : IIdentifiable
{
public ObjectType Type { get { return ObjectType.B; } }
}
void Foo(IIdentifiable o)
{
switch (o.Type)
{
case ObjectType.A:
case ObjectType.B:
//......
}
}
这也是在BCL中实现的。MemberInfo就是一个例子。MemberTypes，另一个是GetTypeCode用于基本类型，比如:
void Foo(object o)
{
switch (Type.GetTypeCode(o.GetType())) // for IConvertible, just o.GetTypeCode()
{
case TypeCode.Int16:
case TypeCode.Int32:
//etc ......
}
}
其他回答
一种选择是使用一个从Type到Action(或其他委托)的字典。根据类型查找操作，然后执行它。我以前在工厂用过这个。
你应该重载你的方法，而不是尝试自己去消除歧义。到目前为止，大多数答案都没有考虑到未来的子类，这可能会导致以后真正可怕的维护问题。
创建一个超类(S)，并使a和B从它继承。然后在S上声明一个每个子类都需要实现的抽象方法。
这样做，"foo"方法还可以将其签名更改为foo (S o)，使其类型安全，并且不需要抛出那个丑陋的异常。
你可以创建重载方法:
void Foo(A a)
{
a.Hop();
}
void Foo(B b)
{
b.Skip();
}
void Foo(object o)
{
throw new ArgumentException("Unexpected type: " + o.GetType());
}
并将参数转换为动态类型，以绕过静态类型检查:
Foo((dynamic)something);
在这种情况下，我通常以谓词和操作的列表结束。大致如下:
class Mine {
static List<Func<object, bool>> predicates;
static List<Action<object>> actions;
static Mine() {
AddAction<A>(o => o.Hop());
AddAction<B>(o => o.Skip());
}
static void AddAction<T>(Action<T> action) {
predicates.Add(o => o is T);
actions.Add(o => action((T)o);
}
static void RunAction(object o) {
for (int i=0; o < predicates.Count; i++) {
if (predicates[i](o)) {
actions[i](o);
break;
}
}
}
void Foo(object o) {
RunAction(o);
}
}
