public void CheckpointInstanceState(System.Workflow.ComponentModel.Activity atomicActivity) { TransactionOptions transactionOptions = new TransactionOptions(); WorkflowTransactionOptions options2 = TransactedContextFilter.GetTransactionOptions(atomicActivity); transactionOptions.IsolationLevel = options2.IsolationLevel; if (transactionOptions.IsolationLevel == IsolationLevel.Unspecified) { transactionOptions.IsolationLevel = IsolationLevel.Serializable; } transactionOptions.Timeout = options2.TimeoutDuration; TransactionalProperties properties = new TransactionalProperties(); atomicActivity.SetValue(WorkflowExecutor.TransactionalPropertiesProperty, properties); this.ServiceProvider.CreateTransaction(transactionOptions); this.currentAtomicActivity = atomicActivity; this.scheduler.Pause(); }
public void CheckpointInstanceState(Activity atomicActivity) { // Note that the WF4 runtime does not create checkpoints. If the transaction aborts, the workflow aborts. // We are following the WF4 behavior and not creating a checkpoint. TransactionOptions tranOpts = new TransactionOptions(); WorkflowTransactionOptions atomicTxn = TransactedContextFilter.GetTransactionOptions(atomicActivity); tranOpts.IsolationLevel = atomicTxn.IsolationLevel; if (tranOpts.IsolationLevel == IsolationLevel.Unspecified) { tranOpts.IsolationLevel = IsolationLevel.Serializable; } tranOpts.Timeout = atomicTxn.TimeoutDuration; TransactionalProperties transactionProperties = new TransactionalProperties(); atomicActivity.SetValue(WorkflowExecutor.TransactionalPropertiesProperty, transactionProperties); this.ServiceProvider.CreateTransaction(tranOpts); this.currentAtomicActivity = atomicActivity; this.scheduler.Pause(); }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection errors = base.Validate(manager, obj); Activity activity = obj as Activity; if (activity == null) { throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(Activity).FullName }), "obj"); } WorkflowTransactionOptions transactionOptions = TransactedContextFilter.GetTransactionOptions(activity); if (transactionOptions != null) { if (FaultAndCancellationHandlingFilter.GetFaultHandlers(activity) != null) { ValidationError item = new ValidationError(SR.GetString("Error_AtomicScopeWithFaultHandlersActivityDecl", new object[] { activity.Name }), 0x52c); errors.Add(item); } if (FaultAndCancellationHandlingFilter.GetCancellationHandler(activity) != null) { ValidationError error2 = new ValidationError(SR.GetString("Error_AtomicScopeWithCancellationHandlerActivity", new object[] { activity.Name }), 0x575); errors.Add(error2); } for (Activity activity4 = activity.Parent; activity4 != null; activity4 = activity4.Parent) { if (activity4.SupportsTransaction) { errors.Add(new ValidationError(SR.GetString("Error_AtomicScopeNestedInNonLRT"), 0x52e)); break; } } Queue <Activity> queue = new Queue <Activity>(Helpers.GetAllEnabledActivities((CompositeActivity)activity)); while (queue.Count > 0) { Activity activity5 = queue.Dequeue(); if (activity5.PersistOnClose) { errors.Add(new ValidationError(SR.GetString("Error_LRTScopeNestedInNonLRT"), 0x52f)); break; } if (activity5 is ICompensatableActivity) { errors.Add(new ValidationError(SR.GetString("Error_NestedCompensatableActivity", new object[] { activity5.QualifiedName }), 0x1a6)); break; } if (activity5 is CompositeActivity) { foreach (Activity activity6 in Helpers.GetAllEnabledActivities((CompositeActivity)activity5)) { queue.Enqueue(activity6); } } } if (transactionOptions.TimeoutDuration.Ticks < 0L) { ValidationError error3 = new ValidationError(SR.GetString("Error_NegativeValue", new object[] { transactionOptions.TimeoutDuration.ToString(), "TimeoutDuration" }), 0x531) { PropertyName = "TimeoutDuration" }; errors.Add(error3); } } return(errors); }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection validationErrors = base.Validate(manager, obj); Activity activity = obj as Activity; if (activity == null) { throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(Activity).FullName), "obj"); } WorkflowTransactionOptions atomicTransaction = TransactedContextFilter.GetTransactionOptions(activity); if (atomicTransaction != null) { // Atomic scopes can't have exception handlers. CompositeActivity exceptionHandlers = FaultAndCancellationHandlingFilter.GetFaultHandlers(activity); if (exceptionHandlers != null) { ValidationError error = new ValidationError(SR.GetString(SR.Error_AtomicScopeWithFaultHandlersActivityDecl, activity.Name), ErrorNumbers.Error_AtomicScopeWithFaultHandlersActivityDecl); validationErrors.Add(error); } // Atomic scopes can't have cancel handlers. Activity cancellationHandler = FaultAndCancellationHandlingFilter.GetCancellationHandler(activity); if (cancellationHandler != null) { ValidationError error = new ValidationError(SR.GetString(SR.Error_AtomicScopeWithCancellationHandlerActivity, activity.Name), ErrorNumbers.Error_AtomicScopeWithCancellationHandlerActivity); validationErrors.Add(error); } // check that this transaction scope is not nested inside another transaction scope Activity parent = activity.Parent; while (parent != null) { if (parent.SupportsTransaction) { validationErrors.Add(new ValidationError(SR.GetString(SR.Error_AtomicScopeNestedInNonLRT), ErrorNumbers.Error_AtomicScopeNestedInNonLRT)); break; } parent = parent.Parent; } // check that an activity with PersistOnClose/SupportsTransaction/ICompensatableActivity attribute is not nested inside the transaction scope Queue <Activity> nestedEnabledActivities = new Queue <Activity>(Helpers.GetAllEnabledActivities((CompositeActivity)activity)); while (nestedEnabledActivities.Count > 0) { Activity nestedEnabledActivity = nestedEnabledActivities.Dequeue(); if (nestedEnabledActivity.PersistOnClose) { validationErrors.Add(new ValidationError(SR.GetString(SR.Error_LRTScopeNestedInNonLRT), ErrorNumbers.Error_LRTScopeNestedInNonLRT)); break; } if (nestedEnabledActivity is ICompensatableActivity) { validationErrors.Add(new ValidationError(SR.GetString(SR.Error_NestedCompensatableActivity, nestedEnabledActivity.QualifiedName), ErrorNumbers.Error_NestedCompensatableActivity)); break; } if (nestedEnabledActivity is CompositeActivity) { foreach (Activity nestedEnabledActivity2 in Helpers.GetAllEnabledActivities((CompositeActivity)nestedEnabledActivity)) { nestedEnabledActivities.Enqueue(nestedEnabledActivity2); } } } // check timeout property if (atomicTransaction.TimeoutDuration.Ticks < 0) { ValidationError timeoutError = new ValidationError(SR.GetString(SR.Error_NegativeValue, new object[] { atomicTransaction.TimeoutDuration.ToString(), "TimeoutDuration" }), ErrorNumbers.Error_NegativeValue); timeoutError.PropertyName = "TimeoutDuration"; validationErrors.Add(timeoutError); } } return(validationErrors); }