System.IDisposable felület

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

A felület elsődleges használata a IDisposable nem felügyelt erőforrások felszabadítása. A szemétgyűjtő automatikusan felszabadítja a felügyelt objektum számára lefoglalt memóriát, ha az objektum már nincs használatban. A szemétgyűjtés időpontjának előrejelzése azonban nem lehetséges. Ezenkívül a szemétgyűjtő nem ismeri a nem felügyelt erőforrásokat, például az ablakkezelőket, illetve a fájlok és streamek megnyitását.

Ennek a felületnek a Dispose metódusával explicit módon szabadíthat fel nem felügyelt erőforrásokat a szemétgyűjtővel együtt. Az objektum felhasználója akkor hívhatja ezt a metódust, ha már nincs rá szükség.

Figyelmeztetés

Ez egy kompatibilitástörő változás, ha hozzáadja a IDisposable felületet egy meglévő osztályhoz. Mivel a típus korábbi felhasználói nem hívhatók Dispose, nem lehet biztos abban, hogy a típus által birtokolt nem felügyelt erőforrások ki lesznek adva.

Mivel az IDisposable.Dispose implementációt egy adott típusú felhasználó hívja meg, amikor a példány tulajdonában lévő erőforrásokra már nincs szükség, a felügyelt objektumot SafeHandle egy (az ajánlott alternatíva) sorba kell burkolnia, vagy felül kell bírálnia Object.Finalize a nem felügyelt erőforrások felszabadítását abban az esetben, ha a fogyasztó elfelejt meghívni Dispose.

Fontos

.NET-keretrendszer a C++ fordító támogatja az erőforrások determinisztikus ártalmatlanítását, és nem teszi lehetővé a módszer közvetlen megvalósításátDispose.

A felület és a Object.Finalize metódus használatáról részletes ismertetést a Szemétgyűjtés és az Ártalmatlanítási módszer implementálása témakörökben talál.

Az IDisposable-t megvalósító objektum használata

Ha az alkalmazás egyszerűen egy olyan objektumot használ, amely implementálja az IDisposable interfészt, akkor a használat befejezésekor meg kell hívnia az objektum implementációját IDisposable.Dispose . A programozási nyelvtől függően ezt kétféleképpen teheti meg:

• Olyan nyelvi szerkezettel, mint a C# és a using Visual Basic utasítása, valamint az use F# utasítása vagy using függvénye.
• Ha egy blokkba try/finally csomagolja a IDisposable.Dispose megvalósításra irányuló hívást.

Feljegyzés

A megvalósító IDisposable típusok dokumentációja megjegyzi ezt a tényt, és emlékeztetőt is tartalmaz a megvalósítás meghívásához Dispose .

A C#, F# és Visual Basic Using utasítás

Ha a nyelv támogatja az olyan szerkezeteket, mint a C#-beli használati utasítás, a Visual BasicBen a Using utasítás vagy az F# használati utasítása, használhatja azt ahelyett, hogy kifejezetten meghívja IDisposable.Dispose magát. Az alábbi példa ezt a megközelítést használja egy WordCount olyan osztály definiálásához, amely megőrzi egy fájl adatait és a benne lévő szavak számát.

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();
        }
        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; } }
}

open System.IO
open System.Text.RegularExpressions

type WordCount(filename) =
    let txt = 
        if File.Exists filename |> not then
            raise (FileNotFoundException "The file does not exist.")

        use sr = new StreamReader(filename)
        sr.ReadToEnd()

    let pattern = @"\b\w+\b"
    
    let nWords = Regex.Matches(txt, pattern).Count

    member _.FullName = filename

    member _.Name = Path.GetFileName filename

    member _.Count = nWords

Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Using sr As New StreamReader(filename)
         txt = sr.ReadToEnd()
      End Using
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

