CloneSet989

src/NHibernate/AdoNet/AbstractBatcher.cs

src/NHibernate/Driver/NHybridDataReader.cs

                /// <summary>
                /// Finalizer that ensures the object is correctly disposed of.
                /// </summary>
                ~AbstractBatcher()
                {
                        // Don't log in the finalizer, it causes problems
                        // if the output stream is finalized before the batcher.
                        //log.Debug( "running BatcherImpl.Dispose(false)" );
                        Dispose(false);
                }

                /// <summary>
                /// Takes care of freeing the managed and unmanaged resources that 
                /// this class is responsible for.
                /// </summary>
                public void Dispose()
                {
                        log.Debug("running BatcherImpl.Dispose(true)");
                        Dispose(true);
                }

                /// <summary>
                /// Takes care of freeing the managed and unmanaged resources that 
                /// this class is responsible for.
                /// </summary>
                /// <param name="isDisposing">Indicates if this BatcherImpl is being Disposed of or Finalized.</param>
                /// <remarks>
                /// If this BatcherImpl is being Finalized (<c>isDisposing==false</c>) then make sure not
                /// to call any methods that could potentially bring this BatcherImpl back to life.
                /// </remarks>
                protected virtual void Dispose(bool isDisposing)
                {
                        if (_isAlreadyDisposed)
                        {
                                // don't dispose of multiple times.
                                return;
                        }

                        // free managed resources that are being managed by the AdoTransaction if we
                        // know this call came through Dispose()
                        if (isDisposing)
                        {
                                CloseCommands();
                        }

                        // free unmanaged resources here

                        _isAlreadyDisposed = true;
                        // nothing for Finalizer to do - so tell the GC to ignore it
                        GC.SuppressFinalize(this );
                }

                /// <summary>
                /// Finalizer that ensures the object is correctly disposed of.
                /// </summary>
                ~NHybridDataReader()
                {
                        Dispose(false);
                }

                /// <summary>
                /// Takes care of freeing the managed and unmanaged resources that 
                /// this class is responsible for.
                /// </summary>
                public void Dispose()
                {
                        log.Debug("running NHybridDataReader.Dispose()");
                        Dispose(true);
                }

                /// <summary>
                /// Takes care of freeing the managed and unmanaged resources that 
                /// this class is responsible for.
                /// </summary>
                /// <param name="isDisposing">Indicates if this NHybridDataReader is being Disposed of or Finalized.</param>
                /// <remarks>
                /// If this NHybridDataReader is being Finalized (<c>isDisposing==false</c>) then make sure not
                /// to call any methods that could potentially bring this NHybridDataReader back to life.
                /// </remarks>
                protected virtual void Dispose(bool isDisposing)
                {
                        if (_isAlreadyDisposed)
                        {
                                // don't dispose of multiple times.
                                return;
                        }

                        // free managed resources that are being managed by the NHybridDataReader if we
                        // know this call came through Dispose()
                        if (isDisposing)
                        {
                                _reader.Dispose();
                        }

                        // free unmanaged resources here

                        _isAlreadyDisposed = true;
                        // nothing for Finalizer to do - so tell the GC to ignore it
                        GC.SuppressFinalize(this );
                }

/// <summary>
/// Finalizer that ensures the object is correctly disposed of.
/// </summary>
~ [[#variable573e3b20]]()
{
   // Don't log in the finalizer, it causes problems
   // if the output stream is finalized before the batcher.
   //log.Debug( "running BatcherImpl.Dispose(false)" );
   Dispose(false);
}

/// <summary>
/// Takes care of freeing the managed and unmanaged resources that 
/// this class is responsible for.
/// </summary>
public void Dispose()
{
   log.Debug( [[#variable54b1eea0]]);
   Dispose(true);
}

/// <summary>
/// Takes care of freeing the managed and unmanaged resources that 
/// this class is responsible for.
/// </summary>
/// <param name="isDisposing">Indicates if this BatcherImpl is being Disposed of or Finalized.</param>
/// <param name="isDisposing">Indicates if this NHybridDataReader is being Disposed of or Finalized.</param>
/// <remarks>
/// If this BatcherImpl is being Finalized (<c>isDisposing==false</c>) then make sure not
/// to call any methods that could potentially bring this BatcherImpl back to life.
/// If this NHybridDataReader is being Finalized (<c>isDisposing==false</c>) then make sure not
/// to call any methods that could potentially bring this NHybridDataReader back to life.
/// </remarks>
protected virtual void Dispose(bool isDisposing)
{
   if (_isAlreadyDisposed)
   {
      // don't dispose of multiple times.
      return;
   }
   // free managed resources that are being managed by the AdoTransaction if we
   // free managed resources that are being managed by the NHybridDataReader if we
   // know this call came through Dispose()
   if (isDisposing)
   {
       [[#variable5e425b80]]();
   }
   // free unmanaged resources here
   _isAlreadyDisposed = true;
   // nothing for Finalizer to do - so tell the GC to ignore it
   GC.SuppressFinalize(this );
}

 

AbstractBatcher 

NHybridDataReader 

"running BatcherImpl.Dispose(true)" 

"running NHybridDataReader.Dispose()" 

CloseCommands 

_reader.Dispose