C# 将对象强制转换为类型并使用方法

假设我有一个抽象类ObjectA。ObjectC和ObjectB继承自ObjectA。从ObjectA继承的还有很多

然后，我有一些方法可以根据对象的类型做一些事情

public void DoSomething(ObjectC data){}
public void DoSomething(ObjectB data){}

我想知道是否有一种方法可以根据对象的类型调用我需要的方法，这是因为我不知道我将得到什么类型的对象

public void DoSomething(ObjectA data){
    DoSomething(data);
}

目前我正在使用

public void DoSomething(ObjectA data){
    if (data is ObjectB dataB){
        DoSomething(dataB);
    }else if (data is ObjectC dataC){
        DoSomething(dataC);
    }
}

我想知道是否有办法避免使用

if/else

---

谢谢。

您可以使用

is

操作符和强制转换。 退房：

---

您可以使用

is

操作符和强制转换。 退房：

---

实现这一点的传统方法是颠倒您的要求，并使用

虚拟

函数以@RuiJarimba在评论中描述的方式实现

多态性

。例如，考虑这三个类（我将您的ObjutX类重命名为Cyrx）：

ClassB

和

ClassC

的每个实例本质上都是

ClassA

（通过继承）。

ClassB

和

ClassC

都实现了一个

DoSomething

方法，该方法覆盖了

ClassA

定义的抽象定义。现在，我可以使用任何

ClassA

对象（它必须是

ClassA

的子类的一个实例，因为

ClassA

是抽象的）调用

DoSomething（）

，并获得

DoSomething（）

的特定于类的实现。在下面的代码中，我创建了单独的实例。在现实生活中，您通常有一组

ClassA

对象引用，通过调用适当的方法来遍历这些引用：

   ClassA objectB = new ClassB();
   ClassA objectC = new ClassC();

   objectB.DoSomething();      //calls ClassB's version
   objectC.DoSomething();      //calls ClassC's version

这不完全是你要问的，但我认为这是你想要的

继续 如果要保留相同的函数签名，可以将以下内容添加到

ClassA

定义中：

  public static void DoSomething<T>(T data) where T : ClassA
  {
      data.DoSomething();     //dispath through the right class using a virtual function
  }

---

新代码所做的是获取它所传递的对象（它必须是

ClassA

子类的一个实例），并简单地调用先前定义的虚函数，将内容分派到适当的类的实现。

传统的方法是颠倒您的请求，并使用

虚拟
函数以@RuiJarimba在注释中描述的方式实现
多态性。例如，考虑这三个类（我将您的ObjutX类重命名为Cyrx）：

ClassB
和
ClassC
的每个实例本质上都是
ClassA
（通过继承）。
ClassB
和
ClassC
都实现了一个
DoSomething
方法，该方法覆盖了
ClassA
定义的抽象定义。现在，我可以使用任何
ClassA
对象（它必须是
ClassA
的子类的一个实例，因为
ClassA
是抽象的）调用
DoSomething（）
，并获得
DoSomething（）
的特定于类的实现。在下面的代码中，我创建了单独的实例。在现实生活中，您通常有一组
ClassA
对象引用，通过调用适当的方法来遍历这些引用：

   ClassA objectB = new ClassB();
   ClassA objectC = new ClassC();

   objectB.DoSomething();      //calls ClassB's version
   objectC.DoSomething();      //calls ClassC's version

这不完全是你要问的，但我认为这是你想要的

继续
如果要保留相同的函数签名，可以将以下内容添加到
ClassA
定义中：

  public static void DoSomething<T>(T data) where T : ClassA
  {
      data.DoSomething();     //dispath through the right class using a virtual function
  }

新代码所做的是获取它所传递的对象（它必须是
ClassA
子类的一个实例），并简单地调用先前定义的虚拟函数，将东西分派到相应的类的实现中。
Hi@Asdren的可能重复，我想你说的是多态性，请查看我发布的链接！使用接口。稍后我将提供一个例子，使用泛型，您可以创建一个方法，并用于许多您不知道的对象。
DoSomething
是
ObjectA
的虚拟或可重写方法吗？Hi@Asdren的可能重复，我想您在谈论多态性，当然请检查我发布的链接！使用接口。稍后我将提供一个例子，使用泛型，您可以创建一个方法，并用于许多您不知道的对象。
DoSomething
是
ObjectA
的虚拟或可重写方法吗？您是打算将
o
声明为
Object
，还是打算将其声明为
ObjectA
？这两种情况下都可以，但我认为
ObjectA
更好。在小提琴是
ObjectA
中，我改为
Object
，只是为了表明它可以是任何对象。这是一种方法，但是if/else是不幸的。如果
DoSomething
不是
ObjectA
的成员函数，那么就没有其他方法可以做到这一点。。。你必须检查你在某处用
if/else
接收到的类型…这就是它现在的实现方式，问题是，有很多类型，所以有很多
if/else
。你是打算将
o
声明为
对象
，还是打算将其声明为
ObjectA
？这两种情况下都可以，但我认为
ObjectA
更好。在小提琴是
ObjectA
中，我改为
Object
，只是为了表明它可以是任何对象。这是一种方法，但是if/else是不幸的。如果
DoSomething
不是
ObjectA
的成员函数，那么就没有其他方法可以做到这一点。。。你必须在某处用
if/else
检查你接收到的类型…这就是它现在的实现方式，问题是，有很多类型，所以有很多
if/else
。这也是一个不错的解决方案，但谁想继续创建新对象来调用每个方法呢？对不起，我不明白
    ClassA.DoSomething(objectB);      //calls ClassB's version
    ClassA.DoSomething(objectC);      //calls ClassC's version