using System;
using System.Collections.Generic;

class Sample {
  static void Main()
  {
    var l = new List<string>(); // オブジェクト(List)を作成する

    l.Add("Hello, world!");

    delete l; // deleteのような、オブジェクトを明示的に破棄する構文はない

    l = null; // nullを代入することにより、確保したオブジェクトへの*参照を破棄する*ことはできる
              // ただし、オブジェクトの破棄を指示するものとはならない

    // 参照が破棄された(どこからも参照されなくなった)オブジェクトは、
    // いずれかのタイミングでガベージコレクタによって収集・破棄される
  }
}

Imports System
Imports System.Collections.Generic

Class Sample
  Shared Sub Main()
    Dim l As New List(Of String)(); ' オブジェクト(List)を作成する

    l.Add("Hello, world!")

    Delete l ' deleteのような、オブジェクトを明示的に破棄する構文はない

    l = Nothing ' Nothingを代入することにより、確保したオブジェクトへの*参照を破棄する*ことはできる
                ' ただし、オブジェクトの破棄を指示するものとはならない

    ' 参照が破棄された(どこからも参照されなくなった)オブジェクトは、
    ' いずれかのタイミングでガベージコレクタによって収集・破棄される
  End Sub
End Class

using System;
using System.Collections.Generic;

class C {
  private readonly List<string> l;

  // コンストラクタ
  public C()
  {
    l = new List<string>(); // オブジェクト(List)を確保する
  }

  // ファイナライザ/デストラクタ (あくまで例示、実際は実装する必要がない)
  ~C()
  {
    delete l; // オブジェクト'l'はガベージコレクタによって自動的に収集されるので、
              // このように明示的に破棄する必要はない (そもそもそのような構文がない)
  }
}

Imports System
Imports System.Collections.Generic

Class C
  Private ReadOnly l As List(Of String)

  ' コンストラクタ
  Public Sub New()
    l = New List(Of String)() ' オブジェクト(List)を確保する
  End Sub

  ' ファイナライザ (あくまで例示、実際は実装する必要がない)
  Protected Overrides Sub Finalize()
    Delete l ' オブジェクト'l'はガベージコレクタによって自動的に収集されるので、
             ' このように明示的に破棄する必要はない (そもそもそのような構文がない)
  End Sub
End Class

using System;
using System.IO;

class Sample {
  static void Main()
  {
    // FileStreamでファイルを開く (FileStreamが、指定されたファイルのファイルハンドルを取得する)
    var stream = new FileStream("file.dat", FileMode.Open, FileAccess.Read, FileShare.Read);

    stream.ReadByte();
      :
      :

    // (ガベージコレクタによって)FileStreamが解放される時点で、FileStream自身がファイルハンドルの解放を行う
  }
}

Imports System
Imports System.IO

Class Sample
  Shared Sub Main()
    ' FileStreamでファイルを開く (FileStreamが、指定されたファイルのファイルハンドルを取得する)
    Dim stream As New FileStream("file.dat", FileMode.Open, FileAccess.Read, FileShare.Read)

    stream.ReadByte()
      :
      :
    ' (ガベージコレクタによって)FileStreamが解放される時点で、FileStream自身がファイルハンドルの解放を行う
  End Sub
End Class

using System;
using System.Runtime.InteropServices;

class Sample {
  static void Main()
  {
    const int length = 8;

    // アンマネージメモリ領域を確保する
    IntPtr ptr = Marshal.AllocHGlobal(length);

    // アンマネージメモリ領域を解放する
    Marshal.FreeHGlobal(ptr);
  }
}

Imports System
Imports System.Runtime.InteropServices

Class Sample
  Shared Sub Main()
    Const length As Integer = 8

    ' アンマネージメモリ領域を確保する
    Dim ptr As IntPtr = Marshal.AllocHGlobal(length)

    ' アンマネージメモリ領域を解放する
    Marshal.FreeHGlobal(ptr)
  End Sub
End Class

using System;
using System.Runtime.InteropServices;

class UnmanagedMemory : IDisposable {
  public IntPtr Ptr; // アンマネージメモリ領域を参照するポインタ

  public UnmanagedMemory(int size)
  {
    // メモリ領域を確保する
    Ptr = Marshal.AllocHGlobal(size);
  }

