public RuntimeDelegateArgument(string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
if (string.IsNullOrEmpty(name))
{
throw FxTrace.Exception.ArgumentNullOrEmpty("name");
}
if (type == null)
{
throw FxTrace.Exception.ArgumentNull("type");
}
ArgumentDirectionHelper.Validate(direction, "direction");
if (boundArgument != null)
{
// Validations that the bound argument matches are done
// in CacheMetadata for ActivityDelegate.
boundArgument.Bind(this);
}
this.Name = name;
this.Type = type;
this.Direction = direction;
this.BoundArgument = boundArgument;
}
public RuntimeDelegateArgument (string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
Name = name;
Type = type;
Direction = direction;
BoundArgument = boundArgument;
}
public RuntimeDelegateArgument(string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
Name = name;
Type = type;
Direction = direction;
BoundArgument = boundArgument;
}
public static InArgument <T> FromDelegateArgument(DelegateArgument delegateArgument)
{
if (delegateArgument == null)
{
throw FxTrace.Exception.ArgumentNull("delegateArgument");
}
return(new InArgument <T>(delegateArgument));
}
public InArgument(DelegateArgument delegateArgument) : this()
{
if (delegateArgument != null)
{
DelegateArgumentValue <T> value2 = new DelegateArgumentValue <T> {
DelegateArgument = delegateArgument
};
this.Expression = value2;
}
}
public OutArgument(DelegateArgument delegateArgument) : this()
{
if (delegateArgument != null)
{
DelegateArgumentReference <T> reference = new DelegateArgumentReference <T> {
DelegateArgument = delegateArgument
};
this.Expression = reference;
}
}
public RuntimeDelegateArgument(string name, System.Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
if (string.IsNullOrEmpty(name))
{
throw FxTrace.Exception.ArgumentNullOrEmpty("name");
}
if (type == null)
{
throw FxTrace.Exception.ArgumentNull("type");
}
ArgumentDirectionHelper.Validate(direction, "direction");
if (boundArgument != null)
{
boundArgument.Bind(this);
}
this.Name = name;
this.Type = type;
this.Direction = direction;
this.BoundArgument = boundArgument;
}
internal bool InitializeRelationship(Activity parent, ActivityCollectionType collectionType, ref IList <ValidationError> validationErrors)
{
if (this.cacheId == parent.CacheId)
{
Activity owner = parent.MemberOf.Owner;
if (owner == null)
{
Activity activity2 = this.Handler;
if (activity2 == null)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedWithoutTargetNoHandler(parent.DisplayName, this.owner.DisplayName), false, parent));
}
else
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedWithoutTarget(activity2.DisplayName, parent.DisplayName, this.owner.DisplayName), false, parent));
}
return(false);
}
if (owner.Delegates.Contains(this) || owner.ImportedDelegates.Contains(this))
{
return(true);
}
Activity handler = this.Handler;
if (handler == null)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedNoHandler(parent.DisplayName, owner.DisplayName, this.owner.DisplayName), false, parent));
}
else
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferenced(handler.DisplayName, parent.DisplayName, owner.DisplayName, this.owner.DisplayName), false, parent));
}
return(false);
}
this.owner = parent;
this.cacheId = parent.CacheId;
this.parentCollectionType = collectionType;
this.InternalCacheMetadata();
LocationReferenceEnvironment implementationEnvironment = null;
if (collectionType == ActivityCollectionType.Implementation)
{
implementationEnvironment = parent.ImplementationEnvironment;
}
else
{
implementationEnvironment = parent.PublicEnvironment;
}
if (this.RuntimeDelegateArguments.Count > 0)
{
ActivityLocationReferenceEnvironment environment2 = new ActivityLocationReferenceEnvironment(implementationEnvironment);
implementationEnvironment = environment2;
for (int i = 0; i < this.RuntimeDelegateArguments.Count; i++)
{
RuntimeDelegateArgument argument = this.RuntimeDelegateArguments[i];
DelegateArgument boundArgument = argument.BoundArgument;
if (boundArgument != null)
{
if (boundArgument.Direction != argument.Direction)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RuntimeDelegateArgumentDirectionIncorrect, parent));
}
if (boundArgument.Type != argument.Type)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RuntimeDelegateArgumentTypeIncorrect, parent));
}
environment2.Declare(boundArgument, this.owner, ref validationErrors);
}
}
}
this.Environment = implementationEnvironment;
if (this.Handler != null)
{
return(this.Handler.InitializeRelationship(this, collectionType, ref validationErrors));
}
return(true);
}
internal bool InitializeRelationship(Activity parent, ActivityCollectionType collectionType, ref IList <ValidationError> validationErrors)
{
if (this.cacheId == parent.CacheId)
{
Fx.Assert(this.owner != null, "We must have set the owner when we set the cache ID");
// This means that we've already encountered a parent in the tree
// Validate that it is visible.
// In order to see the activity the new parent must be
// in the implementation IdSpace of an activity which has
// a public reference to it.
Activity referenceTarget = parent.MemberOf.Owner;
if (referenceTarget == null)
{
Activity handler = this.Handler;
if (handler == null)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedWithoutTargetNoHandler(parent.DisplayName, this.owner.DisplayName), false, parent));
}
else
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedWithoutTarget(handler.DisplayName, parent.DisplayName, this.owner.DisplayName), false, parent));
}
return(false);
}
else if (!referenceTarget.Delegates.Contains(this) && !referenceTarget.ImportedDelegates.Contains(this))
{
Activity handler = this.Handler;
if (handler == null)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedNoHandler(parent.DisplayName, referenceTarget.DisplayName, this.owner.DisplayName), false, parent));
}
else
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferenced(handler.DisplayName, parent.DisplayName, referenceTarget.DisplayName, this.owner.DisplayName), false, parent));
}
return(false);
}
// This is a valid reference so we want to allow
// normal processing to proceed.
return(true);
}
this.owner = parent;
this.cacheId = parent.CacheId;
this.parentCollectionType = collectionType;
InternalCacheMetadata();
// We need to setup the delegate environment so that it is
// available when we process the Handler.
LocationReferenceEnvironment delegateEnvironment = null;
if (collectionType == ActivityCollectionType.Implementation)
{
delegateEnvironment = parent.ImplementationEnvironment;
}
else
{
delegateEnvironment = parent.PublicEnvironment;
}
if (this.RuntimeDelegateArguments.Count > 0)
{
ActivityLocationReferenceEnvironment newEnvironment = new ActivityLocationReferenceEnvironment(delegateEnvironment);
delegateEnvironment = newEnvironment;
for (int argumentIndex = 0; argumentIndex < this.RuntimeDelegateArguments.Count; argumentIndex++)
{
RuntimeDelegateArgument runtimeDelegateArgument = this.RuntimeDelegateArguments[argumentIndex];
DelegateArgument delegateArgument = runtimeDelegateArgument.BoundArgument;
if (delegateArgument != null)
{
if (delegateArgument.Direction != runtimeDelegateArgument.Direction)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RuntimeDelegateArgumentDirectionIncorrect, parent));
}
if (delegateArgument.Type != runtimeDelegateArgument.Type)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RuntimeDelegateArgumentTypeIncorrect, parent));
}
// NOTE: We don't initialize this relationship here because
// at runtime we'll actually just place these variables in the
// environment of the Handler. We'll initialize and set an
// ID when we process the Handler.
newEnvironment.Declare(delegateArgument, this.owner, ref validationErrors);
}
}
}
this.Environment = delegateEnvironment;
if (this.Handler != null)
{
return(this.Handler.InitializeRelationship(this, collectionType, ref validationErrors));
}
return(true);
}
public RuntimeDelegateArgument(string name, System.Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
if (string.IsNullOrEmpty(name))
{
throw FxTrace.Exception.ArgumentNullOrEmpty("name");
}
if (type == null)
{
throw FxTrace.Exception.ArgumentNull("type");
}
ArgumentDirectionHelper.Validate(direction, "direction");
if (boundArgument != null)
{
boundArgument.Bind(this);
}
this.Name = name;
this.Type = type;
this.Direction = direction;
this.BoundArgument = boundArgument;
}
private static void ProcessActivity(ChildActivity childActivity, ref ChildActivity nextActivity, ref Stack <ChildActivity> activitiesRemaining, ActivityCallStack parentChain, ref IList <ValidationError> validationErrors, ProcessActivityTreeOptions options, ProcessActivityCallback callback)
{
Activity element = childActivity.Activity;
IList <Constraint> runtimeConstraints = element.RuntimeConstraints;
IList <ValidationError> list2 = null;
if (!element.HasStartedCachingMetadata)
{
element.MemberOf.AddMember(element);
element.InternalCacheMetadata(options.CreateEmptyBindings, ref list2);
ActivityValidationServices.ValidateArguments(element, element.Parent == null, ref list2);
ActivityLocationReferenceEnvironment environment = null;
ActivityLocationReferenceEnvironment environment2 = new ActivityLocationReferenceEnvironment(element.HostEnvironment)
{
InternalRoot = element
};
int nextEnvironmentId = 0;
ProcessChildren(element, element.Children, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessChildren(element, element.ImportedChildren, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessChildren(element, element.ImplementationChildren, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessArguments(element, element.RuntimeArguments, true, ref environment2, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessVariables(element, element.RuntimeVariables, ActivityCollectionType.Public, true, ref environment, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessVariables(element, element.ImplementationVariables, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref environment2, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2);
if (element.HandlerOf != null)
{
for (int i = 0; i < element.HandlerOf.RuntimeDelegateArguments.Count; i++)
{
RuntimeDelegateArgument argument = element.HandlerOf.RuntimeDelegateArguments[i];
DelegateArgument boundArgument = argument.BoundArgument;
if ((boundArgument != null) && boundArgument.InitializeRelationship(element, ref list2))
{
boundArgument.Id = nextEnvironmentId;
nextEnvironmentId++;
}
}
}
if (environment == null)
{
element.PublicEnvironment = new ActivityLocationReferenceEnvironment(element.GetParentEnvironment());
}
else
{
if (environment.Parent == null)
{
environment.InternalRoot = element;
}
element.PublicEnvironment = environment;
}
element.ImplementationEnvironment = environment2;
ProcessDelegates(element, element.Delegates, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessDelegates(element, element.ImportedDelegates, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref list2);
ProcessDelegates(element, element.ImplementationDelegates, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref list2);
if (callback != null)
{
callback(childActivity, parentChain);
}
if (list2 != null)
{
Activity activity2;
if (validationErrors == null)
{
validationErrors = new List <ValidationError>();
}
string str = ActivityValidationServices.GenerateValidationErrorPrefix(childActivity.Activity, parentChain, out activity2);
for (int j = 0; j < list2.Count; j++)
{
ValidationError item = list2[j];
item.Source = activity2;
item.Id = activity2.Id;
if (!string.IsNullOrEmpty(str))
{
item.Message = str + item.Message;
}
validationErrors.Add(item);
}
list2 = null;
}
if (options.StoreTempViolations && (validationErrors != null))
{
childActivity.Activity.SetTempValidationErrorCollection(validationErrors);
validationErrors = null;
}
}
else
{
SetupForProcessing(element.Children, true, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.ImportedChildren, false, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.RuntimeArguments, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.RuntimeVariables, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.Delegates, true, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.ImportedDelegates, false, ref nextActivity, ref activitiesRemaining);
if (!options.SkipPrivateChildren)
{
SetupForProcessing(element.ImplementationChildren, true, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.ImplementationDelegates, true, ref nextActivity, ref activitiesRemaining);
SetupForProcessing(element.ImplementationVariables, ref nextActivity, ref activitiesRemaining);
}
if ((callback != null) && !options.OnlyCallCallbackForDeclarations)
{
callback(childActivity, parentChain);
}
if (childActivity.Activity.HasTempViolations && !options.StoreTempViolations)
{
childActivity.Activity.TransferTempValidationErrors(ref validationErrors);
}
}
if ((!options.SkipConstraints && parentChain.WillExecute) && (childActivity.CanBeExecuted && (runtimeConstraints.Count > 0)))
{
ActivityValidationServices.RunConstraints(childActivity, parentChain, runtimeConstraints, options, false, ref validationErrors);
}
}
public RuntimeDelegateArgument(string name, Type type, ArgumentDirection direction, DelegateArgument boundArgument)
{
if (string.IsNullOrEmpty(name))
{
throw FxTrace.Exception.ArgumentNullOrEmpty(nameof(name));
}
ArgumentDirectionHelper.Validate(direction, "direction");
if (boundArgument != null)
{
// Validations that the bound argument matches are done
// in CacheMetadata for ActivityDelegate.
boundArgument.Bind(this);
}
this.Name = name;
this.Type = type ?? throw FxTrace.Exception.ArgumentNull(nameof(type));
this.Direction = direction;
this.BoundArgument = boundArgument;
}
public DelegateArgumentReference(System.Activities.DelegateArgument delegateArgument) : this()
{
this.DelegateArgument = delegateArgument;
}
public DelegateArgumentValue(System.Activities.DelegateArgument delegateArgument) : this()
{
this.DelegateArgument = delegateArgument;
}
