处置物件

ゞ浴缸里的玫瑰 2022-12-06 15:29 100阅读 0赞

In the article, Coding New Instances of Objects, I wrote about the various ways that **New** instances of objects can be created. The opposite problem, disposing an object, is something that you won't have to worry about in VB.NET very often. .NET includes a technology called **Garbage Collector** (**GC**) that usually takes care of everything behind the scenes silently and efficiently. But occasionally, usually when using file streams, sql objects or graphics (GDI+) objects (that is, **unmanaged resources**), you may need to take control of disposing objects in your own code.

在文章“编码对象的新实例”中，我写了关于可以创建对象的**新**实例的各种方法。 相反的问题，即放置对象，是您不必经常在VB.NET中担心的问题。 .NET包含一项称为**垃圾收集器** ( **GC** )的技术，该技术通常以无声，高效的方式处理幕后的一切。 但是有时，通常在使用文件流，sql对象或图形(GDI +)对象(即**非托管资源** )时，可能需要控制将对象放置在自己的代码中的控制。

## 首先，一些背景 **(** First, Some Background **)** ##

Just as a *con*structor (the **New** keyword) creates a new [object][], a *de*structor is a method that is called when an object is destroyed. But there's a catch. The people who created .NET realized that it was a formula for bugs if two different pieces of code could actually destroy an object. So the .NET GC is actually in control and it's usually the only code that can destroy the instance of the object. The GC destroys an object when it decides to and not before. Normally, after an object leaves scope, it is *released* by the common language runtime (CLR). The GC *destroys* objects when the CLR needs more free memory. So the bottom line is that you can't predict when GC will actually destroy the object.

就像一个*反面* **structor(New**关键字)创建一个新的[对象][object] ， *去* structor是当一个对象被销毁时调用的方法。 但是有一个陷阱。 创建.NET的人们意识到，如果两个不同的代码段实际上可以破坏一个对象，那么它就是错误的解决方案。 因此，.NET GC实际上处于控制之中，它通常是唯一可以破坏对象实例的代码。 GC会在决定时而不是之前破坏对象。 通常，对象离开作用域后，将由公共语言运行库(CLR) *释放* 。 当CLR需要更多可用内存时，GC将*销毁*对象。 因此，最重要的是，您无法预测GC何时真正破坏对象。

(Welllll ... That's true *nearly* all of the time. You can call **GC.Collect** and force a [garbage collection cycle][], but authorities universally say it's a *bad* idea and totally unnecessary.)

(Wellllll ... *几乎*所有时间都是如此。您可以调用**GC.Collect**并强制执行[垃圾回收周期][garbage collection cycle] ，但是当局普遍认为这是一个*坏*主意，完全没有必要。)

For example, if your code has created a **Customer** object, it may seem that this code will destroy it again.

例如，如果您的代码创建了一个**Customer**对象，则该代码似乎将再次销毁它。

## 顾客=无 **(** Customer = Nothing **)** ##

But it doesn't. (Setting a an object to Nothing is commonly called, **dereferencing** the object.) Actually, it just means that the variable isn't associated with an object anymore. At some time later, the GC will notice that the object is available for destruction.

但事实并非如此。 (通常将一个对象设置为Nothing，然后**取消**对该对象的**引用** 。)实际上，这仅意味着该变量不再与某个对象相关联。 稍后，GC将注意到该对象可用于销毁。

By the way, for managed objects, none of this is really necessary. Although an object like a Button will offer a Dispose method, it's not necessary to use it and few people do. Windows Forms components, for example, are added to a container object named **components**. When you close a form, its Dispose method is called automatically. Usually, you only have to worry about any of this when using unmanaged objects, and even then just to optomize your program.

顺便说一句，对于托管对象，这些都不是必须的。 尽管诸如Button之类的对象将提供Dispose方法，但没有必要使用它，很少有人这样做。 例如，将Windows Forms组件添加到名为**components**的容器对象中。 关闭窗体时，将自动调用其Dispose方法。 通常，在使用非托管对象时，您只需要担心其中的任何一个，甚至只是为了优化您的程序。

