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); }
/// <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) { 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); }
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> /// 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); }
/// <summary> /// Register activity's metadata /// </summary> /// <param name="metadata"></param> protected override void CacheMetadata(NativeActivityMetadata metadata) { // Register In arguments RuntimeArgument dictArg = new RuntimeArgument("SplitedDocument", typeof(SplitedDocument), ArgumentDirection.In); metadata.AddArgument(dictArg); metadata.Bind(this.SplitedDocument, dictArg); // [ParaSenDictionary] Argument must be set if (this.SplitedDocument == null) { metadata.AddValidationError( new System.Activities.Validation.ValidationError( "[SplitedDocument] argument must be set!", false, "SplitedDocument")); } // Register In arguments RuntimeArgument localEpisodeArg = new RuntimeArgument("LocalEpisode", typeof(LocalEpisode), ArgumentDirection.In); metadata.AddArgument(localEpisodeArg); metadata.Bind(this.LocalEpisode, localEpisodeArg); // [ParaSenDictionary] Argument must be set if (this.LocalEpisode == null) { metadata.AddValidationError( new System.Activities.Validation.ValidationError( "[LocalEpisode] argument must be set!", false, "LocalEpisode")); } }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(this.CorrelatesWith, argument); metadata.AddArgument(argument); if (this.correlationInitializers != null) { int num = 0; foreach (CorrelationInitializer initializer in this.correlationInitializers) { if (initializer.CorrelationHandle != null) { RuntimeArgument argument2 = new RuntimeArgument("Parameter" + num, initializer.CorrelationHandle.ArgumentType, initializer.CorrelationHandle.Direction, true); metadata.Bind(initializer.CorrelationHandle, argument2); metadata.AddArgument(argument2); num++; } } } RuntimeArgument argument3 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out); metadata.Bind(this.Message, argument3); metadata.AddArgument(argument3); RuntimeArgument argument4 = new RuntimeArgument("noPersistHandle", System.ServiceModel.Activities.Constants.NoPersistHandleType, ArgumentDirection.In); metadata.Bind(this.NoPersistHandle, argument4); metadata.AddArgument(argument4); metadata.AddImplementationVariable(this.receiveMessageInstance); metadata.AddImplementationChild(this.waitForReply); }
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) { 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) { 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) { //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); }
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> /// 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 ... }
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) { // Tell the runtime that we need this extension metadata.RequireExtension(typeof(WaiterExtension)); // Provide a Func to create the extension if it does not already exist metadata.AddDefaultExtensionProvider(() => new WaiterExtension()); metadata.AddArgument(new RuntimeArgument("Waiter", typeof(Waiter), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("Result", typeof(object), ArgumentDirection.Out, false)); metadata.AddImplementationVariable(_noPersistHandle); }
/// <summary> /// Add activities, variables and argument to metadata /// </summary> /// <param name="metadata">Metadata</param> private void SetupMetadata(NativeActivityMetadata metadata) { metadata.AddImplementationChild(_startWorkflowCatch); var workflowIdArgument = new RuntimeArgument("WorkflowId", typeof(string), ArgumentDirection.Out); metadata.Bind(WorkflowId, workflowIdArgument); metadata.AddArgument(workflowIdArgument); var resultArgument = new RuntimeArgument("WorkflowResult", typeof(string), ArgumentDirection.Out); metadata.Bind(WorkflowResult, resultArgument); metadata.AddArgument(resultArgument); metadata.AddImplementationVariable(_currentRequest); }
/// <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) { // Tell the runtime that we need this extension metadata.RequireExtension(typeof(Hosting.FolderWatcherExtension)); // Provide a Func<T> to create the extension if it does not already exist metadata.AddDefaultExtensionProvider(() => new Hosting.FolderWatcherExtension()); metadata.AddArgument(new RuntimeArgument("WatchFolder", typeof(string), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("WatchPattern", typeof(string), ArgumentDirection.In)); metadata.AddImplementationVariable(this.noPersistHandle); metadata.AddImplementationVariable(this.bookmarkWatcher); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.RequireExtension <IMessageAgent>(); metadata.RequireExtension <IEventBroker>(); var messageType = new RuntimeArgument("MessageType", typeof(MessageType), ArgumentDirection.In); metadata.AddArgument(messageType); metadata.Bind(this.MessageType, messageType); var key = new RuntimeArgument("Key", typeof(string), ArgumentDirection.In); metadata.AddArgument(key); metadata.Bind(this.Key, key); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.AddImplementationVariable(Guess); metadata.AddImplementationVariable(Target); var maxNumber = new RuntimeArgument("MaxNumber", typeof(int), ArgumentDirection.In, true); metadata.Bind(MaxNumber, maxNumber); metadata.AddArgument(maxNumber); var turns = new RuntimeArgument("Turns", typeof(int), ArgumentDirection.Out, true); metadata.Bind(Turns, turns); metadata.AddArgument(turns); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { var arg = new RuntimeArgument("ParentChain", typeof(IEnumerable <Activity>), ArgumentDirection.In, isRequired: true); metadata.Bind(ParentChain, arg); metadata.AddArgument(arg); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.SetImplementationVariablesCollection(new Collection <Variable> { this.currentCompensationToken }); Collection <Activity> children = new Collection <Activity>(); if (this.CompensationHandler != null) { children.Add(this.CompensationHandler); } if (this.ConfirmationHandler != null) { children.Add(this.ConfirmationHandler); } if (this.CancellationHandler != null) { children.Add(this.CancellationHandler); } metadata.SetChildrenCollection(children); Collection <Activity> implementationChildren = new Collection <Activity> { this.DefaultCompensation, this.DefaultConfirmation }; metadata.SetImplementationChildrenCollection(implementationChildren); RuntimeArgument argument = new RuntimeArgument("CompensationId", typeof(long), ArgumentDirection.In); metadata.Bind(this.compensationId, argument); metadata.AddArgument(argument); }
/// <summary> /// Gets or sets the arguments of the child workflow. /// </summary> /// <value> /// The child arguments. /// </value> /// <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 (string argumentKey in this.ChildArguments.Keys) { Argument argument = this.ChildArguments[argumentKey]; RuntimeArgument runtimeArgument = new RuntimeArgument(argumentKey, argument.ArgumentType, argument.Direction); metadata.Bind(argument, runtimeArgument); metadata.AddArgument(runtimeArgument); } try { DynamicActivity dynamicActivity = this.LoadDynamicActivityFromCache(); if (dynamicActivity != null) { this.Validate(metadata, dynamicActivity); } else { metadata.AddValidationError(Resources.SpecifyValidWorkflowValidationErrorText); } } catch (Exception ex) { metadata.AddValidationError(string.Format(Resources.FailedToLoadWorkflowValidationErrorText, ex.Message)); } }
/// <summary> /// Store implementation variables /// </summary> /// <param name="metadata"></param> protected override void CacheMetadata(NativeActivityMetadata metadata) { // add the arguments to the argument collection metadata.AddArgument(new RuntimeArgument("Values", typeof(IEnumerable <T>), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("ThrottleLimit", typeof(int), ArgumentDirection.In)); // initialize the hasCompleted and valueEnumerator and add it to the list of private variables this.hasCompleted = new Variable <bool>(); metadata.AddImplementationVariable(this.hasCompleted); this.valueEnumerator = new Variable <IEnumerator <T> >(); metadata.AddImplementationVariable(this.valueEnumerator); // add the body to the delegates collection metadata.AddDelegate(this.Body); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { //base.CacheMetadata(metadata); metadata.AddDelegate(Notify); metadata.AddArgument(new RuntimeArgument( "Strings", typeof(List <String>), ArgumentDirection.In)); metadata.AddImplementationVariable(NextIndex); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument bookmarkValueArgument = new RuntimeArgument("BookmarkValue", typeof(T), ArgumentDirection.Out); metadata.Bind(this.BookmarkValue, bookmarkValueArgument); metadata.AddArgument(bookmarkValueArgument); }
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 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(NativeActivityMetadata metadata) { // Tell the runtime that we need this extension metadata.RequireExtension(typeof(Hosting.FolderWatcherExtension)); // Provide a Func<T> to create the extension if it does not already exist metadata.AddDefaultExtensionProvider(() => new Hosting.FolderWatcherExtension()); if (this.SubscriptionHandle == null) { metadata.AddValidationError(String.Format( Properties.Resources.SubscriptionHandleCannotBeNull, base.DisplayName)); } metadata.AddArgument(new RuntimeArgument("SubscriptionHandle", typeof(FileChangeSubscriptionHandle), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("WatchFolder", typeof(string), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("WatchPattern", typeof(string), ArgumentDirection.In)); metadata.AddImplementationVariable(this.bookmark); }
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 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); }
/// <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); }
public static void AddRuntimeArgument <T>( this NativeActivityMetadata metadata, InOutArgument <T> argument, string argumentName, bool isRequired, List <string> overloadGroupNames) { RuntimeArgument runtimeArgument = new RuntimeArgument(argumentName, typeof(T), ArgumentDirection.InOut, isRequired, overloadGroupNames); metadata.Bind((Argument)argument, runtimeArgument); metadata.AddArgument(runtimeArgument); }
/// <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); }
/// <summary> /// Add activities, variables and argument to metadata /// </summary> /// <param name="metadata">Metadata</param> private void SetupMetadata(NativeActivityMetadata metadata) { metadata.AddImplementationVariable(_request); metadata.AddImplementationVariable(_response); metadata.AddDelegate(OnCompleting); var runtimeArgument = new RuntimeArgument("WfCorrelation", typeof(CorrelationHandle), ArgumentDirection.In); metadata.Bind(CorrelationHandle, runtimeArgument); metadata.AddArgument(runtimeArgument); metadata.AddImplementationChild(_receive); metadata.AddImplementationChild(_sendReply); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument argument = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.InOut, true); metadata.Bind(this.Message, argument); metadata.AddArgument(argument); if (this.parameters != null) { int num = 0; foreach (OutArgument argument2 in this.parameters) { RuntimeArgument argument3 = new RuntimeArgument("Parameter" + num++, argument2.ArgumentType, ArgumentDirection.Out); metadata.Bind(argument2, argument3); metadata.AddArgument(argument3); } } RuntimeArgument argument4 = new RuntimeArgument("noPersistHandle", System.ServiceModel.Activities.Constants.NoPersistHandleType, ArgumentDirection.In); metadata.Bind(this.NoPersistHandle, argument4); metadata.AddArgument(argument4); }
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); }
/// <summary> /// Creates and validates a description of the activity's arguments. /// </summary> /// <param name="metadata"></param> protected override void CacheMetadata(NativeActivityMetadata metadata) { base.CacheMetadata(metadata); // bind arguments collection Arguments .Select((i, j) => Tuple.Create(i, new RuntimeArgument($"Arg{j}", typeof(object), ArgumentDirection.In))) .ForEach(i => { metadata.Bind(i.Item1, i.Item2); metadata.AddArgument(i.Item2); }); }
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) { // Tell the runtime that we need this extension metadata.RequireExtension(typeof(Hosting.FolderWatcherExtension)); // Provide a Func<T> to create the extension if it does not already exist metadata.AddDefaultExtensionProvider(() => new Hosting.FolderWatcherExtension()); if (this.SubscriptionHandle == null) { metadata.AddValidationError(String.Format( Properties.Resources.SubscriptionHandleCannotBeNull, base.DisplayName)); } metadata.AddArgument(new RuntimeArgument("SubscriptionHandle", typeof(FileChangeSubscriptionHandle), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("WatchFolder", typeof(string), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("WatchPattern", typeof(string), ArgumentDirection.In)); metadata.AddImplementationVariable(this.bookmark); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { // Tell the runtime that we need this extension metadata.RequireExtension(typeof(Hosting.FileCopyExtension)); // Provide a Func<T> to create the extension if it does not already exist metadata.AddDefaultExtensionProvider(() => new Hosting.FileCopyExtension()); if (this.StepIncrement < 0 || this.StepIncrement > 100) metadata.AddValidationError(Properties.Resources.StepIncrementOutOfRange); if (this.OnProgress != null) metadata.AddDelegate(this.OnProgress); metadata.AddImplementationVariable(this.noPersistHandle); metadata.AddImplementationVariable(this.bookmarkProgress); metadata.AddArgument(new RuntimeArgument("Source", typeof(string), ArgumentDirection.In, true)); metadata.AddArgument(new RuntimeArgument("Target", typeof(string), ArgumentDirection.In, true)); }
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); }
/// <summary> /// The cache metadata. /// </summary> /// <param name="metadata"> /// The metadata. /// </param> protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.AddArgument(new RuntimeArgument("UntilDate", typeof(DateTime), ArgumentDirection.In, true)); metadata.AddImplementationChild(this.delay); metadata.AddImplementationVariable(this.delayInterval); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { // Will use config to obtain cache information metadata.RequireExtension(typeof (DataCacheFactory)); metadata.AddDefaultExtensionProvider(() => new DataCacheFactory()); metadata.RequireExtension(typeof (DataCacheNotificationExtension)); metadata.AddDefaultExtensionProvider(() => new DataCacheNotificationExtension()); metadata.AddArgument(new RuntimeArgument("CacheName", typeof (string), ArgumentDirection.In, false)); metadata.AddArgument(new RuntimeArgument("Operations", typeof (IEnumerable<DataCacheOperationDescriptor>), ArgumentDirection.Out, false)); metadata.AddArgument(new RuntimeArgument("NotificationDescriptor", typeof (DataCacheNotificationDescriptor), ArgumentDirection.Out, false)); metadata.AddImplementationVariable(_noPersistHandle); }
/// <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.Result != null) { RuntimeArgument resultArgument = new RuntimeArgument(Constants.Result, this.Result.ArgumentType, ArgumentDirection.In); metadata.Bind(this.Result, resultArgument); metadata.AddArgument(resultArgument); } 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); if (this.Message == null) { this.Message = new OutArgument<Message>(); } metadata.Bind(this.Message, messageArgument); metadata.AddArgument(messageArgument); RuntimeArgument correlatesWithArgument = new RuntimeArgument(Constants.CorrelatesWith, Constants.CorrelationHandleType, ArgumentDirection.In); if (this.CorrelatesWith == null) { this.CorrelatesWith = new InArgument<CorrelationHandle>(); } metadata.Bind(this.CorrelatesWith, correlatesWithArgument); metadata.AddArgument(correlatesWithArgument); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { metadata.SetImplementationVariablesCollection( new Collection<Variable> { this.currentCompensationToken, }); Collection<Activity> children = new Collection<Activity>(); if (this.CompensationHandler != null) { children.Add(CompensationHandler); } if (this.ConfirmationHandler != null) { children.Add(ConfirmationHandler); } if (this.CancellationHandler != null) { children.Add(CancellationHandler); } metadata.SetChildrenCollection(children); Collection<Activity> implementationChildren = new Collection<Activity>(); Fx.Assert(DefaultCompensation != null, "DefaultCompensation must be valid"); implementationChildren.Add(DefaultCompensation); Fx.Assert(DefaultConfirmation != null, "DefaultConfirmation must be valid"); implementationChildren.Add(DefaultConfirmation); metadata.SetImplementationChildrenCollection(implementationChildren); RuntimeArgument compensationIdArgument = new RuntimeArgument("CompensationId", typeof(long), ArgumentDirection.In); metadata.Bind(this.compensationId, compensationIdArgument); metadata.AddArgument(compensationIdArgument); }
protected override void CacheMetadata(NativeActivityMetadata metadata) { RuntimeArgument correlatesWithArgument = new RuntimeArgument(Constants.CorrelatesWith, Constants.CorrelationHandleType, ArgumentDirection.In); if (this.CorrelatesWith == null) { this.CorrelatesWith = new InArgument<CorrelationHandle>(); } metadata.Bind(this.CorrelatesWith, correlatesWithArgument); metadata.AddArgument(correlatesWithArgument); if (this.correlationInitializers != null) { int count = 0; foreach (CorrelationInitializer correlation in this.correlationInitializers) { if (correlation.CorrelationHandle != null) { RuntimeArgument argument = new RuntimeArgument(Constants.Parameter + count, correlation.CorrelationHandle.ArgumentType, correlation.CorrelationHandle.Direction, true); metadata.Bind(correlation.CorrelationHandle, argument); metadata.AddArgument(argument); count++; } } } RuntimeArgument receiveMessageArgument = new RuntimeArgument(Constants.Message, Constants.MessageType, ArgumentDirection.Out); if (this.Message == null) { this.Message = new OutArgument<Message>(); } metadata.Bind(this.Message, receiveMessageArgument); metadata.AddArgument(receiveMessageArgument); RuntimeArgument noPersistHandleArgument = new RuntimeArgument(Constants.NoPersistHandle, Constants.NoPersistHandleType, ArgumentDirection.In); if (this.NoPersistHandle == null) { this.NoPersistHandle = new InArgument<NoPersistHandle>(); } metadata.Bind(this.NoPersistHandle, noPersistHandleArgument); metadata.AddArgument(noPersistHandleArgument); metadata.AddImplementationVariable(this.receiveMessageInstance); metadata.AddImplementationVariable(this.extensionReceiveBookmark); metadata.AddImplementationChild(this.waitForReply); }