/// <summary>
/// Uses ETS to set the property specified by name to the value on
/// the target bindable object.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
/// <exception cref="SetValueException">
/// If the setter raises an exception.
/// </exception>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
Diagnostics.Assert(!string.IsNullOrEmpty(name), "caller to verify name parameter");
try
{
var setter = parameterMetadata != null
? (parameterMetadata.Setter ?? (parameterMetadata.Setter = GetSetter(Target.GetType(), name)))
: GetSetter(Target.GetType(), name);
setter(Target, value);
}
catch (TargetInvocationException ex)
{
Exception inner = ex.InnerException ?? ex;
throw new SetValueInvocationException("CatchFromBaseAdapterSetValueTI",
inner,
ExtendedTypeSystem.ExceptionWhenSetting,
name, inner.Message);
}
catch (SetValueException) { throw; }
catch (Exception e)
{
throw new SetValueInvocationException("CatchFromBaseAdapterSetValue",
e,
ExtendedTypeSystem.ExceptionWhenSetting,
name, e.Message);
}
}
private void RemoveParameter(CompiledCommandParameter parameter)
{
this.bindableParameters.Remove(parameter.Name);
foreach (string alias in parameter.Aliases)
{
this.aliasedParameters.Remove(alias);
}
}
/// <summary>
/// Constructs an association between the CompiledCommandParameter and the
/// binder that should be used to bind it.
/// </summary>
/// <param name="parameter">
/// The metadata for a parameter.
/// </param>
/// <param name="binderAssociation">
/// The type of binder that should be used to bind the parameter.
/// </param>
internal MergedCompiledCommandParameter(
CompiledCommandParameter parameter,
ParameterBinderAssociation binderAssociation)
{
Diagnostics.Assert(parameter != null, "caller to verify parameter is not null");
this.Parameter = parameter;
this.BinderAssociation = binderAssociation;
}
} // GetDefaultParameterValue
#endregion Parameter default values
/// <summary>
/// Uses ETS to set the property specified by name to the value on
/// the target bindable object.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
if (String.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
Target[name].Value = value;
this.CommandLineParameters.Add(name, value);
} // BindParameter
private void ConstructCompiledParametersUsingRuntimeDefinedParameters(RuntimeDefinedParameterDictionary runtimeDefinedParameters, bool processingDynamicParameters, bool checkNames)
{
foreach (RuntimeDefinedParameter parameter in runtimeDefinedParameters.Values)
{
if (parameter != null)
{
CompiledCommandParameter parameter2 = new CompiledCommandParameter(parameter, processingDynamicParameters);
this.AddParameter(parameter2, checkNames);
}
}
}
internal CommandParameterInfo(CompiledCommandParameter parameter, uint parameterSetFlag)
{
using (CommandParameterInfo.tracer.TraceConstructor((object)this))
{
this.name = parameter != null ? parameter.Name : throw CommandParameterInfo.tracer.NewArgumentNullException(nameof(parameter));
this.parameterType = parameter.Type;
this.isDynamic = parameter.IsDynamic;
this.aliases = new ReadOnlyCollection <string>((IList <string>)parameter.Aliases);
this.SetAttributes((IList <CompiledCommandAttribute>)parameter.CompiledAttributes);
this.SetParameterSetData(parameter.GetParameterSetData(parameterSetFlag));
}
}
internal CommandParameterInfo(CompiledCommandParameter parameter, int parameterSetFlag)
{
if (parameter == null)
{
throw PSTraceSource.NewArgumentNullException("parameter");
}
this.name = parameter.Name;
this.parameterType = parameter.Type;
this.isDynamic = parameter.IsDynamic;
this.aliases = new ReadOnlyCollection<string>(parameter.Aliases);
this.SetAttributes(parameter.CompiledAttributes);
this.SetParameterSetData(parameter.GetParameterSetData(parameterSetFlag));
}
internal CommandParameterInfo(CompiledCommandParameter parameter, int parameterSetFlag)
{
if (parameter == null)
{
throw PSTraceSource.NewArgumentNullException("parameter");
}
this.name = parameter.Name;
this.parameterType = parameter.Type;
this.isDynamic = parameter.IsDynamic;
this.aliases = new ReadOnlyCollection <string>(parameter.Aliases);
this.SetAttributes(parameter.CompiledAttributes);
this.SetParameterSetData(parameter.GetParameterSetData(parameterSetFlag));
}
private static string RetrieveParameterNameForAlias(string key, IDictionary <string, MergedCompiledCommandParameter> dict)
{
MergedCompiledCommandParameter parameter = dict[key];
if (parameter != null)
{
CompiledCommandParameter parameter2 = parameter.Parameter;
if ((parameter2 != null) && !string.IsNullOrEmpty(parameter2.Name))
{
return(parameter2.Name);
}
}
return(string.Empty);
}
private static bool IsParameterMandatory(CompiledCommandParameter parameterMetadata)
{
bool flag = false;
foreach (ParameterSetSpecificMetadata metadata in parameterMetadata.ParameterSetData.Values)
{
if (metadata.IsMandatory)
{
flag = true;
break;
}
}
tracer.WriteLine("isMandatory = {0}", new object[] { flag });
return(flag);
}
private void ValidateNullOrEmptyArgument(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, Type argumentType, object parameterValue, bool recurseIntoCollections)
{
if ((parameterValue == null) && (argumentType != typeof(bool?)))
{
if (!parameterMetadata.AllowsNullArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be null", new object[0]);
ParameterBindingValidationException exception = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, argumentType, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[0]);
throw exception;
}
}
else if (argumentType == typeof(string))
{
string str = parameterValue as string;
if ((str.Length == 0) && !parameterMetadata.AllowsEmptyStringArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be an empty string", new object[0]);
ParameterBindingValidationException exception2 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorEmptyStringNotAllowed", new object[0]);
throw exception2;
}
}
else if (recurseIntoCollections)
{
switch (parameterMetadata.CollectionTypeInformation.ParameterCollectionType)
{
case ParameterCollectionType.IList:
case ParameterCollectionType.Array:
case ParameterCollectionType.ICollectionGeneric:
{
IEnumerator enumerator = LanguagePrimitives.GetEnumerator(parameterValue);
bool flag = true;
while (ParserOps.MoveNext(null, null, enumerator))
{
object obj2 = ParserOps.Current(null, enumerator);
flag = false;
this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.CollectionTypeInformation.ElementType, obj2, false);
}
if (flag && !parameterMetadata.AllowsEmptyCollectionArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be an empty collection", new object[0]);
ParameterBindingValidationException exception3 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", (parameterMetadata.CollectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) ? "ParameterArgumentValidationErrorEmptyArrayNotAllowed" : "ParameterArgumentValidationErrorEmptyCollectionNotAllowed", new object[0]);
throw exception3;
}
return;
}
}
}
}
private void AddParameter(CompiledCommandParameter parameter, bool checkNames)
{
if (checkNames)
{
this.CheckForReservedParameter(parameter.Name);
}
this.bindableParameters.Add(parameter.Name, parameter);
foreach (string str in parameter.Aliases)
{
if (this.aliasedParameters.ContainsKey(str))
{
throw new System.Management.Automation.MetadataException("AliasDeclaredMultipleTimes", null, DiscoveryExceptions.AliasDeclaredMultipleTimes, new object[] { str });
}
this.aliasedParameters.Add(str, parameter);
}
}
private void AddParameter(CompiledCommandParameter parameter, bool checkNames)
{
if (checkNames)
{
this.CheckForReservedParameter(parameter.Name);
}
this.bindableParameters.Add(parameter.Name, parameter);
foreach (string str in parameter.Aliases)
{
if (this.aliasedParameters.ContainsKey(str))
{
throw new System.Management.Automation.MetadataException("AliasDeclaredMultipleTimes", null, DiscoveryExceptions.AliasDeclaredMultipleTimes, new object[] { str });
}
this.aliasedParameters.Add(str, parameter);
}
}
/// <summary>
/// Constructs the parameter info using the specified aliases, attributes, and
/// parameter set metadata.
/// </summary>
/// <param name="parameter">
/// The parameter metadata to retrieve the parameter information from.
/// </param>
/// <param name="parameterSetFlag">
/// The parameter set flag to get the parameter information from.
/// </param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="parameter"/> is null.
/// </exception>
internal CommandParameterInfo(
CompiledCommandParameter parameter,
uint parameterSetFlag)
{
if (parameter is null)
{
throw PSTraceSource.NewArgumentNullException(nameof(parameter));
}
Name = parameter.Name;
ParameterType = parameter.Type;
IsDynamic = parameter.IsDynamic;
Aliases = new ReadOnlyCollection <string>(parameter.Aliases);
SetAttributes(parameter.CompiledAttributes);
SetParameterSetData(parameter.GetParameterSetData(parameterSetFlag));
}
private void AddParameter(MemberInfo member, bool processingDynamicParameters)
{
bool flag1 = false;
bool flag2 = false;
this.CheckForReservedParameter(member.Name);
if (this.bindableParameters.ContainsKey(member.Name))
{
CompiledCommandParameter bindableParameter = this.bindableParameters[member.Name];
Type declaringType = bindableParameter.DeclaringType;
if (declaringType == null)
{
flag1 = true;
}
else
{
InternalParameterMetadata.tracer.WriteLine("Existing parameter DeclaringType = {0}", (object)declaringType.FullName);
InternalParameterMetadata.tracer.WriteLine("New parameter DeclaringType = {0}", (object)member.DeclaringType);
if (declaringType.IsSubclassOf(member.DeclaringType))
{
flag2 = true;
}
else if (member.DeclaringType.IsSubclassOf(declaringType))
{
this.RemoveParameter(bindableParameter);
}
else
{
flag1 = true;
}
}
}
if (flag1)
{
throw new MetadataException("DuplicateParameterDefinition", (Exception)null, "ParameterBinderStrings", "DuplicateParameterDefinition", new object[1]
{
(object)member.Name
});
}
if (flag2)
{
return;
}
this.AddParameter(new CompiledCommandParameter(member, processingDynamicParameters), true);
}
private bool ShouldContinueUncoercedBind(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags, ref object parameterValue)
{
bool flag = false;
Type c = parameterMetadata.Type;
if (parameterValue == null)
{
return(((c == null) || ((flags & ParameterBindingFlags.IsDefaultValue) != ParameterBindingFlags.None)) || (!c.IsValueType && (c != typeof(string))));
}
Type type = parameterValue.GetType();
if (type == c)
{
return(true);
}
if (type.IsSubclassOf(c))
{
return(true);
}
if (c.IsAssignableFrom(type))
{
return(true);
}
if ((parameterValue is PSObject) && !((PSObject)parameterValue).immediateBaseObjectIsEmpty)
{
parameterValue = ((PSObject)parameterValue).BaseObject;
type = parameterValue.GetType();
if (((type == c) || type.IsSubclassOf(c)) || c.IsAssignableFrom(type))
{
return(true);
}
}
if (parameterMetadata.CollectionTypeInformation.ParameterCollectionType != ParameterCollectionType.NotCollection)
{
bool coercionRequired = false;
object obj2 = this.EncodeCollection(parameter, parameterMetadata.Name, parameterMetadata.CollectionTypeInformation, c, parameterValue, false, out coercionRequired);
if ((obj2 != null) && !coercionRequired)
{
parameterValue = obj2;
flag = true;
}
}
return(flag);
}
} // GetParameterSetName
/// <summary>
/// Helper function to retrieve the name of the parameter
/// which defined an alias.
/// </summary>
/// <param name="key"></param>
/// <param name="dict"></param>
/// <returns></returns>
private static string RetrieveParameterNameForAlias(
string key,
IDictionary <string, MergedCompiledCommandParameter> dict)
{
MergedCompiledCommandParameter mergedParam = dict[key];
if (null != mergedParam)
{
CompiledCommandParameter compiledParam = mergedParam.Parameter;
if (null != compiledParam)
{
if (!String.IsNullOrEmpty(compiledParam.Name))
{
return(compiledParam.Name);
}
}
}
return(String.Empty);
}
private void AddParameter(CompiledCommandParameter parameter, bool checkNames)
{
if (checkNames)
{
this.CheckForReservedParameter(parameter.Name);
}
this.bindableParameters.Add(parameter.Name, parameter);
foreach (string alias in parameter.Aliases)
{
if (this.aliasedParameters.ContainsKey(alias))
{
throw new MetadataException("AliasDeclaredMultipleTimes", (Exception)null, "DiscoveryExceptions", "AliasDeclaredMultipleTimes", new object[1]
{
(object)alias
});
}
this.aliasedParameters.Add(alias, parameter);
}
}
/// <summary>
/// Binds the parameters to local variables in the function scope.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
if (value == AutomationNull.Value || value == UnboundParameter.Value)
{
value = null;
}
Diagnostics.Assert(name != null, "The caller should verify that name is not null");
var varPath = new VariablePath(name, VariablePathFlags.Variable);
// If the parameter was allocated in the LocalsTuple, we can avoid creating a PSVariable,
if (LocalScope != null &&
varPath.IsAnyLocal() &&
LocalScope.TrySetLocalParameterValue(varPath.UnqualifiedPath, CopyMutableValues(value)))
{
return;
}
// Otherwise we'll fall through and enter a new PSVariable in the current scope. This
// is what normally happens when dotting (though the above may succeed if a parameter name
// was an automatic variable like $PSBoundParameters.
// First we need to make a variable instance and apply
// any attributes from the script.
PSVariable variable = new PSVariable(varPath.UnqualifiedPath, value,
varPath.IsPrivate ? ScopedItemOptions.Private : ScopedItemOptions.None);
Context.EngineSessionState.SetVariable(varPath, variable, false, CommandOrigin.Internal);
RuntimeDefinedParameter runtimeDefinedParameter;
if (Script.RuntimeDefinedParameters.TryGetValue(name, out runtimeDefinedParameter))
{
// The attributes have already been checked and conversions run, so it is wrong
// to do so again.
variable.AddParameterAttributesNoChecks(runtimeDefinedParameter.Attributes);
}
}
internal void Initialize(CompiledCommandParameter compiledParameterMD)
{
this.name = compiledParameterMD.Name;
this.parameterType = compiledParameterMD.Type;
this.isDynamic = compiledParameterMD.IsDynamic;
this.parameterSets = new Dictionary <string, ParameterSetMetadata>(StringComparer.OrdinalIgnoreCase);
foreach (string str in compiledParameterMD.ParameterSetData.Keys)
{
ParameterSetSpecificMetadata psMD = compiledParameterMD.ParameterSetData[str];
this.parameterSets.Add(str, new ParameterSetMetadata(psMD));
}
this.aliases = new Collection <string>();
foreach (string str2 in compiledParameterMD.Aliases)
{
this.aliases.Add(str2);
}
this.attributes = new Collection <Attribute>();
foreach (Attribute attribute in compiledParameterMD.CompiledAttributes)
{
this.attributes.Add(attribute);
}
}
private void BuildSyntaxForParameterSet(XmlElement command, XmlElement syntax, MergedCommandParameterMetadata parameterMetadata, int i)
{
XmlElement newChild = this.doc.CreateElement("command:syntaxItem", commandURI);
XmlElement element2 = this.doc.CreateElement("maml:name", mamlURI);
XmlText text = this.doc.CreateTextNode(this.commandName);
newChild.AppendChild(element2).AppendChild(text);
foreach (MergedCompiledCommandParameter parameter in parameterMetadata.GetParametersInParameterSet(((int)1) << i))
{
if (parameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
CompiledCommandParameter parameter2 = parameter.Parameter;
ParameterSetSpecificMetadata parameterSetData = parameter2.GetParameterSetData(((int)1) << i);
string parameterDescription = this.GetParameterDescription(parameter2.Name);
bool supportsWildcards = (from attribute in parameter2.CompiledAttributes
where attribute is SupportsWildcardsAttribute
select attribute).Any <System.Attribute>();
XmlElement element3 = this.BuildXmlForParameter(parameter2.Name, parameterSetData.IsMandatory, parameterSetData.ValueFromPipeline, parameterSetData.ValueFromPipelineByPropertyName, parameterSetData.IsPositional ? ((1 + parameterSetData.Position)).ToString(CultureInfo.InvariantCulture) : "named", parameter2.Type, parameterDescription, supportsWildcards, "", true);
newChild.AppendChild(element3);
}
}
command.AppendChild(syntax).AppendChild(newChild);
}
private void ValidatePSTypeName(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, bool retryOtherBindingAfterFailure, object parameterValue)
{
if (parameterValue != null)
{
IEnumerable <string> internalTypeNames = PSObject.AsPSObject(parameterValue).InternalTypeNames;
string pSTypeName = parameterMetadata.PSTypeName;
if (!internalTypeNames.Contains <string>(pSTypeName, StringComparer.OrdinalIgnoreCase))
{
ParameterBindingException exception2;
object[] arguments = new object[] { ((this.invocationInfo != null) && (this.invocationInfo.MyCommand != null)) ? this.invocationInfo.MyCommand.Name : string.Empty, parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), 0, 0, pSTypeName };
PSInvalidCastException innerException = new PSInvalidCastException(ErrorCategory.InvalidArgument.ToString(), null, ResourceManagerCache.GetResourceString("ParameterBinderStrings", "MismatchedPSTypeName"), arguments);
if (!retryOtherBindingAfterFailure)
{
exception2 = new ParameterBindingArgumentTransformationException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName });
}
else
{
exception2 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName });
}
throw exception2;
}
}
}
private int AddParameterSetToMap(string parameterSetName, CompiledCommandParameter parameter)
{
int num = -1;
if (!string.IsNullOrEmpty(parameterSetName))
{
num = this.parameterSetMap.IndexOf(parameterSetName);
if (num == -1)
{
if (this.nextAvailableParameterSetIndex == uint.MaxValue)
{
ParsingMetadataException metadataException = new ParsingMetadataException("ParsingTooManyParameterSets", (Exception)null, "Metadata", "ParsingTooManyParameterSets", new object[0]);
MergedCommandParameterMetadata.tracer.TraceException((Exception)metadataException);
throw metadataException;
}
this.parameterSetMap.Add(parameterSetName);
num = this.parameterSetMap.IndexOf(parameterSetName);
++this.nextAvailableParameterSetIndex;
}
MergedCommandParameterMetadata.tracer.WriteLine("ParameterSet: {0} Added At: {1}", (object)parameterSetName, (object)num);
}
return(num);
}
private void AddParameter(MemberInfo member, bool processingDynamicParameters)
{
bool flag = false;
bool flag2 = false;
this.CheckForReservedParameter(member.Name);
if (this.bindableParameters.ContainsKey(member.Name))
{
CompiledCommandParameter parameter = this.bindableParameters[member.Name];
Type declaringType = parameter.DeclaringType;
if (declaringType == null)
{
flag = true;
}
else if (declaringType.IsSubclassOf(member.DeclaringType))
{
flag2 = true;
}
else if (member.DeclaringType.IsSubclassOf(declaringType))
{
this.RemoveParameter(parameter);
}
else
{
flag = true;
}
}
if (flag)
{
throw new System.Management.Automation.MetadataException("DuplicateParameterDefinition", null, ParameterBinderStrings.DuplicateParameterDefinition, new object[] { member.Name });
}
if (!flag2)
{
CompiledCommandParameter parameter2 = new CompiledCommandParameter(member, processingDynamicParameters);
this.AddParameter(parameter2, true);
}
}
private void BuildSyntaxForParameterSet(
XmlElement command,
XmlElement syntax,
MergedCommandParameterMetadata parameterMetadata,
int i)
{
XmlElement element1 = this.doc.CreateElement("command:syntaxItem", HelpCommentsParser.commandURI);
XmlElement element2 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
XmlText textNode = this.doc.CreateTextNode(this.commandName);
element1.AppendChild((XmlNode)element2).AppendChild((XmlNode)textNode);
foreach (MergedCompiledCommandParameter parametersInParameter in parameterMetadata.GetParametersInParameterSet((uint)(1 << i)))
{
if (parametersInParameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
CompiledCommandParameter parameter = parametersInParameter.Parameter;
ParameterSetSpecificMetadata parameterSetData = parameter.GetParameterSetData((uint)(1 << i));
string parameterDescription = this.GetParameterDescription(parameter.Name);
XmlElement xmlElement = this.BuildXmlForParameter(parameter.Name, parameterSetData.IsMandatory, parameterSetData.ValueFromPipeline, parameterSetData.ValueFromPipelineByPropertyName, parameterSetData.IsPositional ? (1 + parameterSetData.Position).ToString((IFormatProvider)CultureInfo.InvariantCulture) : "named", parameter.Type, parameterDescription, true);
element1.AppendChild((XmlNode)xmlElement);
}
}
command.AppendChild((XmlNode)syntax).AppendChild((XmlNode)element1);
}
/// <summary>
/// Fills in the data for an instance of this class using the specified runtime-defined parameters
/// </summary>
///
/// <param name="runtimeDefinedParameters">
/// A description of the parameters and their metadata.
/// </param>
///
/// <param name="processingDynamicParameters">
/// True if dynamic parameters are being processed, or false otherwise.
/// </param>
///
/// <param name="checkNames">
/// Check if the parameter name has been reserved.
/// </param>
///
/// <exception cref="MetadataException">
/// If a parameter defines the same parameter-set name multiple times.
/// If the attributes could not be read from a property or field.
/// </exception>
///
private void ConstructCompiledParametersUsingRuntimeDefinedParameters(
RuntimeDefinedParameterDictionary runtimeDefinedParameters,
bool processingDynamicParameters,
bool checkNames)
{
Diagnostics.Assert(
runtimeDefinedParameters != null,
"This method should only be called when constructed with a valid runtime-defined parameter collection");
foreach (RuntimeDefinedParameter parameterDefinition in runtimeDefinedParameters.Values)
{
// Create the compiled parameter and add it to the bindable parameters collection
// NTRAID#Windows Out Of Band Releases-926374-2005/12/22-JonN
if (null == parameterDefinition)
continue;
CompiledCommandParameter parameter = new CompiledCommandParameter(parameterDefinition, processingDynamicParameters);
AddParameter(parameter, checkNames);
}
} // ConstructCompiledParametersUsingRuntimeDefinedParameters
private bool PrepareCommandElements(ExecutionContext context)
{
int num = 0;
bool dotSource = this._commandAst.InvocationOperator == TokenKind.Dot;
CommandProcessorBase base2 = null;
string resolvedCommandName = null;
bool flag2 = false;
try
{
base2 = this.PrepareFromAst(context, out resolvedCommandName) ?? context.CreateCommand(resolvedCommandName, dotSource);
}
catch (RuntimeException exception)
{
CommandProcessorBase.CheckForSevereException(exception);
if ((this._commandAst.IsInWorkflow() && (resolvedCommandName != null)) && CompletionCompleters.PseudoWorkflowCommands.Contains<string>(resolvedCommandName, StringComparer.OrdinalIgnoreCase))
{
flag2 = true;
}
else
{
return false;
}
}
CommandProcessor commandProcessor = base2 as CommandProcessor;
ScriptCommandProcessorBase base3 = base2 as ScriptCommandProcessorBase;
bool flag3 = (commandProcessor != null) && commandProcessor.CommandInfo.ImplementsDynamicParameters;
List<object> list = flag3 ? new List<object>(this._commandElements.Count) : null;
if (((commandProcessor != null) || (base3 != null)) || flag2)
{
num++;
while (num < this._commandElements.Count)
{
CommandParameterAst parameterAst = this._commandElements[num] as CommandParameterAst;
if (parameterAst != null)
{
if (list != null)
{
list.Add(parameterAst.Extent.Text);
}
AstPair item = (parameterAst.Argument != null) ? new AstPair(parameterAst, parameterAst.Argument) : new AstPair(parameterAst);
this._arguments.Add(item);
}
else
{
StringConstantExpressionAst ast2 = this._commandElements[num] as StringConstantExpressionAst;
if ((ast2 == null) || !ast2.Value.Trim().Equals("-", StringComparison.OrdinalIgnoreCase))
{
ExpressionAst argumentAst = this._commandElements[num] as ExpressionAst;
if (argumentAst != null)
{
if (list != null)
{
list.Add(argumentAst.Extent.Text);
}
this._arguments.Add(new AstPair(null, argumentAst));
}
}
}
num++;
}
}
if (commandProcessor != null)
{
this._function = false;
if (flag3)
{
ParameterBinderController.AddArgumentsToCommandProcessor(commandProcessor, list.ToArray());
bool flag4 = false;
bool flag5 = false;
do
{
CommandProcessorBase currentCommandProcessor = context.CurrentCommandProcessor;
try
{
context.CurrentCommandProcessor = commandProcessor;
commandProcessor.SetCurrentScopeToExecutionScope();
if (!flag4)
{
commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(commandProcessor.arguments);
}
else
{
flag5 = true;
commandProcessor.CmdletParameterBinderController.ClearUnboundArguments();
commandProcessor.CmdletParameterBinderController.BindCommandLineParametersNoValidation(new Collection<CommandParameterInternal>());
}
}
catch (ParameterBindingException exception2)
{
if ((exception2.ErrorId == "MissingArgument") || (exception2.ErrorId == "AmbiguousParameter"))
{
flag4 = true;
}
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
}
finally
{
context.CurrentCommandProcessor = currentCommandProcessor;
commandProcessor.RestorePreviousScope();
}
}
while (flag4 && !flag5);
}
this._commandInfo = commandProcessor.CommandInfo;
this._commandName = commandProcessor.CommandInfo.Name;
this._bindableParameters = commandProcessor.CmdletParameterBinderController.BindableParameters;
this._defaultParameterSetFlag = commandProcessor.CommandInfo.CommandMetadata.DefaultParameterSetFlag;
}
else if (base3 != null)
{
this._function = true;
this._commandInfo = base3.CommandInfo;
this._commandName = base3.CommandInfo.Name;
this._bindableParameters = base3.ScriptParameterBinderController.BindableParameters;
this._defaultParameterSetFlag = 0;
}
else if (!flag2)
{
return false;
}
if (this._commandAst.IsInWorkflow())
{
Type type = Type.GetType("Microsoft.PowerShell.Workflow.AstToWorkflowConverter, Microsoft.PowerShell.Activities, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
if (type != null)
{
Dictionary<string, Type> dictionary = (Dictionary<string, Type>) type.GetMethod("GetActivityParameters").Invoke(null, new object[] { this._commandAst });
if (dictionary != null)
{
bool flag6 = dictionary.ContainsKey("PSComputerName") && !dictionary.ContainsKey("ComputerName");
List<MergedCompiledCommandParameter> source = new List<MergedCompiledCommandParameter>();
Collection<Attribute> attributes = new Collection<Attribute> {
new ParameterAttribute()
};
foreach (KeyValuePair<string, Type> pair2 in dictionary)
{
if (flag2 || !this._bindableParameters.BindableParameters.ContainsKey(pair2.Key))
{
Type actualActivityParameterType = GetActualActivityParameterType(pair2.Value);
RuntimeDefinedParameter runtimeDefinedParameter = new RuntimeDefinedParameter(pair2.Key, actualActivityParameterType, attributes);
CompiledCommandParameter parameter = new CompiledCommandParameter(runtimeDefinedParameter, false) {
IsInAllSets = true
};
MergedCompiledCommandParameter parameter3 = new MergedCompiledCommandParameter(parameter, ParameterBinderAssociation.DeclaredFormalParameters);
source.Add(parameter3);
}
}
if (source.Any<MergedCompiledCommandParameter>())
{
MergedCommandParameterMetadata metadata = new MergedCommandParameterMetadata();
if (!flag2)
{
metadata.ReplaceMetadata(this._bindableParameters);
}
foreach (MergedCompiledCommandParameter parameter5 in source)
{
metadata.BindableParameters.Add(parameter5.Parameter.Name, parameter5);
}
this._bindableParameters = metadata;
}
foreach (string str2 in ignoredWorkflowParameters)
{
if (this._bindableParameters.BindableParameters.ContainsKey(str2))
{
this._bindableParameters.BindableParameters.Remove(str2);
}
}
if (this._bindableParameters.BindableParameters.ContainsKey("ComputerName") && flag6)
{
this._bindableParameters.BindableParameters.Remove("ComputerName");
string key = (from aliasPair in this._bindableParameters.AliasedParameters
where string.Equals("ComputerName", aliasPair.Value.Parameter.Name)
select aliasPair.Key).FirstOrDefault<string>();
this._bindableParameters.AliasedParameters.Remove(key);
}
}
}
}
this._unboundParameters.AddRange(this._bindableParameters.BindableParameters.Values);
CommandBaseAst ast4 = null;
PipelineAst parent = this._commandAst.Parent as PipelineAst;
if (parent.PipelineElements.Count > 1)
{
foreach (CommandBaseAst ast6 in parent.PipelineElements)
{
if (ast6.GetHashCode() == this._commandAst.GetHashCode())
{
this._isPipelineInputExpected = ast4 != null;
if (this._isPipelineInputExpected)
{
this._pipelineInputType = typeof(object);
}
break;
}
ast4 = ast6;
}
}
return true;
}
} // ReparseUnboundArgumentsForBinder
private static bool IsSwitchAndSetValue(
String argumentName,
CommandParameterInternal argument,
CompiledCommandParameter matchingParameter)
{
bool result = false;
if (matchingParameter.Type == typeof(SwitchParameter))
{
argument.ParameterName = argumentName;
argument.SetArgumentValue(PositionUtilities.EmptyExtent, SwitchParameter.Present);
result = true;
}
return result;
} // EnsureBoolOrSwitchAndSetValue
internal XmlDocument BuildXmlFromComments()
{
this.doc = new XmlDocument();
XmlElement newChild = this.doc.CreateElement("command:command", commandURI);
newChild.SetAttribute("xmlns:maml", mamlURI);
newChild.SetAttribute("xmlns:command", commandURI);
newChild.SetAttribute("xmlns:dev", devURI);
this.doc.AppendChild(newChild);
XmlElement element2 = this.doc.CreateElement("command:details", commandURI);
newChild.AppendChild(element2);
XmlElement element3 = this.doc.CreateElement("command:name", commandURI);
XmlText text = this.doc.CreateTextNode(this.commandName);
element2.AppendChild(element3).AppendChild(text);
if (!string.IsNullOrEmpty(this._sections.Synopsis))
{
XmlElement element4 = this.doc.CreateElement("maml:description", mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:para", mamlURI);
XmlText text2 = this.doc.CreateTextNode(this._sections.Synopsis);
element2.AppendChild(element4).AppendChild(element5).AppendChild(text2);
}
this.DetermineParameterDescriptions();
XmlElement syntax = this.doc.CreateElement("command:syntax", commandURI);
MergedCommandParameterMetadata staticCommandParameterMetadata = this.commandMetadata.StaticCommandParameterMetadata;
if (staticCommandParameterMetadata.ParameterSetCount > 0)
{
for (int i = 0; i < staticCommandParameterMetadata.ParameterSetCount; i++)
{
this.BuildSyntaxForParameterSet(newChild, syntax, staticCommandParameterMetadata, i);
}
}
else
{
this.BuildSyntaxForParameterSet(newChild, syntax, staticCommandParameterMetadata, 0x7fffffff);
}
XmlElement element7 = this.doc.CreateElement("command:parameters", commandURI);
foreach (KeyValuePair <string, MergedCompiledCommandParameter> pair in staticCommandParameterMetadata.BindableParameters)
{
MergedCompiledCommandParameter parameter = pair.Value;
if (parameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
ParameterSetSpecificMetadata parameterSetData;
string key = pair.Key;
string parameterDescription = this.GetParameterDescription(key);
bool isMandatory = false;
bool valueFromPipeline = false;
bool valueFromPipelineByPropertyName = false;
string position = "named";
int num2 = 0;
CompiledCommandParameter parameter2 = parameter.Parameter;
parameter2.ParameterSetData.TryGetValue("__AllParameterSets", out parameterSetData);
while ((parameterSetData == null) && (num2 < 0x20))
{
parameterSetData = parameter2.GetParameterSetData(((int)1) << num2++);
}
if (parameterSetData != null)
{
isMandatory = parameterSetData.IsMandatory;
valueFromPipeline = parameterSetData.ValueFromPipeline;
valueFromPipelineByPropertyName = parameterSetData.ValueFromPipelineByPropertyName;
position = parameterSetData.IsPositional ? ((1 + parameterSetData.Position)).ToString(CultureInfo.InvariantCulture) : "named";
}
Collection <System.Attribute> compiledAttributes = parameter2.CompiledAttributes;
bool supportsWildcards = compiledAttributes.OfType <SupportsWildcardsAttribute>().Any <SupportsWildcardsAttribute>();
string help = "";
object obj2 = null;
PSDefaultValueAttribute attribute = compiledAttributes.OfType <PSDefaultValueAttribute>().FirstOrDefault <PSDefaultValueAttribute>();
if (attribute != null)
{
help = attribute.Help;
if (string.IsNullOrEmpty(help))
{
obj2 = attribute.Value;
}
}
if (string.IsNullOrEmpty(help))
{
RuntimeDefinedParameter parameter3;
if ((obj2 == null) && this.scriptBlock.RuntimeDefinedParameters.TryGetValue(key, out parameter3))
{
obj2 = parameter3.Value;
}
Compiler.DefaultValueExpressionWrapper wrapper = obj2 as Compiler.DefaultValueExpressionWrapper;
if (wrapper != null)
{
help = wrapper.Expression.Extent.Text;
}
else if (obj2 != null)
{
help = PSObject.ToStringParser(null, obj2);
}
}
XmlElement element8 = this.BuildXmlForParameter(key, isMandatory, valueFromPipeline, valueFromPipelineByPropertyName, position, parameter2.Type, parameterDescription, supportsWildcards, help, false);
element7.AppendChild(element8);
}
}
newChild.AppendChild(element7);
if (!string.IsNullOrEmpty(this._sections.Description))
{
XmlElement element9 = this.doc.CreateElement("maml:description", mamlURI);
XmlElement element10 = this.doc.CreateElement("maml:para", mamlURI);
XmlText text3 = this.doc.CreateTextNode(this._sections.Description);
newChild.AppendChild(element9).AppendChild(element10).AppendChild(text3);
}
if (!string.IsNullOrEmpty(this._sections.Notes))
{
XmlElement element11 = this.doc.CreateElement("maml:alertSet", mamlURI);
XmlElement element12 = this.doc.CreateElement("maml:alert", mamlURI);
XmlElement element13 = this.doc.CreateElement("maml:para", mamlURI);
XmlText text4 = this.doc.CreateTextNode(this._sections.Notes);
newChild.AppendChild(element11).AppendChild(element12).AppendChild(element13).AppendChild(text4);
}
if (this._examples.Count > 0)
{
XmlElement element14 = this.doc.CreateElement("command:examples", commandURI);
int num3 = 1;
foreach (string str5 in this._examples)
{
string str7;
string str8;
string str9;
XmlElement element15 = this.doc.CreateElement("command:example", commandURI);
XmlElement element16 = this.doc.CreateElement("maml:title", mamlURI);
string str6 = string.Format(CultureInfo.InvariantCulture, "\t\t\t\t-------------------------- {0} {1} --------------------------", new object[] { HelpDisplayStrings.ExampleUpperCase, num3++ });
XmlText text5 = this.doc.CreateTextNode(str6);
element15.AppendChild(element16).AppendChild(text5);
GetExampleSections(str5, out str7, out str8, out str9);
XmlElement element17 = this.doc.CreateElement("maml:introduction", mamlURI);
XmlElement element18 = this.doc.CreateElement("maml:para", mamlURI);
XmlText text6 = this.doc.CreateTextNode(str7);
element15.AppendChild(element17).AppendChild(element18).AppendChild(text6);
XmlElement element19 = this.doc.CreateElement("dev:code", devURI);
XmlText text7 = this.doc.CreateTextNode(str8);
element15.AppendChild(element19).AppendChild(text7);
XmlElement element20 = this.doc.CreateElement("dev:remarks", devURI);
XmlElement element21 = this.doc.CreateElement("maml:para", mamlURI);
XmlText text8 = this.doc.CreateTextNode(str9);
element15.AppendChild(element20).AppendChild(element21).AppendChild(text8);
for (int j = 0; j < 4; j++)
{
element20.AppendChild(this.doc.CreateElement("maml:para", mamlURI));
}
element14.AppendChild(element15);
}
newChild.AppendChild(element14);
}
if (this._inputs.Count > 0)
{
XmlElement element22 = this.doc.CreateElement("command:inputTypes", commandURI);
foreach (string str10 in this._inputs)
{
XmlElement element23 = this.doc.CreateElement("command:inputType", commandURI);
XmlElement element24 = this.doc.CreateElement("dev:type", devURI);
XmlElement element25 = this.doc.CreateElement("maml:name", mamlURI);
XmlText text9 = this.doc.CreateTextNode(str10);
element22.AppendChild(element23).AppendChild(element24).AppendChild(element25).AppendChild(text9);
}
newChild.AppendChild(element22);
}
IEnumerable outputType = null;
if (this._outputs.Count > 0)
{
outputType = this._outputs;
}
else if (this.scriptBlock.OutputType.Count > 0)
{
outputType = this.scriptBlock.OutputType;
}
if (outputType != null)
{
XmlElement element26 = this.doc.CreateElement("command:returnValues", commandURI);
foreach (object obj3 in outputType)
{
XmlElement element27 = this.doc.CreateElement("command:returnValue", commandURI);
XmlElement element28 = this.doc.CreateElement("dev:type", devURI);
XmlElement element29 = this.doc.CreateElement("maml:name", mamlURI);
string str11 = (obj3 as string) ?? ((PSTypeName)obj3).Name;
XmlText text10 = this.doc.CreateTextNode(str11);
element26.AppendChild(element27).AppendChild(element28).AppendChild(element29).AppendChild(text10);
}
newChild.AppendChild(element26);
}
if (this._links.Count > 0)
{
XmlElement element30 = this.doc.CreateElement("maml:relatedLinks", mamlURI);
foreach (string str12 in this._links)
{
XmlElement element31 = this.doc.CreateElement("maml:navigationLink", mamlURI);
string qualifiedName = Uri.IsWellFormedUriString(Uri.EscapeUriString(str12), UriKind.Absolute) ? "maml:uri" : "maml:linkText";
XmlElement element32 = this.doc.CreateElement(qualifiedName, mamlURI);
XmlText text11 = this.doc.CreateTextNode(str12);
element30.AppendChild(element31).AppendChild(element32).AppendChild(text11);
}
newChild.AppendChild(element30);
}
return(this.doc);
}
/// <summary>
/// Constructs an association between the CompiledCommandParameter and the
/// binder that should be used to bind it.
/// </summary>
///
/// <param name="parameter">
/// The metadata for a parameter.
/// </param>
///
/// <param name="binderAssociation">
/// The type of binder that should be used to bind the parameter.
/// </param>
internal MergedCompiledCommandParameter(
CompiledCommandParameter parameter,
ParameterBinderAssociation binderAssociation)
{
Diagnostics.Assert(parameter != null, "caller to verify parameter is not null");
this.Parameter = parameter;
this.BinderAssociation = binderAssociation;
}
/// <summary>
///
/// </summary>
/// <param name="compiledParameterMD"></param>
internal void Initialize(CompiledCommandParameter compiledParameterMD)
{
_name = compiledParameterMD.Name;
_parameterType = compiledParameterMD.Type;
_isDynamic = compiledParameterMD.IsDynamic;
// Create parameter set metadata
_parameterSets = new Dictionary<string, ParameterSetMetadata>(StringComparer.OrdinalIgnoreCase);
foreach (string key in compiledParameterMD.ParameterSetData.Keys)
{
ParameterSetSpecificMetadata pMD = compiledParameterMD.ParameterSetData[key];
_parameterSets.Add(key, new ParameterSetMetadata(pMD));
}
// Create aliases for this parameter
_aliases = new Collection<string>();
foreach (string alias in compiledParameterMD.Aliases)
{
_aliases.Add(alias);
}
// Create attributes for this parameter
_attributes = new Collection<Attribute>();
foreach (var attrib in compiledParameterMD.CompiledAttributes)
{
_attributes.Add(attrib);
}
}
private void RemoveParameter(CompiledCommandParameter parameter)
{
BindableParameters.Remove(parameter.Name);
// Now add entries in the parameter aliases collection for any aliases.
foreach (string alias in parameter.Aliases)
{
AliasedParameters.Remove(alias);
}
}
internal MergedCompiledCommandParameter(CompiledCommandParameter parameter, ParameterBinderAssociation binderAssociation)
{
this.Parameter = parameter;
this.BinderAssociation = binderAssociation;
}
internal void Initialize(CompiledCommandParameter compiledParameterMD)
{
this.name = compiledParameterMD.Name;
this.parameterType = compiledParameterMD.Type;
this.isDynamic = compiledParameterMD.IsDynamic;
this.parameterSets = new Dictionary<string, ParameterSetMetadata>(StringComparer.OrdinalIgnoreCase);
foreach (string str in compiledParameterMD.ParameterSetData.Keys)
{
ParameterSetSpecificMetadata psMD = compiledParameterMD.ParameterSetData[str];
this.parameterSets.Add(str, new ParameterSetMetadata(psMD));
}
this.aliases = new Collection<string>();
foreach (string str2 in compiledParameterMD.Aliases)
{
this.aliases.Add(str2);
}
this.attributes = new Collection<Attribute>();
foreach (Attribute attribute in compiledParameterMD.CompiledAttributes)
{
this.attributes.Add(attribute);
}
}
} // GetDefaultParameterValue
#endregion Parameter default values
/// <summary>
/// Uses ETS to set the property specified by name to the value on
/// the target bindable object.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
if (String.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
Target[name].Value = value;
this.CommandLineParameters.Add(name, value);
} // BindParameter
private void ValidatePSTypeName(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, bool retryOtherBindingAfterFailure, object parameterValue)
{
if (parameterValue != null)
{
IEnumerable<string> internalTypeNames = PSObject.AsPSObject(parameterValue).InternalTypeNames;
string pSTypeName = parameterMetadata.PSTypeName;
if (!internalTypeNames.Contains<string>(pSTypeName, StringComparer.OrdinalIgnoreCase))
{
ParameterBindingException exception2;
object[] arguments = new object[] { ((this.invocationInfo != null) && (this.invocationInfo.MyCommand != null)) ? this.invocationInfo.MyCommand.Name : string.Empty, parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), 0, 0, pSTypeName };
PSInvalidCastException innerException = new PSInvalidCastException(ErrorCategory.InvalidArgument.ToString(), null, ResourceManagerCache.GetResourceString("ParameterBinderStrings", "MismatchedPSTypeName"), arguments);
if (!retryOtherBindingAfterFailure)
{
exception2 = new ParameterBindingArgumentTransformationException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName });
}
else
{
exception2 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, parameterValue.GetType(), "ParameterBinderStrings", "MismatchedPSTypeName", new object[] { pSTypeName });
}
throw exception2;
}
}
}
internal virtual bool BindParameter(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags)
{
bool flag = false;
bool flag2 = (flags & ParameterBindingFlags.ShouldCoerceType) != ParameterBindingFlags.None;
if (parameter == null)
{
throw PSTraceSource.NewArgumentNullException("parameter");
}
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
using (bindingTracer.TraceScope("BIND arg [{0}] to parameter [{1}]", new object[] { parameter.ArgumentValue, parameterMetadata.Name }))
{
parameter.ParameterName = parameterMetadata.Name;
object argumentValue = parameter.ArgumentValue;
ScriptParameterBinder binder = this as ScriptParameterBinder;
bool bindingScriptCmdlet = false;
if (binder != null)
{
bindingScriptCmdlet = binder.Script.UsesCmdletBinding;
}
foreach (ArgumentTransformationAttribute attribute in parameterMetadata.ArgumentTransformationAttributes)
{
using (bindingTracer.TraceScope("Executing DATA GENERATION metadata: [{0}]", new object[] { attribute.GetType() }))
{
try
{
ArgumentTypeConverterAttribute attribute2 = attribute as ArgumentTypeConverterAttribute;
if (attribute2 != null)
{
if (flag2)
{
argumentValue = attribute2.Transform(this.engine, argumentValue, true, bindingScriptCmdlet);
}
}
else
{
argumentValue = attribute.Transform(this.engine, argumentValue);
}
bindingTracer.WriteLine("result returned from DATA GENERATION: {0}", new object[] { argumentValue });
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
bindingTracer.WriteLine("ERROR: DATA GENERATION: {0}", new object[] { exception.Message });
ParameterBindingException exception2 = new ParameterBindingArgumentTransformationException(exception, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentTransformationError", new object[] { exception.Message });
throw exception2;
}
}
}
if (flag2)
{
argumentValue = this.CoerceTypeAsNeeded(parameter, parameterMetadata.Name, parameterMetadata.Type, parameterMetadata.CollectionTypeInformation, argumentValue);
}
else if (!this.ShouldContinueUncoercedBind(parameter, parameterMetadata, flags, ref argumentValue))
{
goto Label_040E;
}
if ((parameterMetadata.PSTypeName != null) && (argumentValue != null))
{
IEnumerable enumerable = LanguagePrimitives.GetEnumerable(argumentValue);
if (enumerable != null)
{
foreach (object obj3 in enumerable)
{
this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, obj3);
}
}
else
{
this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, argumentValue);
}
}
if ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None)
{
foreach (ValidateArgumentsAttribute attribute3 in parameterMetadata.ValidationAttributes)
{
using (bindingTracer.TraceScope("Executing VALIDATION metadata: [{0}]", new object[] { attribute3.GetType() }))
{
try
{
attribute3.InternalValidate(argumentValue, this.engine);
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
bindingTracer.WriteLine("ERROR: VALIDATION FAILED: {0}", new object[] { exception3.Message });
ParameterBindingValidationException exception4 = new ParameterBindingValidationException(exception3, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationError", new object[] { exception3.Message });
throw exception4;
}
tracer.WriteLine("Validation attribute on {0} returned {1}.", new object[] { parameterMetadata.Name, flag });
}
}
if (IsParameterMandatory(parameterMetadata))
{
this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.Type, argumentValue, true);
}
}
Exception innerException = null;
try
{
this.BindParameter(parameter.ParameterName, argumentValue);
flag = true;
}
catch (SetValueException exception6)
{
innerException = exception6;
}
if (innerException != null)
{
Type typeSpecified = (argumentValue == null) ? null : argumentValue.GetType();
ParameterBindingException exception7 = new ParameterBindingException(innerException, ErrorCategory.WriteError, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, typeSpecified, "ParameterBinderStrings", "ParameterBindingFailed", new object[] { innerException.Message });
throw exception7;
}
Label_040E :;
bindingTracer.WriteLine("BIND arg [{0}] to param [{1}] {2}", new object[] { argumentValue, parameter.ParameterName, flag ? "SUCCESSFUL" : "SKIPPED" });
if (flag)
{
if (this.RecordBoundParameters)
{
this.CommandLineParameters.Add(parameter.ParameterName, argumentValue);
}
MshCommandRuntime commandRuntime = this.Command.commandRuntime as MshCommandRuntime;
if ((commandRuntime != null) && commandRuntime.LogPipelineExecutionDetail)
{
IEnumerable source = LanguagePrimitives.GetEnumerable(argumentValue);
if (source != null)
{
string parameterValue = string.Join(", ", source.Cast <object>().ToArray <object>());
commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, parameterValue);
}
else
{
commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, (argumentValue == null) ? "" : argumentValue.ToString());
}
}
}
return(flag);
}
}
internal MergedCompiledCommandParameter(CompiledCommandParameter parameter, ParameterBinderAssociation binderAssociation)
{
this.Parameter = parameter;
this.BinderAssociation = binderAssociation;
}
/// <summary>
/// Binds a parameter for a native command (application).
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to. For applications
/// this just becomes another parameter...
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
Diagnostics.Assert(false, "Unreachable code");
throw new NotSupportedException();
} // BindParameter
// NTRAID#Windows Out Of Band Releases-906345-2005/06/30-JeffJon
// This call verifies that the parameter is unique or
// can be deemed unique. If not, an exception is thrown.
// If it is unique (or deemed unique), then it is added
// to the bindableParameters collection
//
private void AddParameter(MemberInfo member, bool processingDynamicParameters)
{
bool error = false;
bool useExisting = false;
CheckForReservedParameter(member.Name);
do // false loop
{
CompiledCommandParameter existingParameter;
if (!BindableParameters.TryGetValue(member.Name, out existingParameter))
{
break;
}
Type existingParamDeclaringType = existingParameter.DeclaringType;
if (existingParamDeclaringType == null)
{
error = true;
break;
}
if (existingParamDeclaringType.IsSubclassOf(member.DeclaringType))
{
useExisting = true;
break;
}
if (member.DeclaringType.IsSubclassOf(existingParamDeclaringType))
{
// Need to swap out the new member for the parameter definition
// that is already defined.
RemoveParameter(existingParameter);
break;
}
error = true;
} while (false);
if (error)
{
// A duplicate parameter was found and could not be deemed unique
// through inheritance.
throw new MetadataException(
"DuplicateParameterDefinition",
null,
ParameterBinderStrings.DuplicateParameterDefinition,
member.Name);
}
if (!useExisting)
{
CompiledCommandParameter parameter = new CompiledCommandParameter(member, processingDynamicParameters);
AddParameter(parameter, true);
}
}
private void AddParameter(CompiledCommandParameter parameter, bool checkNames)
{
if (checkNames)
{
CheckForReservedParameter(parameter.Name);
}
BindableParameters.Add(parameter.Name, parameter);
// Now add entries in the parameter aliases collection for any aliases.
foreach (string alias in parameter.Aliases)
{
// NTRAID#Windows Out Of Band Releases-917356-JonN
if (AliasedParameters.ContainsKey(alias))
{
throw new MetadataException(
"AliasDeclaredMultipleTimes",
null,
DiscoveryExceptions.AliasDeclaredMultipleTimes,
alias);
}
AliasedParameters.Add(alias, parameter);
}
}
/// <summary>
/// Binds the parameters to local variables in the function scope
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
if (value == AutomationNull.Value || value == UnboundParameter.Value)
{
value = null;
}
Diagnostics.Assert(name != null, "The caller should verify that name is not null");
var varPath = new VariablePath(name, VariablePathFlags.Variable);
// If the parameter was allocated in the LocalsTuple, we can avoid creating a PSVariable,
if (LocalScope != null
&& varPath.IsAnyLocal()
&& LocalScope.TrySetLocalParameterValue(varPath.UnqualifiedPath, CopyMutableValues(value)))
{
return;
}
// Otherwise we'll fall through and enter a new PSVariable in the current scope. This
// is what normally happens when dotting (though the above may succeed if a parameter name
// was an automatic variable like $PSBoundParameters.
// First we need to make a variable instance and apply
// any attributes from the script.
PSVariable variable = new PSVariable(varPath.UnqualifiedPath, value,
varPath.IsPrivate ? ScopedItemOptions.Private : ScopedItemOptions.None);
Context.EngineSessionState.SetVariable(varPath, variable, false, CommandOrigin.Internal);
RuntimeDefinedParameter runtimeDefinedParameter;
if (Script.RuntimeDefinedParameters.TryGetValue(name, out runtimeDefinedParameter))
{
// The attributes have already been checked and conversions run, so it is wrong
// to do so again.
variable.AddParameterAttributesNoChecks(runtimeDefinedParameter.Attributes);
}
} // BindParameter
/// <summary>
/// An internal constructor which constructs a ParameterMetadata object
/// from compiled command parameter metadata. ParameterMetadata
/// is a proxy written on top of CompiledCommandParameter
/// </summary>
/// <param name="cmdParameterMD">
/// Internal CompiledCommandParameter metadata
/// </param>
internal ParameterMetadata(CompiledCommandParameter cmdParameterMD)
{
Dbg.Assert(null != cmdParameterMD,
"CompiledCommandParameter cannot be null");
Initialize(cmdParameterMD);
}
internal XmlDocument BuildXmlFromComments()
{
this.doc = new XmlDocument();
XmlElement element1 = this.doc.CreateElement("command:command", HelpCommentsParser.commandURI);
element1.SetAttribute("xmlns:maml", HelpCommentsParser.mamlURI);
element1.SetAttribute("xmlns:command", HelpCommentsParser.commandURI);
element1.SetAttribute("xmlns:dev", HelpCommentsParser.devURI);
this.doc.AppendChild((XmlNode)element1);
XmlElement element2 = this.doc.CreateElement("command:details", HelpCommentsParser.commandURI);
element1.AppendChild((XmlNode)element2);
XmlElement element3 = this.doc.CreateElement("command:name", HelpCommentsParser.commandURI);
XmlText textNode1 = this.doc.CreateTextNode(this.commandName);
element2.AppendChild((XmlNode)element3).AppendChild((XmlNode)textNode1);
if (!string.IsNullOrEmpty(this.sections.synopsis))
{
XmlElement element4 = this.doc.CreateElement("maml:description", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.synopsis);
element2.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)textNode2);
}
this.DetermineParameterDescriptions();
XmlElement element6 = this.doc.CreateElement("command:syntax", HelpCommentsParser.commandURI);
MergedCommandParameterMetadata parameterMetadata = this.commandMetadata.StaticCommandParameterMetadata;
if (parameterMetadata.ParameterSetCount > 0)
{
for (int i = 0; i < parameterMetadata.ParameterSetCount; ++i)
{
this.BuildSyntaxForParameterSet(element1, element6, parameterMetadata, i);
}
}
else
{
this.BuildSyntaxForParameterSet(element1, element6, parameterMetadata, int.MaxValue);
}
XmlElement element7 = this.doc.CreateElement("command:parameters", HelpCommentsParser.commandURI);
foreach (KeyValuePair <string, MergedCompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters)
{
MergedCompiledCommandParameter commandParameter = bindableParameter.Value;
if (commandParameter.BinderAssociation != ParameterBinderAssociation.CommonParameters)
{
string key = bindableParameter.Key;
string parameterDescription = this.GetParameterDescription(key);
ParameterSetSpecificMetadata specificMetadata = (ParameterSetSpecificMetadata)null;
bool isMandatory = false;
bool valueFromPipeline = false;
bool valueFromPipelineByPropertyName = false;
string position = "named";
int num = 0;
CompiledCommandParameter parameter = commandParameter.Parameter;
parameter.ParameterSetData.TryGetValue("__AllParameterSets", out specificMetadata);
while (specificMetadata == null && num < 32)
{
specificMetadata = parameter.GetParameterSetData((uint)(1 << num++));
}
if (specificMetadata != null)
{
isMandatory = specificMetadata.IsMandatory;
valueFromPipeline = specificMetadata.ValueFromPipeline;
valueFromPipelineByPropertyName = specificMetadata.ValueFromPipelineByPropertyName;
position = specificMetadata.IsPositional ? (1 + specificMetadata.Position).ToString((IFormatProvider)CultureInfo.InvariantCulture) : "named";
}
XmlElement xmlElement = this.BuildXmlForParameter(key, isMandatory, valueFromPipeline, valueFromPipelineByPropertyName, position, parameter.Type, parameterDescription, false);
element7.AppendChild((XmlNode)xmlElement);
}
}
element1.AppendChild((XmlNode)element7);
if (!string.IsNullOrEmpty(this.sections.description))
{
XmlElement element4 = this.doc.CreateElement("maml:description", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.description);
element1.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)textNode2);
}
if (!string.IsNullOrEmpty(this.sections.notes))
{
XmlElement element4 = this.doc.CreateElement("maml:alertSet", HelpCommentsParser.mamlURI);
XmlElement element5 = this.doc.CreateElement("maml:alert", HelpCommentsParser.mamlURI);
XmlElement element8 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(this.sections.notes);
element1.AppendChild((XmlNode)element4).AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
}
if (this.sections.examples.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("command:examples", HelpCommentsParser.commandURI);
int num = 1;
foreach (string example in this.sections.examples)
{
XmlElement element5 = this.doc.CreateElement("command:example", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("maml:title", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "\t\t\t\t-------------------------- {0} {1} --------------------------", (object)ResourceManagerCache.GetResourceString("HelpDisplayStrings", "ExampleUpperCase"), (object)num++));
element5.AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
string prompt_str;
string code_str;
string remarks_str;
this.GetExampleSections(example, out prompt_str, out code_str, out remarks_str);
XmlElement element9 = this.doc.CreateElement("maml:introduction", HelpCommentsParser.mamlURI);
XmlElement element10 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode3 = this.doc.CreateTextNode(prompt_str);
element5.AppendChild((XmlNode)element9).AppendChild((XmlNode)element10).AppendChild((XmlNode)textNode3);
XmlElement element11 = this.doc.CreateElement("dev:code", HelpCommentsParser.devURI);
XmlText textNode4 = this.doc.CreateTextNode(code_str);
element5.AppendChild((XmlNode)element11).AppendChild((XmlNode)textNode4);
XmlElement element12 = this.doc.CreateElement("dev:remarks", HelpCommentsParser.devURI);
XmlElement element13 = this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI);
XmlText textNode5 = this.doc.CreateTextNode(remarks_str);
element5.AppendChild((XmlNode)element12).AppendChild((XmlNode)element13).AppendChild((XmlNode)textNode5);
for (int index = 0; index < 4; ++index)
{
element12.AppendChild((XmlNode)this.doc.CreateElement("maml:para", HelpCommentsParser.mamlURI));
}
element4.AppendChild((XmlNode)element5);
}
element1.AppendChild((XmlNode)element4);
}
if (this.sections.inputs.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("command:inputTypes", HelpCommentsParser.commandURI);
foreach (string input in this.sections.inputs)
{
XmlElement element5 = this.doc.CreateElement("command:inputType", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("dev:type", HelpCommentsParser.devURI);
XmlElement element9 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(input);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)element9).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
IEnumerable enumerable = (IEnumerable)null;
if (this.sections.outputs.Count > 0)
{
enumerable = (IEnumerable)this.sections.outputs;
}
else if (this.scriptBlock.OutputType.Count > 0)
{
enumerable = (IEnumerable)this.scriptBlock.OutputType;
}
if (enumerable != null)
{
XmlElement element4 = this.doc.CreateElement("command:returnValues", HelpCommentsParser.commandURI);
foreach (object obj in enumerable)
{
XmlElement element5 = this.doc.CreateElement("command:returnValue", HelpCommentsParser.commandURI);
XmlElement element8 = this.doc.CreateElement("dev:type", HelpCommentsParser.devURI);
XmlElement element9 = this.doc.CreateElement("maml:name", HelpCommentsParser.mamlURI);
if (!(obj is string text))
{
text = ((PSTypeName)obj).Name;
}
XmlText textNode2 = this.doc.CreateTextNode(text);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)element9).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
if (this.sections.links.Count > 0)
{
XmlElement element4 = this.doc.CreateElement("maml:relatedLinks", HelpCommentsParser.mamlURI);
foreach (string link in this.sections.links)
{
XmlElement element5 = this.doc.CreateElement("maml:navigationLink", HelpCommentsParser.mamlURI);
XmlElement element8 = this.doc.CreateElement(Uri.IsWellFormedUriString(Uri.EscapeUriString(link), UriKind.Absolute) ? "maml:uri" : "maml:linkText", HelpCommentsParser.mamlURI);
XmlText textNode2 = this.doc.CreateTextNode(link);
element4.AppendChild((XmlNode)element5).AppendChild((XmlNode)element8).AppendChild((XmlNode)textNode2);
}
element1.AppendChild((XmlNode)element4);
}
return(this.doc);
}
internal ParameterMetadata(CompiledCommandParameter cmdParameterMD)
{
this.Initialize(cmdParameterMD);
}
private void ConstructCompiledParametersUsingRuntimeDefinedParameters(RuntimeDefinedParameterDictionary runtimeDefinedParameters, bool processingDynamicParameters, bool checkNames)
{
foreach (RuntimeDefinedParameter parameter in runtimeDefinedParameters.Values)
{
if (parameter != null)
{
CompiledCommandParameter parameter2 = new CompiledCommandParameter(parameter, processingDynamicParameters);
this.AddParameter(parameter2, checkNames);
}
}
}
internal ParameterMetadata(CompiledCommandParameter cmdParameterMD)
{
this.Initialize(cmdParameterMD);
}
/// <summary>
/// Uses ETS to set the property specified by name to the value on
/// the target bindable object.
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to.
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
/// <exception cref="SetValueException">
/// If the setter raises an exception.
/// </exception>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
Diagnostics.Assert(!string.IsNullOrEmpty(name), "caller to verify name parameter");
try
{
var setter = parameterMetadata != null
? (parameterMetadata.Setter ?? (parameterMetadata.Setter = GetSetter(Target.GetType(), name)))
: GetSetter(Target.GetType(), name);
setter(Target, value);
}
catch (TargetInvocationException ex)
{
Exception inner = ex.InnerException ?? ex;
throw new SetValueInvocationException("CatchFromBaseAdapterSetValueTI",
inner,
ExtendedTypeSystem.ExceptionWhenSetting,
name, inner.Message);
}
catch (SetValueException) { throw; }
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
throw new SetValueInvocationException("CatchFromBaseAdapterSetValue",
e,
ExtendedTypeSystem.ExceptionWhenSetting,
name, e.Message);
}
} // BindParameter
private void RemoveParameter(CompiledCommandParameter parameter)
{
this.bindableParameters.Remove(parameter.Name);
foreach (string str in parameter.Aliases)
{
this.aliasedParameters.Remove(str);
}
}
internal virtual bool BindParameter(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags)
{
bool flag = false;
bool flag2 = (flags & ParameterBindingFlags.ShouldCoerceType) != ParameterBindingFlags.None;
if (parameter == null)
{
throw PSTraceSource.NewArgumentNullException("parameter");
}
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
using (bindingTracer.TraceScope("BIND arg [{0}] to parameter [{1}]", new object[] { parameter.ArgumentValue, parameterMetadata.Name }))
{
parameter.ParameterName = parameterMetadata.Name;
object argumentValue = parameter.ArgumentValue;
ScriptParameterBinder binder = this as ScriptParameterBinder;
bool bindingScriptCmdlet = false;
if (binder != null)
{
bindingScriptCmdlet = binder.Script.UsesCmdletBinding;
}
foreach (ArgumentTransformationAttribute attribute in parameterMetadata.ArgumentTransformationAttributes)
{
using (bindingTracer.TraceScope("Executing DATA GENERATION metadata: [{0}]", new object[] { attribute.GetType() }))
{
try
{
ArgumentTypeConverterAttribute attribute2 = attribute as ArgumentTypeConverterAttribute;
if (attribute2 != null)
{
if (flag2)
{
argumentValue = attribute2.Transform(this.engine, argumentValue, true, bindingScriptCmdlet);
}
}
else
{
argumentValue = attribute.Transform(this.engine, argumentValue);
}
bindingTracer.WriteLine("result returned from DATA GENERATION: {0}", new object[] { argumentValue });
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
bindingTracer.WriteLine("ERROR: DATA GENERATION: {0}", new object[] { exception.Message });
ParameterBindingException exception2 = new ParameterBindingArgumentTransformationException(exception, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentTransformationError", new object[] { exception.Message });
throw exception2;
}
}
}
if (flag2)
{
argumentValue = this.CoerceTypeAsNeeded(parameter, parameterMetadata.Name, parameterMetadata.Type, parameterMetadata.CollectionTypeInformation, argumentValue);
}
else if (!this.ShouldContinueUncoercedBind(parameter, parameterMetadata, flags, ref argumentValue))
{
goto Label_040E;
}
if ((parameterMetadata.PSTypeName != null) && (argumentValue != null))
{
IEnumerable enumerable = LanguagePrimitives.GetEnumerable(argumentValue);
if (enumerable != null)
{
foreach (object obj3 in enumerable)
{
this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, obj3);
}
}
else
{
this.ValidatePSTypeName(parameter, parameterMetadata, !flag2, argumentValue);
}
}
if ((flags & ParameterBindingFlags.IsDefaultValue) == ParameterBindingFlags.None)
{
foreach (ValidateArgumentsAttribute attribute3 in parameterMetadata.ValidationAttributes)
{
using (bindingTracer.TraceScope("Executing VALIDATION metadata: [{0}]", new object[] { attribute3.GetType() }))
{
try
{
attribute3.InternalValidate(argumentValue, this.engine);
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
bindingTracer.WriteLine("ERROR: VALIDATION FAILED: {0}", new object[] { exception3.Message });
ParameterBindingValidationException exception4 = new ParameterBindingValidationException(exception3, ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (argumentValue == null) ? null : argumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationError", new object[] { exception3.Message });
throw exception4;
}
tracer.WriteLine("Validation attribute on {0} returned {1}.", new object[] { parameterMetadata.Name, flag });
}
}
if (IsParameterMandatory(parameterMetadata))
{
this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.Type, argumentValue, true);
}
}
Exception innerException = null;
try
{
this.BindParameter(parameter.ParameterName, argumentValue);
flag = true;
}
catch (SetValueException exception6)
{
innerException = exception6;
}
if (innerException != null)
{
Type typeSpecified = (argumentValue == null) ? null : argumentValue.GetType();
ParameterBindingException exception7 = new ParameterBindingException(innerException, ErrorCategory.WriteError, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, typeSpecified, "ParameterBinderStrings", "ParameterBindingFailed", new object[] { innerException.Message });
throw exception7;
}
Label_040E:;
bindingTracer.WriteLine("BIND arg [{0}] to param [{1}] {2}", new object[] { argumentValue, parameter.ParameterName, flag ? "SUCCESSFUL" : "SKIPPED" });
if (flag)
{
if (this.RecordBoundParameters)
{
this.CommandLineParameters.Add(parameter.ParameterName, argumentValue);
}
MshCommandRuntime commandRuntime = this.Command.commandRuntime as MshCommandRuntime;
if ((commandRuntime != null) && commandRuntime.LogPipelineExecutionDetail)
{
IEnumerable source = LanguagePrimitives.GetEnumerable(argumentValue);
if (source != null)
{
string parameterValue = string.Join(", ", source.Cast<object>().ToArray<object>());
commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, parameterValue);
}
else
{
commandRuntime.PipelineProcessor.LogExecutionParameterBinding(this.InvocationInfo, parameter.ParameterName, (argumentValue == null) ? "" : argumentValue.ToString());
}
}
}
return flag;
}
}
private void AddParameter(MemberInfo member, bool processingDynamicParameters)
{
bool flag = false;
bool flag2 = false;
this.CheckForReservedParameter(member.Name);
if (this.bindableParameters.ContainsKey(member.Name))
{
CompiledCommandParameter parameter = this.bindableParameters[member.Name];
Type declaringType = parameter.DeclaringType;
if (declaringType == null)
{
flag = true;
}
else if (declaringType.IsSubclassOf(member.DeclaringType))
{
flag2 = true;
}
else if (member.DeclaringType.IsSubclassOf(declaringType))
{
this.RemoveParameter(parameter);
}
else
{
flag = true;
}
}
if (flag)
{
throw new System.Management.Automation.MetadataException("DuplicateParameterDefinition", null, ParameterBinderStrings.DuplicateParameterDefinition, new object[] { member.Name });
}
if (!flag2)
{
CompiledCommandParameter parameter2 = new CompiledCommandParameter(member, processingDynamicParameters);
this.AddParameter(parameter2, true);
}
}
private static bool IsParameterMandatory(CompiledCommandParameter parameterMetadata)
{
bool flag = false;
foreach (ParameterSetSpecificMetadata metadata in parameterMetadata.ParameterSetData.Values)
{
if (metadata.IsMandatory)
{
flag = true;
break;
}
}
tracer.WriteLine("isMandatory = {0}", new object[] { flag });
return flag;
}
/// <summary>
/// Binds a parameter for a native command (application).
/// </summary>
/// <param name="name">
/// The name of the parameter to bind the value to. For applications
/// this just becomes another parameter...
/// </param>
/// <param name="value">
/// The value to bind to the parameter. It should be assumed by
/// derived classes that the proper type coercion has already taken
/// place and that any prerequisite metadata has been satisfied.
/// </param>
/// <param name="parameterMetadata"></param>
internal override void BindParameter(string name, object value, CompiledCommandParameter parameterMetadata)
{
Diagnostics.Assert(false, "Unreachable code");
throw new NotSupportedException();
}
private bool ShouldContinueUncoercedBind(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, ParameterBindingFlags flags, ref object parameterValue)
{
bool flag = false;
Type c = parameterMetadata.Type;
if (parameterValue == null)
{
return (((c == null) || ((flags & ParameterBindingFlags.IsDefaultValue) != ParameterBindingFlags.None)) || (!c.IsValueType && (c != typeof(string))));
}
Type type = parameterValue.GetType();
if (type == c)
{
return true;
}
if (type.IsSubclassOf(c))
{
return true;
}
if (c.IsAssignableFrom(type))
{
return true;
}
if ((parameterValue is PSObject) && !((PSObject) parameterValue).immediateBaseObjectIsEmpty)
{
parameterValue = ((PSObject) parameterValue).BaseObject;
type = parameterValue.GetType();
if (((type == c) || type.IsSubclassOf(c)) || c.IsAssignableFrom(type))
{
return true;
}
}
if (parameterMetadata.CollectionTypeInformation.ParameterCollectionType != ParameterCollectionType.NotCollection)
{
bool coercionRequired = false;
object obj2 = this.EncodeCollection(parameter, parameterMetadata.Name, parameterMetadata.CollectionTypeInformation, c, parameterValue, false, out coercionRequired);
if ((obj2 != null) && !coercionRequired)
{
parameterValue = obj2;
flag = true;
}
}
return flag;
}
private void ValidateNullOrEmptyArgument(CommandParameterInternal parameter, CompiledCommandParameter parameterMetadata, Type argumentType, object parameterValue, bool recurseIntoCollections)
{
if ((parameterValue == null) && (argumentType != typeof(bool?)))
{
if (!parameterMetadata.AllowsNullArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be null", new object[0]);
ParameterBindingValidationException exception = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, argumentType, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[0]);
throw exception;
}
}
else if (argumentType == typeof(string))
{
string str = parameterValue as string;
if ((str.Length == 0) && !parameterMetadata.AllowsEmptyStringArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be an empty string", new object[0]);
ParameterBindingValidationException exception2 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", "ParameterArgumentValidationErrorEmptyStringNotAllowed", new object[0]);
throw exception2;
}
}
else if (recurseIntoCollections)
{
switch (parameterMetadata.CollectionTypeInformation.ParameterCollectionType)
{
case ParameterCollectionType.IList:
case ParameterCollectionType.Array:
case ParameterCollectionType.ICollectionGeneric:
{
IEnumerator enumerator = LanguagePrimitives.GetEnumerator(parameterValue);
bool flag = true;
while (ParserOps.MoveNext(null, null, enumerator))
{
object obj2 = ParserOps.Current(null, enumerator);
flag = false;
this.ValidateNullOrEmptyArgument(parameter, parameterMetadata, parameterMetadata.CollectionTypeInformation.ElementType, obj2, false);
}
if (flag && !parameterMetadata.AllowsEmptyCollectionArgument)
{
bindingTracer.WriteLine("ERROR: Argument cannot be an empty collection", new object[0]);
ParameterBindingValidationException exception3 = new ParameterBindingValidationException(ErrorCategory.InvalidData, this.InvocationInfo, this.GetErrorExtent(parameter), parameterMetadata.Name, parameterMetadata.Type, (parameterValue == null) ? null : parameterValue.GetType(), "ParameterBinderStrings", (parameterMetadata.CollectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) ? "ParameterArgumentValidationErrorEmptyArrayNotAllowed" : "ParameterArgumentValidationErrorEmptyCollectionNotAllowed", new object[0]);
throw exception3;
}
return;
}
}
}
}
private static bool IsSwitchAndSetValue(string argumentName, CommandParameterInternal argument, CompiledCommandParameter matchingParameter)
{
bool flag = false;
if (matchingParameter.Type == typeof(SwitchParameter))
{
argument.ParameterName = argumentName;
argument.SetArgumentValue(PositionUtilities.EmptyExtent, SwitchParameter.Present);
flag = true;
}
return(flag);
}