  // メモリ領域を確保するためのメソッドとして、Disposeではない別名のメソッドを提供する
  // (IDisposable.Disposeを明示的な実装にし、それを呼び出すようにする)
  public void Free() => (this as IDisposable).Dispose();

  // '明示的な'IDisposable.Disposeの実装
  void IDisposable.Dispose()
  {
    if (Ptr == IntPtr.Zero)
      return;

    Marshal.FreeHGlobal(Ptr);

    Ptr = IntPtr.Zero;
  }
}

class Sample {
  static void Main()
  {
    // IDisposableインターフェイスを実装するオブジェクトを作成する
    // (本来ならusingステートメントを使ったほうがよいが、例示のため省略)
    var mem = new UnmanagedMemory(4);

    Marshal.WriteInt32(mem.Ptr, 16);

    // Freeメソッドでアンマネージリソースを解放する
    // (このメソッド経由でIDisposable.Disposeメソッドが呼び出される)
    mem.Free();
  }
}

Imports System
Imports System.Runtime.InteropServices

Class UnmanagedMemory
  Implements IDisposable

  Public Ptr As IntPtr ' アンマネージメモリ領域を参照するポインタ

  Public Sub New(ByVal size As Integer)
    ' メモリ領域を確保する
    Ptr = Marshal.AllocHGlobal(size)
  End Sub

  ' メモリ領域を確保するためのメソッドとして、Disposeではない別名のメソッドを提供する
  ' (IDisposable.DisposeをPrivateな実装にし、それを呼び出すようにする)
  Public Sub Free()
    DirectCast(Me, IDisposable).Dispose()
  End Sub
  
  ' PrivateなIDisposable.Disposeの実装
  Private Sub Dispose() Implements IDisposable.Dispose
    If Ptr = IntPtr.Zero Then Return

    Marshal.FreeHGlobal(Ptr)

    Ptr = IntPtr.Zero
  End Sub
End Class

Class Sample
  Shared Sub Main()
    ' IDisposableインターフェイスを実装するオブジェクトを作成する
    ' (本来ならUsingステートメントを使ったほうがよいが、例示のため省略)
    Dim mem As New UnmanagedMemory(4)

    Marshal.WriteInt32(mem.Ptr, 16)

    ' Freeメソッドでアンマネージリソースを解放する
    ' (このメソッド経由でIDisposable.Disposeメソッドが呼び出される)
    mem.Free()
  End Sub
End Class

using System;
using System.Runtime.InteropServices;

class UnmanagedMemory : IDisposable {
  private IntPtr ptr; // アンマネージメモリ領域を参照するポインタ

  public UnmanagedMemory(int size)
  {
    ptr = Marshal.AllocHGlobal(size);
  }

  public void Clear()
  {
    // Ptrが0の場合(すでにDisposeメソッドで解放済みの場合)、例外ObjectDisposedExceptionをスローする
    if (ptr == IntPtr.Zero)
      throw new ObjectDisposedException(GetType().FullName); // 例外の原因となるオブジェクト名として型名を指定する

    // そうでない場合はメソッドの通常の処理を行う
  }

  public void Dispose()
  {
    if (ptr == IntPtr.Zero)
      return; // すでに解放されている場合は何もしない(DisposeメソッドはObjectDisposedExceptionをスローしてはならない)

    Marshal.FreeHGlobal(ptr);

    // 解放済みであることを示すためにIntPtr.Zeroを設定する
    ptr = IntPtr.Zero;
  }
}

class Sample {
  static void Main()
  {
    // IDisposableインターフェイスを実装するオブジェクトを作成する
    // (本来ならusingステートメントを使ったほうがよいが、例示のため省略)
    var mem = new UnmanagedMemory(4);

    // Disposeメソッドを呼び出し、アンマネージリソースを解放する
    mem.Dispose();

    // アンマネージリソースへのアクセスを試みる
    // (オブジェクトはすでに破棄されているため、ObjectDisposedExceptionとなる)
    mem.Clear();
  }
}

Imports System
Imports System.Runtime.InteropServices

