Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Método GC.SuppressFinalize

Solicita que o sistema não telefonar o finalizador do objeto especificado.

Namespace:  System
Assembly:  mscorlib (em mscorlib.dll)

public static void SuppressFinalize(
	Object obj
)

Parâmetros

obj
Tipo: System.Object
O objeto que não deve ser chamado um finalizador para.

ExceçãoCondição
ArgumentNullException

obj é null.

Este método define um bit no cabeçalho do objeto, o sistema verifica ao chamar finalizadores.The obj parâmetro é necessário ser o chamador desse método.

Objetos que implementam o IDisposable interface pode chamar esse método a partir do IDisposable.Dispose método para impedir que o coletor de lixo em telefonar Object.Finalize em um objeto que não requer.

O exemplo a seguir demonstra como usar o método SuppressFinalize em uma classe de recurso para impedir que um lixo redundante coleção do que está sendo chamada.

using System;
using System.ComponentModel;

// The following example demonstrates how to use the // GC.SuppressFinalize method in a resource class to prevent// the clean-up code for the object from being called twice.publicclass DisposeExample
{
    // A class that implements IDisposable.// By implementing IDisposable, you are announcing that // instances of this type allocate scarce resources.publicclass MyResource: IDisposable
    {
        // Pointer to an external unmanaged resource.private IntPtr handle;
        // Other managed resource this class uses.private Component component = new Component();
        // Track whether Dispose has been called.privatebool disposed = false;

        // The class constructor.public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        // Implement IDisposable.// Do not make this method virtual.// A derived class should not be able to override this method.publicvoid Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method.// Therefore, you should call GC.SupressFinalize to// take this object off the finalization queue // and prevent finalization code for this object// from executing a second time.
            GC.SuppressFinalize(this);
        }

        // Dispose(bool disposing) executes in two distinct scenarios.// If disposing equals true, the method has been called directly// or indirectly by a user's code. Managed and unmanaged resources// can be disposed.// If disposing equals false, the method has been called by the // runtime from inside the finalizer and you should not reference // other objects. Only unmanaged resources can be disposed.privatevoid Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.if(!this.disposed)
            {
                // If disposing equals true, dispose all managed // and unmanaged resources.if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }
		 
                // Call the appropriate methods to clean up // unmanaged resources here.// If disposing is false, // only the following code is executed.
                CloseHandle(handle);
                handle = IntPtr.Zero;			
            }
            disposed = true;         
        }

        // Use interop to call the method necessary  // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        privateexternstatic Boolean CloseHandle(IntPtr handle);

        // Use C# destructor syntax for finalization code.// This destructor will run only if the Dispose method // does not get called.// It gives your base class the opportunity to finalize.// Do not provide destructors in types derived from this class.
        ~MyResource()      
        {
            // Do not re-create Dispose clean-up code here.// Calling Dispose(false) is optimal in terms of// readability and maintainability.
            Dispose(false);
        }
    }

    publicstaticvoid Main()
    {
        // Insert code here to create// and use a MyResource object.
    }
}


import System.* ;
import System.ComponentModel.* ;

// The following example demonstrates how to use the 
// GC.SuppressFinalize method in a resource class to prevent
// the clean-up code for the object from being called twice.
public class DisposeExample
{
    // A class that implements IDisposable.
    // By implementing IDisposable, you are announcing that 
    // instances of this type allocate scarce resources.
    public static class MyResource implements IDisposable
    {
        // Pointer to an external unmanaged resource.
        private IntPtr handle;
        // Other managed resource this class uses.
        private Component component =  new Component();
        // Track whether Dispose has been called.
        private boolean disposed = false;

        // The class constructor.
        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        } //MyResource

        // Implement IDisposable.
        // Do not make this method virtual.
        // A derived class should not be able to override this method.
        public void Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SupressFinalize to
            // take this object off the finalization queue 
            // and prevent finalization code for this object
            // from executing a second time.
            GC.SuppressFinalize(this);
        } //Dispose

        // Dispose(bool disposing) executes in two distinct scenarios.
        // If disposing equals true, the method has been called directly
        // or indirectly by a user's code. Managed and unmanaged resources
        // can be disposed.
        // If disposing equals false, the method has been called by the 
        // runtime from inside the finalizer and you should not reference 
        // other objects. Only unmanaged resources can be disposed.
        private void Dispose(boolean disposing)
        {
            // Check to see if Dispose has already been called.
            if (!(this.disposed)) {
                // If disposing equals true, dispose all managed 
                // and unmanaged resources.
                if (disposing) {
                    // Dispose managed resources.
                    component.Dispose();
                }

                // Call the appropriate methods to clean up 
                // unmanaged resources here.
                // If disposing is false, 
                // only the following code is executed.
                CloseHandle(handle);
                handle = IntPtr.Zero;
            }
            disposed = true;
        } //Dispose

        // Use interop to call the method necessary to clean up the unmanaged 
        // resource.

        /** @attribute System.Runtime.InteropServices.DllImport("Kernel32")
         */
        private static native Boolean CloseHandle(IntPtr handle);

        // Use VJ# destructor syntax for finalization code.
        // This destructor will run only if the Dispose method 
        // does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide destructors in types derived from this class.
        public void finalize()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
            try {
                super.finalize();
            }
            catch (System.Exception e) {
            }

        } //finalize
    } //MyResource

    public static void main(String[] args)
    {
        // Insert code here to create
        // and use a MyResource object.
    } //main
} //DisposeExample


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatível com: 3.5, 2.0, 1.0

XNA Framework

Compatível com: , 1.0

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft