GZ>>Ага, и выучить Dispose Pattern назубок. Сейчас как раз наблюдаю крутую очистку в финалайзере.

public class BaseResource: IDisposable
{
  private bool disposed = false;
  public void Dispose()
  {
    if (!disposed)
        {
      DisposeManaged();
            DisposeUnmanaged();
            disposed = true;
      GC.SuppressFinalize(this);
        }
  }

  // Dispose managed resources.
  protected virtual void DisposeManaged()
  {
    Components.Dispose();
  }
  // Release unmanaged resources. 
    protected virtual void DisposeUnmanaged()
    {
        CloseHandle(handle);
        handle = IntPtr.Zero;
  }

   // Do not provide destructors in types derived from this class.
   ~BaseResource()      
   {
      DisposeUnmanaged(false);
   }

   public void DoSomething()
   {
      if(this.disposed)
      {
         throw new ObjectDisposedException();
      }
   }
}

// Design pattern for a derived class.
// Note that this derived class inherently implements the 
// IDisposable interface because it is implemented in the base class.
public class MyResourceWrapper: BaseResource
{
   // A managed resource that you add in this derived class.
   private ManagedResource addedManaged;
   // A native unmanaged resource that you add in this derived class.
   private NativeResource addedNative;
   private bool disposed = false;

  // Constructor for this object.
   public MyResourceWrapper()
   {
      // Insert appropriate constructor code here.
   }

  protected override void DisposeManaged()
  {
        addedManaged.Dispose();         
        base.DisposeManaged();
    }
    protected override void DisposeUnmanaged()
    {
        CloseHandle(addedNative);
        base.DisposeUnmanaged();
  }
}

1.1.4 stable rev. 510

mihailik >>>>Многие наши программисты предпочитают что-то слащаво-подростковое, например Рихтера. Классный дядька Рихтер, успешный. Но есть у него много методических провалов.

Gollum >>Ну и "борюсь с Рихтером" — это немного смешно.

>>Финализатор имеет смысл только если непосредственно ваш класс хранит в себе Handle внешнего ресурса (за редчайшим исключением).

Очевидно, что именно это и говорит нам Рихтер. Процитирую свой перевод: "Каждый объект, который работает с неуправляемыми ресурсами [skip], должен поддерживать финализацию [skip]." У меня нету сейчас под рукой русского издания, но в этом месте если и возникает разночтение, то только по вине этого самого русского издания. В английском варианте лично для меня тут все достаточно прозрачно.

Тут, между прочим, даже сам Рихтер оговаривается по поводу метода Finalize(), мол, девелоперы не тем боком этот метод юзают, поэтому команда разработчиков компилятора языка C# подумала-подумала, и сделала потенциально опасный код вне закона. Вопрос: это защита от дурака, или от Рихтера? Причем, Рихтер опять же оговаривается, что, в общем-то зря они синтаксис деструктора C# слизали с С++, ведь это только вгоняет сишников в ступор. Опять предупреждение, и не от кого бы то ни было, а от самого Рихтера. А ученики, похоже, просто прохлопали ушами этот момент. Читаем дальше.

В _очередной_ раз видим необоснованный выпад, и кстати, не только в сторону Джеффри Рихтера...

>>Они похожи на деструкторы C++
>>— в результате, программисты пишут и думают себе что-то одно, а получается ОЧЕНЬ другое

Я не знаю, о чем думают программисты, когда пишут свой код, но явно не о Рихтере... И приведенный выше фрагмент в моей интерпретации это полностью доказывает.

>>Они вызываются в нефиксированный момент времени
>>— при отладке в условиях A мы видим одно поведение, а при реальной работе в условиях B имеем совсем другое

Именно об этом нам и пишет Рихтер. Кратко но _доходчиво_ разъясняя технические аспекты. Вот этот отрывок (это мой литературный перевод, можете cверить с "настоящим" русским изданием, вполне возможно, там содержатся ошибки, которые и ведут к оказиям):

