このページは役に立ちましたか。
このページのコンテンツについての ご意見をお待ちしております
その他にご意見はありますか。
残り 1500 文字
IDisposable インターフェイス
Collapse the table of content
Expand the table of content
この記事は機械翻訳されたものです。 記事の文章にポインターを重ねると、原文のテキストが表示されます。 詳細情報
訳文
原文

IDisposable インターフェイス

アンマネージ リソースの解放のための機能を提供します。

名前空間:  System
アセンブリ:  mscorlib (mscorlib.dll 内)

[ComVisibleAttribute(true)]
public interface IDisposable

IDisposable 型で公開されるメンバーは以下のとおりです。

  名前説明
パブリック メソッドXNA Framework によるサポート汎用性のあるクラス ライブラリ によるサポートサポート対象: Windows ストア アプリ用 .NETDisposeアンマネージ リソースの解放およびリセットに関連付けられているアプリケーション定義のタスクを実行します。
このページのトップへ

このインターフェイスは主に、アンマネージ リソースを解放するために使用します。 マネージ オブジェクトが使用されなくなると、同オブジェクトに割り当てられているメモリはガベージ コレクターによって自動的に解放されます。 ただし、ガベージ コレクションが行われるタイミングは特定できません。 また、ガベージ コレクターでは、ウィンドウ ハンドル、開いたファイルやストリームなどのアンマネージ リソースが認識されません。

ガベージ コレクターを使用して、明示的にアンマネージ リソースを解放するにはこのインターフェイスの Dispose メソッドを使用します。 オブジェクトがもはや必要でない場合、オブジェクトのコンシューマーはこのメソッドを呼び出します。

Caution メモ注意

これが互換性に影響する変更であるため、既存のクラスに IDisposable インターフェイスを追加しないでください。

インスタンスが所有しているリソースが不要になった場合 IDisposable.Dispose の実装が型のコンシューマーによって呼び出されるため、SafeHandle (方法として) のマネージ オブジェクトをラップするか、または、コンシューマーが Disposeを呼び出すことを忘れると、アンマネージ リソースを解放するために Object.Finalize をオーバーライドする必要があります。

重要 : 重要

C++ プログラマは、「Visual C++ デストラクターとファイナライザー」を参照してください。 .NET Framework では、C++ コンパイラはリソースの確定的な破棄をサポートし、Dispose のメソッドの直接実装はできません。

このインターフェイスおよび Object.Finalize メソッドの使用方法の詳細については、「ガベージ コレクション」と「Dispose メソッドの実装」を参照してください。

IDisposable を実装するオブジェクトを使用して

アンマネージ リソースを直接使用する場合にのみ IDisposable を実装してください。 アプリケーションが IDisposableを実装するオブジェクトを使用する場合は、IDisposable の実装を提供しません。 代わりにそれを使用して終了すると、オブジェクトの IDisposable.Dispose の実装を呼び出す必要があります。 プログラミング言語に応じて、2 種類の方法は 1 とおりでこれを行うことができますが、T:

  • C# と Visual Basic での using ステートメントなどの言語構成要素を使用して。

  • try /catch ブロックの IDisposable.Dispose の実装の呼び出しをラップすることによって異なります。

メモメモ

ファクトが Dispose の実装を呼び出すために、エントリを含む IDisposable を実装する型のドキュメント。

aax125c9.collapse_all(ja-jp,VS.110).gifステートメントを使用して、C# および Visual Basic

言語サポートが明示的に IDisposable.Dispose を呼び出す代わりに、C# と Visual Basic の独自の using のステートメントなど、構造を使用できます。 次の例では、ファイルに関する情報とその単語のカウントを保持する WordCount クラスの定義では、この方法を使用します。


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 のステートメントは、実際には、構文を簡略化します。 コンパイル時に、言語コンパイラは try/catch ブロックに対して Intermediate Language (IL) を実装します。

