public LockTransactionContractBundle(IContractBundle contractBundle, LockOrder lockOrder = LockOrder.Unknown, ILockTransactionMember[] transactionMembers = null)
     :this(contractBundle.Preconditions,
           contractBundle.PostconditionsOnReturn,
           contractBundle.PostconditionsOnThrow,
           contractBundle.InstanceValidations,
           contractBundle.ThreadCountRestriction,
           contractBundle.ThreadCountRestrictionTimeout,
           contractBundle.ThreadWaitHandleSignalRestriction,
           contractBundle.ThreadWaitHandleSignalRestrictionTimeout,
           transactionMembers,
           lockOrder)
 {
                
 }
 public LockTransactionContractBundle(IImmutableQueue<IContractCondition> preconditions = null,
                                      IImmutableQueue<IContractCondition> postconditionsOnReturn = null,
                                      IImmutableQueue<IContractCondition> postconditionsOnThrow = null,
                                      IImmutableQueue<Action> instanceValidations = null,
                                      int threadCountRestriction = 0,
                                      WaitTimeout? threadCountRestrictionTimeout = null,
                                      WaitHandle threadWaitHandleSignalRestriction = null,
                                      WaitTimeout? threadWaitHandleSignalRestrictionTimeout = null,
                                      ILockTransactionMember[] transactionMembers = null,
                                      LockOrder lockOrder = Runtime.LockOrder.Unknown)
     :base(preconditions,
           postconditionsOnReturn,
           postconditionsOnThrow,
           instanceValidations,
           threadCountRestriction, 
           threadCountRestrictionTimeout,
           threadWaitHandleSignalRestriction,
           threadWaitHandleSignalRestrictionTimeout)
 {
     this.transactionMembers = transactionMembers.DefaultIfNull();
     this.lockOrder = lockOrder;
 }
 private static IEnumerable<ILockTransactionMember> OrderLocksBy(ILockTransactionMember[] members, LockOrder order)
 {
     switch(order)
     {
         case LockOrder.Default: return members.OrderBy(x => x.Id);
         case LockOrder.ParameterOrder: return members;
         default:
             throw new ArgumentOutOfRangeException("order", order, "Lock order for transaction is unknown or invalid");
     }
 }