Az using utasítás (use kifejezés F#-ban) valójában szintaktikai kényelem. Fordításkor a nyelvi fordító implementálja a blokkok köztes nyelvét try/finally (IL).

Az utasítással kapcsolatos további információkért using tekintse meg az Utasítás használata vagy az Utasítás használata témakört.

A Kipróbálás/Végül blokk

Ha a programozási nyelv nem támogatja az olyan szerkezeteket, mint a C# vagy a using Visual Basic utasítása, vagy az use F# utasítás, vagy ha nem szeretné használni, meghívhatja az IDisposable.Dispose implementációt egy/finallytryfinally utasításblokkból. Az alábbi példa az using előző példában szereplő blokkot egy try/finally blokkra cseréli.

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

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

    public WordCount2(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();
        }
        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; } }
}

open System.IO
open System.Text.RegularExpressions

type WordCount2(filename) =
    let txt = 
        if File.Exists filename |> not then
            raise (FileNotFoundException "The file does not exist.")

        let sr = new StreamReader(filename)
        try
            sr.ReadToEnd()
        finally
            sr.Dispose()

    let pattern = @"\b\w+\b"
    
    let nWords = Regex.Matches(txt, pattern).Count

    member _.FullName = filename

    member _.Name = Path.GetFileName filename

    member _.Count = nWords

Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount2
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Dim sr As StreamReader = Nothing
      Try
         sr = New StreamReader(filename)
         txt = sr.ReadToEnd()
      Finally
         If sr IsNot Nothing Then sr.Dispose() 
      End Try
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

A mintával kapcsolatos további információkért try/finally lásd : Kipróbálás... Fogás... Végül nyilatkozat, try-finally, try... végül Kifejezés, vagy try-finally utasítás.

IDisposable implementálása

Implementálnia IDisposable kell, ha a típus közvetlenül nem felügyelt erőforrásokat használ, vagy ha saját maga szeretné használni az eldobható erőforrásokat. Az Ön típusának felhasználói meghívhatják az implementációt IDisposable.Dispose az erőforrások felszabadítására, ha a példányra már nincs szükség. Ha olyan eseteket szeretne kezelni, amelyekben nem sikerül meghívni Disposeőket, használjon egy, a nem felügyelt erőforrások burkolásához származtatott SafeHandle osztályt, vagy felül kell bírálnia egy Object.Finalize referenciatípus metódusát. Mindkét esetben a Dispose nem felügyelt erőforrások ( például a nem felügyelt erőforrások felszabadítása, felszabadítása vagy alaphelyzetbe állítása) használata után bármilyen szükséges tisztítást végrehajthat. A megvalósítással IDisposable.Disposekapcsolatos további információkért lásd az Dispose(bool) metódus túlterhelését.

Fontos

Ha olyan alaposztályt határoz meg, amely nem felügyelt erőforrásokat használ, és amelyek vagy rendelkeznek vagy valószínűleg rendelkeznek olyan alosztályokkal, amelyeket el kell helyezni, akkor implementálnia kell a IDisposable.Dispose metódust, és a következő szakaszban ismertetett második túlterhelést Disposekell biztosítania.

Az IDisposable és az öröklési hierarchia

Az eldobható alosztályokkal rendelkező alaposztálynak az alábbiak szerint kell implementálnia IDisposable . Ezt a mintát akkor érdemes használnia, ha olyan típust implementál IDisposable , amely nem sealed (NotInheritable a Visual Basicben).

• Egy nyilvános, nem virtuális Dispose() metódust és egy védett virtuális Dispose(Boolean disposing) módszert kell biztosítania.
• A Dispose() metódusnak meg kell hívnia Dispose(true) , és el kell tiltania a véglegesítést a teljesítmény szempontjából.
• Az alaptípus nem tartalmazhat véglegesítőket.

Az alábbi kódrészlet az alaposztályok elidegenítési mintáját tükrözi. Feltételezi, hogy a típus nem bírálja felül a metódust Object.Finalize .

using System;
using System.IO;
using System.Runtime.InteropServices;

class BaseClass1 : IDisposable
{
    // Flag: Has Dispose already been called?
    bool disposed = false;
    // Instantiate a FileStream instance.
    FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);

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

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

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

        disposed = true;
    }
}

open System
open System.IO

