CompositeTransaction.cs

using System;
using System.Threading.Tasks;
 
namespace Waher.Runtime.Transactions
{
    public class CompositeTransaction : Transaction
    {
        private readonly ITransaction[] transactions;
        private readonly bool parallel;
 
        public CompositeTransaction(Guid Id, bool Parallel, params ITransaction[] Transactions)
            : base(Id)
        {
            if (Transactions is null)
                throw new ArgumentNullException("Array of transactions cannot be null.");
 
            this.transactions = Transactions;
            this.parallel = Parallel;
        }
 
        protected override async Task<bool> DoPrepare()
        {
            if (this.parallel)
            {
                int i, c = this.transactions.Length;
                Task<bool>[] Tasks = new Task<bool>[c];
 
                for (i = 0; i < c; i++)
                    Tasks[i] = this.transactions[i].Prepare();
 
                await Task.WhenAll(Tasks);
 
                return And(Tasks);
            }
            else
            {
                foreach (ITransaction Transaction in this.transactions)
                {
                    if (!await Transaction.Prepare())
                        return false;
                }
 
                return true;
            }
        }
 
        private static bool And(Task<bool>[] Tasks)
        {
            foreach (Task<bool> Task in Tasks)
            {
                if (!Task.Result)
                    return false;
            }
 
            return true;
        }
 
        protected override async Task<bool> DoExecute()
        {
            if (this.parallel)
            {
                int i, c = this.transactions.Length;
                Task<bool>[] Tasks = new Task<bool>[c];
 
                for (i = 0; i < c; i++)
                    Tasks[i] = this.transactions[i].Execute();
 
                await Task.WhenAll(Tasks);
 
                return And(Tasks);
            }
            else
            {
                foreach (ITransaction Transaction in this.transactions)
                {
                    if (!await Transaction.Execute())
                        return false;
                }
 
                return true;
            }
        }
 
        protected override async Task<bool> DoCommit()
        {
            if (this.parallel)
            {
                int i, c = this.transactions.Length;
                Task<bool>[] Tasks = new Task<bool>[c];
 
                for (i = 0; i < c; i++)
                    Tasks[i] = this.transactions[i].Commit();
 
                await Task.WhenAll(Tasks);
 
                return And(Tasks);
            }
            else
            {
                foreach (ITransaction Transaction in this.transactions)
                {
                    if (!await Transaction.Commit())
                        return false;
                }
 
                return true;
            }
        }
 
        protected override async Task<bool> DoRollback()
        {
            if (this.parallel)
            {
                int i, c = this.transactions.Length;
                Task[] Tasks = new Task[c];
 
                for (i = 0; i < c; i++)
                    Tasks[i] = this.transactions[i].Abort();
 
                await Task.WhenAll(Tasks);
            }
            else
            {
                foreach (ITransaction Transaction in this.transactions)
                    await Transaction.Abort();
            }
 
            return true;
        }
    }
}