Byla tato stránka užitečná?
Váš názor na tento obsah je důležitý. Sdělte nám, co si myslíte.
Další podněty?
Zbývající počet znaků: 1500
Exportovat (0) Tisk
Rozbalit vše
Tento článek byl přeložen strojově počítačem. Původní text zobrazíte přesunutím ukazatele myši nad jednotlivé věty článku. Další informace
Překlad
Originál

IDisposable – rozhraní

Poskytuje mechanismus pro vydání nespravované prostředky.

Obor názvů:  System
Sestavení:  mscorlib (v mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IDisposable

Typ IDisposable zveřejňuje následující členy.

  NázevPopis
Veřejná metodaPodporováno rozhraním XNA FrameworkPodporováno rozhraním Knihovny přenosných třídPodporováno v: .NET pro aplikace pro Windows StoreDisposeProvádí úkoly definované aplikací, které jsou spojeny s uvolněním nebo obnovením nespravovaných prostředků.
Nahoru

Toto rozhraní používá primárního uvolnit nespravované prostředky. Systém uvolňování paměti automaticky uvolňuje paměť přidělené spravovaného objektu v případě, že tento objekt je již používán. Však není možné předvídat, kdy dojde k uvolnění paměti. Kromě toho uvolňování nezná nespravované prostředky jako jsou popisovače oken nebo otevření souborů a datových proudů.

Použití Dispose metody tohoto rozhraní explicitně uvolnit nespravované prostředky ve spojení s uvolňování. Příjemce objektu lze tuto metodu volat v případě, že objekt již není potřeba.

Poznámka k upozorněníUpozornění

Nepřidávejte IDisposable do existující třídy, rozhraní, protože se jedná o změně rozdělení.

Protože IDisposable.Dispose implementace nazývá spotřebitel typu prostředků, které vlastní instanci již nejsou potřebné, buď zalamován spravovaného objektu v SafeHandle (Doporučená alternativa), nebo byste měli přepsat Object.Finalize uvolnit nespravované prostředky v případě, že klient zapomene zavolat Dispose.

Důležitá poznámkaDůležité

Přečtěte si programátoři C++ Destruktory a finalizačních metod jazyka Visual C++. V rozhraní.NET Framework, kompilátor C++ podporuje deterministický zneškodňování zdroje a neumožňuje přímé provádění Dispose metody.

Podrobné informace o rozhraní a Object.Finalize metody se používají, naleznete Uvolňování paměti a Implementace metody Dispose témata.

Pomocí objektu, který implementuje IDisposable

Implementace IDisposable pouze v případě, že používáte nespravované prostředky přímo. Pokud vaše aplikace používá pouze objekt, který implementuje IDisposable, neposkytují IDisposable provedení. Místo toho byste měli zavolat objektu IDisposable.Dispose provádění po dokončení jeho použití. V závislosti na programovací jazyk lze provést jedním ze dvou způsobů:

  • Pomocí jazyka sestavení, jako using prohlášení v jazyce C# a Visual Basic.

  • Obalením volání IDisposable.Dispose v provedení try/catch blok.

PoznámkaPoznámka

Dokumentace pro typy, které implementují IDisposable Poznámka: Tato skutečnost a připomenutí pro volání jeho Dispose provedení.

aax125c9.collapse_all(cs-cz,VS.110).gifC# a Visual Basic pomocí příkazu

Pokud váš jazyk podporuje konstrukce, jako using prohlášení v jazyce C# a Visual Basic, můžete jej použít namísto explicitně voláním IDisposable.Dispose sami. Následující příklad používá tento přístup při definování WordCount třída, která zachová informace o souboru a počet slov v něm.


using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount
{
   private String filename = String.Empty;
   private int nWords = 0;
   private String pattern = @"\b\w+\b"; 

   public WordCount(string filename)
   {
      if (! File.Exists(filename))
         throw new FileNotFoundException("The file does not exist.");

      this.filename = filename;
      string txt = String.Empty;
      using (StreamReader sr = new StreamReader(filename)) {
         txt = sr.ReadToEnd();
         sr.Close();
      }
      nWords = Regex.Matches(txt, pattern).Count;
   }

   public string FullName
   { get { return filename; } }

   public string Name
   { get { return Path.GetFileName(filename); } }

   public int Count 
   { get { return nWords; } }
}   


using Prohlášení, je ve skutečnosti syntaktické pohodlí. V době kompilace kompilátor jazyka implementuje pro intermediate language (IL) try/catch blok.

Další informace o using prohlášení, najdete Using – příkaz (Visual Basic) nebo using – příkaz (Referenční dokumentace jazyka C#) témata.

aax125c9.collapse_all(cs-cz,VS.110).gifBlok Try/Catch

Pokud programovací jazyk nepodporuje konstrukce jako using prohlášení v jazyce C# nebo Visual Basic, nebo pokud nechcete používat, můžete zavolat IDisposable.Dispose od finally blokovat z try/catch prohlášení. V následujícím příkladu nahradí using bloku v předchozím příkladu s try/catch/finally blok.


using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount
{
   private String filename = String.Empty;
   private int nWords = 0;
   private String pattern = @"\b\w+\b"; 

   public WordCount(string filename)
   {
      if (! File.Exists(filename))
         throw new FileNotFoundException("The file does not exist.");

      this.filename = filename;
      string txt = String.Empty;
      StreamReader sr = null;
      try {
         sr = new StreamReader(filename);
         txt = sr.ReadToEnd();
         sr.Close();
      }
      catch {}
      finally {
         if (sr != null) sr.Dispose();     
      }
      nWords = Regex.Matches(txt, pattern).Count;
   }

   public string FullName
   { get { return filename; } }

   public string Name
   { get { return Path.GetFileName(filename); } }

   public int Count 
   { get { return nWords; } }
}   


For more information about the try/finally pattern, see Try...Catch....Finally – příkaz (Visual Basic), try-finally (Referenční dokumentace jazyka C#), or try-finally – příkaz (C).

Implementace IDisposable

Měli byste IDisposable pouze tehdy, pokud váš typ přímo používá nespravované prostředky. Spotřebitelé stejného typu můžete volat vaše IDisposable.Dispose implementace uvolnit prostředky při instance již není potřeba. Pro zpracování případů, ve kterých se nezdaří volání Dispose, měli byste použít třídu odvozenou z SafeHandle obtékání nespravované prostředky nebo byste měli přepsat Object.Finalize metoda pro typ odkazu. V obou případech můžete použít Dispose metoda provádět jakékoli čištění je nutné po použití nespravované prostředky, jako je například uvolnění, uvolnění nebo obnovení nespravované prostředky.

Důležitá poznámkaDůležité

Pokud definujete základní třídy, která používá nespravované prostředky a která buď má nebo by mohl mít podtříd, které by měly být odstraněny, byste měli implementovat IDisposable.Dispose metoda a poskytují přetížení druhé Dispose, jak je popsáno v následující části.

IDisposable a hierarchii dědičnosti

Základní třída s podtřídami, které by měly být na jedno použití, musí implementovat IDisposable takto:

  • Měl by poskytovat jednu veřejnou, nevirtuální metodu Dispose() a chráněnou virtuální metodu Dispose(Boolean disposing).

  • Dispose() , Musí volat metodu Dispose(true) a dokončení výkonu by měl potlačit.

  • Základní typ by neměl obsahovat žádné finalizační metody.

Následující fragment kódu znázorňuje vzor dispose základní třídy. Předpokládá, že typ vašeho přepsat Object.Finalize metody.


using System;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;

   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }

   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //
      disposed = true;
   }
}