Class UnmanagedMemory
  Implements IDisposable

  Private ptr As IntPtr ' アンマネージメモリ領域を参照するポインタ

  Public Sub New(ByVal size As Integer)
    ptr = Marshal.AllocHGlobal(size)
  End Sub

  Public Sub Clear()
    ' Ptrが0の場合(すでにDisposeメソッドで解放済みの場合)、例外ObjectDisposedExceptionをスローする
    ' (例外の原因となるオブジェクト名として型名を指定する)
    If ptr = IntPtr.Zero Then Throw New ObjectDisposedException(Me.GetType().FullName)

    ' そうでない場合はメソッドの通常の処理を行う
  End Sub

  Public Sub Dispose() Implements IDisposable.Dispose
    ' すでに解放されている場合は何もしない(DisposeメソッドはObjectDisposedExceptionをスローしてはならない)
    If ptr = IntPtr.Zero Then Return

    Marshal.FreeHGlobal(ptr)

    ' 解放済みであることを示すためにIntPtr.Zeroを設定する
    ptr = IntPtr.Zero
  End Sub
End Class

Class Sample
  Shared Sub Main()
    ' IDisposableインターフェイスを実装するオブジェクトを作成する
    ' (本来ならUsingステートメントを使ったほうがよいが、例示のため省略)
    Dim mem As New UnmanagedMemory(4)

    ' Disposeメソッドを呼び出し、アンマネージリソースを解放する
    mem.Dispose()

    ' アンマネージリソースへのアクセスを試みる
    ' (オブジェクトはすでに破棄されているため、ObjectDisposedExceptionとなる)
    mem.Clear()
  End Sub
End Class

using System;
using System.Runtime.InteropServices;

class UnmanagedMemory : IDisposable {
  private IntPtr ptr; // アンマネージメモリ領域を参照するポインタ

  public UnmanagedMemory(int size)
  {
    // アンマネージリソースを確保する
    ptr = Marshal.AllocHGlobal(size);
  }

  // IDisposable.Disposeの実装
  public void Dispose()
  {
    // アンマネージリソースの解放処理を行う
    Free();

    // 以降このオブジェクトに対するファイナライザ呼び出しは不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(this);
  }

  // デストラクタ(ファイナライザ)の実装
  // (Disposeメソッドが呼び出されている場合は、GC.SuppressFinalizeでファイナライザの
  // 呼び出しが抑止されるため、呼び出されない)
  ~UnmanagedMemory()
  {
    // アンマネージリソースの解放処理を行う
    Free();
  }

  private void Free()
  {
    // すでに解放されている場合は何もしない(二重解放の抑止)
    if (ptr == IntPtr.Zero)
      return;

    // 解放されていなければ、解放処理を行う
    Marshal.FreeHGlobal(ptr);

    // 解放済みであることを示すためにIntPtr.Zeroを設定する
    ptr = IntPtr.Zero;
  }
}

class Sample {
  static void Main()
  {
    // IDisposableインターフェイスを実装するオブジェクトを作成する
    // (本来ならusingステートメントを使ったほうがよいが、例示のため省略)
    var mem = new UnmanagedMemory(4);

    // Disposeメソッドが明示的に呼び出されなかった場合を想定
    // mem.Dispose();

    // 以降、ガベージコレクタによってオブジェクトが回収される場合、
    // ファイナライザが呼び出され、アンマネージリソースが解放される
  }
}

Imports System
Imports System.Runtime.InteropServices

Class UnmanagedMemory
  Implements IDisposable

  Private ptr As IntPtr ' アンマネージメモリ領域を参照するポインタ

  Public Sub New(ByVal size As Integer)
    ' アンマネージリソースを確保する
    ptr = Marshal.AllocHGlobal(size)
  End Sub

  ' IDisposable.Disposeの実装
  Public Sub Dispose() Implements IDisposable.Dispose
    ' アンマネージリソースの解放処理を行う
    Free()

    ' 以降このオブジェクトに対するファイナライザ呼び出しは不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(Me)
  End Sub

  ' ファイナライザの実装
  ' (Disposeメソッドが呼び出されている場合は、GC.SuppressFinalizeでファイナライザの
  ' 呼び出しが抑止されるため、呼び出されない)
  Protected Overrides Sub Finalize()
    ' アンマネージリソースの解放処理を行う
    Free()
  End Sub

  Private Sub Free()
    ' すでに解放されている場合は何もしない(二重解放の抑止)
    If ptr = IntPtr.Zero Then Return

    ' 解放されていなければ、解放処理を行う
    Marshal.FreeHGlobal(ptr)

    ' 解放済みであることを示すためにIntPtr.Zeroを設定する
    ptr = IntPtr.Zero
  End Sub
