When you initialize a variable using the new operator, you are in fact asking the compiler to provide you some memory
space in the heap memory. The compiler is said to "allocate" memory for
your variable. When that variable is no longer needed, such as when
your program closes, it (the variable) must be removed from memory and
the space it was using can be made available to other variables or other
programs. This is referred to as garbage collection. In the past,
namely in C/C++, this was a concern for programmers because they usually
had to remember to manually delete such a variable (a pointer) and free
its memory.
The
.NET Framework solves the problem of garbage collection by letting the
compiler "clean" memory after you. This is done automatically when the
compiler judges it necessary so that the programmer doesn't need to
worry about this issue.
Garbage collection is a mechanism that allows the computer
to detect when an object can no longer is accessed. It then
automatically releases the memory used by that object (as well as
calling a clean-up routine, called a "finalizer," which is written by
the user). Some garbage collectors like the one used by .NET, compact
memory and therefore decrease your program's working set.
For
most programmers, having a garbage collector (and using garbage
collected objects) means that you never have to worry about deallocating
memory, or reference counting objects, even if you use sophisticated
.data .structures. It does require some changes in coding style,
however, if you typically deallocate system resources (file handles,
locks, and so forth) in the same block of code that releases the memory
for an object. With a garbage collected object you should provide a
method that releases the system resources deterministically (that is,
under your program control) and let the garbage collector release the
memory: when it compact the working set.
0 comments:
Post a Comment