Pokud přepíšete Object.Finalize metoda, vaše třída musí implementovat následující vzor.


using System;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;

   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }

   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //
      disposed = true;
   }

   ~BaseClass()
   {
      Dispose(false);
   }
}


Podtřídy by měly implementovat vzor na jedno použití takto:

  • Musí přepsat Dispose(Boolean) a volat implementaci základní třídy Dispose(Boolean).

  • V případě potřeby mohou poskytovat finalizační metody. Finalizační metoda musí volat Dispose(false).

Všimněte si, že odvozené třídy samotné implementováno IDisposable rozhraní a neobsahují metodu Dispose metody. Pouze potlačí základní třídy Dispose(Boolean) metody.

Následující fragment kódu znázorňuje dispose vzorek pro odvozené třídy. Předpokládá, že typ vašeho přepsat Object.Finalize metody.


using System;

class DerivedClass : BaseClass
{
   // Flag: Has Dispose already been called?
   bool disposed = false;

   // Protected implementation of Dispose pattern.
   protected override void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //
      disposed = true;
   }
}


Následující příklad ukazuje, jak vytvořit prostředek třídy, která implementuje IDisposable rozhraní.


using System;
using System.ComponentModel;

// The following example demonstrates how to create
// a resource class that implements the IDisposable interface
// and the IDisposable.Dispose method.

public class DisposeExample
{
    // A base class that implements IDisposable.
    // By implementing IDisposable, you are announcing that
    // instances of this type allocate scarce resources.
    public class 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.
        private bool 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.
        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(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.
        protected virtual void 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;

                // Note disposing has been done.
                disposed = true;

            }
        }

        // Use interop to call the method necessary
        // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private extern static 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);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.
    }
}


.NET Framework

Podporováno v: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Podporováno v: 4, 3.5 SP1

Knihovny přenosných tříd

Podporováno v: Knihovny přenosných tříd

.NET pro aplikace pro Windows Store

Podporováno v: Windows 8

.NET pro aplikace pro Windows Phone

Podporováno v: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (role Server Core není podporována), Windows Server 2008 R2 (role Server Core je podporována s aktualizací SP1 nebo novější, architektura Itanium není podporována)

.NET Framework nepodporuje některé verze platforem. Seznam podporovaných verzí naleznete v tématu .NET – požadavky na systém.

Obsah vytvořený komunitou

Přidat
Zobrazit:
© 2015 Microsoft