この記事は機械翻訳されています。英語版の記事を表示するには、[英語] のチェック ボックスをオンにしてください。また、テキストにマウス ポインターを合わせると、ポップアップ ウィンドウに英語のテキストを表示することもできます。
翻訳
英語

IDisposable インターフェイス

 

アンマネージ リソースを解放するためのメカニズムを提供します。

この型の .NET Framework ソース コードを参照するを参照してください。、 Reference Sourceです。

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

[ComVisibleAttribute(true)]
public interface IDisposable

名前説明
System_CAPS_pubmethodDispose()

アンマネージ リソースの解放またはリセットに関連付けられているアプリケーション定義のタスクを実行します。

System_CAPS_noteメモ

この型の .NET Framework ソース コードを表示するを参照してください。、 Reference Sourceです。 ソース コードをオンラインで参照するか、リファレンスをダウンロードしてオフラインで表示するか、デバッグ中にソース (パッチや更新を含む) をステップ実行することができます。 instructionsを参照してください。

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

使用して、Dispose明示的に、ガベージ コレクターで組み合わせてのアンマネージ リソースを解放するには、このインターフェイスのメソッドです。 オブジェクトのコンシューマーは、オブジェクトが不要になったとき、このメソッドを呼び出すことができます。

System_CAPS_warning警告

重大な変更を追加するのには、IDisposable既存のクラスへのインターフェイスです。 型の既存のコンシューマーが呼び出すことはできませんのでDispose、特定の種類によって保持されているアンマネージ リソースを解放することをすることはできません。

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

System_CAPS_important重要

.NET Framework で、C++ コンパイラ リソースの確定的な破棄をサポートしているし、の直接の実装はできません、Disposeメソッドです。

方法の詳細についてはこのインターフェイスとObject.Finalizeメソッドを使用するを参照してください、Garbage CollectionDispose メソッドの実装トピックです。

実装IDisposableアンマネージ リソースを直接使用している場合にのみです。 アプリは単に実装するオブジェクトを使用する場合IDisposableが提供されない、IDisposable実装します。 代わりに、オブジェクトを呼び出す必要がありますIDisposable.Disposeその使用が終了した場合に実装します。 プログラミング言語によっては、これには 2 つの方法のいずれかの操作を行います。

  • 言語を使用して構築など、 using c# および Visual Basic でのステートメント。

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

System_CAPS_noteメモ

ドキュメント型を実装するIDisposableそのことに注意してくださいし、アラームを呼び出してそのDispose実装します。

など、言語にコンストラクトがサポートしている場合、を使用して(C#) ステートメントとUsing Visual Basic でのステートメントを使用する明示的に呼び出す代わりにIDisposable.Dispose自分でします。 次の例で定義するには、このアプローチは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();
      }
      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ステートメントは構文上の便利な実際にします。 コンパイル時に、言語コンパイラを実装する中間言語 (IL) のtry/catchブロックします。

詳細については、usingステートメントを参照してください、Using Statement (Visual Basic)またはusing ステートメント (C# リファレンス)トピックです。

使用するプログラミング言語がのようなコンストラクトをサポートしないかどうか、 using c# または Visual Basic では、ステートメントで呼び出すか、またはそれを使用しないようにする場合、IDisposable.Dispose実装から、finallyのブロック、 try/catchステートメントです。 次の例が置き換えられます、usingブロックの前の例で、 try/catch/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();
      }
      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 Statement (Visual Basic)try-finally (C# リファレンス)、またはtry-finally ステートメント (C)です。

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

System_CAPS_important重要

基本クラスを定義する場合はアンマネージ リソースを使用する、またはのいずれかが傾向があります、サブクラスは破棄されなければなりません、実装する必要があります、IDisposable.Disposeメソッドの 2 番目のオーバー ロードを提供およびDispose、次のセクションで説明したようにします。

破棄可能にする必要のあるサブクラスを持つ基本クラスを実装する必要がありますIDisposable次のようにします。 実装するときに、このパターンを使用する必要がありますIDisposable任意の型にはないsealed(NotInheritable Visual Basic で)。

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

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

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

次のコード フラグメントでは、基本クラスで dispose パターンを反映しています。 種類をオーバーライドしないことを想定しています、Object.Finalizeメソッドです。

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

   // 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) {
         handle.Dispose();
         // 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)メソッドです。

次のコード フラグメントでは、派生クラスで dispose パターンを反映しています。 種類をオーバーライドしないことを想定しています、Object.Finalizeメソッドです。

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class DerivedClass : BaseClass
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

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

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

      // Free any unmanaged objects here.
      //

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

次の例は、リソースを実装するクラスを作成する方法を示します、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.
    }
}

ユニバーサル Windows プラットフォーム
8 以降で使用可能
.NET Framework
1.1 以降で使用可能
ポータブル クラス ライブラリ
サポート対象: 移植可能 .NET プラットフォーム
Silverlight
2.0 以降で使用可能
Windows Phone Silverlight
7.0 以降で使用可能
Windows Phone
8.1 以降で使用可能
トップに戻る
表示: