Content deleted Content added
→References: MSDN |
→top: rewrite so not RAII-centric |
||
Line 1:
{{redirect|Dispose||Disposal (disambiguation)}}
{{Refimprove|date=February 2013}}
In [[
The dispose pattern is primarily used in languages whose [[runtime environment]] have [[automatic garbage collection]] (see motivation below), and thus may be styled as ''manual'' resource management in languages with [[automatic memory management|''automatic'' memory management]].
== Motivation ==
=== Wrapping resources in objects ===
Wrapping resources in objects is the object-oriented form of [[Encapsulation (computer programming)|encapsulation]], and underlies the dispose pattern.
Resources are typically represented by [[Handle (computing)|handles]] (abstract references), concretely usually integers, which are use to communicate with an external system that provides the resource. For example, files are provided by the [[operating system]] (specifically the [[file system]]), which in many systems represents files with a [[file descriptor]] (an integer representing the file).
These handles can be used directly, by storing the value in a variable and passing it as an argument to functions that use the resource. However, it is frequently useful to abstract from the handle itself (for example, if different operating systems represent files differently), and to store additional auxiliary data with the handle, so handles can be stored as a field in a [[Record (computer science)|record]], along with other data; if this in an [[opaque data type]], then this provides [[information hiding]] and the user is abstracted from the actual representation.
For example, in [[C file input/output]], files are represented by objects of the <code>FILE</code> type (confusingly called "[[file handle]]s": these are a language-level abstraction), which stores an (operating system) handle to the file ("[[file descriptor]]"), together with auxiliary information like I/O mode (reading, writing) and position in the stream. These objects are created by calling <code>[[open (system call)|open]]</code> (in object-oriented terms, a [[factory method|factory]]), which acquires the resource, and the resource is released by calling <code>[[close (system call)|close]]</code> on the <code>FILE</code> object. In code:
<source lang="c">
FILE f = open(filename);
// Do something with f.
close(f);
</source>
Note that <code>close</code> is a function with a <code>FILE</code> parameter. In object-oriented programming, this is instead an [[instance method]] on a file object, as in Python:
<source lang="python">
f = open(filename)
# Do something with f.
f.close()
</source>
This is precisely the dispose pattern, and only differs in syntax and code structure{{efn|In [[class-based programming]], methods are defined in a class, using an implicit <code>this</code> or <code>self</code> parameter, rather than as functions taking an explicit parameter.}} from traditional file opening and closing. Other resources can be managed in exactly the same way: being acquired in a constructor or factory, and released by an explicit <code>close</code> or <code>dispose</code> method.
=== Prompt release ===
The fundamental problem that the dispose pattern aims to solve is that resources are expensive (for example, there may be a limit on the number of open files), and thus should be released promptly. Further, some finalization work is often need, particularly for I/O, such as flushing buffers to ensure that all data is actually written.
If a resource is unlimited or effectively unlimited, and no explicit finalization is necessary, it is not important to release it, and in fact short-lived programs often do not explicitly release resources: due to short run time, they are unlikely to exhaust resources, and they rely on the [[runtime system]] or [[operating system]] to do any finalization.
However, in general resources must be managed (particularly for long-lived programs, programs that use many resources, or for safety, to ensure that data is written out). Explicit disposal means that resource finalization and release is deterministic and prompt: the <code>dispose</code> method does not complete until these are done.
An alternative to requiring explicit disposal is to tie resource management to [[object lifetime]]: resources are acquired during [[object creation]], and released during [[object destruction]]. This approach is known as the [[Resource Acquisition Is Initialization]] (RAII) idiom, and is used in languages with deterministic memory management (e.g. [[C++]]). In this case, in the example above, the resource is acquired when the file object is created, and when the scope of the variable <code>f</code> is exited, the file object that <code>f</code> refers to is destroyed, and as part of this, the resource is released.
RAII relies on object lifetime being deterministic; however, with automatic memory management, [[object lifetime]] is not a concern of the programmer: objects are destroyed at some point after they are no longer used, but ''when'' is abstracted. Indeed, lifetime is often not deterministic, though it may be, notably if [[reference counting]] is used. Indeed, in some cases there is no guarantee that objects will ''ever'' be finalized: when the program terminates, it may not finalize the objects, and instead just let the operating system reclaim memory; if finalization is required (e.g., to flush buffers), data loss can occur.
Thus by not coupling resource management to object lifetime, the dispose pattern allows ''resources'' to be released promptly, while giving implementation flexibility for memory management. The cost of this is that resources must be managed manually, which can be tedious and error-prone.
== Exceptions ==
| |||