protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument;
argument = new RuntimeArgument("JobGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.JobGuid, argument);
metadata.AddArgument(argument);
argument = new RuntimeArgument("UserGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.UserGuid, argument);
metadata.AddArgument(argument);
if (this.Try != null)
{
metadata.AddChild(this.Try);
}
if (this.Finally != null)
{
metadata.AddChild(this.Finally);
}
argument = new RuntimeArgument("MaxRetries", typeof(int), ArgumentDirection.In);
metadata.Bind(this.MaxRetries, argument);
metadata.AddArgument(argument);
metadata.AddImplementationVariable(this.retries);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument;
argument = new RuntimeArgument("JobGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.JobGuid, argument);
metadata.AddArgument(argument);
argument = new RuntimeArgument("UserGuid", typeof(Guid), ArgumentDirection.In);
metadata.Bind(this.UserGuid, argument);
metadata.AddArgument(argument);
if (this.Try != null)
{
metadata.AddChild(this.Try);
}
if (this.Finally != null)
{
metadata.AddChild(this.Finally);
}
argument = new RuntimeArgument("MaxRetries", typeof(int), ArgumentDirection.In);
metadata.Bind(this.MaxRetries, argument);
metadata.AddArgument(argument);
metadata.AddImplementationVariable(this.retries);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.SetVariablesCollection(this.Variables);
metadata.AddChild(this.Body);
metadata.AddChild(this.Condition);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//clean up
this.internalStates.Clear();
this.internalStateFuncs.Clear();
this.internalTransitions.Clear();
StateMachineHelper.ProcessChildStates(metadata, this.States, this.internalStates, this.internalStateFuncs);
if (this.Entry != null)
{
metadata.AddChild(this.Entry);
}
if (this.Exit != null)
{
metadata.AddChild(this.Exit);
}
ProcessTransitions(metadata);
metadata.AddArgument(new RuntimeArgument("ToState", this.ToState.ArgumentType, ArgumentDirection.In));
metadata.AddArgument(new RuntimeArgument("EventManager", this.EventManager.ArgumentType, ArgumentDirection.In));
metadata.AddImplementationVariable(this.currentRunningTriggers);
metadata.AddImplementationVariable(this.hasRunningChildState);
metadata.AddImplementationVariable(this.isExiting);
metadata.AddImplementationVariable(this.evaluateConditionBookmark);
metadata.AddImplementationVariable(this.completeStateBookmark);
}
static void AddTransitionData(NativeActivityMetadata metadata, InternalTransition internalTransition, Transition transition)
{
TransitionData transitionData = new TransitionData();
Activity <bool> condition = transition.Condition;
transitionData.Condition = condition;
if (condition != null)
{
metadata.AddChild(condition);
}
Activity action = transition.Action;
transitionData.Action = action;
if (action != null)
{
metadata.AddChild(action);
}
if (transition.To != null)
{
transitionData.To = transition.To.InternalState;
}
internalTransition.TransitionDataList.Add(transitionData);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.AddChild(this.CancellationHandler);
metadata.SetVariablesCollection(this.Variables);
metadata.AddImplementationVariable(this.suppressCancel);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(Body);
metadata.AddChild(Condition);
metadata.AddImplementationVariable(_elements);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(SkipCondition);
metadata.AddChild(Body);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
_internalTransitions.Clear();
if (this.Entry != null)
{
metadata.AddChild(this.Entry);
}
if (this.Exit != null)
{
metadata.AddChild(this.Exit);
}
this.ProcessTransitions(metadata);
metadata.SetVariablesCollection(this.Variables);
RuntimeArgument eventManagerArgument = new RuntimeArgument("EventManager", this.EventManager.ArgumentType, ArgumentDirection.In);
metadata.Bind(this.EventManager, eventManagerArgument);
metadata.SetArgumentsCollection(
new Collection <RuntimeArgument>
{
eventManagerArgument
});
metadata.AddImplementationVariable(_currentRunningTriggers);
metadata.AddImplementationVariable(_isExiting);
metadata.AddImplementationVariable(_evaluateConditionBookmark);
}
/// <summary>
/// Creates and validates a description of the activity's arguments, variables, child activities, and activity delegates.
/// </summary>
/// <param name="metadata">The activity's metadata that encapsulates the activity's arguments, variables, child activities, and activity delegates.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// Add a validation error if the Operation is not defined.
if (this.Operation == null)
{
metadata.AddValidationError("AzureAsyncOperation requires an Azure activity to execute.");
return;
}
// Add the publicly defined activities as children.
metadata.AddChild(this.Operation);
metadata.AddChild(this.Success);
metadata.AddChild(this.Failure);
// Define internal variables.
metadata.AddImplementationVariable(this.PollingEndTime);
metadata.AddImplementationVariable(this.OperationId);
metadata.AddImplementationVariable(this.AzureActivityExceptionCaught);
// Define public arguments.
var thumbArgument = new RuntimeArgument("CertificateThumbprintId", typeof(string), ArgumentDirection.In);
metadata.Bind(this.CertificateThumbprintId, thumbArgument);
metadata.AddArgument(thumbArgument);
var subArgument = new RuntimeArgument("SubscriptionId", typeof(string), ArgumentDirection.In);
metadata.Bind(this.SubscriptionId, subArgument);
metadata.AddArgument(subArgument);
// Add our activities as delegates.
metadata.AddDelegate(this.PollingBody);
metadata.AddDelegate(this.DelayBody);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Try != null)
{
metadata.AddChild(this.Try);
}
if (this.Finally != null)
{
metadata.AddChild(this.Finally);
}
Collection <ActivityDelegate> delegates = new Collection <ActivityDelegate>();
if (this.catches != null)
{
foreach (Catch @catch in this.catches)
{
ActivityDelegate action = @catch.GetAction();
if (action != null)
{
delegates.Add(action);
}
}
}
metadata.AddImplementationVariable(this.state);
metadata.SetDelegatesCollection(delegates);
metadata.SetVariablesCollection(this.Variables);
if ((this.Finally == null) && (this.Catches.Count == 0))
{
metadata.AddValidationError(System.Activities.SR.CatchOrFinallyExpected(base.DisplayName));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (BatchingStrategy == null) metadata.AddValidationError("BatchingStrategy is required.");
if (GetNextVectors.IsNull()) metadata.AddValidationError("GetNextVectors function is required.");
if (ItemCountExpression == null) metadata.AddValidationError("ItemCountExpression is required.");
metadata.AddChild(BatchingStrategy);
metadata.AddDelegate(GetNextVectors);
metadata.AddDelegate(DoReinitializeVectorProvider);
RuntimeArgument arg;
metadata.AddArgument(arg = new RuntimeArgument("LastResult", typeof(BatchExecutionResult), ArgumentDirection.In));
metadata.Bind(LastResult, arg);
metadata.AddArgument(arg = new RuntimeArgument("ReinitializationFrequency", typeof(int), ArgumentDirection.In));
metadata.Bind(ReinitializationFrequency, arg);
metadata.AddArgument(arg = new RuntimeArgument("UseCache", typeof(bool), ArgumentDirection.In));
metadata.Bind(UseCache, arg);
metadata.AddChild(ItemCountExpression);
metadata.AddImplementationVariable(cachedVectors);
metadata.AddImplementationVariable(strategyHasJustInited);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.AddChild(this.CancellationHandler);
metadata.SetVariablesCollection(this.Variables);
metadata.AddImplementationVariable(this.suppressCancel);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.RepeatForever);
foreach (Activity current in this.Triggers)
{
metadata.AddChild(current);
}
metadata.RequireExtension <BookmarkResumptionHelper>();
base.CacheMetadata(metadata);
metadata.AddDefaultExtensionProvider <BookmarkResumptionHelper>(() => new BookmarkResumptionHelper());
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Request == null)
{
metadata.AddValidationError(new ValidationError(SR2.TransactedReceiveScopeMustHaveValidReceive(this.DisplayName), false, RequestPropertyName));
}
metadata.AddChild(this.Request);
metadata.AddChild(this.Body);
metadata.SetVariablesCollection(this.Variables);
metadata.AddImplementationVariable(this.transactionHandle);
metadata.AddImplementationVariable(this.isNested);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
//call base.CacheMetadata to add the Activities and Variables to this activity's metadata
base.CacheMetadata(metadata);
// Declare children activities
foreach (MatchCase matchCase in this.Cases)
{
metadata.AddChild(matchCase.Expression);
metadata.AddChild(matchCase.Case);
}
metadata.AddImplementationVariable(this.CaseIndex);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.SetVariablesCollection(this.Variables);
metadata.AddChild(this.Body);
if (this.Condition == null)
{
metadata.AddValidationError(System.Activities.SR.WhileRequiresCondition(base.DisplayName));
}
else
{
metadata.AddChild(this.Condition);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.SetVariablesCollection(this.Variables);
metadata.AddChild(this.Body);
if (this.Condition == null)
{
metadata.AddValidationError(System.Activities.SR.WhileRequiresCondition(base.DisplayName));
}
else
{
metadata.AddChild(this.Condition);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Console.WriteLine("CacheMetadata");
if (Activities != null && Activities.Count > 0)
{
foreach (Activity activity in Activities)
{
metadata.AddChild(activity);
}
}
metadata.AddChild(Condition);
metadata.AddImplementationVariable(scheduledChildren);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Console.WriteLine("CacheMetadata");
metadata.SetChildrenCollection(Activities);
metadata.AddChild(Condition);
metadata.AddImplementationVariable(activityIndex);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.branchBodies == null)
{
this.branchBodies = new Collection <Activity>();
}
else
{
this.branchBodies.Clear();
}
foreach (PickBranch branch in this.Branches)
{
if (branch.Trigger == null)
{
metadata.AddValidationError(new ValidationError(SR.PickBranchRequiresTrigger(branch.DisplayName), false, null, branch));
}
PickBranchBody pickBranchBody = new PickBranchBody
{
Action = branch.Action,
DisplayName = branch.DisplayName,
Trigger = branch.Trigger,
Variables = branch.Variables,
};
this.branchBodies.Add(pickBranchBody);
metadata.AddChild(pickBranchBody, origin: branch);
}
metadata.AddImplementationVariable(this.pickStateVariable);
}
private void ProcessTransitions(NativeActivityMetadata metadata)
{
for (int i = 0; i < this.Transitions.Count; i++)
{
Transition transition = this.Transitions[i];
InternalTransition internalTransition = null;
Activity triggerActivity = transition.ActiveTrigger;
if (!_triggerInternalTransitionMapping.TryGetValue(triggerActivity, out internalTransition))
{
metadata.AddChild(triggerActivity);
internalTransition = new InternalTransition
{
Trigger = triggerActivity,
InternalTransitionIndex = _internalTransitions.Count,
};
_triggerInternalTransitionMapping.Add(triggerActivity, internalTransition);
_internalTransitions.Add(internalTransition);
}
AddTransitionData(metadata, internalTransition, transition);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Child != null)
{
metadata.AddChild(this.Child);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
// Add CaseRanges and Default as children of SwitchRange so they can be scheduled
foreach (CaseRange <T> range in Cases)
{
metadata.AddChild(range.Action);
}
// Perform validations
int malformedRanges = 0;
foreach (CaseRange <T> range in Cases)
{
if (range.From == null || range.To == null)
{
malformedRanges++;
}
}
if (malformedRanges > 0)
{
metadata.AddValidationError(string.Format(CultureInfo.InvariantCulture, "SwitchRange {0}: There is/are {1} CaseRange(s) that have either From or To unspecified", DisplayName, malformedRanges));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(Body);
// add arguments
metadata.AddArgument(new RuntimeArgument("Action", typeof(Command?), ArgumentDirection.In, true));
metadata.AddArgument(new RuntimeArgument("Bookmark", typeof(CustomBookmark), ArgumentDirection.In, false));
metadata.AddArgument(new RuntimeArgument("BookmarkHistory", typeof(List <CustomBookmark>), ArgumentDirection.InOut, false));
}
/// <summary>
/// Creates and validates a description of the activity’s arguments, variables, child activities, and activity delegates.
/// </summary>
/// <param name="metadata">The activity’s metadata that encapsulates the activity’s arguments, variables, child activities, and activity delegates.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
foreach (var kvp in this.Arguments)
{
metadata.AddArgument(new RuntimeArgument(kvp.Key, kvp.Value.ArgumentType, kvp.Value.Direction));
}
metadata.SetVariablesCollection(this.Variables);
metadata.AddChild(this.StateMachine);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
fields.Add(new ActivityDTO("[[FormView]]", Html, 0));
_assignActivity = new DsfMultiAssignActivity {
OutputMapping = null, FieldsCollection = fields, InputMapping = null
};
metadata.AddChild(_assignActivity);
metadata.AddDelegate(_delegate);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
if (Body.IsNull()) metadata.AddValidationError("Body is required.");
metadata.AddDelegate(Body);
if (Condition == null) metadata.AddValidationError("Condition is required.");
metadata.AddChild(Condition);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// activities
foreach (Activity activity in this.Activities)
{
metadata.AddChild(activity);
}
metadata.AddImplementationVariable(this.LastIndex);
metadata.AddImplementationVariable(this.ResumeParent);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Body == null)
{
metadata.AddValidationError("The Body property must contain an Activity.");
}
else if (impl == null)
{
CreateImplementation();
metadata.AddChild(impl);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.Body == null)
{
metadata.AddValidationError("The Body property must contain an Activity.");
}
else if (impl == null)
{
CreateImplementation();
metadata.AddChild(impl);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.SetImplementationVariablesCollection(
new Collection<Variable>
{
this.declaredHandle
});
RuntimeArgument correlatesWithArgument = new RuntimeArgument("CorrelatesWith", typeof(CorrelationHandle), ArgumentDirection.In);
metadata.Bind(this.CorrelatesWith, correlatesWithArgument);
metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { correlatesWithArgument });
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// activities
foreach (Activity activity in this.Activities)
{
metadata.AddChild(activity);
}
metadata.AddImplementationVariable(this.LastIndex);
metadata.AddImplementationVariable(this.ResumeParent);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.SetImplementationVariablesCollection(new Collection <Variable> {
this.declaredHandle
});
RuntimeArgument argument = new RuntimeArgument("CorrelatesWith", typeof(CorrelationHandle), ArgumentDirection.In);
metadata.Bind(this.CorrelatesWith, argument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
argument
});
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
base.CacheMetadata(metadata);
//
// Must use AddChild (which adds children as 'public') otherwise you will get the following exception:
//
// The private implementation of activity Decision has the following validation error:
// Compiler error(s) encountered processing expression t.Eq(d.Get("FirstName",AmbientDataList),"Trevor").
// 't' is not declared. It may be inaccessible due to its protection level
// 'd' is not declared. It may be inaccessible due to its protection level
//
metadata.AddChild(_expression);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (Try != null)
{
metadata.AddChild(this.Try);
}
if (this.Finally != null)
{
metadata.AddChild(this.Finally);
}
Collection <ActivityDelegate> delegates = new Collection <ActivityDelegate>();
if (this.catches != null)
{
foreach (Catch item in this.catches)
{
ActivityDelegate catchDelegate = item.GetAction();
if (catchDelegate != null)
{
delegates.Add(catchDelegate);
}
}
}
metadata.AddImplementationVariable(this.state);
metadata.SetDelegatesCollection(delegates);
metadata.SetVariablesCollection(this.Variables);
if (this.Finally == null && this.Catches.Count == 0)
{
metadata.AddValidationError(SR.CatchOrFinallyExpected(this.DisplayName));
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// child activities
metadata.AddChild(this.Body);
// arguments
metadata.AddArgument(new RuntimeArgument("ConnectionString", typeof(string), ArgumentDirection.In, true));
// variables
metadata.AddImplementationVariable(this.noPersistHandle);
foreach (Variable variable in this.variables)
{
metadata.AddVariable(variable);
}
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// child activities
metadata.AddChild(this.Body);
// arguments
metadata.AddArgument(new RuntimeArgument("ConnectionString", typeof(string), ArgumentDirection.In, true));
// variables
metadata.AddImplementationVariable(this.noPersistHandle);
foreach (Variable variable in this.variables)
{
metadata.AddVariable(variable);
}
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddDelegate(Body);
metadata.AddChild(LoopAction);
Interfaces.Extensions.AddCacheArgument(metadata, "MaxResults", MaxResults);
Interfaces.Extensions.AddCacheArgument(metadata, "MinResults", MinResults);
Interfaces.Extensions.AddCacheArgument(metadata, "Timeout", Timeout);
Interfaces.Extensions.AddCacheArgument(metadata, "Selector", Selector);
Interfaces.Extensions.AddCacheArgument(metadata, "From", From);
Interfaces.Extensions.AddCacheArgument(metadata, "Elements", Elements);
Interfaces.Extensions.AddCacheArgument(metadata, "WaitForReady", WaitForReady);
metadata.AddImplementationVariable(_elements);
metadata.AddImplementationVariable(_allelements);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
RuntimeArgument argument = new RuntimeArgument("Timeout", typeof(TimeSpan), ArgumentDirection.In, false);
metadata.Bind(this.Timeout, argument);
metadata.SetArgumentsCollection(new Collection <RuntimeArgument> {
argument
});
metadata.AddImplementationChild(this.NestedScopeTimeoutWorkflow);
if (this.Body != null)
{
metadata.AddChild(this.Body);
}
metadata.AddImplementationVariable(this.runtimeTransactionHandle);
metadata.AddImplementationVariable(this.nestedScopeTimeout);
metadata.AddImplementationVariable(this.delayWasScheduled);
metadata.AddImplementationVariable(this.nestedScopeTimeoutActivityInstance);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (GetBatchingStrategyFactory.IsNull()) metadata.AddValidationError("GetBatchingStrategyFactory function is expected.");
if (GetNextVectors.IsNull()) metadata.AddValidationError("GetNextVectors function is expected.");
if (ItemCount == null) metadata.AddValidationError("ItemCount expression expected.");
metadata.AddDelegate(GetBatchingStrategyFactory);
metadata.AddDelegate(GetNextVectors);
metadata.AddDelegate(ReinitializeVectorProvider);
RuntimeArgument arg;
metadata.AddArgument(arg = new RuntimeArgument("LastResult", typeof(BatchExecutionResult), ArgumentDirection.In));
metadata.Bind(LastResult, arg);
metadata.AddArgument(arg = new RuntimeArgument("ReinitializationFrequency", typeof(int), ArgumentDirection.In));
metadata.Bind(ReinitializationFrequency, arg);
metadata.AddChild(ItemCount);
base.CacheMetadata(metadata);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(Body);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.TaskBody != null)
{
metadata.AddChild(this.TaskBody);
if (ContainsTaskActivity(this.TaskBody))
{
metadata.AddValidationError(typeof(TaskActivityAssignException).Name);
}
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>();
foreach (KeyValuePair<string, Argument> entry in this.DelegateArguments)
{
RuntimeArgument argument = new RuntimeArgument(entry.Key, entry.Value.ArgumentType, entry.Value.Direction);
metadata.Bind(entry.Value, argument);
arguments.Add(argument);
}
metadata.SetArgumentsCollection(arguments);
metadata.AddDelegate(this.Delegate);
if (this.Delegate != null)
{
IList<RuntimeDelegateArgument> targetDelegateArguments = this.Delegate.RuntimeDelegateArguments;
if (this.DelegateArguments.Count != targetDelegateArguments.Count)
{
metadata.AddValidationError(SR.WrongNumberOfArgumentsForActivityDelegate);
}
// Validate that the names and directionality of arguments in DelegateArguments dictionary
// match the names and directionality of arguments returned by the ActivityDelegate.GetDelegateParameters
// call above.
for (int i = 0; i < targetDelegateArguments.Count; i++)
{
RuntimeDelegateArgument expectedParameter = targetDelegateArguments[i];
Argument delegateArgument = null;
string parameterName = expectedParameter.Name;
if (this.DelegateArguments.TryGetValue(parameterName, out delegateArgument))
{
if (delegateArgument.Direction != expectedParameter.Direction)
{
metadata.AddValidationError(SR.DelegateParameterDirectionalityMismatch(parameterName, delegateArgument.Direction, expectedParameter.Direction));
}
if (expectedParameter.Direction == ArgumentDirection.In)
{
if (!TypeHelper.AreTypesCompatible(delegateArgument.ArgumentType, expectedParameter.Type))
{
metadata.AddValidationError(SR.DelegateInArgumentTypeMismatch(parameterName, expectedParameter.Type, delegateArgument.ArgumentType));
}
}
else
{
if (!TypeHelper.AreTypesCompatible(expectedParameter.Type, delegateArgument.ArgumentType))
{
metadata.AddValidationError(SR.DelegateOutArgumentTypeMismatch(parameterName, expectedParameter.Type, delegateArgument.ArgumentType));
}
}
}
else
{
metadata.AddValidationError(SR.InputParametersMissing(expectedParameter.Name));
}
if (!this.hasOutputArguments && ArgumentDirectionHelper.IsOut(expectedParameter.Direction))
{
this.hasOutputArguments = true;
}
}
}
metadata.AddChild(this.Default);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
if (this.branchBodies == null)
{
this.branchBodies = new Collection<Activity>();
}
else
{
this.branchBodies.Clear();
}
foreach (PickBranch branch in this.Branches)
{
if (branch.Trigger == null)
{
metadata.AddValidationError(new ValidationError(SR.PickBranchRequiresTrigger(branch.DisplayName), false, null, branch));
}
PickBranchBody pickBranchBody = new PickBranchBody
{
Action = branch.Action,
DisplayName = branch.DisplayName,
Trigger = branch.Trigger,
Variables = branch.Variables,
};
this.branchBodies.Add(pickBranchBody);
metadata.AddChild(pickBranchBody, origin: branch);
}
metadata.AddImplementationVariable(this.pickStateVariable);
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddChild(this.Body);
metadata.AddImplementationVariable(this.noPersistHandle);
}
/// <summary>
/// Informs the runtime about our activity and the data
/// </summary>
/// <param name="metadata">The metadata</param>
/// <remarks>
/// The base class implementation
/// will discover variables and child activities using reflection. By overriding
/// CacheMetadata we avoid this and get improved performance.
/// </remarks>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
/// implementation variables are variables that are
/// private to our workflow.
metadata.AddImplementationVariable(lastIndexHint);
metadata.AddImplementationVariable(preCompleted);
metadata.AddImplementationVariable(bodyCompleted);
metadata.SetVariablesCollection(Variables);
metadata.AddChild(Pre);
metadata.AddChild(Post);
// Cannot use metadata.SetActivitiesCollection because of Pre/Post
foreach (Activity activity in Activities)
{
metadata.AddChild(activity);
}
}
/// <summary>
/// Validate the required number of activities of pipeline activity.
/// Setup the cachemetadata with variables and activities.
/// </summary>
/// <param name="metadata"></param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
int count = 0;
if (this.Activities != null)
{
count = this.Activities.Count;
}
if (count == 0)
{
metadata.AddValidationError(new ValidationError(ActivityResources.NoChildPipeline, true));
return;
}
//BUGBUG: As written, the following checks cause error in scenarios where they should not.
// They are left in for the time being but disabled until we verify that there are no
// scenarios where we need to check for two variables being assigned.
#if false
if (Input != null && Input.Expression != null && this.Activities[0].Input != null && this.Activities[0].Input.Expression != null)
{
metadata.AddValidationError(new ValidationError(ActivityResources.DuplicateInputDefinedInPipeline, true));
this.inputValidationFailed = true;
return;
}
if (Result != null && Result.Expression != null && this.Activities[count - 1].Result != null && this.Activities[count - 1].Result.Expression != null)
{
metadata.AddValidationError(new ValidationError(ActivityResources.DuplicateResultDefinedInPipeline, true));
this.resultValidationFailed = true;
return;
}
#endif
// Adding variables into the CacheMetadata of pipeline activity.
metadata.AddImplementationVariable(this.lastIndexHint);
// We use a GUID here to make this name hard to guess. It's not a security issue,
// it just prevents code from accidentally taking a dependency on it.
this.OutputStream = new Variable<PSDataCollection<PSObject>>(Guid.NewGuid().ToString().Replace("-","_"));
this.InputStream = new Variable<PSDataCollection<PSObject>>(Guid.NewGuid().ToString().Replace("-","_"));
metadata.AddVariable(this.OutputStream);
metadata.AddVariable(this.InputStream);
bool appendOutput = false;
if ((this.AppendOutput != null) && (this.AppendOutput.Value))
{
appendOutput = true;
}
// Adding activities into the CacheMetadata of pipeline activity.
if (count == 1)
{
if (Input != null && Input.Expression != null)
{
this.Activities[0].Input = this.Input;
}
if (Result != null && Result.Expression != null)
{
this.Activities[0].Result = this.Result;
}
if (appendOutput)
{
this.Activities[0].AppendOutput = true;
}
metadata.AddChild(this.Activities[0]);
}
else
{
if (Input != null && Input.Expression != null)
{
this.Activities[0].Input = this.Input;
}
// Connecting child activities with temporary input and out streams.
this.Activities[0].Result = this.OutputStream;
metadata.AddChild(this.Activities[0]);
for (int i = 1; i < (count - 1); i++)
{
this.Activities[i].Input = this.InputStream;
this.Activities[i].Result = this.OutputStream;
metadata.AddChild(this.Activities[i]);
}
if (Result != null && Result.Expression != null)
{
this.Activities[count - 1].Result = this.Result;
}
if (appendOutput)
{
this.Activities[count - 1].AppendOutput = true;
}
this.Activities[count - 1].Input = this.InputStream;
metadata.AddChild(this.Activities[count - 1]);
}
}
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
metadata.AddImplementationVariable(noPersistHandle);
metadata.AddChild(tryCatch);
//base.CacheMetadata(metadata); // it would add the public Body activity twice
}
/// <summary>
/// Creates and validates a description of the activity's arguments, variables, child activities, and activity delegates.
/// </summary>
/// <param name="metadata">The activity's metadata that encapsulates the activity's arguments, variables, child activities, and activity delegates.</param>
protected override void CacheMetadata(NativeActivityMetadata metadata)
{
// Add a validation error if the Operation is not defined.
if (this.Operation == null)
{
metadata.AddValidationError("AzureAsyncOperation requires an Azure activity to execute.");
return;
}
// Add the publicly defined activities as children.
metadata.AddChild(this.Operation);
metadata.AddChild(this.Success);
metadata.AddChild(this.Failure);
// Define internal variables.
metadata.AddImplementationVariable(this.PollingEndTime);
metadata.AddImplementationVariable(this.OperationId);
metadata.AddImplementationVariable(this.AzureActivityExceptionCaught);
// Define public arguments.
var thumbArgument = new RuntimeArgument("CertificateThumbprintId", typeof(string), ArgumentDirection.In);
metadata.Bind(this.CertificateThumbprintId, thumbArgument);
metadata.AddArgument(thumbArgument);
var subArgument = new RuntimeArgument("SubscriptionId", typeof(string), ArgumentDirection.In);
metadata.Bind(this.SubscriptionId, subArgument);
metadata.AddArgument(subArgument);
// Add our activities as delegates.
metadata.AddDelegate(this.PollingBody);
metadata.AddDelegate(this.DelayBody);
}