The recommended way to release any resources that might be held by an object is to call the **Dispose** method for the object (if one is available) and then dereference the object.

释放对象可能占用的任何资源的建议方法是调用该对象的**Dispose**方法(如果有)，然后取消对该对象的引用。

Customer.Dispose()
    Customer = Nothing

Because GC will destroy an orphaned object, whether or not you set the object variable to Nothing, it's not really necessary.

因为GC会销毁一个孤立的对象，所以无论您是否将对象变量设置为Nothing，都没有必要。

Another recommended way to make sure that objects are destroyed when they're not needed anymore is to put the code that uses an object into a **Using** block. A Using block guarantees the disposal of one or more such resources when your code is finished with them.

确保不再需要对象时销毁对象的另一种推荐方法是将使用对象的代码放入**Using**块中。 使用代码块可以保证在您的代码完成后，处置一个或多个此类资源。

In the GDI+ series, the **Using** block is put to use quite frequently to manage those pesky graphics objects. For example ...

在GDI +系列中， **Using**块经常用于管理那些讨厌的图形对象。 例如 ...

Using myBrush As LinearGradientBrush _
    = New LinearGradientBrush( _
    Me.ClientRectangle, _
    Color.Blue, Color.Red, _
    LinearGradientMode.Horizontal)
    <... more code ...>
    End Using

**myBrush** is disposed of automagically when the end of the block is executed.

当执行块的末尾时， **myBrush**将自动**清除** 。

The GC approach to managing memory is a big change from the way VB6 did it. COM objects (used by VB6) were destroyed when an internal counter of references reached zero. But it was too easy to make a mistake so the internal counter was off. (Because memory was tied up and not available to other objects when this happened, this was called a "memory leak".) Instead, GC actually checks to see whether anything is referencing an object and destroys it when there are no more references. The GC approach has a good history in languages like Java and is one of the big improvements in .NET.

与VB6相比，GC管理内存的方法有了很大的变化。 当引用的内部计数器达到零时，COM对象(由VB6使用)被破坏。 但是犯错太容易了，所以内部计数器关闭了。 (由于发生这种情况，内存被捆绑在一起，无法供其他对象使用，因此这被称为“内存泄漏”。)相反，GC实际上会检查是否有任何对象在引用该对象，并在没有更多引用时将其销毁。 GC方法在Java之类的语言中拥有悠久的历史，并且是.NET的重大改进之一。

On the next page, we look into the IDisposable interface... the interface to use when you need to Dispose unmanaged objects in your own code.

在下一页上，我们研究IDisposable接口...需要在自己的代码中处理非托管对象时使用的接口。

If you code your own object that uses unmanaged resources, you should use the **IDisposable** interface for the object. Microsoft makes this easy by including a code snippet that creates the right pattern for you.

如果您编写使用非托管资源的自己的对象，则应为该对象使用**IDisposable**接口。 Microsoft通过包含一个代码片段为您创建正确的模式，从而使此操作变得容易。

**--------Click Here to display the illustrationClick the Back button on your browser to return--------**

**--------单击此处以显示插图单击浏览器上的“后退”按钮以返回--------**

The code that is added looks like this (VB.NET 2008):

添加的代码如下所示(VB.NET 2008)：

Class ResourceClass
       Implements IDisposable
       ' To detect redundant calls
       Private disposed As Boolean = False
       ' IDisposable
       Protected Overridable Sub Dispose( _
          ByVal disposing As Boolean)
          If Not Me.disposed Then
             If disposing Then
             ' Free other state (managed objects).
             End If
             ' Free your own state (unmanaged objects).
             ' Set large fields to null.
          End If
          Me.disposed = True
       End Sub
    #Region " IDisposable Support "
       ' This code added by Visual Basic to
       ' correctly implement the disposable pattern.
       Public Sub Dispose() Implements IDisposable.Dispose
          ' Do not change this code.
          ' Put cleanup code in
          ' Dispose(ByVal disposing As Boolean) above.
          Dispose(True)
          GC.SuppressFinalize(Me)
       End Sub
       Protected Overrides Sub Finalize()
          ' Do not change this code.
          ' Put cleanup code in
          ' Dispose(ByVal disposing As Boolean) above.
          Dispose(False)
          MyBase.Finalize()
       End Sub
    #End Region
    End Class