End Class

Class Sample
  Shared Sub Main()
    ' IDisposableインターフェイスを実装するオブジェクトを作成する
    ' (本来ならusingステートメントを使ったほうがよいが、例示のため省略)
    Dim mem As New UnmanagedMemory(4)

    ' Disposeメソッドが明示的に呼び出されなかった場合を想定
    ' mem.Dispose();

    ' 以降、ガベージコレクタによってオブジェクトが回収される場合、
    ' ファイナライザが呼び出され、アンマネージリソースが解放される
  End Sub
End Class

using System;

class Resource {
  // コンストラクタ
  public Resource()
  {
    Console.WriteLine("constructed");
  }

  // ファイナライザ(デストラクタ構文によってObject.Finalizeをオーバーライドする)
  ~Resource()
  {
    Console.WriteLine("finalized");
  }
}

class Sample {
  static void AllocateAndRelease()
  {
    new Resource();
  }

  static void Main()
  {
    // オブジェクトを作成して、そのまま放棄する(破棄・解放ではない)
    AllocateAndRelease();

    // ガベージコレクションを行わせ、ファイナライザの呼び出しを待機する
    // (例示のためのものであり、通常は不必要に呼び出すものではない)
    GC.Collect();
    GC.WaitForPendingFinalizers();
  }
}

Imports System

Class Resource
  ' コンストラクタ
  Public Sub New()
    Console.WriteLine("constructed")
  End Sub

  ' ファイナライザ
  Protected Overrides Sub Finalize()
    Console.WriteLine("finalized")
  End Sub
End Class

Class Sample
  Shared Sub AllocateAndRelease()
    Dim res As New Resource()
  End Sub

  Shared Sub Main()
    ' オブジェクトを作成して、そのまま放棄する(破棄・解放ではない)
    AllocateAndRelease()

    ' ガベージコレクションを行わせ、ファイナライザの呼び出しを待機する
    ' (例示のためのものであり、通常は不必要に呼び出すものではない)
    GC.Collect()
    GC.WaitForPendingFinalizers()
  End Sub
End Class

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

// 使用後に解放されるべきリソースを扱うクラス
sealed class Resource : IDisposable {
  private bool disposed = false; // リソースが破棄(解放)されていることを表すフラグ
  private IntPtr ptr = Marshal.AllocHGlobal(4); // コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト
  private Stream stream = Stream.Null; // コンストラクタ等で確保されるマネージリソースを想定したオブジェクト

  // ファイナライザ
  ~Resource()
  {
    // アンマネージリソースのみを破棄させる
    Dispose(false);
  }

  // IDisposable.Disposeの実装
  public void Dispose()
  {
    // アンマネージリソースと、マネージリソースの両方を破棄させる
    Dispose(true);
    // すべてのリソースが破棄されているため、以後ファイナライザの実行は不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(this);
  }

  // リソースの解放処理を行うためのメソッド
  private void Dispose(bool disposing)
  {
    // 既にリソースが破棄されている場合は何もしない
    if (disposed) return;

    // アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
    if (disposing) {
      // 破棄されていないマネージリソースの解放処理を行う
      if (stream != null) {
        stream.Close(); // Disposeメソッド、あるいはそれを呼び出すメソッドを呼び出して解放する
        stream = null;
      }
    }

    // 破棄されていないアンマネージリソースの解放処理を行う
    if (ptr != IntPtr.Zero) {
      Marshal.FreeHGlobal(ptr);
      ptr = IntPtr.Zero;
    }

    // リソースは破棄されている
    disposed = true;
  }

  // 既にリソースが破棄されているかチェックして、ObjectDisposedExceptionをスローするためのメソッド
  private void ThrowIfDisposed()
  {
    if (disposed) throw new ObjectDisposedException(GetType().FullName);
  }

  // 保持しているリソースを使って何らかの操作を行うメソッドを想定
  public void UseResource()
  {
    // 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed();

    // 以降、リソースが利用可能な場合はそれを使った操作を行う
  }
}

Imports System
Imports System.IO
Imports System.Runtime.InteropServices

