C# 为什么实现IDispose的类没有OnDisposed覆盖？

我有一个具有以下定义的类，我希望它具有对Dispose方法的重写：

编辑

结果是有一个Dispose（）方法，但它不是重写。我在等一个超控。这可能是一个无效的问题。。。。但为什么它不是一个覆盖

public class MyClient : IMyClient2
{
    public void Dispose()
    {
        Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if(disposing)
        {
            Stop();
        }
    }
}

其中，它扩展的接口及其后续接口定义为：

public interface IMyClient2 : IMyClient
{
    // one or two methods
}

public interface IMyClient : IDisposable
{
    // a bunch of methods
}

我认为实现IDisposable需要我的类具有Dispose（）覆盖。但事实并非如此，我也不知道我需要做些什么才能做到这一点

---

要正确处理我的类的实例，我需要做什么？

如果您的类真的实现了问题中提到的这些接口，您应该得到一个编译错误

MyClass

未实现接口成员

IDisposable.Dispose（）

在添加

public void Dispose（）

实现时，将解决此问题

---

更新：

结果是有一个Dispose（）方法，但它不是重写。我在等一个超控。这可能是一个无效的问题。。。。但为什么它不是一个覆盖

public class MyClient : IMyClient2
{
    public void Dispose()
    {
        Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if(disposing)
        {
            Stop();
        }
    }
}

override

关键字用于从基类重写

abstract

或

virtual

方法。实现接口时，不需要关键字。MSDN在以下文件上声明：

重写修饰符是扩展或修改继承的方法、属性、索引器或事件的抽象或虚拟实现所必需的

如果不是接口，而是扩展基类，

Dispose

方法将具有

抽象

或

虚拟

关键字，则可以

覆盖它在派生类中的实现

请参见对象的
ToString（）
作为示例：

public class Object
{       
    // Returns a String which represents the object instance.  The default
    // for an object is to return the fully qualified name of the class.
    // 
    public virtual String ToString()
    {
        return GetType().ToString();
    }    
}

如果在您的类中，您将添加以下函数：

public override string ToString()
{
    // Add your implementation
}

如果您的类真的像问题中那样实现了这些接口，那么您应该得到一个编译错误

MyClass
未实现接口成员
IDisposable.Dispose（）


在添加
public void Dispose（）
实现时，将解决此问题


更新：

结果是有一个Dispose（）方法，但它不是重写。我在等一个超控。这可能是一个无效的问题。。。。但为什么它不是一个覆盖

public class MyClient : IMyClient2
{
    public void Dispose()
    {
        Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if(disposing)
        {
            Stop();
        }
    }
}

override
关键字用于从基类重写
abstract
或
virtual
方法。实现接口时，不需要关键字。MSDN在以下文件上声明：

重写修饰符是扩展或修改继承的方法、属性、索引器或事件的抽象或虚拟实现所必需的

如果不是接口，而是扩展基类，
Dispose
方法将具有
抽象
或
虚拟
关键字，则可以
覆盖它在派生类中的实现

请参见对象的
ToString（）
作为示例：

public class Object
{       
    // Returns a String which represents the object instance.  The default
    // for an object is to return the fully qualified name of the class.
    // 
    public virtual String ToString()
    {
        return GetType().ToString();
    }    
}

如果在您的类中，您将添加以下函数：

public override string ToString()
{
    // Add your implementation
}

我认为实现IDisposable需要我的类具有Dispose（）覆盖。但事实并非如此，我也不知道我需要做些什么才能做到这一点

更改基类

public class MyClient : IMyClient2
{
    public virtual void Dispose()
    {
        Dispose(true);
    }
}

public abstract class MyClient : IMyClient2
{
    public abstract void Dispose()
    {
        Dispose(true);
    }
}

你的新类型

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

这将允许从
MyClient
类型派生的类型也实现它们自己对
Dispose
方法的重写。不需要在重写类型中实现
Dispose
。如果您想要这样做，那么您必须使用抽象Dispose方法将
MyClient
类标记为抽象类

更改基类

public class MyClient : IMyClient2
{
    public virtual void Dispose()
    {
        Dispose(true);
    }
}

public abstract class MyClient : IMyClient2
{
    public abstract void Dispose()
    {
        Dispose(true);
    }
}

你的新类型

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

我认为实现IDisposable需要我的类具有Dispose（）覆盖。但事实并非如此，我也不知道我需要做些什么才能做到这一点

更改基类

public class MyClient : IMyClient2
{
    public virtual void Dispose()
    {
        Dispose(true);
    }
}

public abstract class MyClient : IMyClient2
{
    public abstract void Dispose()
    {
        Dispose(true);
    }
}

你的新类型

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

这将允许从
MyClient
类型派生的类型也实现它们自己对
Dispose
方法的重写。不需要在重写类型中实现
Dispose
。如果您想要这样做，那么您必须使用抽象Dispose方法将
MyClient
类标记为抽象类

更改基类

public class MyClient : IMyClient2
{
    public virtual void Dispose()
    {
        Dispose(true);
    }
}

public abstract class MyClient : IMyClient2
{
    public abstract void Dispose()
    {
        Dispose(true);
    }
}

你的新类型

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

public class MyClient2 : MyClient
{
    public override void Dispose()
    {
        // add your dispose information
        base.Dispose(true);
    }
}

我认为实现IDisposable需要我的类具有Dispose（）覆盖。但事实并非如此，我也不知道我需要做些什么才能做到这一点

不可以。接口不使用
抽象/虚拟/覆盖
关键字。作者实现了接口，没有重写任何虚拟方法

注意：IDisposable定义中没有
虚拟/抽象
：

public interface IDisposable
{
    void Dispose();
}

为什么它不是一个覆盖

public class MyClient : IMyClient2
{
    public void Dispose()
    {
        Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if(disposing)
        {
            Stop();
        }
    }
}

作者本可以选择遵循最佳实践并提供受保护的虚拟void Dispose（bool disposing）
，但选择不太合适。

我猜他没想到你会想延长课程


你现在能做什么？
如果您有权修改代码，那么您可以按照自己的意愿实现IDisposable。例如

如果你不能修改代码，那么你仍然有选择。您可以使用composition/decorator模式来提供自己的Dispose实现

您可以从
MyClient
继承，然后显式地为自己提供实现。当对象被释放时，它将是与被调用的接口关联的方法。

这实际上与覆盖相同。例如：

public class MyClient2 : MyClient
{
    void IDisposable.Dispose()
    {
        base.Dispose();
        //Do whatever you like here.
    }
}

我认为实现IDisposable需要我的类具有Dispose（）覆盖。但是没有，我也不知道我需要什么