**Dispose** is almost an "enforced" developer design pattern in .NET. There's really only one correct way to do it and this is it. You might think this code does something magic. It doesn't.

**Dispose**几乎是.NET中“强制”的开发人员设计模式。 实际上，只有一种正确的方法可以做到这一点。 您可能会认为此代码具有神奇的作用。 没有。

First note that the internal flag **disposed** simply short-circuits the whole thing so you can call **Dispose(disposing)** as often as you like.

首先要注意的是，内部标志**设置**简单地短路了整个事情，所以你可以调用**Dispose(处置)**往往你喜欢。

The code ...

代码 ...

GC.SuppressFinalize(Me)

... makes your code more efficient by telling the GC that the object has already been disposed (an 'expensive' operation in terms of execution cycles). Finalize is Protected because GC calls it automatically when an object is destroyed. You should never call Finalize. The Boolean **disposing** tells the code whether your code initiated the object's disposal (True) or whether the GC did it (as part of the **Finalize** sub. Note that the only code that uses the Boolean **disposing** is:

通过告诉GC对象已经被处置(在执行周期方面是“昂贵的”操作)，从而使代码更高效。 Finalize受保护，因为当对象被销毁时，GC会自动调用它。 您永远不应致电Finalize。 布尔**处理**告诉代码您的代码是启动对象的处理(True)还是GC是否进行了处理(作为**Finalize**子程序的一部分。请注意，唯一使用布尔**处理的**代码是：

If disposing Then
       ' Free other state (managed objects).
    End If

When you dispose of an object, all of its resources must be disposed of. When the CLR [garbage collector][garbage collection cycle] disposes of an object only the unmanaged resources must be disposed of because the garbage collector automatically takes care of the managed resources.

处置对象时，必须处置其所有资源。 当CLR [垃圾收集器][garbage collection cycle]处置对象时，只有非托管资源必须被处置，因为垃圾收集器会自动处理托管资源。

The idea behind this code snippet is that you add code to take care of managed and unmanaged objects in the indicated locations.

此代码段背后的想法是，您可以添加代码来照顾指定位置的托管和非托管对象。

When you derive a class from a [base class][] that implements IDisposable, you don't have to override any of the base methods unless you use other resources that also need to be disposed. If that happens, the derived class should override the base class's Dispose(disposing) method to dispose of the derived class's resources. But remember to call the base class's Dispose(disposing) method.

当您从实现IDisposable的[基类][base class]派生一个类时，除非您使用了也需要处置的其他资源，否则不必重写任何基类方法。 如果发生这种情况，派生类应重写基类的Dispose(dispose)方法以处置派生类的资源。 但是请记住要调用基类的Dispose(dispose)方法。

Protected Overrides Sub Dispose(ByVal disposing As Boolean)
       If Not Me.disposed Then
          If disposing Then
          ' Add your code to free managed resources.
          End If
          ' Add your code to free unmanaged resources.
       End If
       MyBase.Dispose(disposing)
    End Sub

The subject can be slightly overwhelming. The purpose of the explanation here is to "demystify" what's actually happening because most of the information you can find doesn't tell you!

这个主题可能会有些让人不知所措。 此处进行解释的目的是“揭开神秘面纱”实际发生的事情，因为您可以找到的大多数信息都不会告诉您！

> 翻译自: [https://www.thoughtco.com/disposing-objects-3424392][https_www.thoughtco.com_disposing-objects-3424392]

[object]: https://www.thoughtco.com/object-2034254
[garbage collection cycle]: https://www.thoughtco.com/design-your-delphi-program-1058488
[base class]: https://www.thoughtco.com/superclass-2034298
[https_www.thoughtco.com_disposing-objects-3424392]: https://www.thoughtco.com/disposing-objects-3424392