能否彻底密封C#类方法，防止子类以任何方式重写？

在C#中，直接使用sealed关键字无法阻止子类通过new关键字隐藏基类方法，但可以通过显式接口实现或封装核心逻辑到私有密封方法的方式，确保调用接口/基类实例时，始终执行基类的固定逻辑，避免子类破坏既定流程。

问题场景分析 #

1. 工作者类示例 #

你定义了IWorker接口和抽象基类AbstractWorker，基类实现了DoWork()的固定逻辑（先判断ShouldProcess()再执行Process()），但子类Worker可以通过new关键字定义同名方法，偏离基类逻辑。需要注意：当调用方使用IWorker类型变量调用DoWork()时，实际执行的仍是基类的实现——new只是隐藏子类自身的方法，而非重写接口或基类的方法。但如果调用方误用子类类型变量，就会执行子类的篡改逻辑。

2. 责任链模式示例 #

在责任链场景中，AbstractHandler定义了HandleRequest()的固定流程（处理或转发请求），但子类BadHandler通过new隐藏该方法后，若调用方用BadHandler类型变量调用，会导致请求无法转发，破坏责任链。

解决方案：用显式接口实现锁定核心逻辑 #

最可靠的方式是使用显式接口实现，将接口方法的实现封装在基类内部，让子类无法访问或重写该方法，从而彻底杜绝篡改可能。

1. 工作者类改造后的代码 #

public interface IWorker
{
    void DoWork();
}

public abstract class AbstractWorker : IWorker
{
    // 显式接口实现：只能通过IWorker接口调用，子类无法访问或重写
    void IWorker.DoWork()
    {
        if (ShouldProcess()) Process();
    }

    public abstract bool ShouldProcess();
    public abstract void Process();
}

public class Worker : AbstractWorker
{
    // 即使定义同名方法，也只是子类自身的方法，不会影响IWorker接口的调用
    public new void DoWork()
    {
        // 子类自定义逻辑（仅当用Worker类型变量调用时才会执行）
    }

    public override bool ShouldProcess() => true;
    public override void Process() => Console.WriteLine("Processed");
}

// 调用方代码
public void SomeFunction()
{
    IWorker worker = new Worker();
    worker.DoWork(); // 始终执行AbstractWorker的核心逻辑
}

2. 责任链模式改造后的代码 #

public interface IHandler
{ 
    void HandleRequest();
    IHandler SetNextHandler(IHandler nextHandler);
}

public abstract class AbstractHandler : IHandler
{
    private IHandler _nextHandler;
    
    public IHandler SetNextHandler(IHandler nextHandler)
    {
        _nextHandler = nextHandler;
        return nextHandler;
    }

    // 显式接口实现，锁定责任链核心流程
    void IHandler.HandleRequest()
    {
        if (CanHandleRequest()) 
            ProcessRequest();
        else if (_nextHandler != null) 
            _nextHandler.HandleRequest();
    }

    public abstract bool CanHandleRequest();
    public abstract void ProcessRequest();
}

public class GoodHandler : AbstractHandler
{
    public override bool CanHandleRequest() => true;
    public override void ProcessRequest() 
    { 
        // 处理逻辑
    }
}

public class BadHandler : AbstractHandler
{
    // 子类定义的同名方法仅对自身类型生效
    public new void HandleRequest()
    {
        if (CanHandleRequest()) ProcessRequest();
        // 即使不转发，也不会影响IHandler接口的调用逻辑
    }

    public override bool CanHandleRequest() => false;
    public override void ProcessRequest() 
    { 
        // 处理逻辑
    }
}

// 调用方代码
public void SomeFunction()
{
    IHandler good = new GoodHandler();
    IHandler bad = new BadHandler();

    bad.SetNextHandler(good);
    bad.HandleRequest(); // 始终执行AbstractHandler的转发逻辑，不会断裂
}

额外优化：封装核心逻辑到私有密封方法 #

如果不想用显式接口实现，也可以将核心逻辑封装到私有密封方法中，确保子类无法修改：

public abstract class AbstractWorker : IWorker
{
    public void DoWork()
    {
        // 调用私有密封方法，子类无法访问或重写
        CoreDoWork();
    }

    private sealed void CoreDoWork()
    {
        if (ShouldProcess()) Process();
    }

    public abstract bool ShouldProcess();
    public abstract void Process();
}

这种方式下，子类即使通过new隐藏DoWork()，只要调用方使用IWorker或AbstractWorker类型，就会执行基类的DoWork()，进而调用不可篡改的核心逻辑。

内容的提问来源于stack exchange，提问作者Avery Ferrante