public void AddError(IActivityDescriptor descriptor, [NotNull] string errorMessage)
{
descriptor.AssertNotNull("descriptor != null");
errorMessage.AssertNotNullOrEmpty("Error message cannot be null or empty");
myErrors.Add(new ValidationError(descriptor.Id, descriptor.Name, errorMessage));
}
private void CheckForMultipleInitializers(IActivityDescriptor descriptor)
{
if (descriptor.PropertyBindings.Count == 0)
{
return;
}
var bindings = descriptor.PropertyBindings;
for (int current = 1; current < bindings.Count; ++current)
{
var currentProperty = bindings[current].PropertyName;
for (int beforeCurrent = 0; beforeCurrent < current; ++beforeCurrent)
{
var beforeCurrentProperty = bindings[beforeCurrent].PropertyName;
if (currentProperty == beforeCurrentProperty)
{
var message =
"Multiple initializers of the property " +
$"{descriptor.ActivityType.Name}.{currentProperty}";
Result.AddError(descriptor, message);
break;
}
}
}
}
public static void Add(IActivityDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
descriptors.Insert(0, descriptor);
}
public static void Add(IActivityDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
descriptors.Insert(0, descriptor);
}
private void CheckRequiredInitializers(IActivityDescriptor descriptor)
{
var bindings = descriptor.PropertyBindings;
var requiredProperties = descriptor.ActivityType.GetRequiredProperties();
foreach (var requiredProperty in requiredProperties)
{
bool hasInitializer = bindings.Any(binding => requiredProperty == binding.PropertyName);
if (!hasInitializer)
{
var message =
"No initializer of the property " +
$"{descriptor.ActivityType.Name}.{requiredProperty}";
Result.AddError(descriptor, message);
}
}
}
public Task VisitForkJoin(ForkJoinNode forkJoinNode)
{
forkJoinNode.AssertNotNull("forkJoinNode != null");
var activities = new InjectableObjectsCollection <IActivity>(forkJoinNode.Forks.Count);
try
{
foreach (IActivityDescriptor fork in forkJoinNode.Forks)
{
IActivityDescriptor temp = fork;
IActivity activity = activities.Add(temp.ActivityType, ServiceProvider);
temp.ExecuteInitializersFor(activity);
Log.Info("At node: {0}. Fork created: {1}", forkJoinNode, activity);
}
Task <object>[] tasks = activities.ConvertInstances(a => a.Execute());
Task <object[]> task = tasks.WhenAll();
Log.Info("At node: {0}. Forks started", forkJoinNode);
Task <Task> continuation = task.ContinueWith(t =>
{
forkJoinNode.OnForksJoined(tasks, task);
// ReSharper disable once AccessToDisposedClosure
activities.Dispose();
return(ExecuteNextNode(forkJoinNode, t));
}, myScheduler);
return(continuation.Unwrap());
}
catch (Exception)
{
activities.Dispose();
throw;
}
}
public WellKnownDescriptorContainer()
{
var wellKnownDescriptors = new IActivityDescriptor[]
{
new SequenceDescriptor(),
new IfDescriptor(),
new WhileDescriptor(),
new DoWhileDescriptor(),
new WriteLineDescriptor(),
new TraceDescriptor(),
new UserTaskDescriptor(),
new SwitchDescriptor(),
new ForeachDescriptor(),
new AssignDescriptor(),
new PickDescriptor(),
new ParallelDescriptor(),
new StateMachineDescriptor(),
};
foreach (var wellKnownDescriptor in wellKnownDescriptors)
{
_descriptors.Add(wellKnownDescriptor.Name, wellKnownDescriptor);
}
}
public static void Remove(IActivityDescriptor descriptor)
{
descriptors.Remove(descriptor);
}
private void CheckActivityBindings(IActivityDescriptor descriptor)
{
CheckForMultipleInitializers(descriptor);
CheckRequiredInitializers(descriptor);
}
public bool Add(IActivityDescriptor descriptor)
{
return(_descriptors.TryAdd(descriptor.Name, descriptor));
}
public static void Remove(IActivityDescriptor descriptor)
{
descriptors.Remove(descriptor);
}
