DbTransaction.cs

Go to the documentation of this file.

using System.Threading;
using System.Threading.Tasks;
 
namespace System.Data.Common;
 
public abstract class DbTransaction : MarshalByRefObject, IDbTransaction, IDisposable, IAsyncDisposable
{
    public DbConnection? Connection => DbConnection;
 
    IDbConnection? IDbTransaction.Connection => DbConnection;
 
    protected abstract DbConnection? DbConnection { get; }
 
    public abstract IsolationLevel IsolationLevel { get; }
 
    public virtual bool SupportsSavepoints => false;
 
    public abstract void Commit();
 
    public virtual Task CommitAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled(cancellationToken);
        }
        try
        {
            Commit();
            return Task.CompletedTask;
        }
        catch (Exception exception)
        {
            return Task.FromException(exception);
        }
    }
 
    public void Dispose()
    {
        Dispose(disposing: true);
    }
 
    protected virtual void Dispose(bool disposing)
    {
    }
 
    public virtual ValueTask DisposeAsync()
    {
        Dispose();
        return default(ValueTask);
    }
 
    public abstract void Rollback();
 
    public virtual Task RollbackAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled(cancellationToken);
        }
        try
        {
            Rollback();
            return Task.CompletedTask;
        }
        catch (Exception exception)
        {
            return Task.FromException(exception);
        }
    }
 
    public virtual Task SaveAsync(string savepointName, CancellationToken cancellationToken = default(CancellationToken))
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled(cancellationToken);
        }
        try
        {
            Save(savepointName);
            return Task.CompletedTask;
        }
        catch (Exception exception)
        {
            return Task.FromException(exception);
        }
    }
 
    public virtual Task RollbackAsync(string savepointName, CancellationToken cancellationToken = default(CancellationToken))
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled(cancellationToken);
        }
        try
        {
            Rollback(savepointName);
            return Task.CompletedTask;
        }
        catch (Exception exception)
        {
            return Task.FromException(exception);
        }
    }
 
    public virtual Task ReleaseAsync(string savepointName, CancellationToken cancellationToken = default(CancellationToken))
    {
        if (cancellationToken.IsCancellationRequested)
        {
            return Task.FromCanceled(cancellationToken);
        }
        try
        {
            Release(savepointName);
            return Task.CompletedTask;
        }
        catch (Exception exception)
        {
            return Task.FromException(exception);
        }
    }
 
    public virtual void Save(string savepointName)
    {
        throw new NotSupportedException();
    }
 
    public virtual void Rollback(string savepointName)
    {
        throw new NotSupportedException();
    }
 
    public virtual void Release(string savepointName)
    {
    }
}