public void SetValue <T>(OutArgument <T> argument, T value)
{
this.ThrowIfDisposed();
if (argument != null)
{
argument.ThrowIfNotInTree();
this.SetValueCore <T>(argument.RuntimeArgument, value);
}
}
public T GetValue <T>(OutArgument <T> argument)
{
this.ThrowIfDisposed();
if (argument == null)
{
throw FxTrace.Exception.ArgumentNull("argument");
}
argument.ThrowIfNotInTree();
return(this.GetValueCore <T>(argument.RuntimeArgument));
}
public static OutArgument CreateReference(OutArgument argumentToReference, string referencedArgumentName)
{
if (argumentToReference == null)
{
throw FxTrace.Exception.ArgumentNull("argumentToReference");
}
if (string.IsNullOrEmpty(referencedArgumentName))
{
throw FxTrace.Exception.ArgumentNullOrEmpty("referencedArgumentName");
}
return((OutArgument)ActivityUtilities.CreateReferenceArgument(argumentToReference.ArgumentType, ArgumentDirection.Out, referencedArgumentName));
}
public static OutArgument CreateReference(OutArgument argumentToReference, string referencedArgumentName)
{
if (argumentToReference == null)
{
throw FxTrace.Exception.ArgumentNull("argumentToReference");
}
if (string.IsNullOrEmpty(referencedArgumentName))
{
throw FxTrace.Exception.ArgumentNullOrEmpty("referencedArgumentName");
}
return (OutArgument) ActivityUtilities.CreateReferenceArgument(argumentToReference.ArgumentType, ArgumentDirection.Out, referencedArgumentName);
}
//[SuppressMessage(FxCop.Category.Design, FxCop.Rule.ConsiderPassingBaseTypesAsParameters,
// Justification = "Generic needed for type inference")]
public void SetValue <T>(OutArgument <T> argument, T value)
{
ThrowIfDisposed();
if (argument == null)
{
// We want to shortcut if the argument is null
return;
}
argument.ThrowIfNotInTree();
SetValueCore(argument.RuntimeArgument, value);
}
public CodeActivityContext(System.Activities.CodeActivityContext context, OutArgument<string[]> buildErrors)
{
_context = context;
_buildErrors = buildErrors;
}
public static OutArgument CreateReference (OutArgument argumentToReference, string referencedArgumentName)
{
throw new NotImplementedException ();
}
// Updates and returns the version of the specified attribute.
private string UpdateVersion(string attributeName, string format, OutArgument<Version> maxVersion)
{
var oldValue = this.file[attributeName];
if (oldValue == null || string.IsNullOrWhiteSpace(format))
{
// do nothing
return oldValue;
}
// parse old version (handle * character)
bool containsWildcard = oldValue.Contains('*');
string versionPattern = "{0}.{1}.{2}.{3}";
if (containsWildcard)
{
if (oldValue.Split('.').Length == 3)
{
oldValue = oldValue.Replace("*", "0.0");
versionPattern = "{0}.{1}.*";
}
else
{
oldValue = oldValue.Replace("*", "0");
versionPattern = "{0}.{1}.{2}.*";
}
}
if (!VersionParser.IsMatch(oldValue))
{
throw new FormatException("Current value for attribute '" + attributeName + "' is not in a correct version format.");
}
var version = new Version(oldValue);
// update version
var tokens = format.Split('.');
if (tokens.Length != 4)
{
throw new FormatException("Specified value for attribute '" + attributeName + "' is not a correct version format.");
}
version = new Version(
Convert.ToInt32(this.ReplaceTokens(tokens[0], version.Major)),
Convert.ToInt32(this.ReplaceTokens(tokens[1], version.Minor)),
Convert.ToInt32(this.ReplaceTokens(tokens[2], version.Build)),
Convert.ToInt32(this.ReplaceTokens(tokens[3], version.Revision)));
this.file[attributeName] = string.Format(versionPattern, version.Major, version.Minor, version.Build, version.Revision);
if (version > maxVersion.Get(this.ActivityContext))
{
maxVersion.Set(this.ActivityContext, version);
}
return version.ToString();
}
public static ReceiveMessageContent Create(OutArgument message, Type declaredMessageType)
{
return new ReceiveMessageContent(message) { DeclaredMessageType = declaredMessageType };
}
public void SetValue <T> (OutArgument <T> argument, T value)
{
throw new NotImplementedException();
}
public ReceiveMessageContent(OutArgument message)
: this()
{
this.Message = message;
}
// Copies the specified attribute string value to the specified argument if present.
private void ReadStringAttribute(string attributeName, OutArgument argument)
{
var value = this.file[attributeName];
if (value == null)
{
// do nothing
return;
}
argument.Set(this.ActivityContext, value);
}
public static OutArgument CreateReference(OutArgument 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);
}
}
// Copies the specified attribute boolean value to the specified argument if present.
private void ReadBoolAttribute(string attributeName, OutArgument argument)
{
var value = this.file[attributeName];
if (value == null)
{
argument.Set(this.ActivityContext, null);
return;
}
argument.Set(this.ActivityContext, Convert.ToBoolean(value));
}
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);
}
// Copies the specified attribute GUID value to the specified argument if present.
private void ReadGuidAttribute(string attributeName, OutArgument argument)
{
var value = this.file[attributeName];
if (value == null)
{
argument.Set(this.ActivityContext, null);
return;
}
argument.Set(this.ActivityContext, new System.Guid(value));
}
public ReceiveMessageContent(OutArgument message, Type declaredMessageType)
: this(message)
{
this.DeclaredMessageType = declaredMessageType;
}
public static ReceiveMessageContent Create(OutArgument message)
{
return new ReceiveMessageContent(message);
}
public T GetValue <T> (OutArgument <T> argument)
{
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>())
},
}
}
};
}
