Dispose与Disposed有什么区别? [英] What is the difference between Dispose vs Disposed?

问题描述

处置与处置之间有何区别?

我建立了一个类对象x，它具有void Dispose和event Disposed
所以我为我的班级创建了dispose，然后在x中调用Dispose.

但是我该如何为我的班级创建Disposed并调用x.Disposed

感谢您的帮助.

What a difference between Dispose and Disposed ?

I have built a class object x and it has void Dispose and event Disposed
so I created dispose for my class and call Dispose in x.

But how can I create Disposed to my class and call x.Disposed

Thanks for any help.

推荐答案

Dispose是一个方法，而Disposed是一个事件.一旦Dispose方法被调用并完成，则在Disposed事件触发时发生.

可以调用方法，但必须处理事件.

示例:

Dispose is a method whereas Disposed is an Event. On Disposed event fire once Dispose method is called and completed.

Method can be called but Event has to be handled.

Example:

obj.Dispose();

obj.Disposed += new EventHandler(OnDisposed);

private void OnDisposed(object sender, EventArgs e)
{
   // Do your stuffs
}

将其标记为答案"，如果有帮助的话

Mark it as Answer, if it is helpful

首先，Dispose基本上是IDisposable.Dispose()嵌入在C#中，因为使用了结构:

First, of all, Dispose is IDisposable.Dispose() fundamentally embedded in C# because using construct:

class MyDisposableClass: IDisposable {
    void IDisposable.Dispose() {/* should be implemented */}
    //...
}

using (disposableObject obj = new MyDisposableClass()) {
    //use disposableObject...
} //disposableObject.Dispose automatically called

Dispose甚至在异常时也被调用(这是语法糖，严格等同于try- finally块的情况).

至于Disposed-不同的东西都有这个名字(我看到了boolean属性和事件).感兴趣的成员最有可能是事件System.ComponentModel.IComponent.Disposed. System.ComponentModel.Component以调用Dispose时事件的方式实现IDisposable.Dispose和IComponent.

您不能直接调用Disposed(或者可以直接调用System.ComponentModel.IComponent.Disposed，但是可以通过继承Component来实现).

您可以将一个或多个事件处理程序添加到Disposed事件.
但是，另一个示例中显示的语法已过时.
使用匿名会更好:

The Dispose is called even on exception (this is syntactic sugar strictly equivalent to the case of try-finally block).

As to Disposed -- different things have this name (I saw boolean property and event). Most likely, the member of interest is the event System.ComponentModel.IComponent.Disposed. System.ComponentModel.Component implements IDisposable.Dispose and IComponent the way the event is when Dispose is called.

You cannot call Disposed directly (or you could if you implement System.ComponentModel.IComponent.Disposed directly, but by inheriting from Component).

You can add one or more event handler to Disposed event.
However, the syntax shown in the other sample is obsolete.
Using anonymous is much better:

myClass.Disposed += (sender, eventArgs) => {
    //whatever you want here
};

这样比较好，因为如果您从此处理程序中调用一个或多个方法，则不需要传递完全相同的参数列表(object sender, System.EventArgs eventArgs) －通常，您确实需要一个或两个参数，因此使代码更简单.您甚至可以编写整个处理程序，包括在此块中.另外，它使用类型推断，因此您无需键入类型.

较旧的语法可以与.NET 2.0一起使用-无需类型推断，但仍可以匿名:

This is better because if you call one or more methods from within this handler, you do not need to pass exact same parameter list (object sender, System.EventArgs eventArgs) -- very often you do need one or both arguments, so it make code simpler. You can even write the whole handler insdide this block. Also, it uses type inference, so you don''t type the Types.

Older syntax can be used with .NET 2.0 -- no type inference, but still anonymous:

myClass.Disposed += delegate(
    object sender,
    System.EventArgs eventArgs) {
    //whatever you want here
}

至少您不必使用带有精确参数列表的处理程序.

At least you don''t have to use a handler with exact parameter list.

这篇关于Dispose与Disposed有什么区别?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！