' 使用後に解放されるべきリソースを扱うクラス
NotInheritable Class Resource
  Implements IDisposable

  Private disposed As Boolean = False ' リソースが破棄(解放)されていることを表すフラグ
  Private ptr As IntPtr = Marshal.AllocHGlobal(4) ' コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト
  Private stream As Stream = Stream.Null ' コンストラクタ等で確保されるマネージリソースを想定したオブジェクト

  ' ファイナライザ
  Protected Overrides Sub Finalize()
    ' アンマネージリソースのみを破棄させる
    Dispose(false)
  End Sub

  ' IDisposable.Disposeの実装
  Public Overloads Sub Dispose() Implements IDisposable.Dispose
    ' アンマネージリソースと、マネージリソースの両方を破棄させる
    Dispose(true)
    ' すべてのリソースが破棄されているため、以後ファイナライザの実行は不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(Me)
  End Sub

  ' リソースの解放処理を行うためのメソッド
  Private Overloads Sub Dispose(ByVal disposing As Boolean)
    ' 既にリソースが破棄されている場合は何もしない
    If disposed Then Return

    ' アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
    If disposing Then
      ' 破棄されていないマネージリソースの解放処理を行う
      If Not stream Is Nothing Then
        stream.Close() ' Disposeメソッド、あるいはそれを呼び出すメソッドを呼び出して解放する
        stream = Nothing
      End If
    End If

    ' 破棄されていないアンマネージリソースの解放処理を行う
    If ptr <> IntPtr.Zero Then
      Marshal.FreeHGlobal(ptr)
      ptr = IntPtr.Zero
    End If

    ' リソースは破棄されている
    disposed = True
  End Sub

  ' 既にリソースが破棄されているかチェックして、ObjectDisposedExceptionをスローするためのメソッド
  Private Sub ThrowIfDisposed()
    If disposed Then Throw New ObjectDisposedException(Me.GetType().FullName)
  End Sub

  ' 保持しているリソースを使って何らかの操作を行うメソッドを想定
  Public Sub UseResource()
    ' 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed()

    ' 以降、リソースが利用可能な場合はそれを使った操作を行う
  End Sub
End Class

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

// 使用後に解放されるべきリソースを扱うクラス
class ResourceBase : IDisposable {
  private bool disposed = false; // リソースが破棄(解放)されていることを表すフラグ
  private IntPtr ptr = Marshal.AllocHGlobal(4); // コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト

  // ファイナライザ
  ~ResourceBase()
  {
    // アンマネージリソースのみを破棄させる
    Dispose(false);
  }

  // IDisposable.Disposeの実装
  public void Dispose()
  {
    // アンマネージリソースと、マネージリソースの両方を破棄させる
    Dispose(true);
    // すべてのリソースが破棄されているため、以後ファイナライザの実行は不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(this);
  }

  // リソースの解放処理を行うためのメソッド
  protected virtual void Dispose(bool disposing)
  {
    // 既にリソースが破棄されている場合は何もしない
    if (disposed) return;

    // アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
    if (disposing) {
      // このクラスはマネージリソースを持たないので、ここですべきことは無い
    }

    // 破棄されていないアンマネージリソースの解放処理を行う
    if (ptr != IntPtr.Zero) {
      Marshal.FreeHGlobal(ptr);
      ptr = IntPtr.Zero;
    }

    // リソースは破棄されている
    disposed = true;
  }

  // 既にリソースが破棄されているかチェックして、ObjectDisposedExceptionをスローするためのメソッド
  protected void ThrowIfDisposed()
  {
    if (disposed) throw new ObjectDisposedException(GetType().FullName);
  }

  // 保持しているリソースを使って何らかの操作を行うメソッドを想定
  public virtual void UseResource()
  {
    // 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed();

    // リソースが利用可能な場合はそれを使った操作を行う
  }
}

// IDisposableとファイナライザが実装された型を継承したクラス
class ExtendedResource : ResourceBase {
  private IntPtr ptr = Marshal.AllocHGlobal(8); // コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト
  private Stream stream = Stream.Null; // コンストラクタ等で確保されるマネージリソースを想定したオブジェクト