type BaseClass1() =
    // Flag: Has Dispose already been called?
    let mutable disposed = false

    // Instantiate a FileStream instance.
    let fs = new FileStream("test.txt", FileMode.OpenOrCreate)

    interface IDisposable with
        // Public implementation of Dispose pattern callable by consumers.
        member this.Dispose() =
            this.Dispose true
            GC.SuppressFinalize this

    // Implementation of Dispose pattern.
    abstract Dispose: bool -> unit
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                fs.Dispose()
                // Free any other managed objects here.
            disposed <- true

Imports System.IO
Imports System.Runtime.InteropServices

Class BaseClass1 : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a FileStream instance.
   Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)

   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(disposing:=True)
      GC.SuppressFinalize(Me)
   End Sub

   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         fs.Dispose()
         ' Free any other managed objects here.
         '
      End If

      disposed = True
   End Sub
End Class

Ha felülírja a metódust Object.Finalize , az osztálynak az alábbi mintát kell implementálnia.

using System;

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

    // Public implementation of Dispose pattern callable by consumers.
    public void Dispose()
    {
        Dispose(disposing: 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;
    }

    ~BaseClass2()
    {
        Dispose(disposing: false);
    }
}

open System

type BaseClass2() =
    // Flag: Has Dispose already been called?
    let mutable disposed = false

    interface IDisposable with
        // Public implementation of Dispose pattern callable by consumers.
        member this.Dispose() =
            this.Dispose true
            GC.SuppressFinalize this

    // Implementation of Dispose pattern.
    abstract Dispose: bool -> unit
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                // Free any other managed objects here.
                ()

            // Free any unmanaged objects here.
            disposed <- true

    override this.Finalize() =
        this.Dispose false

Class BaseClass : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False

   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(disposing:=True)
      GC.SuppressFinalize(Me)
   End Sub

   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         ' Free any other managed objects here.
         '
      End If

      ' Free any unmanaged objects here.
      '
      disposed = True
   End Sub

   Protected Overrides Sub Finalize()
      Dispose(disposing:=False)
   End Sub
End Class

Az alosztályoknak az alábbiak szerint kell megvalósítaniuk az eldobható mintát:

• Felül kell bírálniuk Dispose(Boolean) és meg kell hívniuk az alaposztály Dispose(Boolean) implementációt.
• Szükség esetén finalizert is biztosíthatnak. A véglegesítőnek meg kell hívnia Dispose(false).

Vegye figyelembe, hogy a származtatott osztályok maguk nem implementálják az IDisposable interfészt, és nem tartalmaznak paraméter nélküli Dispose metódust. Csak az alaposztály Dispose(Boolean) metódusát bírálják felül.

A következő kódrészlet a származtatott osztályok elidegenítési mintáját tükrözi. Feltételezi, hogy a típus nem bírálja felül a metódust Object.Finalize .

using System;
using System.IO;
using System.Runtime.InteropServices;

class MyDerivedClass : MyBaseClass
{
    // Flag: Has Dispose already been called?
    bool disposed = false;
    // Instantiate a FileStream instance.
    FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);

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

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

        // Free any unmanaged objects here.
        //

        disposed = true;
        // Call base class implementation.
        base.Dispose(disposing);
    }
}

open Microsoft.Win32.SafeHandles
open System

type MyDerivedClass() =
    inherit MyBaseClass()
    
    // Flag: Has Dispose already been called?
    let mutable disposed = false
    // Instantiate a FileStream instance.
    let fs = new FileStream("test.txt", FileMode.OpenOrCreate)

    // Implementation of Dispose pattern.
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                fs.Dispose()
                // Free any other managed objects here.

            // Free any unmanaged objects here.
            disposed <- true
            // Call base class implementation.
            base.Dispose disposing

Imports System.IO
Imports System.Runtime.InteropServices

Class DerivedClass2 : Inherits BaseClass2
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a FileStream instance.
   Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)

   ' Protected implementation of Dispose pattern.
   Protected Overrides Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         fs.Dispose()
         ' Free any other managed objects here.
         '
      End If

      ' Free any unmanaged objects here.
      '
      disposed = True

      ' Call base class implementation.
      MyBase.Dispose(disposing)
   End Sub
End Class