如何确定哪个继承类正在使用抽象类的方法

Question

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

我还有一个辅助类（ConsoleWrapper），它封装和扩展System.Console，包含用于写入控制台信息的方法，用于解释WorldListener和MasterListener实例的内容。

我需要一种方法来在抽象的ListenerClass中确定哪个Inheriting类正在调用它的方法。

任何有关此问题的帮助将不胜感激！ 我很难过：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();
}

预期产出

[世界]有所作为！
[世界]我做了一些具体的事！
[大师]做了些什么！
[世界]我做了一些具体的事！

Answer 1

如果您知道要比较的每种类型，请使用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] Did something! 。 这种方法的优点是，如果你想要添加另一种类型的监听器，只需用适当的Decorate方法为它定义一个新类; 没有必要修改Listener本身。

Answer 2

嗯..在你的简化示例中，你不要调用DoSomething（）和DoSomethingSpecific（），并且没有MasterListener的实现。另外，如果我理解正确，在你的预期输出中你的MasterListener.DoSomethingSpecific（）运行一个ConsoleWrapper.WorldWrite ..你可能意味着MasterWrite？

在任何情况下..这是一个做你想要的工作例子（至少以我理解你的要求的方式：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!");
    }
}

Answer 3

您可以使用

if (this is WorldListener)

而不是你的伪代码

if (inheriting class == WorldListener) 

然而，这样做是一个糟糕的设计气味。 您应该强烈考虑替代解决方案，例如，在虚方法中执行对控制台包装器的写入，而不是在基类及其子类之间添加这种强耦合。