public If(InArgument<bool> condition) : this() { if (condition == null) { throw FxTrace.Exception.ArgumentNull("condition"); } this.Condition = condition; }
/// <summary> /// Initializes a new instance of the LogBuildMessage class /// </summary> public LogBuildMessage() { this.importance = new InArgument<BuildMessageImportance>(new VisualBasicValue<BuildMessageImportance> { ExpressionText = "Microsoft.TeamFoundation.Build.Client.BuildMessageImportance.Normal" }); }
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; }
public SubscribeFileChanges(InArgument<FileChangeSubscriptionHandle> subscriptionHandle, InArgument<string> folder, InArgument<string> pattern, bool subfolders) : this() { this.SubscriptionHandle = subscriptionHandle; this.WatchFolder = folder; this.WatchPattern = pattern; this.WatchSubfolders = subfolders; }
/// <summary> /// Converts a csv In-Argument to list of string /// </summary> /// <param name="context">Context</param> /// <param name="inArgument">In-Argument with csv-string</param> /// <returns>list of string</returns> internal static List<string> getList(CodeActivityContext context, InArgument<string> inArgument) { List<string> returnList = new List<string>(); if (convertCSVtoListofString(context.GetValue(inArgument)).Count() > 0) { foreach (string i in convertCSVtoListofString(context.GetValue(inArgument))) { returnList.Add(i); } } return returnList; }
public static InArgument CreateReference(InArgument argumentToReference, string referencedArgumentName) { if (argumentToReference == null) { throw FxTrace.Exception.ArgumentNull("argumentToReference"); } if (string.IsNullOrEmpty(referencedArgumentName)) { throw FxTrace.Exception.ArgumentNullOrEmpty("referencedArgumentName"); } return (InArgument) ActivityUtilities.CreateReferenceArgument(argumentToReference.ArgumentType, ArgumentDirection.In, referencedArgumentName); }
public SyncMethodExecutor(MethodInfo syncMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { this.syncMethod = syncMethod; }
public AsyncPatternMethodExecutor(MethodInfo beginMethod, MethodInfo endMethod, Activity invokingActivity, Type targetType, InArgument targetObject, Collection<Argument> parameters, RuntimeArgument returnObject) : base(invokingActivity, targetType, targetObject, parameters, returnObject) { this.beginMethod = beginMethod; this.endMethod = endMethod; }
public UnsubscribeFileChanges(InArgument<FileChangeSubscriptionHandle> subscriptionHandle) : this() { this.SubscriptionHandle = subscriptionHandle; }
static SendReply CreateSendReply(ModelItem target, object context) { SendReply reply = null; ModelItem receive = (ModelItem)context; if (null != receive) { Receive receiveInstance = (Receive)receive.GetCurrentValue(); string name = null; //if no correlation is set - create one if (null == receiveInstance.CorrelatesWith) { Variable handleVariable = null; //first, look for nearest variable scope ModelItemCollection variableScope = VariableHelper.FindRootVariableScope(receive).GetVariableCollection(); if (null != variableScope) { ModelItemCollection correlations = receive.Properties["CorrelationInitializers"].Collection; bool hasRequestReplyHandle = false; foreach (ModelItem item in correlations) { if (item.ItemType.IsAssignableFrom(typeof(RequestReplyCorrelationInitializer))) { hasRequestReplyHandle = true; break; } } if (!hasRequestReplyHandle) { //create unique variable name name = variableScope.CreateUniqueVariableName("__handle", 1); //create variable handleVariable = Variable.Create(name, typeof(CorrelationHandle), VariableModifiers.None); //add it to the scope variableScope.Add(handleVariable); //setup correlation ImportDesigner.AddImport(CorrelationHandleTypeNamespace, receive.GetEditingContext()); VariableValue<CorrelationHandle> expression = new VariableValue<CorrelationHandle> { Variable = handleVariable }; InArgument<CorrelationHandle> handle = new InArgument<CorrelationHandle>(expression); correlations.Add(new RequestReplyCorrelationInitializer { CorrelationHandle = handle }); } } } reply = new SendReply() { DisplayName = string.Format(CultureInfo.CurrentUICulture, "SendReplyTo{0}", receive.Properties["DisplayName"].ComputedValue), Request = (Receive)receive.GetCurrentValue(), }; } else { MessageBox.Show( (string)StringResourceDictionary.Instance["receiveActivityCreateReplyErrorLabel"] ?? "Source 'Reply' element not found!", (string)StringResourceDictionary.Instance["MessagingActivityTitle"] ?? "Send", MessageBoxButton.OK, MessageBoxImage.Error); } return reply; }
public SendMessageContent(InArgument message, Type declaredMessageType) : this(message) { this.DeclaredMessageType = declaredMessageType; }
protected override void CacheMetadata(CodeActivityMetadata metadata) { RuntimeArgument instanceArgument = new RuntimeArgument("Instance", typeof(VolatileReceiveMessageInstance), ArgumentDirection.In); if (this.Instance == null) { this.Instance = new InArgument<VolatileReceiveMessageInstance>(); } metadata.Bind(this.Instance, instanceArgument); metadata.SetArgumentsCollection( new Collection<RuntimeArgument> { instanceArgument }); }
public static SendMessageContent Create(InArgument message, Type declaredMessageType) { return new SendMessageContent(message) { DeclaredMessageType = declaredMessageType }; }
public static SendMessageContent Create(InArgument message) { return new SendMessageContent(message); }
public static InArgument CreateReference (InArgument argumentToReference, string referencedArgumentName) { throw new NotImplementedException (); }
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); } }
public SendMessageContent(InArgument message) : this() { this.Message = message; }
/// <summary> /// Gets the string passed as parameter if the argument has the value /// true /// </summary> /// <param name="argument">the argument to check</param> /// <param name="context">activity context</param> /// <param name="value">the value to be returned if the variable holds true </param> /// <returns>The value if true an empty string otherwise</returns> private static string GetStringIfTrue(InArgument<bool> argument, ActivityContext context, string value) { return GetStringIfTrue(argument.Get(context), value); }
public If (InArgument<bool> condition) { throw new NotImplementedException (); }
static Activity CreateAverageCalculationWorkflow() { // Variables var iterationVariable = new DelegateInArgument<int>() { Name = "iterationVariable" }; var accumulator = new Variable<int>() { Default = 0, Name = "accumulator" }; // Define the Input and Output arguments that the DynamicActivity binds to var numbers = new InArgument<List<int>>(); var average = new OutArgument<double>(); var result = new Variable<double>() { Name = "result" }; return new DynamicActivity() { DisplayName = "Find average", Properties = { // Input argument new DynamicActivityProperty { Name = "Numbers", Type = typeof(InArgument<List<int>>), Value = numbers }, // Output argument new DynamicActivityProperty { Name = "Average", Type = typeof(OutArgument<double>), Value = average } }, Implementation = () => new Sequence { Variables = { result, accumulator }, Activities = { new ForEach<int> { Values = new ArgumentValue<IEnumerable<int>> { ArgumentName = "Numbers" }, Body = new ActivityAction<int> { Argument = iterationVariable, Handler = new Assign<int> { To = accumulator, Value = new InArgument<int>(env => iterationVariable.Get(env) + accumulator.Get(env)) } } }, // Calculate the average and assign to the output argument. new Assign<double> { To = new ArgumentReference<double> { ArgumentName = "Average" }, Value = new InArgument<double>(env => accumulator.Get(env) / numbers.Get(env).Count<int>()) }, } } }; }