C# 如何确定哪个继承类正在使用抽象类'；s方法

在我的控制台应用程序中有一个抽象的工厂类“Listener”，它包含用于侦听和接受连接以及生成客户端类的代码。该类由另外两个类（WorldListener和MasterListener）继承，它们包含更多特定于协议的重写和函数

我还有一个助手类（ConsoleWrapper），它封装和扩展System.Console，包含一些方法，用于向控制台写入有关WorldListener和MasterListener实例的信息

我需要一种方法来确定抽象ListenerClass中哪个继承类正在调用其方法。 对此问题的任何帮助都将不胜感激！我被难住了：X

我正在尝试做的简单示例

abstract class Listener
{
   public void DoSomething()
   {
      if(inheriting class == WorldListener)
      ConsoleWrapper.WorldWrite("Did something!");
      if(inheriting class == MasterListener)
      ConsoleWrapper.MasterWrite("Did something!");
   }
}

public static ConsoleWrapper
{
   public void WorldWrite(string input)
   {
       System.Console.WriteLine("[World] {0}", input);
   }
}

public class WorldListener : Listener
{
   public void DoSomethingSpecific()
   {
       ConsoleWrapper.WorldWrite("I did something specific!");
   }
}

public void Main()
{
   new WorldListener();
   new MasterListener();
}

预期产量

[世界]做了些什么
[世界]我做了一些特别的事
[师父]做了点什么
[世界]我做了一些特别的事

---

如果知道要比较的每种类型，请使用

is

运算符：

if (this is WorldListener)
{
 // ...
}
else if (this is MasterListener)
{
 // ...
}

或者，如果您需要更大的灵活性，可以使用

GetType

：

var type = GetType();
// Do some logic on the type to determine what to do next.

然而，你应该小心使用这种方法；通常情况下，您需要显式地检查类型（正如他们坚持的那样），这表明设计很糟糕。相反，使用多态性将所需行为委托给基类（在基类中使用虚拟或抽象方法）几乎总是更合适的——毕竟，这就是它的设计目的

您可以应用类似以下内容的多态性：

static class Program
{
    static void Main(string[] args)
    {
        Listener listener = new WorldListener();
        listener.DoSomething();
    }
}

abstract class Listener
{
    public void DoSomething()
    {
        var output = Decorate("Did something!");
        ConsoleWrapper.WriteLine(output);
    }

    protected abstract string Decorate(string input);
}

class WorldListener : Listener
{
    protected override string Decorate(string input)
    {
        return string.Format("[World] {0}", input);
    }
}

class MasterListener : Listener
{
    protected override string Decorate(string input)
    {
        return string.Format("[Master] {0}", input);
    }
}

---

这将产生输出

[World]做了些什么。这种方法的优点是，如果您想添加另一种类型的侦听器，只需使用适当的
decoration
方法为其定义一个新类；不需要修改监听器本身。
Hmm。。在您的简化示例中，您没有调用DoSomething（）和DoSomethingSpecific（），也没有MasterListener的实现。。
另外，如果我理解正确的话，在您的预期输出中，您的MasterListener.DoSomethingSpecific（）运行一个ConsoleWrapper.WorldWrite。。你可能是指大师

无论如何。。这里有一个工作示例，它可以满足您的需求（至少以我理解您的请求的方式：P）

打印结果为：

[World] Did something
[World] I did sth specific!
[Master] Did something
[Master] I did sth specific!

守则：

    void Main()
{
    var wl = new WorldListener();
    wl.DoSomething();
    wl.DoSpecific();
    var ml = new MasterListener();
    ml.DoSomething();
    ml.DoSpecific();
}

public abstract class Listener
{
    public abstract string Category { get; }
    public void DoSomething()
    {
        ConsoleWrapper.Write(Category, "Did something");
    }
}

public static class ConsoleWrapper
{
    public static void Write(string category, string input)
    {
        Console.WriteLine("[{0}] {1}", category, input);
    }
}

public class WorldListener : Listener
{
    public override string Category { get { return "World"; } }
    public void DoSpecific()
    {
        ConsoleWrapper.Write(Category, "I did sth specific!");
    }
}

public class MasterListener : Listener
{
    public override string Category { get { return "Master"; } }
    public void DoSpecific()
    {
        ConsoleWrapper.Write(Category, "I did sth specific!");
    }
}

你可以用

if (this is WorldListener)

而不是你的伪代码

if (inheriting class == WorldListener) 

然而，这样做是一个糟糕的设计气味。您应该强烈地考虑另一种解决方案，例如在虚拟方法中执行对控制台包装器的写入，而不是在基类和它的子类之间添加这种强耦合。这是否会导致我不得不将更多的任务委托给继承类？几乎所有的功能都被重复使用，这取决于你的授权程度；您可以保留
侦听器中的大部分逻辑，只需委托代码来修饰输入（即附加
[World]
和
[Master]
标记）。听起来我对抽象方法的理解一定有缺陷，谢谢您的帮助。@Kin：我已经修改了演示的示例。我已经用您可能需要的内容更新了这个示例-侦听器类不依赖于子继承类。相反，子类必须实现一个Category属性，该属性将定义哪个类向ConsoleWrapper发送了字符串。