protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); Type objectType = TypeHelper.ObjectType; if (this.Value != null) { objectType = this.Value.ArgumentType; } RuntimeArgument argument = new RuntimeArgument("Value", objectType, ArgumentDirection.In, true); metadata.Bind(this.Value, argument); Type argumentType = TypeHelper.ObjectType; if (this.To != null) { argumentType = this.To.ArgumentType; } RuntimeArgument argument2 = new RuntimeArgument("To", argumentType, ArgumentDirection.Out, true); metadata.Bind(this.To, argument2); arguments.Add(argument); arguments.Add(argument2); metadata.SetArgumentsCollection(arguments); if (((this.Value != null) && (this.To != null)) && !TypeHelper.AreTypesCompatible(this.Value.ArgumentType, this.To.ArgumentType)) { metadata.AddValidationError(System.Activities.SR.TypeMismatchForAssign(this.Value.ArgumentType, this.To.ArgumentType, base.DisplayName)); } }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument subInstanceArgument = new RuntimeArgument("Scope", typeof(BookmarkScope), ArgumentDirection.In); metadata.Bind(this.Scope, subInstanceArgument); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { subInstanceArgument }); }
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) { // The Body introduces another layer of scope. Method metadata.AddImplementationChild // (instead of metadata.AddChild) enable access to LoopVariable from the inner // block scope of Body. if (this.Body != null && this.Body.Handler != null) { this.invokeBody.Action = this.Body; metadata.AddImplementationChild(this.invokeBody); } // Need to bind the arguments to the custom activity variables explicitly // and then add them to the metadata. RuntimeArgument startArg = new RuntimeArgument("Start", typeof(int), ArgumentDirection.In, true); metadata.Bind(this.Start, startArg); metadata.AddArgument(startArg); RuntimeArgument stopArg = new RuntimeArgument("Stop", typeof(int), ArgumentDirection.In, true); metadata.Bind(this.Stop, stopArg); metadata.AddArgument(stopArg); RuntimeArgument stepArg = new RuntimeArgument("Step", typeof(int), ArgumentDirection.In, true); metadata.Bind(this.Step, stepArg); metadata.AddArgument(stepArg); // Register variables used in the custom activity. metadata.AddImplementationVariable(this.loopVariable); }
internal override void CacheMetadata(ActivityMetadata metadata, Activity owner, string operationName) { this.ShredParameters(); int index = 0; foreach (Type type in this.argumentTypes) { if ((type == null) || (type == TypeHelper.VoidType)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.ArgumentCannotHaveNullOrVoidType(owner.DisplayName, this.argumentNames[index])); } if ((type == MessageDescription.TypeOfUntypedMessage) || MessageBuilder.IsMessageContract(type)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.ReceiveParametersContentDoesNotSupportMessage(owner.DisplayName, this.argumentNames[index])); } index++; } if (!metadata.HasViolations) { foreach (KeyValuePair<string, OutArgument> pair in this.Parameters) { RuntimeArgument argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out); metadata.Bind(pair.Value, argument); metadata.AddArgument(argument); } } }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); Type objectType = TypeHelper.ObjectType; if (this.TargetObject != null) { objectType = this.TargetObject.ArgumentType; } RuntimeArgument argument = new RuntimeArgument("TargetObject", objectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, argument); arguments.Add(argument); Type argumentType = TypeHelper.ObjectType; if (this.Result != null) { argumentType = this.Result.ArgumentType; } this.resultArgument = new RuntimeArgument("Result", argumentType, ArgumentDirection.Out); metadata.Bind(this.Result, this.resultArgument); arguments.Add(this.resultArgument); this.methodResolver = this.CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, out this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In); metadata.Bind(this.Target, targetArgument); metadata.SetArgumentsCollection( new Collection<RuntimeArgument> { targetArgument }); metadata.SetImplementationVariablesCollection( new Collection<Variable> { this.currentCompensationToken }); Fx.Assert(DefaultConfirmation != null, "DefaultConfirmation must be valid"); Fx.Assert(InternalConfirm != null, "InternalConfirm must be valid"); metadata.SetImplementationChildrenCollection( new Collection<Activity> { DefaultConfirmation, InternalConfirm }); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument valuesArgument = new RuntimeArgument("Values", typeof(IEnumerable), ArgumentDirection.In, true); metadata.Bind(this.Values, valuesArgument); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { valuesArgument }); // declare the CompletionCondition as a child if (this.CompletionCondition != null) { metadata.SetChildrenCollection(new Collection<Activity> { this.CompletionCondition }); } // declare the hasCompleted variable if (this.CompletionCondition != null) { if (this.hasCompleted == null) { this.hasCompleted = new Variable<bool>(); } metadata.AddImplementationVariable(this.hasCompleted); } metadata.AddDelegate(this.Body); }
protected override void CacheMetadata(ActivityMetadata metadata) { if (string.IsNullOrEmpty(this.OperationName)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingOperationName(base.DisplayName)); } MessagingActivityHelper.ValidateCorrelationInitializer(metadata, this.correlationInitializers, false, base.DisplayName, this.OperationName); MessagingActivityHelper.AddRuntimeArgument(this.CorrelatesWith, "CorrelatesWith", Constants.CorrelationHandleType, ArgumentDirection.In, metadata); this.InternalContent.CacheMetadata(metadata, this, this.OperationName); if (this.correlationInitializers != null) { for (int i = 0; i < this.correlationInitializers.Count; i++) { CorrelationInitializer initializer = this.correlationInitializers[i]; initializer.ArgumentName = "Parameter" + i; RuntimeArgument argument = new RuntimeArgument(initializer.ArgumentName, Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(initializer.CorrelationHandle, argument); metadata.AddArgument(argument); } } if (!metadata.HasViolations) { this.internalReceive = this.CreateInternalReceive(); this.InternalContent.ConfigureInternalReceive(this.internalReceive, out this.requestFormatter); } else { this.internalReceive = null; this.requestFormatter = null; } }
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.AddArgument(arg = new RuntimeArgument("UseCache", typeof(bool), ArgumentDirection.In)); metadata.Bind(UseCache, arg); metadata.AddChild(ItemCount); metadata.AddImplementationVariable(cachedVectors); metadata.AddImplementationVariable(strategyHasJustInited); base.CacheMetadata(metadata); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { if (this.Result != null) { RuntimeArgument argument = new RuntimeArgument("Result", this.Result.ArgumentType, ArgumentDirection.In); metadata.Bind(this.Result, argument); metadata.AddArgument(argument); } if (this.parameters != null) { int num = 0; foreach (InArgument argument2 in this.parameters) { RuntimeArgument argument3 = new RuntimeArgument("Parameter" + num++, argument2.ArgumentType, ArgumentDirection.In); metadata.Bind(argument2, argument3); metadata.AddArgument(argument3); } } RuntimeArgument argument4 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out, true); metadata.Bind(this.Message, argument4); metadata.AddArgument(argument4); RuntimeArgument argument5 = new RuntimeArgument("CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(this.CorrelatesWith, argument5); metadata.AddArgument(argument5); }
/// <summary> /// The cache metadata. /// </summary> /// <param name="metadata"> /// The metadata. /// </param> protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.RequireExtension<IMessagingStub>(); var parametersContent = this.Content as ReceiveParametersContent; if (parametersContent != null) { foreach (var pair in parametersContent.Parameters) { var argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out); metadata.Bind(pair.Value, argument); metadata.AddArgument(argument); } } var messageContent = this.Content as ReceiveMessageContent; if (messageContent != null) { var runtimeArgumentType = (messageContent.Message == null) ? typeof(object) : messageContent.Message.ArgumentType; var argument = new RuntimeArgument("Message", runtimeArgumentType, ArgumentDirection.Out); metadata.Bind(messageContent.Message, argument); metadata.AddArgument(argument); } // Note: Not adding other properties here as arguments }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In); metadata.Bind(this.Target, argument); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument }); metadata.SetImplementationVariablesCollection(new Collection<Variable> { this.toConfirmToken }); metadata.SetImplementationChildrenCollection(new Collection<Activity> { this.Body }); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Text", typeof(string), ArgumentDirection.In); metadata.Bind(this.Text, argument); RuntimeArgument argument2 = new RuntimeArgument("TextWriter", typeof(System.IO.TextWriter), ArgumentDirection.In); metadata.Bind(this.TextWriter, argument2); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument, argument2 }); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.RequireExtension<ICountModel>(); var currentCountArg = new RuntimeArgument( "CurrentCount", typeof(Int32), ArgumentDirection.In); metadata.AddArgument(currentCountArg); metadata.Bind(this.CurrentCount, currentCountArg); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Duration", typeof(TimeSpan), ArgumentDirection.In, true); metadata.Bind(this.Duration, argument); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument }); metadata.AddImplementationVariable(this.timerBookmark); metadata.AddDefaultExtensionProvider<TimerExtension>(getDefaultTimerExtension); }
public MethodExecutor(Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) { this.invokingActivity = invokingActivity; this.targetType = targetType; this.targetObject = targetObject; this.parameters = parameters; this.returnObject = returnObject; }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument valuesArgument = new RuntimeArgument("Values", typeof(IEnumerable), ArgumentDirection.In, true); metadata.Bind(this.Values, valuesArgument); metadata.AddArgument(valuesArgument); metadata.AddDelegate(this.Body); metadata.AddImplementationVariable(this.valueEnumerator); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.AddDelegate(OnRun); var runtimeArgument = new RuntimeArgument("TaskCode", typeof(string), ArgumentDirection.In); metadata.Bind(TaskCode, runtimeArgument); metadata.AddArgument(runtimeArgument); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Collection", typeof(ICollection <T>), ArgumentDirection.In, true); metadata.Bind(this.Collection, argument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { argument }); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.RequireExtension <ICountModel>(); var currentCountArg = new RuntimeArgument( "CurrentCount", typeof(Int32), ArgumentDirection.In); metadata.AddArgument(currentCountArg); metadata.Bind(this.CurrentCount, currentCountArg); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument exceptionArgument = new RuntimeArgument("Exception", typeof(Exception), ArgumentDirection.In, true); metadata.Bind(this.Exception, exceptionArgument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { exceptionArgument }); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Scope", typeof(BookmarkScope), ArgumentDirection.In); metadata.Bind(this.Scope, argument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { argument }); }
public void GetValueRuntimeArgumentRValue() { Variable <int> var = new Variable <int>(); RuntimeArgument ra = new RuntimeArgument("InArgument", typeof(int), ArgumentDirection.In); Expression <Func <ActivityContext, object> > expression = (env) => env.GetValue(ra); ArgumentValue <object> expectedActivity = new ArgumentValue <object>("InArgument"); ConvertAndValidate(expression, expectedActivity, null); }
public static void OnGetArguments <TOperand>(CodeActivityMetadata metadata, InArgument <TOperand> operand) { RuntimeArgument argument = new RuntimeArgument("Operand", typeof(TOperand), ArgumentDirection.In, true); metadata.Bind(operand, argument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { argument }); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { metadata.RequireExtension <IEventBroker>(); var button = new RuntimeArgument("Button", typeof(ManagerButtonsEnum), ArgumentDirection.In); metadata.AddArgument(button); metadata.Bind(this.Button, button); }
public AsyncPatternMethodExecutor(AsyncPatternMethodExecutor copy, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject) : base(copy.invokingActivity, targetType, targetObject, parameters, returnObject) { this.beginMethod = copy.beginMethod; this.endMethod = copy.endMethod; this.beginFunc = copy.beginFunc; this.endFunc = copy.endFunc; }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In); metadata.Bind(this.Target, targetArgument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { targetArgument }); }
protected virtual void VisitVariableScopeArgument(RuntimeArgument runtimeArgument, out bool exit) { VisitArgument(runtimeArgument, out exit); if (exit) { return; } exit = false; }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.AddDelegate(this.Action); RuntimeArgument argument = new RuntimeArgument("Argument", typeof(T), ArgumentDirection.In, true); metadata.Bind(this.Argument, argument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { argument }); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { for (int i = 0; i < this.Elements.Count; i++) { RuntimeArgument argArgument = new RuntimeArgument( "Element_" + i, this.Elements[i].ArgumentType, ArgumentDirection.In); //NOXLATE metadata.Bind(this.Elements[i], argArgument); metadata.AddArgument(argArgument); } }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument runtimeArgument1 = new RuntimeArgument("Print", typeof(object), ArgumentDirection.In); metadata.Bind((Argument)this.Print, runtimeArgument1); metadata.SetArgumentsCollection(new Collection <RuntimeArgument>() { runtimeArgument1, }); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument runtimeArgument1 = new RuntimeArgument("Число", typeof(Int32), ArgumentDirection.InOut); metadata.Bind((Argument)this.Число, runtimeArgument1); metadata.SetArgumentsCollection(new Collection <RuntimeArgument>() { runtimeArgument1, }); }
protected override void CacheMetadata(ActivityMetadata metadata) { IPSHelper.CacheMetadataHelper(metadata, this.Input, this.Errors, this.CommandText, GetType().Name, this.DisplayName, this.PowerShellVariables, this.Parameters, this.childPowerShellVariables, this.childParameters); RuntimeArgument outputArgument = new RuntimeArgument("Output", typeof(Collection <PSObject>), ArgumentDirection.Out, false); metadata.Bind(this.Output, outputArgument); metadata.AddArgument(outputArgument); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument textArgument = new RuntimeArgument("Test", typeof(string), ArgumentDirection.In); metadata.Bind(this.Test, textArgument); metadata.SetArgumentsCollection( new Collection<RuntimeArgument> { textArgument, }); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument runtimeArgument = new RuntimeArgument("ValidationContext", typeof(ValidationContext), ArgumentDirection.In, true); metadata.Bind(this.ValidationContext, runtimeArgument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { runtimeArgument }); }
public static void CacheMetadataHelper( ActivityMetadata metadata, InArgument <IEnumerable> input, OutArgument <Collection <ErrorRecord> > errors, string commandText, string typeName, string displayName, IDictionary <string, Argument> variables, IDictionary <string, InArgument> parameters, IDictionary <string, Argument> childVariables, IDictionary <string, InArgument> childParameters) { childVariables.Clear(); childParameters.Clear(); RuntimeArgument inputArgument = new RuntimeArgument("Input", typeof(IEnumerable), ArgumentDirection.In); metadata.Bind(input, inputArgument); metadata.AddArgument(inputArgument); RuntimeArgument errorArgument = new RuntimeArgument("Errors", typeof(Collection <ErrorRecord>), ArgumentDirection.Out); metadata.Bind(errors, errorArgument); metadata.AddArgument(errorArgument); if (commandText == null || string.IsNullOrEmpty(commandText.Trim())) { metadata.AddValidationError(string.Format(ErrorMessages.PowerShellRequiresCommand, displayName)); } foreach (KeyValuePair <string, Argument> variable in variables) { string name = variable.Key; Argument argument = variable.Value; RuntimeArgument ra = new RuntimeArgument(name, argument.ArgumentType, argument.Direction, true); metadata.Bind(argument, ra); metadata.AddArgument(ra); Argument childArgument = Argument.Create(argument.ArgumentType, argument.Direction); childVariables.Add(name, Argument.CreateReference(argument, name)); } foreach (KeyValuePair <string, InArgument> parameter in parameters) { string name = parameter.Key; InArgument argument = parameter.Value; RuntimeArgument ra; if (argument.ArgumentType == typeof(bool)) { ra = new RuntimeArgument(name, argument.ArgumentType, argument.Direction, false); } else { ra = new RuntimeArgument(name, argument.ArgumentType, argument.Direction, true); } metadata.Bind(argument, ra); metadata.AddArgument(ra); Argument childArgument = Argument.Create(argument.ArgumentType, argument.Direction); childParameters.Add(name, Argument.CreateReference(argument, name) as InArgument); } }
/// <summary> /// Register activity's metadata /// </summary> /// <param name="metadata"></param> protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.RequireExtension <INotifyInitialize>(); // Register In arguments var episodeArg = new RuntimeArgument(nameof(Episode), typeof(XEpisode), ArgumentDirection.In); metadata.AddArgument(episodeArg); metadata.Bind(this.Episode, episodeArg); // [Episode] Argument must be set if (this.Episode == null) { metadata.AddValidationError( new System.Activities.Validation.ValidationError( "[Episode] argument must be set!", false, nameof(Episode))); } var targetArg = new RuntimeArgument(nameof(Target), typeof(BaseTarget), ArgumentDirection.In); metadata.AddArgument(targetArg); metadata.Bind(this.Target, targetArg); // [Target] Argument must be set if (this.Target == null) { metadata.AddValidationError( new System.Activities.Validation.ValidationError( "[Target] argument must be set!", false, nameof(Target))); } // Register Out arguments var resultArg = new RuntimeArgument("Result", typeof(LocalEpisode), ArgumentDirection.Out); metadata.AddArgument(resultArg); metadata.Bind(this.Result, resultArg); // [Result] Argument must be set if (this.Result == null) { metadata.AddValidationError( new System.Activities.Validation.ValidationError( "[Result] argument must be set!", false, "Result")); } // TODO : Add arguments ... etc ... }
private void ValidateExpressionSubtree(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain) { if (childActivity.Activity.InternalCanInduceIdle) { Activity activity = childActivity.Activity; Activity expressionRoot = this.expressionRoot; RuntimeArgument boundRuntimeArgument = ActivityValidationServices.GetBoundRuntimeArgument(expressionRoot); ValidationError data = new ValidationError(System.Activities.SR.CanInduceIdleActivityInArgumentExpression(boundRuntimeArgument.Name, expressionRoot.Parent.DisplayName, activity.DisplayName), true, boundRuntimeArgument.Name, expressionRoot.Parent); ActivityUtilities.Add <ValidationError>(ref this.errors, data); } }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("ParentChain", typeof(IEnumerable <Activity>), ArgumentDirection.In, true); metadata.Bind(this.ParentChain, argument); metadata.AddArgument(argument); RuntimeArgument argument2 = new RuntimeArgument("RethrowActivity", typeof(Rethrow), ArgumentDirection.In, true); metadata.Bind(this.RethrowActivity, argument2); metadata.AddArgument(argument2); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument durationArgument = new RuntimeArgument("Duration", typeof(TimeSpan), ArgumentDirection.In, true); metadata.Bind(this.Duration, durationArgument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { durationArgument }); metadata.AddImplementationVariable(this.timerBookmark); metadata.AddDefaultExtensionProvider(getDefaultTimerExtension); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.AddImplementationChild(_w1); RuntimeArgument exceptionArgument = new RuntimeArgument("OutcomeOnCancellation", typeof(OutcomeState), ArgumentDirection.In, true); metadata.Bind(this.OutcomeOnCancellation, exceptionArgument); metadata.SetArgumentsCollection(new Collection <RuntimeArgument> { exceptionArgument }); //base.CacheMetadata(metadata); }
public AsyncWaitCallbackMethodExecutor(CodeActivityMetadata metadata, MethodInfo asyncMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection <Argument> parameters, RuntimeArgument returnObject, MruCache <MethodInfo, Func <object, object[], object> > funcCache, ReaderWriterLockSlim locker) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { Fx.Assert(asyncMethod != null, "Must provide asyncMethod"); this.asyncMethod = asyncMethod; this.asyncFunc = MethodCallExpressionHelper.GetFunc(metadata, asyncMethod, funcCache, locker); }
/// <summary> /// 创建并验证活动的参数、变量、子活动和活动委托的说明。 /// </summary> /// <param name="metadata"></param> protected override void CacheMetadata(CodeActivityMetadata metadata) { foreach (KeyValuePair <string, Argument> argument2 in Arguments) { Argument value = argument2.Value; RuntimeArgument argument = new RuntimeArgument(argument2.Key, value.ArgumentType, value.Direction); metadata.Bind(value, argument); metadata.AddArgument(argument); } base.CacheMetadata(metadata); }
//创建并验证活动的参数、变量、子活动和活动委托的说明 protected override void CacheMetadata(CodeActivityMetadata metadata) { base.CacheMetadata(metadata); int num = 0; foreach (InArgument para in Parameters) { RuntimeArgument argument = new RuntimeArgument("attachmentArg" + ++num, para.ArgumentType, ArgumentDirection.In); metadata.Bind(para, argument); metadata.AddArgument(argument); } }
protected override void CacheMetadata(NativeActivityMetadata metadata) { Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>(); foreach (KeyValuePair <string, Argument> pair in this.DelegateArguments) { RuntimeArgument argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, pair.Value.Direction); metadata.Bind(pair.Value, argument); arguments.Add(argument); } metadata.SetArgumentsCollection(arguments); metadata.AddDelegate(this.Delegate); if (this.Delegate != null) { IList <RuntimeDelegateArgument> runtimeDelegateArguments = this.Delegate.RuntimeDelegateArguments; if (this.DelegateArguments.Count != runtimeDelegateArguments.Count) { metadata.AddValidationError(System.Activities.SR.WrongNumberOfArgumentsForActivityDelegate); } for (int i = 0; i < runtimeDelegateArguments.Count; i++) { RuntimeDelegateArgument argument2 = runtimeDelegateArguments[i]; Argument argument3 = null; string name = argument2.Name; if (this.DelegateArguments.TryGetValue(name, out argument3)) { if (argument3.Direction != argument2.Direction) { metadata.AddValidationError(System.Activities.SR.DelegateParameterDirectionalityMismatch(name, argument3.Direction, argument2.Direction)); } if (argument2.Direction == ArgumentDirection.In) { if (!TypeHelper.AreTypesCompatible(argument3.ArgumentType, argument2.Type)) { metadata.AddValidationError(System.Activities.SR.DelegateInArgumentTypeMismatch(name, argument2.Type, argument3.ArgumentType)); } } else if (!TypeHelper.AreTypesCompatible(argument2.Type, argument3.ArgumentType)) { metadata.AddValidationError(System.Activities.SR.DelegateOutArgumentTypeMismatch(name, argument2.Type, argument3.ArgumentType)); } } else { metadata.AddValidationError(System.Activities.SR.InputParametersMissing(argument2.Name)); } if (!this.hasOutputArguments && ArgumentDirectionHelper.IsOut(argument2.Direction)) { this.hasOutputArguments = true; } } } }
/// <summary> /// Add activities, variables and argument to metadata /// </summary> /// <param name="metadata">Metadata</param> private void SetupMetadata(NativeActivityMetadata metadata) { metadata.AddDelegate(OnInit); metadata.AddDelegate(OnComplete); metadata.AddImplementationChild(_approveSequence); metadata.AddDefaultExtensionProvider(() => new WorkflowStateData()); metadata.AddImplementationVariable(DelaySpan); var argAssignTo = new RuntimeArgument("AssignResultTo", typeof(string), ArgumentDirection.Out); metadata.Bind(AssignResultTo, argAssignTo); metadata.AddArgument(argAssignTo); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); foreach (KeyValuePair<string, Argument> pair in this.DelegateArguments) { RuntimeArgument argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, pair.Value.Direction); metadata.Bind(pair.Value, argument); arguments.Add(argument); } metadata.SetArgumentsCollection(arguments); metadata.AddDelegate(this.Delegate); if (this.Delegate != null) { IList<RuntimeDelegateArgument> runtimeDelegateArguments = this.Delegate.RuntimeDelegateArguments; if (this.DelegateArguments.Count != runtimeDelegateArguments.Count) { metadata.AddValidationError(System.Activities.SR.WrongNumberOfArgumentsForActivityDelegate); } for (int i = 0; i < runtimeDelegateArguments.Count; i++) { RuntimeDelegateArgument argument2 = runtimeDelegateArguments[i]; Argument argument3 = null; string name = argument2.Name; if (this.DelegateArguments.TryGetValue(name, out argument3)) { if (argument3.Direction != argument2.Direction) { metadata.AddValidationError(System.Activities.SR.DelegateParameterDirectionalityMismatch(name, argument3.Direction, argument2.Direction)); } if (argument2.Direction == ArgumentDirection.In) { if (!TypeHelper.AreTypesCompatible(argument3.ArgumentType, argument2.Type)) { metadata.AddValidationError(System.Activities.SR.DelegateInArgumentTypeMismatch(name, argument2.Type, argument3.ArgumentType)); } } else if (!TypeHelper.AreTypesCompatible(argument2.Type, argument3.ArgumentType)) { metadata.AddValidationError(System.Activities.SR.DelegateOutArgumentTypeMismatch(name, argument2.Type, argument3.ArgumentType)); } } else { metadata.AddValidationError(System.Activities.SR.InputParametersMissing(argument2.Name)); } if (!this.hasOutputArguments && ArgumentDirectionHelper.IsOut(argument2.Direction)) { this.hasOutputArguments = true; } } } }
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) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); RuntimeArgument argument = new RuntimeArgument("Message", typeof(string), ArgumentDirection.In); metadata.Bind(this.Message, argument); arguments.Add(argument); RuntimeArgument argument2 = new RuntimeArgument("IsWarning", typeof(bool), ArgumentDirection.In, false); metadata.Bind(this.IsWarning, argument2); arguments.Add(argument2); RuntimeArgument argument3 = new RuntimeArgument("PropertyName", typeof(string), ArgumentDirection.In, false); metadata.Bind(this.PropertyName, argument3); arguments.Add(argument3); metadata.SetArgumentsCollection(arguments); }
public MethodExecutor(Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) { Fx.Assert(invokingActivity != null, "Must provide invokingActivity"); Fx.Assert(targetType != null || (targetObject != null), "Must provide targetType or targetObject"); Fx.Assert(parameters != null, "Must provide parameters"); // returnObject is optional this.invokingActivity = invokingActivity; this.targetType = targetType; this.targetObject = targetObject; this.parameters = parameters; this.returnObject = returnObject; }
protected override void CacheMetadata(NativeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); RuntimeArgument argument = new RuntimeArgument("Reason", typeof(string), ArgumentDirection.In, false); metadata.Bind(this.Reason, argument); RuntimeArgument argument2 = new RuntimeArgument("Exception", typeof(System.Exception), ArgumentDirection.In, false); metadata.Bind(this.Exception, argument2); arguments.Add(argument); arguments.Add(argument2); metadata.SetArgumentsCollection(arguments); if (((this.Reason == null) || this.Reason.IsEmpty) && ((this.Exception == null) || this.Exception.IsEmpty)) { metadata.AddValidationError(System.Activities.SR.OneOfTwoPropertiesMustBeSet("Reason", "Exception", "TerminateWorkflow", base.DisplayName)); } }
protected override void CacheMetadata(CodeActivityMetadata metadata) { if (this.parameters != null) { int num = 0; foreach (InArgument argument in this.parameters) { RuntimeArgument argument2 = new RuntimeArgument("Parameter" + num++, argument.ArgumentType, ArgumentDirection.In); metadata.Bind(argument, argument2); metadata.AddArgument(argument2); } } RuntimeArgument argument3 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out, true); metadata.Bind(this.Message, argument3); metadata.AddArgument(argument3); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Condition", typeof(bool), ArgumentDirection.In, true); metadata.Bind(this.Condition, argument); metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument }); Collection<Activity> collection = null; if (this.Then != null) { ActivityUtilities.Add<Activity>(ref collection, this.Then); } if (this.Else != null) { ActivityUtilities.Add<Activity>(ref collection, this.Else); } metadata.SetChildrenCollection(collection); }
private static bool CheckIfArgumentIsNotBound(RuntimeArgument argument, IDictionary<string, object> inputs) { if (((argument.Owner != null) && (argument.Owner.Parent == null)) && ArgumentDirectionHelper.IsOut(argument.Direction)) { return false; } if ((argument.BoundArgument != null) && (argument.BoundArgument.Expression != null)) { return false; } if ((inputs != null) && inputs.ContainsKey(argument.Name)) { return false; } return true; }
public ArgumentInfo(RuntimeArgument argument) { this.Name = argument.Name; Fx.Assert(argument.Type != null, "argument Type must not be null."); this.Type = argument.Type; this.HasGetTypeBeenAttempted = true; this.FullAssemblyQualifiedTypeName = this.Type.AssemblyQualifiedName; // this versionless assembly-qualified type name causes types of different versions // to be considered equal for the sake of argument matching. // Serializing the argument type info in a string format allows // the map to be loaded into environment in which the types may not be available. this.versionlessAssemblyQualifiedTypeName = GenerateVersionlessAssemblyQualifiedTypeName(argument.Type); this.Direction = argument.Direction; }
protected override void CacheMetadata(CodeActivityMetadata metadata) { if (this.parameters != null) { int count = 0; foreach (InArgument parameter in this.parameters) { RuntimeArgument parameterArgument = new RuntimeArgument(Constants.Parameter + count++, parameter.ArgumentType, ArgumentDirection.In); metadata.Bind(parameter, parameterArgument); metadata.AddArgument(parameterArgument); } } RuntimeArgument messageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out, true); metadata.Bind(this.Message, messageArgument); metadata.AddArgument(messageArgument); Fx.Assert(this.Send != null, "Send cannot be null"); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument messageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.InOut, true); metadata.Bind(this.Message, messageArgument); metadata.AddArgument(messageArgument); if (this.parameters != null) { int count = 0; foreach (OutArgument parameter in this.parameters) { RuntimeArgument parameterArgument = new RuntimeArgument(Constants.Parameter + count++, parameter.ArgumentType, ArgumentDirection.Out); metadata.Bind(parameter, parameterArgument); metadata.AddArgument(parameterArgument); } } RuntimeArgument noPersistHandleArgument = new RuntimeArgument(Constants.NoPersistHandle, Constants.NoPersistHandleType, ArgumentDirection.In); metadata.Bind(this.NoPersistHandle, noPersistHandleArgument); metadata.AddArgument(noPersistHandleArgument); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); Type valueType = TypeHelper.ObjectType; if (this.Value != null) { valueType = this.Value.ArgumentType; } RuntimeArgument valueArgument = new RuntimeArgument("Value", valueType, ArgumentDirection.In, true); metadata.Bind(this.Value, valueArgument); Type toType = TypeHelper.ObjectType; if (this.To != null) { toType = this.To.ArgumentType; } RuntimeArgument toArgument = new RuntimeArgument("To", toType, ArgumentDirection.Out, true); metadata.Bind(this.To, toArgument); arguments.Add(valueArgument); arguments.Add(toArgument); metadata.SetArgumentsCollection(arguments); if (this.Value != null && this.To != null) { if (!TypeHelper.AreTypesCompatible(this.Value.ArgumentType, this.To.ArgumentType)) { metadata.AddValidationError(SR.TypeMismatchForAssign( this.Value.ArgumentType, this.To.ArgumentType, this.DisplayName)); } } }