using のステートメントに関する詳細については、Using ステートメント (Visual Basic) または using ステートメント (C# リファレンス) "を参照します。

aax125c9.collapse_all(ja-jp,VS.110).gifTry ブロックと Catch ブロック

プログラミング言語が C# または Visual Basic の using のステートメントなどの構造体をサポートしていない場合、またはそれを使用しない場合は try/catch のステートメントの finally ブロックから IDisposable.Dispose の実装を呼び出すことができます。 次の例では try/catchと前の例の using ブロックとfinally ブロックされます。


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


try /finally パターンの詳細については、「Try...Catch...Finally ステートメント (Visual Basic)」、「try-finally (C# リファレンス)」、または「try-finally ステートメント (C)」を参照してください。

IDisposable の実装

型でアンマネージ リソースを直接使用する場合にのみ IDisposable を実装する必要があります。 型のコンシューマーは、インスタンスが不要になったときにリソースを解放するに IDisposable.Dispose の実装を呼び出すことができます。 Dispose を呼び出し、に失敗したケースを処理するには SafeHandle からアンマネージ リソースをラップするために派生クラスを使用するか、または、参照型の Object.Finalize のメソッドをオーバーライドする必要があります。 どちらの場合も、クリーンアップはアンマネージ リソースを解放するか、解放する、またはリセットなどのアンマネージ リソースを使用すると、必要な実行に Dispose のメソッドを使用します。

重要 : 重要

アンマネージ リソースを使用するのか、または表示する可能性があり、基本クラスを定義し、破棄される必要がある IDisposable.Dispose サブクラスのメソッドを実装し、次のセクションで説明するように Disposeの 2 番目のオーバーロードを提供する必要があります。

IDisposable、継承階層

破棄可能なサブクラスを持つ基底クラスは、IDisposable を次のように実装する必要があります。

  • これは、1 つの Dispose() パブリック非仮想メソッドと 1 つの Dispose(Boolean disposing) プロテクト仮想メソッドを提供します。

  • Dispose() のメソッドは Dispose(true) を呼び出す必要があり、パフォーマンスの終了を抑制する必要があります。

  • 基本型はファイナライザーを含めることはできません。

次のコードは、基本クラスの破棄パターンを反映します。 型が Object.Finalize のメソッドをオーバーライドしないと想定します。


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


Object.Finalize のメソッドをオーバーライドする場合、クラスには次のパターンを実装する必要があります。


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


サブクラスは破棄可能なパターンを次のように実装する必要があります。

  • これらは Dispose(Boolean) をオーバーライドし、基底クラスの Dispose(Boolean) の実装を呼び出す必要があります。

  • 必要な場合にはファイナライザーを提供します。 ファイナライザーは Dispose(false) を呼び出す必要があります。

派生クラス自体を実装し、IDisposable インターフェイスを含まない Dispose メソッドのパラメーターであることに注意してください。 これらは、基本クラスの Dispose(Boolean) のメソッドのみをオーバーライドします。

次のコードは、派生クラスの破棄パターンを反映します。 型が Object.Finalize のメソッドをオーバーライドしないと想定します。


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


IDisposable インターフェイスを実装するリソース クラスを作成する方法を次の例に示します。


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

サポート対象 : 4.5.2、4.5.1、4.5、4、3.5、3.0、2.0、1.1、1.0

.NET Framework Client Profile

サポート対象 : 4、3.5 SP1

汎用性のあるクラス ライブラリ

サポート対象 : 汎用性のあるクラス ライブラリ

Windows ストア アプリ用 .NET

サポート対象 : Windows 8

Windows Phone アプリ用 .NET

サポート対象 : 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 (サーバー コア ロールはサポート対象外), Windows Server 2008 R2 (SP1 以降でサーバー コア ロールをサポート。Itanium はサポート対象外)

.NET Framework では、各プラットフォームのすべてのバージョンはサポートしていません。サポートされているバージョンについては、「.NET Framework システム要件」を参照してください。

コミュニティの追加

追加
表示:
© 2015 Microsoft