"
Примечание.
В таблице 19-1 обратите внимание, что на аргумент arg1 нашего метода больше никто не ссылается после инструкций процессора со смещением 0x00000020. Это значит, что объект arg1 помечается как "пригодный для сборки в любое время" после выполнения этих инструкций (предполагается, что в приложении больше нет корневых элементов, которые ссылаются на этот объект). Другими словами, как только объект становится недостижимым [чтобы понять смысл этой фразы, нужно читнуть пару абзацев выше, но эти потуги я уже возложу на плечи наших "учеников"], он превращается в кандидата на сборку, поэтому не гарантируется, что объекты будут жить на протяжении всего времени выполнения метода.
[Дальше пошло самое вкусное.]
Одако, когда приложение выполняется через отладчик, или когда сборка помечена атрибутом System.Diagnostics.DebuggableAttribute с параметром isJITOptimizerDisabled выставленным в true, компилятор JIT продлевает время жизни всех переменных (будь то типы, передающиеся по значению или по ссылке) до окончания их области видимости, что в большинстве случаев означает конец самого метода. (Между прочим, компилятор C#, при использовании ключа /debug в командной строке, помечает сборку атрибутом DebuggerAttribute, устанавливая параметр isJITOptimizerDisabled в true.) Это расширение предотвращает сборщика мусора от сборки ссылочных типов во время выполнения кода в данной области видимости, что полезно при отладке. Было бы совсем неуместно, если бы вы вызвали метод объекта, получили неправильный результат, а затем не смогли бы даже взглянуть на этот объект!
"

Рихтер сказал один в один по писаному... Или наоборот.

// Это примерный код. Просто, для прояснения ситуации.
class SomeManagedResource : IDisposable
{
    byte[] _managedResource;
    static byte[] _cache;

    public SomeManagedResource()
    {
        _managedResource = ManagedAllocate();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        ManagedRelease(_managedResource);
        _managedResource = null;
    }

    ~SomeManagedResource()
    {
        Dispose(false);
    }

    static byte[] ManagedAllocate()
    {
        byte[] resource;

        if (_cache == null)
        {
            resource = new byte[VERY_BIG_ARRAY];
        }
        else
        {
            resource = _cache;
            _cache = null;
        }

        return resource;
    }

    static void ManagedRelease(byte[] resource)
    {
        _cache = resource;
    }
}

public class WindowDescriptor
{
  private Form _targetWindow;
  private int _descId;

  private static extern void CloseDescriptor(IntPtr hwnd, int descId);

  private static extern void CloseAllDescriptors(IntPtr hwnd);

  protected override void DisposeManaged()
  {
    _targetWindow.Dispose();
  }

  protected override void DisposeUnmanaged()
  {
    CloseDescriptor(_targetWindow.Handle, _descId); // тут вылезет все, что угодно, т.к. наше окно уже уничтожено.
  }
}

public class BaseResource: IDisposable
{
  private bool _disposed = false;
    public bool Disposed { 
    [DebuggerStepThrough]
    get { return _disposed; }
    
    #region IDisposable implementation
  public void Dispose()
  {
    if (!disposed)
    {
      DisposeManaged();
      DisposeUnmanaged();
      _disposed = true;
      GC.SuppressFinalize(this);
    }
  }
    #endregion
    
  // Dispose managed resources.
  protected virtual void DisposeManaged()
  {
    Components.Dispose();
  }
  // Release unmanaged resources. 
  protected virtual void DisposeUnmanaged()
  {
    CloseHandle(handle);
    handle = IntPtr.Zero;
  }

   // Do not provide destructors in types derived from this class.
   ~BaseResource()      
   {
      DisposeUnmanaged();
   }

    protected void CheckDisposed()
    {
    if(Disposed)
    {
       throw new ObjectDisposedException();
    }
    }
  public void DoSomething()
  {
      CheckDisposed();
  }
}

public class MyResourceWrapper: BaseResource
{
   // A managed resource that you add in this derived class.
   private ManagedResource addedManaged;
   // A native unmanaged resource that you add in this derived class.
   private NativeResource addedNative;

  protected override void DisposeManaged()
  {
    addedManaged.Dispose();         
    base.DisposeManaged();
  }
  protected override void DisposeUnmanaged()
  {
    CloseHandle(addedNative);
    base.DisposeUnmanaged();
  }
}

1.1.4 stable rev. 510

TK>Все равно, решение сложное

    if (!disposed)
    {
            try
            {
                DisposeManaged();
            }
            ...
            finally
            {
                DisposeUnmanaged();
            }
      _disposed = true;
      GC.SuppressFinalize(this);
    }

if (!disposing)
{
    Debug.WriteLine(...);
}

MS>public class WindowDescriptor
MS>{
MS>  private Form _targetWindow;
MS>  private int _descId;

MS>  private static extern void CloseDescriptor(IntPtr hwnd, int descId);

MS>  private static extern void CloseAllDescriptors(IntPtr hwnd);

MS>  protected override void DisposeManaged()
MS>  {
MS>    _targetWindow.Dispose();
MS>  }

MS>  protected override void DisposeUnmanaged()
MS>  {
MS>    CloseDescriptor(_targetWindow.Handle, _descId); // тут вылезет все, что угодно, т.к. наше окно уже уничтожено.
MS>  }
MS>}
MS>

public class WindowDescriptor
{
  private Form _targetWindow;
  private int _descId;
  private IntPtr _targetHwnd;
    public WindowDescriptor(Form targetWindow)
    {
      _targetWindow = targetWindow;
        _targetHwnd = _targetWindow.Handle;
        _descId = AllocateDescriptor(_targetHwnd);
    }
    private static extern int AllocateDescriptor(IntPtr hwnd);
  private static extern void CloseDescriptor(IntPtr hwnd, int descId);

  private static extern void CloseAllDescriptors(IntPtr hwnd);

  protected override void DisposeManaged()
  {
    _targetWindow.Dispose();
  }

  protected override void DisposeUnmanaged()
  {
    CloseDescriptor(_targetHwnd, _descId); 
  }
}

1.1.4 stable rev. 510

~Derived()
{
  Debug.WriteLine();
}

TK>

Dispose Pattern: Один метод с одним аргументом
И сложной структурой.
TK>

Dispose "Anti" Pattern: Два метода, поле, свойство, нетривиальный код
TK>(раз уж с первого раза написать не удалось)
Вот только не надо упирать на ошибки, которые я делаю при наборе вслепую в редакторе без IntelliSense.
TK>плюс очень похоже, что есть
TK>проблемы с покрытием существующих use cases (для примера возьмем трейс в
TK>наследнике)
Надуманные проблемы.

1.1.4 stable rev. 510

MS>>Забыл

protected override Dispose(bool disposing)
{
  if (_targetHwnd != IntPtr.Zero)
  {
    CloseDescriptor(_targetHwnd, _descId);
    _targetHwnd = IntPtr.Zero;
  }

  if (disposing && _targetForm != null)
  {
     _targetForm.Dispose();
     _targetForm = null;
  }
}

class SomeManagedResource
{
   byte[] _managedArray;

   public SomeResource()
   {
        _managedArray = ManagedAllocate();
   }

   protected virtual void Dispose(bool disposing)
   {
        ManagedRelease(_managedArray);
   }
}

public class DisposableObject : IDisposable
{
    public void Dispose()
    {
        Dispose(true);
    }
    
    protected virtual void Dispose(bool disposing)
    {
    }

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

TK>> Почему, метод для его возвращения должен называться DisposeUnmanaged?
M>А кто сказал, что он должен так называться?

TK>>То, вначале вызывается DisposeManaged, то DisposeUnmanaged.
M>Совершенно не важно что вызывается в начале

TK>> Почему, метод для его возвращения должен называться DisposeUnmanaged?
M>А кто сказал, что он должен так называться?

TK>>То, вначале вызывается DisposeManaged, то DisposeUnmanaged.
M>Совершенно не важно что вызывается в начале

Перегрузите метод DisposeManaged() в том случае, если ваш объект владеет другими объектами, реализующими IDisposable, и вызовите их Dispose().
Перегрузите метод DisposeUnmanaged() в том случае, если ваш объект владеет какими-либо неуправляемыми ресурсами.

TK>class SomeManagedResource
TK>{
TK>   byte[] _managedArray;

TK>   public SomeResource()
TK>   {
TK>        _managedArray = ManagedAllocate();
TK>   }

TK>   protected virtual void Dispose(bool disposing)
TK>   {
TK>        ManagedRelease(_managedArray);
TK>   }
TK>}
TK>

1.1.4 stable rev. 510

public static void Main()
{
  using (SomeManagedResource resource1 = new SomeManagedResource())
    {
      resource1 = new SomeManagedResource();
    }
}

public class BaseResource : IDisposable
{
  private bool _disposed = false;
    protected bool IsDisposed { return _disposed;}
    
    public void Dispose()
    {
      if (_disposed)
            return;
      DisposeFinalizable();
        DisposeNonFinalizable();
        GC.SuppressFinalize(this);
        _disposed = true;
    }
    
    ~BaseResource()
    {
      DisposeNonFinalizable();
    }
    
    protected void DisposeFinalizable() {}
    protected void DisposeNonFinalizable() {}
}

class SomeManagedResource : BaseResource
{
  byte[] _managedResource;
  static byte[] _cache;

  public SomeManagedResource()
  {
    _managedResource = ManagedAllocate();
  }

  override protected void DisposeNonFinalizable()
    {
    ManagedRelease(_managedResource);
        base.DisposeNonFinalizable();
  }
  
    ~SomeManagedResource()
    {
      Debug.Trace("Warning! Instance of SomeManagedResource has not been properly disposed. This leads to an ineffective pool usage!");
    }
  static byte[] ManagedAllocate()
  {
    byte[] resource;
    if (_cache == null)
    {
      resource = new byte[VERY_BIG_ARRAY];
    }
    else
    {
      resource = _cache;
      _cache = null;
    }

    return resource;
  }

  static void ManagedRelease(byte[] resource)
  {
    _cache = resource;
  }
}

1.1.4 stable rev. 510

public void Dispose()
{
  Dispose(true);
  GC.SuppressFinalize(this);
}

1.1.4 stable rev. 510

protected virtual void Dispose(bool disposing)
{
    if(!this.disposed)
    {
    if(disposing)
    {
        Components.Dispose();
    }
    CloseHandle(handle);
    handle = IntPtr.Zero;
    // Note that this is not thread safe.
    // Another thread could start disposing the object
    // after the managed resources are disposed,
    // but before the disposed flag is set to true.
    // If thread safety is necessary, it must be
    // implemented by the client.
    }
    disposed = true;         
}

1.1.4 stable rev. 510

S>protected virtual void Dispose(bool disposing)
S>{
S>    if(!this.disposed)
S>    {
S>    if(disposing)
S>    {
S>        Components.Dispose();
S>    }
S>    CloseHandle(handle);
S>    handle = IntPtr.Zero;
S>    // Note that this is not thread safe.
S>    // Another thread could start disposing the object
S>    // after the managed resources are disposed,
S>    // but before the disposed flag is set to true.
S>    // If thread safety is necessary, it must be
S>    // implemented by the client.
S>    }
S>    disposed = true;         
S>}
S>

protected virtual void Dispose(bool disposing) {
    if(!disposing) {    
        // блокировка не нужна
        if(handle!=IntPtr.Zero)
            CloseHandle();
        // нижеследующее нам не нужно
        // handle = IntPtr.Zero;
        // disposed = true;
    } else {
        Components.Dispose();
        // блокировка нужна
        if(!disposed) {
            lock(this) {
                if(!disposed) { 
                    CloseHandle(handle);
                    handle = IntPtr.Zero;
                    disposed = true;         
                }
            }
        }
    }
}