public static ValidationResults Validate(Activity toValidate, ValidationSettings settings)
{
if (toValidate == null)
{
throw FxTrace.Exception.ArgumentNull(nameof(toValidate));
}
if (settings == null)
{
throw FxTrace.Exception.ArgumentNull(nameof(settings));
}
if (toValidate.HasBeenAssociatedWithAnInstance)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RootActivityAlreadyAssociatedWithInstance(toValidate.DisplayName)));
}
if (settings.PrepareForRuntime && (settings.SingleLevel || settings.SkipValidatingRootConfiguration || settings.OnlyUseAdditionalConstraints))
{
throw FxTrace.Exception.Argument(nameof(settings), SR.InvalidPrepareForRuntimeValidationSettings);
}
InternalActivityValidationServices validator = new InternalActivityValidationServices(settings, toValidate);
return(validator.InternalValidate());
}
public static ProcessActivityTreeOptions GetValidationOptions(ValidationSettings settings)
{
if (settings.SingleLevel)
{
return SingleLevelValidationOptions;
}
return ValidationOptions;
}
public ValidationResults Validate(ValidationSettings settings)
{
if (this.workflowService != null)
{
return this.workflowService.Validate(settings);
}
else
{
return ActivityValidationServices.Validate(this.activity, settings);
}
}
public static ValidationResults Validate(Activity toValidate, ValidationSettings settings)
{
if (toValidate == null)
{
throw FxTrace.Exception.ArgumentNull("toValidate");
}
if (settings == null)
{
throw FxTrace.Exception.ArgumentNull("settings");
}
if (toValidate.HasBeenAssociatedWithAnInstance)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RootActivityAlreadyAssociatedWithInstance(toValidate.DisplayName)));
}
InternalActivityValidationServices services = new InternalActivityValidationServices(settings, toValidate);
return(services.InternalValidate());
}
static void Main()
{
Sequence wf = new Sequence
{
Activities =
{
new If
{
Condition = true
},
new Pick
{
Branches =
{
new PickBranch
{
Trigger = new WriteLine
{
Text = "When this completes..."
},
Action = new WriteLine
{
Text = "... do this."
}
}
}
}
}
};
// ValidationSettings enables the host to customize the behavior of ActivityValidationServices.Validate.
ValidationSettings validationSettings = new ValidationSettings
{
// AdditionalConstraints enables the host to add specific validation logic (a constraint) to a specify type of activity in the Workflow.
AdditionalConstraints =
{
{typeof(If), new List<Constraint> {ConstraintsLibrary.ConstraintError_IfShouldHaveThenOrElse()}},
{typeof(Pick), new List<Constraint> {ConstraintsLibrary.ConstraintWarning_PickHasOneBranch()}}
}
};
ValidationResults results = ActivityValidationServices.Validate(wf, validationSettings);
PrintResults(results);
}
static void Main(string[] args)
{
//Create a WF with configuration errors
Sequence wf = new Sequence()
{
Activities =
{
new Sequence
{
DisplayName = "Sequence1"
},
new If
{
DisplayName = "If",
Condition = new InArgument<bool>(true)
},
new Switch<bool>
{
DisplayName = "Switch1",
Expression = new InArgument<bool>(true),
Default = new WriteLine()
},
new ForEach<int>
{
DisplayName = "ForEach2",
Values = new InArgument<IEnumerable<int>>((env) => new int[] { 1, 2, 3 })
},
new Parallel
{
DisplayName = "Parallel1"
},
new ParallelForEach<int>
{
DisplayName = "ParallelForEach1",
Values = new InArgument<IEnumerable<int>>((env) => new int[] { 1, 2, 3 })
},
new Pick
{
DisplayName = "Pick1",
Branches =
{
new PickBranch
{
Action = new WriteLine()
}
}
},
new Pick
{
DisplayName = "Pick2"
},
new WriteLine
{
DisplayName = "Wr"
}
}
};
//Create an instance of Validation Settings.
ValidationSettings settings = new ValidationSettings()
{
//Create value pairs constraints and activity types. We are providing a list of constraints that you want to apply on a specify activity type
AdditionalConstraints =
{
{typeof(Activity), new List<Constraint> {ConstraintLibrary.ActivityDisplayNameIsNotSetWarning()}},
{typeof(ForEach<int>), new List<Constraint> {ConstraintLibrary.ForEachPropertyMustBeSetError<int>()}},
{typeof(WriteLine), new List<Constraint> {ConstraintLibrary.WriteLineHasNoTextWarning()}},
{typeof(Pick), new List<Constraint> {ConstraintLibrary.PickHasNoBranchesWarning(), ConstraintLibrary.PickHasOneBranchWarning()}},
{typeof(Parallel), new List<Constraint> {ConstraintLibrary.ParallelHasNoBranchesWarning()}},
{typeof(Switch<bool>), new List<Constraint> {ConstraintLibrary.SwitchHasDefaultButNoCasesWarning<bool>(), ConstraintLibrary.SwitchHasNoCasesOrDefaultWarning<bool>()}},
{typeof(If), new List<Constraint> {ConstraintLibrary.IfShouldHaveThenOrElseError()}},
{typeof(Sequence), new List<Constraint> {ConstraintLibrary.SequenceIsEmptyWarning()}}
}
};
//Call the Validate method with the workflow you want to validate, and the settings you want to use.
ValidationResults results = ActivityValidationServices.Validate(wf, settings);
//Print the validation errors and warning that were generated my ActivityValidationServices.Validate.
PrintResults(results);
}
internal InternalActivityValidationServices(ValidationSettings settings, Activity toValidate)
{
this.settings = settings;
this.rootToValidate = toValidate;
this.environment = settings.Environment;
}
private void ValidateWorkflowInternal(Activity workflow, string runtimeAssembly, PSWorkflowValidationResults validationResults)
{
Tracer.WriteMessage(Facility + "Validating a workflow.");
_structuredTracer.WorkflowValidationStarted(Guid.Empty);
ValidationSettings validationSettings = new ValidationSettings
{
AdditionalConstraints =
{
{ typeof(Activity), new List<Constraint> { ValidateActivitiesConstraint(runtimeAssembly, validationResults)} }
}
};
try
{
validationResults.Results = ActivityValidationServices.Validate(workflow, validationSettings);
}
catch (Exception e)
{
Tracer.TraceException(e);
ValidationException exception = new ValidationException(Resources.ErrorWhileValidatingWorkflow, e);
throw exception;
}
_structuredTracer.WorkflowValidationFinished(Guid.Empty);
}
public static ProcessActivityTreeOptions GetValidationOptions(ValidationSettings settings)
{
ProcessActivityTreeOptions result = null;
if (settings.SkipValidatingRootConfiguration && settings.SingleLevel)
{
result = ProcessActivityTreeOptions.SingleLevelSkipRootConfigurationValidationOptions;
}
else if (settings.SkipValidatingRootConfiguration)
{
result = ProcessActivityTreeOptions.SkipRootConfigurationValidationOptions;
}
else if (settings.SingleLevel)
{
result = ProcessActivityTreeOptions.SingleLevelValidationOptions;
}
else if (settings.PrepareForRuntime)
{
Fx.Assert(!settings.SkipValidatingRootConfiguration && !settings.SingleLevel && !settings.OnlyUseAdditionalConstraints, "PrepareForRuntime cannot be set at the same time any of the three is set.");
result = ProcessActivityTreeOptions.ValidationAndPrepareForRuntimeOptions;
}
else
{
result = ProcessActivityTreeOptions.ValidationOptions;
}
if (settings.CancellationToken == CancellationToken.None)
{
return result;
}
else
{
return AttachCancellationToken(result, settings.CancellationToken);
}
}
internal InternalActivityValidationServices(ValidationSettings settings, Activity toValidate)
{
this.settings = settings;
this.rootToValidate = toValidate;
}
public static ValidationResults Validate(Activity toValidate, ValidationSettings settings)
{
if (toValidate == null)
{
throw FxTrace.Exception.ArgumentNull("toValidate");
}
if (settings == null)
{
throw FxTrace.Exception.ArgumentNull("settings");
}
if (toValidate.HasBeenAssociatedWithAnInstance)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.RootActivityAlreadyAssociatedWithInstance(toValidate.DisplayName)));
}
InternalActivityValidationServices services = new InternalActivityValidationServices(settings, toValidate);
return services.InternalValidate();
}
internal InternalActivityValidationServices(ValidationSettings settings, Activity toValidate)
{
this.settings = settings;
this.rootToValidate = toValidate;
}
internal ValidationService(EditingContext context, TaskDispatcher validationTaskDispatcher)
{
Fx.Assert(validationTaskDispatcher != null, "validationTaskDispatcher cannot be null.");
this.validationTaskDispatcher = validationTaskDispatcher;
this.context = context;
this.settings = new ValidationSettings { SkipValidatingRootConfiguration = true };
this.context.Services.Subscribe<ModelService>(new SubscribeServiceCallback<ModelService>(OnModelServiceAvailable));
this.context.Services.Subscribe<ModelSearchService>(new SubscribeServiceCallback<ModelSearchService>(OnModelSearchServiceAvailable));
this.context.Services.Subscribe<ObjectReferenceService>(new SubscribeServiceCallback<ObjectReferenceService>(OnObjectReferenceServiceAvailable));
this.context.Services.Subscribe<ModelTreeManager>(new SubscribeServiceCallback<ModelTreeManager>(OnModelTreeManagerAvailable));
this.context.Services.Subscribe<IValidationErrorService>(new SubscribeServiceCallback<IValidationErrorService>(OnErrorServiceAvailable));
this.context.Services.Subscribe<AttachedPropertiesService>(new SubscribeServiceCallback<AttachedPropertiesService>(OnAttachedPropertiesServiceAvailable));
AssemblyName currentAssemblyName = Assembly.GetExecutingAssembly().GetName();
StringBuilder validationKeyPath = new StringBuilder(90);
validationKeyPath.Append(ValidationRegKeyInitialPath);
validationKeyPath.AppendFormat("{0}{1}{2}", "v", currentAssemblyName.Version.ToString(), "\\");
validationKeyPath.Append(currentAssemblyName.Name);
RegistryKey validationRegistryKey = Registry.CurrentUser.OpenSubKey(validationKeyPath.ToString());
if (validationRegistryKey != null)
{
object value = validationRegistryKey.GetValue(ValidationRegKeyName);
this.isValidationDisabled = (value != null && string.Equals("1", value.ToString()));
validationRegistryKey.Close();
}
}
private void ValidateWorkflowInternal(Activity workflow, string runtimeAssembly, PSWorkflowValidationResults validationResults)
{
PSWorkflowValidator.Tracer.WriteMessage(string.Concat(PSWorkflowValidator.Facility, "Validating a workflow."));
PSWorkflowValidator._structuredTracer.WorkflowValidationStarted(Guid.Empty);
ValidationSettings validationSetting = new ValidationSettings();
List<Constraint> constraints = new List<Constraint>();
constraints.Add(this.ValidateActivitiesConstraint(runtimeAssembly, validationResults));
validationSetting.AdditionalConstraints.Add(typeof(Activity), constraints);
ValidationSettings validationSetting1 = validationSetting;
try
{
validationResults.Results = ActivityValidationServices.Validate(workflow, validationSetting1);
}
catch (Exception exception1)
{
Exception exception = exception1;
PSWorkflowValidator.Tracer.TraceException(exception);
new ValidationException(Resources.ErrorWhileValidatingWorkflow, exception);
throw exception;
}
PSWorkflowValidator._structuredTracer.WorkflowValidationFinished(Guid.Empty);
}
