如何强制子类实现一个方法

Question

我正在创建一个对象结构，我希望强制基类的所有子类实现一个方法。

我能想到的唯一方法是：

1. 一个抽象类 - 可以工作，但基类有一些有用的辅助函数，可供一些子类使用。

2. 接口 - 如果仅应用于基类，则子类不必仅实现基类所具有的功能。

这甚至可能吗？

注意这是一个.NET 2应用程序。

Answer 1

您可以在类中使用其他方法实现抽象方法。 相对于接口的优点是，您可以在类中包含一些代码，并强制新对象填写抽象方法的详细信息。

public abstract class YourClass
{
    // Your class implementation

    public abstract void DoSomething(int x, int y);

    public void DoSomethingElse(int a, string b)
    {
        // You can implement this here
    }
}

Answer 2

接口 - 如果仅应用于基类，则子类不必仅实现基类所具有的功能。

这不完全正确。 如果基类是抽象的，则可以将属于该接口的方法标记为抽象，并强制实现子类。

这带来了你没有提到的选项：同时使用两者。 你有一个IFoo接口，一个FooBase抽象基类实现它，或者它的一部分。 这为子类提供了接口（或其一部分）的“默认”实现，并且还允许您继承其他内容并仍然实现接口，或者如果要实现接口但不继承基类实现。 一个例子可能有帮助：

// Your interface
interface IFoo { void A(); void B; }

// A "default" implementation of that interface
abstract class FooBase : IFoo
{
    public abstract void A();

    public void B()
    {
        Console.WriteLine("B");
    }
}

// A class that implements IFoo by reusing FooBase partial implementation
class Foo : FooBase
{
    public override void A()
    {
        Console.WriteLine("A");
    }
}

// This is a different class you may want to inherit from
class Bar
{
    public void C()
    {
        Console.WriteLine("C");
    }
}

// A class that inherits from Bar and implements IFoo
class FooBar : Bar, IFoo
{
    public void A()
    {
        Console.WriteLine("Foobar.A");
    }
    public void B()
    {
        Console.WriteLine("Foobar.B");
    }
}

Answer 3

一个抽象类 - 可以工作，但基类有一些有用的辅助函数，可供一些子classe使用

抽象类不要求它提供的所有函数都是抽象的。

abstract class Base {
    public void Foo() {} // Ordinary method
    public virtual void Bar() {} // Can be overridden
    public abstract void Xyz(); // This one *must* be overridden
}

请注意，如果将public替换为protected ，则标记的方法仅对基类和子类可见。

Answer 4

是的，如果您需要执行此操作的所有类都是现有抽象基类的逻辑子类，则将抽象方法添加到基类...这比接口更好，因为它允许您稍后添加实现（通过使用默认实现将抽象基类方法更改为虚方法），如果/当发现，例如，十个派生类中的八个将具有相同的实现，并且说，它们中只有两个不同...

编辑:(基于以下评论中的线程）基类必须声明为抽象来执行此操作...您不能在非抽象类中使用抽象方法，因为可以实例化非抽象类，如果创建了它的一个实例，该方法没有实现。 所以这是非法的。 通过将基数声明为抽象，可以禁止对类进行实例化。 然后，只能实例化非抽象派生类，其中，（因为基本方法是抽象的）你必须为该方法添加一个实现。

Answer 5

和完整的工人样本与params（.netcore 2.2）：

class User{
    public string Name = "Fen";
}

class Message{
    public string Text = "Ho";
}

// Interface
interface IWorkerLoop
{
    // Working with client message
    string MessageWorker(string msg);
}

// AbstractWorkerLoop partial implementation
public abstract class AbstractWorkerLoop : IWorkerLoop
{
    public User user;
    public Message msg;

    // Append session object to loop
    public abstract AbstractWorkerLoop(ref User user, ref Message msg){
        this.user = user;
        this.msg = msg;
    }

    public abstract string MessageWorker(string msg);
}

// Worker class
public class TestWorkerLoop : AbstractWorkerLoop
{
    public TestWorkerLoop(ref User user, ref Message msg) : base(user, msg){
        this.user = user;
        this.msg = msg;
    }

    public override string MessageWorker(string msg){
        // Do something with client message    
        return "Works";
    }
}