TransactionalDataPortal.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="TransactionalDataPortal.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Implements the server-side Serviced </summary>
//-----------------------------------------------------------------------
using System;
using System.Threading.Tasks;
using System.Transactions;
 
namespace Csla.Server
{
  public class TransactionalDataPortal : IDataPortalServer
  {
    private readonly DataPortalBroker _portal;
    private readonly TransactionalAttribute _transactionalAttribute;
 
    public TransactionalDataPortal(DataPortalBroker dataPortalBroker, TransactionalAttribute transactionalAttribute)
    {
      _portal = dataPortalBroker;
      _transactionalAttribute = transactionalAttribute;
    }
 
    public async Task<DataPortalResult> Create(
      Type objectType, object criteria, DataPortalContext context, bool isSync)
    {
      DataPortalResult result;
      using (TransactionScope tr = CreateTransactionScope())
      {
        result = await _portal.Create(objectType, criteria, context, isSync).ConfigureAwait(false);
        tr.Complete();
      }
      return result;
    }
 
    private TransactionScope CreateTransactionScope()
    {
      return new TransactionScope(TransactionScopeOption.Required, GetTransactionOptions(), _transactionalAttribute.AsyncFlowOption);
    }
 
    private TransactionOptions GetTransactionOptions()
    {
      var option = new TransactionOptions
                     {
                       IsolationLevel = GetIsolationLevel(_transactionalAttribute.TransactionIsolationLevel),
                       Timeout = TimeSpan.FromSeconds(_transactionalAttribute.TimeoutInSeconds)
                     };
      return option;
    }
 
    private IsolationLevel GetIsolationLevel(TransactionIsolationLevel transactionIsolationLevel)
    {
      switch (transactionIsolationLevel)
      {
        case TransactionIsolationLevel.Unspecified:
          return IsolationLevel.Unspecified;
        case TransactionIsolationLevel.Serializable:
          return IsolationLevel.Serializable;
        case TransactionIsolationLevel.RepeatableRead:
          return IsolationLevel.RepeatableRead;
        case TransactionIsolationLevel.ReadCommitted:
          return IsolationLevel.ReadCommitted;
        case TransactionIsolationLevel.ReadUncommitted:
          return IsolationLevel.ReadUncommitted;
        default:
          return IsolationLevel.Unspecified;
      }
    }
 
    public async Task<DataPortalResult> Fetch(Type objectType, object criteria, DataPortalContext context, bool isSync)
    {
      DataPortalResult result;
      using (TransactionScope tr = CreateTransactionScope())
      {
        result = await _portal.Fetch(objectType, criteria, context, isSync).ConfigureAwait(false);
        tr.Complete();
      }
      return result;
    }
 
    public async Task<DataPortalResult> Update(object obj, DataPortalContext context, bool isSync)
    {
      DataPortalResult result;
      using (TransactionScope tr = CreateTransactionScope())
      {
        result = await _portal.Update(obj, context, isSync).ConfigureAwait(false);
        tr.Complete();
      }
      return result;
    }
 
    public async Task<DataPortalResult> Delete(Type objectType, object criteria, DataPortalContext context, bool isSync)
    {
      DataPortalResult result;
      using (TransactionScope tr = CreateTransactionScope())
      {
        result = await _portal.Delete(objectType, criteria, context, isSync).ConfigureAwait(false);
        tr.Complete();
      }
      return result;
    }
  }
}