  // 基底クラスのリソース解放処理をオーバーライド
  // (ファイナライザ・IDisposable.Disposeメソッドは直接オーバーライドせず、このメソッドで実装する)
  protected override void Dispose(bool disposing)
  {
    try {
      // アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
      if (disposing) {
        // 破棄されていないマネージリソースの解放処理を行う
        if (stream != null) {
          stream.Close(); // Disposeメソッド、あるいはそれを呼び出すメソッドを呼び出して解放する
          stream = null;
        }
      }

      // 破棄されていないアンマネージリソースの解放処理を行う
      if (ptr != IntPtr.Zero) {
        Marshal.FreeHGlobal(ptr);
        ptr = IntPtr.Zero;
      }
    }
    finally {
      // 例外が発生しても基底クラスのDisposeメソッドを確実に呼び出すようにする
      base.Dispose(disposing);
    }
  }

  public override void UseResource()
  {
    // 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed();

    // 以降、リソースが利用可能な場合はそれを使った操作を行う
  }
}

Imports System
Imports System.IO
Imports System.Runtime.InteropServices

' 使用後に解放されるべきリソースを扱うクラス
Class ResourceBase
  Implements IDisposable

  Private disposed As Boolean = False ' リソースが破棄(解放)されていることを表すフラグ
  Private ptr As IntPtr = Marshal.AllocHGlobal(4) ' コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト

  ' ファイナライザ
  Protected Overrides Sub Finalize()
    ' アンマネージリソースのみを破棄させる
    Dispose(false)
  End Sub

  ' IDisposable.Disposeの実装
  Public Overloads Sub Dispose() Implements IDisposable.Dispose
    ' アンマネージリソースと、マネージリソースの両方を破棄させる
    Dispose(true)
    ' すべてのリソースが破棄されているため、以後ファイナライザの実行は不要であることをガベージコレクタに通知する
    GC.SuppressFinalize(Me)
  End Sub

  ' リソースの解放処理を行うためのメソッド
  Protected Overridable Overloads Sub Dispose(ByVal disposing As Boolean)
    ' 既にリソースが破棄されている場合は何もしない
    If disposed Then Return

    ' アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
    If disposing Then
      ' このクラスはマネージリソースを持たないので、ここですべきことは無い
    End If

    ' 破棄されていないアンマネージリソースの解放処理を行う
    If ptr <> IntPtr.Zero Then
      Marshal.FreeHGlobal(ptr)
      ptr = IntPtr.Zero
    End If

    ' リソースは破棄されている
    disposed = True
  End Sub

  ' 既にリソースが破棄されているかチェックして、ObjectDisposedExceptionをスローするためのメソッド
  Protected Sub ThrowIfDisposed()
    If disposed Then Throw New ObjectDisposedException(Me.GetType().FullName)
  End Sub

  ' 保持しているリソースを使って何らかの操作を行うメソッドを想定
  Public Overridable Sub UseResource()
    ' 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed()

    ' 以降、リソースが利用可能な場合はそれを使った操作を行う
  End Sub
End Class

' IDisposableとファイナライザが実装された型を継承したクラス
Class ExtendedResource
  Inherits ResourceBase

  Private ptr As IntPtr = Marshal.AllocHGlobal(8) ' コンストラクタ等で確保されるアンマネージリソースを想定したオブジェクト
  Private stream As Stream = Stream.Null ' コンストラクタ等で確保されるマネージリソースを想定したオブジェクト

  ' 基底クラスのリソース解放処理をオーバーライド
  ' (ファイナライザ・IDisposable.Disposeメソッドは直接オーバーライドせず、このメソッドで実装する)
  Protected Overrides Sub Dispose(ByVal disposing As Boolean)
    Try
      ' アンマネージリソースと、マネージリソースの両方の破棄が要求された場合
      If disposing Then
        ' 破棄されていないマネージリソースの解放処理を行う
        If Not stream Is Nothing Then
          stream.Close() ' Disposeメソッド、あるいはそれを呼び出すメソッドを呼び出して解放する
          stream = Nothing
        End If
      End If

      ' 破棄されていないアンマネージリソースの解放処理を行う
      If ptr <> IntPtr.Zero Then
        Marshal.FreeHGlobal(ptr)
        ptr = IntPtr.Zero
      End If
    Finally
      ' 例外が発生しても基底クラスのDisposeメソッドを確実に呼び出すようにする
      MyBase.Dispose(disposing)
    End Try
  End Sub

  Public Overrides Sub UseResource()
    ' 既にリソースが破棄されているかチェックし、破棄されていればObjectDisposedExceptionをスローする
    ThrowIfDisposed()

    ' 以降、リソースが利用可能な場合はそれを使った操作を行う
  End Sub
End Class