[C#] C #에서 Finalize / Dispose 메서드 사용

IDisposable 구현은 아래 패턴 (IMHO)을 따라야합니다. 나는 몇 가지 뛰어난 .NET “신들”의 정보를 기반으로이 패턴을 .NET Framework 설계 지침 (MSDN은 어떤 이유로 든 따르지 않음에 유의)을 개발했다. .NET Framework 디자인 지침은 Krzysztof Cwalina (당시 CLR 설계자)와 Brad Abrams (당시 CLR 프로그램 관리자라고 생각 함) 및 Bill Wagner ([Effective C #] 및 [More Effective C #])가 작성했습니다. Amazon.com에서 다음을 찾으십시오.

클래스에 관리되지 않는 리소스를 직접 포함 (상속하지 않음)하지 않는 한 Finalizer를 구현해서는 안됩니다. 클래스에서 Finalizer를 구현 한 후에는 호출되지 않더라도 추가 컬렉션을 위해 라이브를 보장합니다. 단일 스레드에서 실행되는 Finalization Queue에 자동으로 배치됩니다. 또한 매우 중요한 참고 사항 … Finalizer 내에서 실행되는 모든 코드 (하나를 구현해야 함)는 스레드 안전하고 예외 안전해야합니다! 나쁜 일은 그렇지 않으면 일어날 것입니다 … (즉, 결정되지 않은 동작과 예외의 경우 치명적인 복구 할 수없는 응용 프로그램 충돌).

내가 결합하고 코드 스 니펫을 작성한 패턴은 다음과 같습니다.

#region IDisposable implementation

//TODO remember to make this class inherit from IDisposable -> $className$ : IDisposable

// Default initialization for a bool is 'false'
private bool IsDisposed { get; set; }

/// <summary>
/// Implementation of Dispose according to .NET Framework Design Guidelines.
/// </summary>
/// <remarks>Do not make this method virtual.
/// A derived class should not be able to override this method.
/// </remarks>
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.

    // Always use SuppressFinalize() in case a subclass
    // of this type implements a finalizer.
    GC.SuppressFinalize( this );
}

/// <summary>
/// Overloaded Implementation of Dispose.
/// </summary>
/// <param name="isDisposing"></param>
/// <remarks>
/// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
/// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.</item>
/// <item>If <paramref name="isDisposing"/> 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.</item></list></para>
/// </remarks>
protected virtual void Dispose( bool isDisposing )
{
    // TODO If you need thread safety, use a lock around these 
    // operations, as well as in your methods that use the resource.
    try
    {
        if( !this.IsDisposed )
        {
            if( isDisposing )
            {
                // TODO Release all managed resources here

                $end$
            }

            // TODO Release all unmanaged resources here



            // TODO explicitly set root references to null to expressly tell the GarbageCollector
            // that the resources have been disposed of and its ok to release the memory allocated for them.


        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );

        this.IsDisposed = true;
    }
}

//TODO Uncomment this code if this class will contain members which are UNmanaged
// 
///// <summary>Finalizer for $className$</summary>
///// <remarks>This finalizer will run only if the Dispose method does not get called.
///// It gives your base class the opportunity to finalize.
///// DO NOT provide finalizers in types derived from this class.
///// All code executed within a Finalizer MUST be thread-safe!</remarks>
//  ~$className$()
//  {
//     Dispose( false );
//  }
#endregion IDisposable implementation

다음은 파생 클래스에서 IDisposable을 구현하기위한 코드입니다. 파생 클래스 정의에 IDisposable의 상속을 명시 적으로 나열 할 필요는 없습니다.

public DerivedClass : BaseClass, IDisposable (remove the IDisposable because it is inherited from BaseClass)


protected override void Dispose( bool isDisposing )
{
    try
    {
        if ( !this.IsDisposed )
        {
            if ( isDisposing )
            {
                // Release all managed resources here

            }
        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );
    }
}

이 구현을 내 블로그에 게시했습니다. 폐기 패턴을 올바르게 구현하는 방법

답변

using (Var conn = Factory.MakeConnection())
{
     conn.Query(....);
}

Factory.DoWithConnection((conn)=>
{
    conn.Query(...);
}

void DoWithConnection(Action<SqlConnection> action)
{
   using (var conn = MakeConnection())
   {
       action(conn);
   }
}