/// <summary> /// Writes an ErrorRecord to the commands error pipe because the specified /// input object was not bound to the command. /// </summary> /// <param name="inputObject"> /// The pipeline input object that was not bound. /// </param> /// <param name="resourceString"> /// The error message. /// </param> /// <param name="errorId"> /// The resource ID of the error message is also used as error ID /// of the ErrorRecord. /// </param> /// <param name="args"> /// Additional arguments to be formatted into the error message that represented in <paramref name="resourceString"/>. /// </param> private void WriteInputObjectError( object inputObject, string resourceString, string errorId, params object[] args) { Type inputObjectType = inputObject?.GetType(); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, inputObjectType, resourceString, errorId, args); ErrorRecord errorRecord = new ErrorRecord( bindingException, errorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(errorRecord); }
/// <summary> /// Constructs the parameter binder with the specified type metadata. The binder is only valid /// for a single instance of a bindable runtime-defined parameter collection and only for the duration of a command. /// </summary> /// /// <param name="target"> /// The target runtime-defined parameter collection that the parameter values will be bound to. /// </param> /// /// <param name="command"> /// An instance of the command so that attributes can access the context. /// </param> /// /// <param name="commandLineParameters"> /// The Command line parameter collection to update... /// </param> /// internal RuntimeDefinedParameterBinder( RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { // NTRAID#Windows Out Of Band Releases-927103-2006/01/25-JonN foreach (var pair in target) { string key = pair.Key; RuntimeDefinedParameter pp = pair.Value; string ppName = (null == pp) ? null : pp.Name; if (null == pp || key != ppName) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, command.MyInvocation, null, ppName, null, null, ParameterBinderStrings.RuntimeDefinedParameterNameMismatch, "RuntimeDefinedParameterNameMismatch", key); throw bindingException; } } this.CommandLineParameters = commandLineParameters; }
internal override Collection <CommandParameterInternal> BindParameters(Collection <CommandParameterInternal> arguments) { Collection <CommandParameterInternal> collection = new Collection <CommandParameterInternal>(); foreach (CommandParameterInternal internal2 in arguments) { if (!internal2.ParameterNameSpecified) { collection.Add(internal2); } else { MergedCompiledCommandParameter parameter = base.BindableParameters.GetMatchingParameter(internal2.ParameterName, false, true, new InvocationInfo(base.InvocationInfo.MyCommand, internal2.ParameterExtent)); if (parameter != null) { if (base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, base.InvocationInfo, base.GetParameterErrorExtent(internal2), internal2.ParameterName, null, null, "ParameterBinderStrings", "ParameterAlreadyBound", new object[0]); throw exception; } this.BindParameter(int.MaxValue, internal2, parameter, ParameterBindingFlags.ShouldCoerceType); } else if (internal2.ParameterName.Equals("-%", StringComparison.Ordinal)) { base.DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(internal2.ArgumentValue); } else { collection.Add(internal2); } } } return(collection); }
/// <summary> /// Constructs the parameter binder with the specified type metadata. The binder is only valid /// for a single instance of a bindable runtime-defined parameter collection and only for the duration of a command. /// </summary> /// /// <param name="target"> /// The target runtime-defined parameter collection that the parameter values will be bound to. /// </param> /// /// <param name="command"> /// An instance of the command so that attributes can access the context. /// </param> /// /// <param name="commandLineParameters"> /// The Command line parameter collection to update... /// </param> /// internal RuntimeDefinedParameterBinder( RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { // NTRAID#Windows Out Of Band Releases-927103-2006/01/25-JonN foreach (var pair in target) { string key = pair.Key; RuntimeDefinedParameter pp = pair.Value; string ppName = (null == pp) ? null : pp.Name; if (null == pp || key != ppName) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, command.MyInvocation, null, ppName, null, null, ParameterBinderStrings.RuntimeDefinedParameterNameMismatch, "RuntimeDefinedParameterNameMismatch", key); throw bindingException; } } this.CommandLineParameters = commandLineParameters; }
/// <summary> /// Binds the specified parameters to the shell function /// </summary> /// /// <param name="arguments"> /// The arguments to bind. /// </param> /// internal override Collection <CommandParameterInternal> BindParameters(Collection <CommandParameterInternal> arguments) { Collection <CommandParameterInternal> result = new Collection <CommandParameterInternal>(); foreach (CommandParameterInternal argument in arguments) { if (!argument.ParameterNameSpecified) { result.Add(argument); continue; } // We don't want to throw an exception yet because // the parameter might be a positional argument MergedCompiledCommandParameter parameter = BindableParameters.GetMatchingParameter( argument.ParameterName, false, true, new InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); // If the parameter is not in the specified parameter set, // throw a binding exception if (parameter != null) { // Now check to make sure it hasn't already been // bound by looking in the boundParameters collection if (BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.InvocationInfo, GetParameterErrorExtent(argument), argument.ParameterName, null, null, ParameterBinderStrings.ParameterAlreadyBound, "ParameterAlreadyBound"); throw bindingException; } BindParameter(uint.MaxValue, argument, parameter, ParameterBindingFlags.ShouldCoerceType); } else if (argument.ParameterName.Equals(Language.Parser.VERBATIM_PARAMETERNAME, StringComparison.Ordinal)) { // We sometimes send a magic parameter from a remote machine with the values referenced via // a using expression ($using:x). We then access these values via PSBoundParameters, so // "bind" them here. DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(argument.ArgumentValue); } else { result.Add(argument); } } return(result); }
internal override Collection<CommandParameterInternal> BindParameters(Collection<CommandParameterInternal> arguments) { Collection<CommandParameterInternal> collection = new Collection<CommandParameterInternal>(); foreach (CommandParameterInternal internal2 in arguments) { if (!internal2.ParameterNameSpecified) { collection.Add(internal2); } else { MergedCompiledCommandParameter parameter = base.BindableParameters.GetMatchingParameter(internal2.ParameterName, false, true, new InvocationInfo(base.InvocationInfo.MyCommand, internal2.ParameterExtent)); if (parameter != null) { if (base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, base.InvocationInfo, base.GetParameterErrorExtent(internal2), internal2.ParameterName, null, null, "ParameterBinderStrings", "ParameterAlreadyBound", new object[0]); throw exception; } this.BindParameter(int.MaxValue, internal2, parameter, ParameterBindingFlags.ShouldCoerceType); } else if (internal2.ParameterName.Equals("-%", StringComparison.Ordinal)) { base.DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(internal2.ArgumentValue); } else { collection.Add(internal2); } } } return collection; }
internal MergedCompiledCommandParameter GetMatchingParameter(string name, bool throwOnParameterNotFound, bool tryExactMatching, InvocationInfo invocationInfo) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } Collection <MergedCompiledCommandParameter> collection = new Collection <MergedCompiledCommandParameter>(); if ((name.Length > 0) && SpecialCharacters.IsDash(name[0])) { name = name.Substring(1); } foreach (string str in this.bindableParameters.Keys) { if (nameCompareInfo.IsPrefix(str, name, CompareOptions.IgnoreCase)) { if (tryExactMatching && string.Equals(str, name, StringComparison.OrdinalIgnoreCase)) { return(this.bindableParameters[str]); } collection.Add(this.bindableParameters[str]); } } foreach (string str2 in this.aliasedParameters.Keys) { if (nameCompareInfo.IsPrefix(str2, name, CompareOptions.IgnoreCase)) { if (tryExactMatching && string.Equals(str2, name, StringComparison.OrdinalIgnoreCase)) { return(this.aliasedParameters[str2]); } if (!collection.Contains(this.aliasedParameters[str2])) { collection.Add(this.aliasedParameters[str2]); } } } if (collection.Count > 1) { StringBuilder builder = new StringBuilder(); foreach (MergedCompiledCommandParameter parameter in collection) { builder.AppendFormat(" -{0}", parameter.Parameter.Name); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, "ParameterBinderStrings", "AmbiguousParameter", new object[] { builder }); throw exception; } if ((collection.Count == 0) && throwOnParameterNotFound) { ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, "ParameterBinderStrings", "NamedParameterNotFound", new object[0]); throw exception2; } MergedCompiledCommandParameter parameter2 = null; if (collection.Count > 0) { parameter2 = collection[0]; } return(parameter2); }
internal RuntimeDefinedParameterBinder( RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base((object)target, command.MyInvocation, command.Context, command) { using (RuntimeDefinedParameterBinder.tracer.TraceConstructor((object)this)) { foreach (string key in target.Keys) { RuntimeDefinedParameter definedParameter = target[key]; string parameterName = definedParameter == null ? (string)null : definedParameter.Name; if (definedParameter == null || key != parameterName) { ParameterBindingException bindingException = new ParameterBindingException(ErrorCategory.InvalidArgument, command.MyInvocation, (Token)null, parameterName, (Type)null, (Type)null, "ParameterBinderStrings", "RuntimeDefinedParameterNameMismatch", new object[1] { (object)key }); RuntimeDefinedParameterBinder.tracer.TraceException((Exception)bindingException); throw bindingException; } } this.CommandLineParameters = commandLineParameters; } }
private void WriteInputObjectError(object inputObject, string resourceAndErrorId, params object[] args) { Type typeSpecified = (inputObject == null) ? null : inputObject.GetType(); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, base.Command.MyInvocation, null, null, null, typeSpecified, "ParameterBinderStrings", resourceAndErrorId, args); ErrorRecord errorRecord = new ErrorRecord(exception, resourceAndErrorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(base.Command.MyInvocation); base.commandRuntime._WriteErrorSkipAllowCheck(errorRecord, null); }
internal void ReparseUnboundArguments() { Collection <CommandParameterInternal> collection = new Collection <CommandParameterInternal>(); for (int i = 0; i < this._unboundArguments.Count; i++) { CommandParameterInternal item = this._unboundArguments[i]; if (!item.ParameterNameSpecified || item.ArgumentSpecified) { collection.Add(item); } else { string parameterName = item.ParameterName; MergedCompiledCommandParameter parameter = this._bindableParameters.GetMatchingParameter(parameterName, false, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, item.ParameterExtent)); if (parameter == null) { collection.Add(item); } else if (IsSwitchAndSetValue(parameterName, item, parameter.Parameter)) { collection.Add(item); } else if ((this._unboundArguments.Count - 1) > i) { CommandParameterInternal internal3 = this._unboundArguments[i + 1]; if (internal3.ParameterNameSpecified) { if ((this._bindableParameters.GetMatchingParameter(internal3.ParameterName, false, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, internal3.ParameterExtent)) != null) || internal3.ParameterAndArgumentSpecified) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(item), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception; } i++; item.ParameterName = parameter.Parameter.Name; item.SetArgumentValue(internal3.ArgumentExtent, internal3.ParameterText); collection.Add(item); } else { i++; item.ParameterName = parameter.Parameter.Name; item.SetArgumentValue(internal3.ArgumentExtent, internal3.ArgumentValue); collection.Add(item); } } else { ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(item), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } } } this._unboundArguments = collection; }
/// <summary> /// </summary> /// <param name="innerException"></param> /// <param name="pbex"></param> /// <param name="resourceString"></param> /// <param name="args"></param> internal ParameterBindingException( Exception innerException, ParameterBindingException pbex, string resourceString, params object[] args) : base(string.Empty, innerException) { if (pbex == null) { throw PSTraceSource.NewArgumentNullException(nameof(pbex)); } if (string.IsNullOrEmpty(resourceString)) { throw PSTraceSource.NewArgumentException(nameof(resourceString)); } _invocationInfo = pbex.CommandInvocation; if (_invocationInfo != null) { _commandName = _invocationInfo.MyCommand.Name; } IScriptExtent errorPosition = null; if (_invocationInfo != null) { errorPosition = _invocationInfo.ScriptPosition; } _line = pbex.Line; _offset = pbex.Offset; _parameterName = pbex.ParameterName; _parameterType = pbex.ParameterType; _typeSpecified = pbex.TypeSpecified; _errorId = pbex.ErrorId; _resourceString = resourceString; if (args != null) { _args = args; } base.SetErrorCategory(pbex.ErrorRecord._category); base.SetErrorId(_errorId); if (_invocationInfo != null) { base.ErrorRecord.SetInvocationInfo(new InvocationInfo(_invocationInfo.MyCommand, errorPosition)); } }
internal RuntimeDefinedParameterBinder(RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { foreach (string str in target.Keys) { RuntimeDefinedParameter parameter = target[str]; string parameterName = (parameter == null) ? null : parameter.Name; if ((parameter == null) || (str != parameterName)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, command.MyInvocation, null, parameterName, null, null, "ParameterBinderStrings", "RuntimeDefinedParameterNameMismatch", new object[] { str }); throw exception; } } base.CommandLineParameters = commandLineParameters; }
internal RuntimeDefinedParameterBinder(RuntimeDefinedParameterDictionary target, InternalCommand command, CommandLineParameters commandLineParameters) : base(target, command.MyInvocation, command.Context, command) { foreach (string str in target.Keys) { RuntimeDefinedParameter parameter = target[str]; string parameterName = (parameter == null) ? null : parameter.Name; if ((parameter == null) || (str != parameterName)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, command.MyInvocation, null, parameterName, null, null, "ParameterBinderStrings", "RuntimeDefinedParameterNameMismatch", new object[] { str }); throw exception; } } base.CommandLineParameters = commandLineParameters; }
internal ParameterBindingException(Exception innerException, ParameterBindingException pbex, string resourceBaseName, string resourceId, params object[] args) : base(string.Empty, innerException) { this.parameterName = string.Empty; this.line = -9223372036854775808L; this.offset = -9223372036854775808L; this.args = new object[0]; if (pbex == null) { throw PSTraceSource.NewArgumentNullException("pbex"); } if (string.IsNullOrEmpty(resourceBaseName)) { throw PSTraceSource.NewArgumentException("resourceBaseName"); } if (string.IsNullOrEmpty(resourceId)) { throw PSTraceSource.NewArgumentException("resourceId"); } this.invocationInfo = pbex.CommandInvocation; if (this.invocationInfo != null) { this.commandName = this.invocationInfo.MyCommand.Name; } IScriptExtent scriptPosition = null; if (this.invocationInfo != null) { scriptPosition = this.invocationInfo.ScriptPosition; } this.line = pbex.Line; this.offset = pbex.Offset; this.parameterName = pbex.ParameterName; this.parameterType = pbex.ParameterType; this.typeSpecified = pbex.TypeSpecified; this.errorId = pbex.ErrorId; this.resourceBaseName = resourceBaseName; this.resourceId = resourceId; if (args != null) { this.args = args; } base.SetErrorCategory(pbex.ErrorRecord._category); base.SetErrorId(this.errorId); if (this.invocationInfo != null) { base.ErrorRecord.SetInvocationInfo(new InvocationInfo(this.invocationInfo.MyCommand, scriptPosition)); } }
internal ParameterBindingException(Exception innerException, ParameterBindingException pbex, string resourceBaseName, string resourceId, params object[] args) : base(string.Empty, innerException) { this.parameterName = string.Empty; this.line = -9223372036854775808L; this.offset = -9223372036854775808L; this.args = new object[0]; if (pbex == null) { throw PSTraceSource.NewArgumentNullException("pbex"); } if (string.IsNullOrEmpty(resourceBaseName)) { throw PSTraceSource.NewArgumentException("resourceBaseName"); } if (string.IsNullOrEmpty(resourceId)) { throw PSTraceSource.NewArgumentException("resourceId"); } this.invocationInfo = pbex.CommandInvocation; if (this.invocationInfo != null) { this.commandName = this.invocationInfo.MyCommand.Name; } IScriptExtent scriptPosition = null; if (this.invocationInfo != null) { scriptPosition = this.invocationInfo.ScriptPosition; } this.line = pbex.Line; this.offset = pbex.Offset; this.parameterName = pbex.ParameterName; this.parameterType = pbex.ParameterType; this.typeSpecified = pbex.TypeSpecified; this.errorId = pbex.ErrorId; this.resourceBaseName = resourceBaseName; this.resourceId = resourceId; if (args != null) { this.args = args; } base.SetErrorCategory(pbex.ErrorRecord._category); base.SetErrorId(this.errorId); if (this.invocationInfo != null) { base.ErrorRecord.SetInvocationInfo(new InvocationInfo(this.invocationInfo.MyCommand, scriptPosition)); } }
internal virtual bool BindParameter(CommandParameterInternal argument, ParameterBindingFlags flags) { bool flag = false; MergedCompiledCommandParameter parameter = this.BindableParameters.GetMatchingParameter(argument.ParameterName, (flags & ParameterBindingFlags.ThrowOnParameterNotFound) != ParameterBindingFlags.None, true, new System.Management.Automation.InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); if (parameter == null) { return(flag); } if (this.BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), argument.ParameterName, null, null, "ParameterBinderStrings", "ParameterAlreadyBound", new object[0]); throw exception; } flags &= ~ParameterBindingFlags.DelayBindScriptBlock; return(this.BindParameter(this._currentParameterSetFlag, argument, parameter, flags)); }
private object HandleNullParameterForSpecialTypes(CommandParameterInternal argument, string parameterName, Type toType, object currentValue) { if (toType == typeof(bool)) { bindingTracer.WriteLine("ERROR: No argument is specified for parameter and parameter type is BOOL", new object[0]); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[] { "" }); throw exception; } if (toType == typeof(SwitchParameter)) { bindingTracer.WriteLine("Arg is null or not present, parameter type is SWITCHPARAMTER, value is true.", new object[0]); return(SwitchParameter.Present); } if (currentValue == UnboundParameter.Value) { bindingTracer.TraceError("ERROR: No argument was specified for the parameter and the parameter is not of type bool", new object[0]); ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } bindingTracer.WriteLine("Arg is null, parameter type not bool or SwitchParameter, value is null.", new object[0]); return(null); }
protected void ThrowElaboratedBindingException(ParameterBindingException pbex) { if (pbex == null) { throw PSTraceSource.NewArgumentNullException("pbex"); } string message = pbex.Message; StringBuilder builder = new StringBuilder(); foreach (string str2 in this.BoundDefaultParameters) { builder.AppendFormat(CultureInfo.InvariantCulture, " -{0}", new object[] { str2 }); } string resourceId = "DefaultBindingErrorElaborationSingle"; if (this.BoundDefaultParameters.Count > 1) { resourceId = "DefaultBindingErrorElaborationMultiple"; } ParameterBindingException exception = new ParameterBindingException(pbex.InnerException, pbex, "ParameterBinderStrings", resourceId, new object[] { message, builder }); throw exception; }
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 bool HandleUnboundMandatoryParameters(int validParameterSetCount, bool promptForMandatory, bool isPipelineInputExpected, out Collection<MergedCompiledCommandParameter> missingMandatoryParameters) { bool flag = true; missingMandatoryParameters = this.GetMissingMandatoryParameters(validParameterSetCount, isPipelineInputExpected); if (missingMandatoryParameters.Count <= 0) { return flag; } if (promptForMandatory) { if (base.Context.EngineHostInterface == null) { ParameterBinderBase.bindingTracer.WriteLine("ERROR: host does not support prompting for missing mandatory parameters", new object[0]); string parameterName = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, parameterName, null, null, "ParameterBinderStrings", "MissingMandatoryParameter", new object[0]); throw exception; } Collection<FieldDescription> fieldDescriptionList = this.CreatePromptDataStructures(missingMandatoryParameters); Dictionary<string, PSObject> dictionary = this.PromptForMissingMandatoryParameters(fieldDescriptionList, missingMandatoryParameters); using (ParameterBinderBase.bindingTracer.TraceScope("BIND PROMPTED mandatory parameter args", new object[0])) { foreach (KeyValuePair<string, PSObject> pair in dictionary) { CommandParameterInternal argument = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, pair.Key, "-" + pair.Key + ":", PositionUtilities.EmptyExtent, pair.Value, false); flag = this.BindParameter(argument, ParameterBindingFlags.ThrowOnParameterNotFound | ParameterBindingFlags.ShouldCoerceType); } return true; } } return false; }
/// <summary> /// Binds the specified parameters to the shell function /// </summary> /// /// <param name="arguments"> /// The arguments to bind. /// </param> /// internal override Collection<CommandParameterInternal> BindParameters(Collection<CommandParameterInternal> arguments) { Collection<CommandParameterInternal> result = new Collection<CommandParameterInternal>(); foreach (CommandParameterInternal argument in arguments) { if (!argument.ParameterNameSpecified) { result.Add(argument); continue; } // We don't want to throw an exception yet because // the parameter might be a positional argument MergedCompiledCommandParameter parameter = BindableParameters.GetMatchingParameter( argument.ParameterName, false, true, new InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); // If the parameter is not in the specified parameter set, // throw a binding exception if (parameter != null) { // Now check to make sure it hasn't already been // bound by looking in the boundParameters collection if (BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.InvocationInfo, GetParameterErrorExtent(argument), argument.ParameterName, null, null, ParameterBinderStrings.ParameterAlreadyBound, "ParameterAlreadyBound"); throw bindingException; } BindParameter(uint.MaxValue, argument, parameter, ParameterBindingFlags.ShouldCoerceType); } else if (argument.ParameterName.Equals(Language.Parser.VERBATIM_PARAMETERNAME, StringComparison.Ordinal)) { // We sometimes send a magic parameter from a remote machine with the values referenced via // a using expression ($using:x). We then access these values via PSBoundParameters, so // "bind" them here. DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(argument.ArgumentValue); } else { result.Add(argument); } } return result; }
/// <summary> /// Verify if all arguments from the command line are bound. /// </summary> /// <param name="originalBindingException"> /// Previous binding exceptions that possibly causes the failure /// </param> private void VerifyArgumentsProcessed(ParameterBindingException originalBindingException) { // Now verify that all the arguments that were passed in were processed. if (UnboundArguments.Count > 0) { ParameterBindingException bindingException; CommandParameterInternal parameter = UnboundArguments[0]; // Get the argument type that was specified Type specifiedType = null; object argumentValue = parameter.ArgumentValue; if (argumentValue != null && argumentValue != UnboundParameter.Value) { specifiedType = argumentValue.GetType(); } if (parameter.ParameterNameSpecified) { bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, GetParameterErrorExtent(parameter), parameter.ParameterName, null, specifiedType, ParameterBinderStrings.NamedParameterNotFound, "NamedParameterNotFound"); } else { // If this was a positional parameter, and we have the original exception, // report on the original error if (originalBindingException != null) { bindingException = originalBindingException; } // Otherwise, give a generic error. else { string argument = StringLiterals.DollarNull; if (null != parameter.ArgumentValue) { try { argument = parameter.ArgumentValue.ToString(); } catch (Exception e) { CommandProcessorBase.CheckForSevereException(e); bindingException = new ParameterBindingArgumentTransformationException( e, ErrorCategory.InvalidData, this.InvocationInfo, null, null, null, parameter.ArgumentValue.GetType(), ParameterBinderStrings.ParameterArgumentTransformationErrorMessageOnly, "ParameterArgumentTransformationErrorMessageOnly", e.Message); if (!DefaultParameterBindingInUse) { throw bindingException; } else { ThrowElaboratedBindingException(bindingException); } } } bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, argument, null, specifiedType, ParameterBinderStrings.PositionalParameterNotFound, "PositionalParameterNotFound"); } } if (!DefaultParameterBindingInUse) { throw bindingException; } else { ThrowElaboratedBindingException(bindingException); } } }
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); } }
/// <summary> /// Checks for unbound mandatory parameters. If any are found and promptForMandatory is true, /// the user will be prompted for the missing mandatory parameters. /// </summary> /// /// <param name="validParameterSetCount"> /// The number of valid parameter sets. /// </param> /// /// <param name="processMissingMandatory"> /// If true, unbound mandatory parameters will be processed via user prompting (if allowed by promptForMandatory). /// If false, unbound mandatory parameters will cause false to be returned. /// </param> /// /// <param name="promptForMandatory"> /// If true, unbound mandatory parameters will cause the user to be prompted. If false, unbound /// mandatory parameters will cause an exception to be thrown. /// </param> /// /// <param name="isPipelineInputExpected"> /// If true, then only parameters that don't take pipeline input will be prompted for. /// If false, any mandatory parameter that has not been specified will be prompted for. /// </param> /// /// <param name="missingMandatoryParameters"> /// Returns the missing mandatory parameters, if any. /// </param> /// /// <returns> /// True if there are no unbound mandatory parameters. False if there are unbound mandatory parameters /// and promptForMandatory if false. /// </returns> /// /// <exception cref="ParameterBindingException"> /// If prompting didn't result in a value for the parameter (only when <paramref name="promptForMandatory"/> is true.) /// </exception> /// internal bool HandleUnboundMandatoryParameters( int validParameterSetCount, bool processMissingMandatory, bool promptForMandatory, bool isPipelineInputExpected, out Collection<MergedCompiledCommandParameter> missingMandatoryParameters) { bool result = true; missingMandatoryParameters = GetMissingMandatoryParameters(validParameterSetCount, isPipelineInputExpected); if (missingMandatoryParameters.Count > 0) { if (processMissingMandatory) { // If the host interface wasn't specified or we were instructed not to prmopt, then throw // an exception instead if ((Context.EngineHostInterface == null) || (!promptForMandatory)) { Diagnostics.Assert( Context.EngineHostInterface != null, "The EngineHostInterface should never be null"); ParameterBinderBase.bindingTracer.WriteLine( "ERROR: host does not support prompting for missing mandatory parameters"); string missingParameters = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, missingParameters, null, null, ParameterBinderStrings.MissingMandatoryParameter, "MissingMandatoryParameter"); throw bindingException; } // Create a collection to store the prompt descriptions of unbound mandatory parameters Collection<FieldDescription> fieldDescriptionList = CreatePromptDataStructures(missingMandatoryParameters); Dictionary<String, PSObject> parameters = PromptForMissingMandatoryParameters( fieldDescriptionList, missingMandatoryParameters); using (ParameterBinderBase.bindingTracer.TraceScope( "BIND PROMPTED mandatory parameter args")) { // Now bind any parameters that were retrieved. foreach (KeyValuePair<string, PSObject> entry in parameters) { var argument = CommandParameterInternal.CreateParameterWithArgument( PositionUtilities.EmptyExtent, entry.Key, "-" + entry.Key + ":", PositionUtilities.EmptyExtent, entry.Value, false); // Ignore the result since any failure should cause an exception result = BindParameter(argument, ParameterBindingFlags.ShouldCoerceType | ParameterBindingFlags.ThrowOnParameterNotFound); Diagnostics.Assert( result, "Any error in binding the parameter with type coercion should result in an exception"); } result = true; } } else { result = false; } } return result; } // HandleUnboundMandatoryParameters
/// <summary> /// Invokes any delay bind script blocks and binds the resulting value /// to the appropriate parameter. /// </summary> /// /// <param name="inputToOperateOn"> /// The input to the script block. /// </param> /// /// <param name="thereWasSomethingToBind"> /// Returns True if there was a ScriptBlock to invoke and bind, or false if there /// are no ScriptBlocks to invoke. /// </param> /// /// <returns> /// True if the binding succeeds, or false otherwise. /// </returns> /// /// <exception cref="ArgumentNullException"> /// if <paramref name="inputToOperateOn"/> is null. /// </exception> /// /// <exception cref="ParameterBindingException"> /// If execution of the script block throws an exception or if it doesn't produce /// any output. /// </exception> /// private bool InvokeAndBindDelayBindScriptBlock(PSObject inputToOperateOn, out bool thereWasSomethingToBind) { thereWasSomethingToBind = false; bool result = true; // NOTE: we are not doing backup and restore of default parameter // values here. It is not needed because each script block will be // invoked and each delay bind parameter bound for each pipeline object. // This is unlike normal pipeline object processing which may bind // different parameters depending on the type of the incoming pipeline // object. // Loop through each of the delay bind script blocks and invoke them. // Bind the result to the associated parameter foreach (KeyValuePair<MergedCompiledCommandParameter, DelayedScriptBlockArgument> delayedScriptBlock in _delayBindScriptBlocks) { thereWasSomethingToBind = true; CommandParameterInternal argument = delayedScriptBlock.Value._argument; MergedCompiledCommandParameter parameter = delayedScriptBlock.Key; ScriptBlock script = argument.ArgumentValue as ScriptBlock; Diagnostics.Assert( script != null, "An argument should only be put in the delayBindScriptBlocks collection if it is a ScriptBlock"); Collection<PSObject> output = null; Exception error = null; using (ParameterBinderBase.bindingTracer.TraceScope( "Invoking delay-bind ScriptBlock")) { if (delayedScriptBlock.Value._parameterBinder == this) { try { output = script.DoInvoke(inputToOperateOn, inputToOperateOn, Utils.EmptyArray<object>()); delayedScriptBlock.Value._evaluatedArgument = output; } catch (RuntimeException runtimeException) { error = runtimeException; } } else { output = delayedScriptBlock.Value._evaluatedArgument; } } if (error != null) { ParameterBindingException bindingException = new ParameterBindingException( error, ErrorCategory.InvalidArgument, this.Command.MyInvocation, GetErrorExtent(argument), parameter.Parameter.Name, null, null, ParameterBinderStrings.ScriptBlockArgumentInvocationFailed, "ScriptBlockArgumentInvocationFailed", error.Message); throw bindingException; } if (output == null || output.Count == 0) { ParameterBindingException bindingException = new ParameterBindingException( null, ErrorCategory.InvalidArgument, this.Command.MyInvocation, GetErrorExtent(argument), parameter.Parameter.Name, null, null, ParameterBinderStrings.ScriptBlockArgumentNoOutput, "ScriptBlockArgumentNoOutput"); throw bindingException; } // Check the output. If it is only a single value, just pass the single value, // if not, pass in the whole collection. object newValue = output; if (output.Count == 1) { newValue = output[0]; } // Create a new CommandParameterInternal for the output of the script block. var newArgument = CommandParameterInternal.CreateParameterWithArgument( argument.ParameterExtent, argument.ParameterName, "-" + argument.ParameterName + ":", argument.ArgumentExtent, newValue, false); if (!BindParameter(newArgument, parameter, ParameterBindingFlags.ShouldCoerceType)) { result = false; } } return result; } // InvokeAndBindDelayBindScriptBlock
/// <summary> /// Binds the specified argument to the specified parameter using the appropriate /// parameter binder. If the argument is of type ScriptBlock and the parameter takes /// pipeline input, then the ScriptBlock is saved off in the delay-bind ScriptBlock /// container for further processing of pipeline input and is not bound as the argument /// to the parameter. /// </summary> /// /// <param name="parameterSets"> /// The parameter set used to bind the arguments. /// </param> /// /// <param name="argument"> /// The argument to be bound. /// </param> /// /// <param name="parameter"> /// The metadata for the parameter to bind the argument to. /// </param> /// /// <param name="flags"> /// Flags for type coercion, validation, and script block binding. /// /// ParameterBindingFlags.DelayBindScriptBlock: /// If set, arguments that are of type ScriptBlock where the parameter is not of type ScriptBlock, /// Object, or PSObject will be stored for execution during pipeline input and not bound as /// an argument to the parameter. /// </param> /// /// <returns> /// True if the parameter was successfully bound. False if <paramref name="flags"/> /// has the flag <see cref="ParameterBindingFlags.ShouldCoerceType"/> set and the type does not match the parameter type. /// </returns> /// internal override bool BindParameter( uint parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { // Now we need to check to see if the argument value is // a ScriptBlock. If it is and the parameter type is // not ScriptBlock and not Object, then we need to delay // binding until a pipeline object is provided to invoke // the ScriptBlock. // Note: we haven't yet determined that only a single parameter // set is valid, so we have to take a best guess on pipeline input // based on the current valid parameter sets. bool continueWithBinding = true; if ((flags & ParameterBindingFlags.DelayBindScriptBlock) != 0 && parameter.Parameter.DoesParameterSetTakePipelineInput(parameterSets) && argument.ArgumentSpecified) { object argumentValue = argument.ArgumentValue; if ((argumentValue is ScriptBlock || argumentValue is DelayedScriptBlockArgument) && !IsParameterScriptBlockBindable(parameter)) { // Now check to see if the command expects to have pipeline input. // If not, we should throw an exception now to inform the // user with more information than they would get if it was // considered an unbound mandatory parameter. if (_commandRuntime.IsClosed && _commandRuntime.InputPipe.Empty) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.MetadataError, this.Command.MyInvocation, GetErrorExtent(argument), parameter.Parameter.Name, parameter.Parameter.Type, null, ParameterBinderStrings.ScriptBlockArgumentNoInput, "ScriptBlockArgumentNoInput"); throw bindingException; } ParameterBinderBase.bindingTracer.WriteLine( "Adding ScriptBlock to delay-bind list for parameter '{0}'", parameter.Parameter.Name); // We need to delay binding of this argument to the parameter DelayedScriptBlockArgument delayedArg = argumentValue as DelayedScriptBlockArgument ?? new DelayedScriptBlockArgument { _argument = argument, _parameterBinder = this }; if (!_delayBindScriptBlocks.ContainsKey(parameter)) { _delayBindScriptBlocks.Add(parameter, delayedArg); } // We treat the parameter as bound, but really the // script block gets run for each pipeline object and // the result is bound. if (parameter.Parameter.ParameterSetFlags != 0) { _currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } UnboundParameters.Remove(parameter); BoundParameters[parameter.Parameter.Name] = parameter; BoundArguments[parameter.Parameter.Name] = argument; if (DefaultParameterBinder.RecordBoundParameters && !DefaultParameterBinder.CommandLineParameters.ContainsKey(parameter.Parameter.Name)) { DefaultParameterBinder.CommandLineParameters.Add(parameter.Parameter.Name, delayedArg); } continueWithBinding = false; } } bool result = false; if (continueWithBinding) { try { result = BindParameter(argument, parameter, flags); } catch (Exception e) { bool rethrow = true; if ((flags & ParameterBindingFlags.ShouldCoerceType) == 0) { // Attributes are used to do type coercion and result in various exceptions. // We assume that if we aren't trying to do type coercion, we should avoid // propagating type conversion exceptions. while (e != null) { if (e is PSInvalidCastException) { rethrow = false; break; } e = e.InnerException; } } if (rethrow) { throw; } } } return result; }
} // HandleRemainingArguments /// <summary> /// Determines if the cmdlet supports dynamic parameters. If it does, /// the dynamic parameter bindable object is retrieved and the unbound /// arguments are bound to it. /// </summary> /// /// <param name="outgoingBindingException"> /// Returns the underlying parameter binding exception if any was generated. /// </param> /// /// <exception cref="MetadataException"> /// If there was an error compiling the parameter metadata. /// </exception> /// /// <exception cref="ParameterBindingException"> /// If there was an error binding the arguments to the parameters. /// </exception> /// private void HandleCommandLineDynamicParameters(out ParameterBindingException outgoingBindingException) { outgoingBindingException = null; if (_commandMetadata.ImplementsDynamicParameters) { using (ParameterBinderBase.bindingTracer.TraceScope( "BIND cmd line args to DYNAMIC parameters.")) { s_tracer.WriteLine("The Cmdlet supports the dynamic parameter interface"); IDynamicParameters dynamicParameterCmdlet = this.Command as IDynamicParameters; if (dynamicParameterCmdlet != null) { if (_dynamicParameterBinder == null) { s_tracer.WriteLine("Getting the bindable object from the Cmdlet"); var psCompiledScriptCmdlet = this.Command as PSScriptCmdlet; if (psCompiledScriptCmdlet != null) { psCompiledScriptCmdlet.PrepareForBinding( ((ScriptParameterBinder)this.DefaultParameterBinder).LocalScope, this.CommandLineParameters); } // Now get the dynamic parameter bindable object. object dynamicParamBindableObject; try { dynamicParamBindableObject = dynamicParameterCmdlet.GetDynamicParameters(); } catch (Exception e) // Catch-all OK, this is a third-party callout { CommandProcessorBase.CheckForSevereException(e); if (e is ProviderInvocationException) { throw; } ParameterBindingException bindingException = new ParameterBindingException( e, ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, null, ParameterBinderStrings.GetDynamicParametersException, "GetDynamicParametersException", e.Message); // This exception is caused because failure happens when retrieving the dynamic parameters, // this is not caused by introducing the default parameter binding. throw bindingException; } if (dynamicParamBindableObject != null) { ParameterBinderBase.bindingTracer.WriteLine( "DYNAMIC parameter object: [{0}]", dynamicParamBindableObject.GetType()); s_tracer.WriteLine("Creating a new parameter binder for the dynamic parameter object"); InternalParameterMetadata dynamicParameterMetadata; RuntimeDefinedParameterDictionary runtimeParamDictionary = dynamicParamBindableObject as RuntimeDefinedParameterDictionary; if (runtimeParamDictionary != null) { // Generate the type metadata for the runtime-defined parameters dynamicParameterMetadata = InternalParameterMetadata.Get(runtimeParamDictionary, true, true); _dynamicParameterBinder = new RuntimeDefinedParameterBinder( runtimeParamDictionary, this.Command, this.CommandLineParameters); } else { // Generate the type metadata or retrieve it from the cache dynamicParameterMetadata = InternalParameterMetadata.Get(dynamicParamBindableObject.GetType(), Context, true); // Create the parameter binder for the dynamic parameter object _dynamicParameterBinder = new ReflectionParameterBinder( dynamicParamBindableObject, this.Command, this.CommandLineParameters); } // Now merge the metadata with other metadata for the command var dynamicParams = BindableParameters.AddMetadataForBinder( dynamicParameterMetadata, ParameterBinderAssociation.DynamicParameters); foreach (var param in dynamicParams) { UnboundParameters.Add(param); } // Now set the parameter set flags for the new type metadata. _commandMetadata.DefaultParameterSetFlag = this.BindableParameters.GenerateParameterSetMappingFromMetadata(_commandMetadata.DefaultParameterSetName); } } if (_dynamicParameterBinder == null) { s_tracer.WriteLine("No dynamic parameter object was returned from the Cmdlet"); return; } if (UnboundArguments.Count > 0) { using (ParameterBinderBase.bindingTracer.TraceScope( "BIND NAMED args to DYNAMIC parameters")) { // Try to bind the unbound arguments as static parameters to the // dynamic parameter object. ReparseUnboundArguments(); UnboundArguments = BindParameters(_currentParameterSetFlag, UnboundArguments); } using (ParameterBinderBase.bindingTracer.TraceScope( "BIND POSITIONAL args to DYNAMIC parameters")) { UnboundArguments = BindPositionalParameters( UnboundArguments, _currentParameterSetFlag, _commandMetadata.DefaultParameterSetFlag, out outgoingBindingException); } } } // dynamicParameterCmdlet != null } } } // HandleCommandLineDynamicParameters
internal override bool BindParameter(int parameterSets, CommandParameterInternal argument, MergedCompiledCommandParameter parameter, ParameterBindingFlags flags) { bool flag = true; if ((((flags & ParameterBindingFlags.DelayBindScriptBlock) != ParameterBindingFlags.None) && parameter.Parameter.DoesParameterSetTakePipelineInput(parameterSets)) && argument.ArgumentSpecified) { object argumentValue = argument.ArgumentValue; if (((argumentValue is ScriptBlock) || (argumentValue is DelayedScriptBlockArgument)) && !IsParameterScriptBlockBindable(parameter)) { if (this._commandRuntime.IsClosed && this._commandRuntime.InputPipe.Empty) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.MetadataError, this.Command.MyInvocation, base.GetErrorExtent(argument), parameter.Parameter.Name, parameter.Parameter.Type, null, "ParameterBinderStrings", "ScriptBlockArgumentNoInput", new object[0]); throw exception; } ParameterBinderBase.bindingTracer.WriteLine("Adding ScriptBlock to delay-bind list for parameter '{0}'", new object[] { parameter.Parameter.Name }); DelayedScriptBlockArgument argument2 = argumentValue as DelayedScriptBlockArgument; if (argument2 == null) { argument2 = new DelayedScriptBlockArgument { _argument = argument, _parameterBinder = this }; } if (!this._delayBindScriptBlocks.ContainsKey(parameter)) { this._delayBindScriptBlocks.Add(parameter, argument2); } if (parameter.Parameter.ParameterSetFlags != 0) { base._currentParameterSetFlag &= parameter.Parameter.ParameterSetFlags; } base.UnboundParameters.Remove(parameter); if (!base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { base.BoundParameters.Add(parameter.Parameter.Name, parameter); } if (!base.BoundArguments.ContainsKey(parameter.Parameter.Name)) { base.BoundArguments.Add(parameter.Parameter.Name, argument); } if (base.DefaultParameterBinder.RecordBoundParameters && !base.DefaultParameterBinder.CommandLineParameters.ContainsKey(parameter.Parameter.Name)) { base.DefaultParameterBinder.CommandLineParameters.Add(parameter.Parameter.Name, argument2); } flag = false; } } bool flag2 = false; if (flag) { try { flag2 = this.BindParameter(argument, parameter, flags); } catch (Exception innerException) { bool flag3 = true; if ((flags & ParameterBindingFlags.ShouldCoerceType) == ParameterBindingFlags.None) { while (innerException != null) { if (innerException is PSInvalidCastException) { flag3 = false; break; } innerException = innerException.InnerException; } } if (flag3) { throw; } } } return flag2; }
private object EncodeCollection(CommandParameterInternal argument, string parameterName, ParameterCollectionTypeInformation collectionTypeInformation, Type toType, object currentValue, bool coerceElementTypeIfNeeded, out bool coercionRequired) { object obj2 = null; coercionRequired = false; bindingTracer.WriteLine("Binding collection parameter {0}: argument type [{1}], parameter type [{2}], collection type {3}, element type [{4}], {5}", new object[] { parameterName, (currentValue == null) ? "null" : currentValue.GetType().Name, toType, collectionTypeInformation.ParameterCollectionType, collectionTypeInformation.ElementType, coerceElementTypeIfNeeded ? "coerceElementType" : "no coerceElementType" }); if (currentValue != null) { int length = 1; Type elementType = collectionTypeInformation.ElementType; IList iList = GetIList(currentValue); if (iList != null) { length = iList.Count; tracer.WriteLine("current value is an IList with {0} elements", new object[] { length }); bindingTracer.WriteLine("Arg is IList with {0} elements", new object[] { length }); } object obj3 = null; IList list2 = null; MethodInfo info = null; bool flag = toType == typeof(Array); if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { if (flag) { elementType = typeof(object); } bindingTracer.WriteLine("Creating array with element type [{0}] and {1} elements", new object[] { elementType, length }); obj3 = list2 = Array.CreateInstance(elementType, length); } else { if ((collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.IList) && (collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.ICollectionGeneric)) { return(obj2); } bindingTracer.WriteLine("Creating collection [{0}]", new object[] { toType }); bool flag2 = false; Exception innerException = null; try { obj3 = Activator.CreateInstance(toType, BindingFlags.Default, null, new object[0], CultureInfo.InvariantCulture); if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { list2 = (IList)obj3; } else { Type type2 = collectionTypeInformation.ElementType; BindingFlags bindingAttr = BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance; Exception exception2 = null; try { info = toType.GetMethod("Add", bindingAttr, null, new Type[] { type2 }, null); } catch (AmbiguousMatchException exception3) { bindingTracer.WriteLine("Ambiguous match to Add(T) for type " + toType.FullName + ": " + exception3.Message, new object[0]); exception2 = exception3; } catch (ArgumentException exception4) { bindingTracer.WriteLine("ArgumentException matching Add(T) for type " + toType.FullName + ": " + exception4.Message, new object[0]); exception2 = exception4; } if (null == info) { ParameterBindingException exception5 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotExtractAddMethod", new object[] { (exception2 == null) ? "" : exception2.Message }); throw exception5; } } } catch (ArgumentException exception6) { flag2 = true; innerException = exception6; } catch (NotSupportedException exception7) { flag2 = true; innerException = exception7; } catch (TargetInvocationException exception8) { flag2 = true; innerException = exception8; } catch (MethodAccessException exception9) { flag2 = true; innerException = exception9; } catch (MemberAccessException exception10) { flag2 = true; innerException = exception10; } catch (InvalidComObjectException exception11) { flag2 = true; innerException = exception11; } catch (COMException exception12) { flag2 = true; innerException = exception12; } catch (TypeLoadException exception13) { flag2 = true; innerException = exception13; } if (flag2) { ParameterBindingException exception14 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj2 == null) ? "null" : obj2, (innerException == null) ? "" : innerException.Message }); throw exception14; } } if (iList != null) { int num2 = 0; bindingTracer.WriteLine("Argument type {0} is IList", new object[] { currentValue.GetType() }); foreach (object obj4 in iList) { object obj5 = PSObject.Base(obj4); if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("COERCE collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); obj5 = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, obj4); } else if ((null != elementType) && (obj5 != null)) { Type type = obj5.GetType(); Type c = elementType; if ((type != c) && !type.IsSubclassOf(c)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not attempt to coerce collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); coercionRequired = true; break; } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding element of type {0} to array position {1}", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name, num2 }); list2[num2++] = obj5; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding element of type {0} via IList.Add", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); list2.Add(obj5); } else { bindingTracer.WriteLine("Adding element of type {0} via ICollection<T>::Add()", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); info.Invoke(obj3, new object[] { obj5 }); } } catch (Exception exception15) { CommandProcessorBase.CheckForSevereException(exception15); if ((exception15 is TargetInvocationException) && (exception15.InnerException != null)) { exception15 = exception15.InnerException; } ParameterBindingException exception16 = new ParameterBindingException(exception15, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (obj5 == null) ? null : obj5.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj5 == null) ? "null" : obj5, exception15.Message }); throw exception16; } } } else { bindingTracer.WriteLine("Argument type {0} is not IList, treating this as scalar", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); if (elementType != null) { if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("Coercing scalar arg value to type {0}", new object[] { elementType }); currentValue = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, currentValue); } else { Type type5 = currentValue.GetType(); Type type6 = elementType; if ((type5 != type6) && !type5.IsSubclassOf(type6)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not coerce scalar arg value to type {1}", new object[] { elementType }); coercionRequired = true; return(obj2); } } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding scalar element of type {0} to array position {1}", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name, 0 }); list2[0] = currentValue; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding scalar element of type {0} via IList.Add", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); list2.Add(currentValue); } else { bindingTracer.WriteLine("Adding scalar element of type {0} via ICollection<T>::Add()", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); info.Invoke(obj3, new object[] { currentValue }); } } catch (Exception exception17) { CommandProcessorBase.CheckForSevereException(exception17); if ((exception17 is TargetInvocationException) && (exception17.InnerException != null)) { exception17 = exception17.InnerException; } ParameterBindingException exception18 = new ParameterBindingException(exception17, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (currentValue == null) ? "null" : currentValue, exception17.Message }); throw exception18; } } if (!coercionRequired) { obj2 = obj3; } } return(obj2); }
private void VerifyArgumentsProcessed(ParameterBindingException originalBindingException) { if (base.UnboundArguments.Count > 0) { ParameterBindingException exception; CommandParameterInternal cpi = base.UnboundArguments[0]; Type typeSpecified = null; object argumentValue = cpi.ArgumentValue; if ((argumentValue != null) && (argumentValue != UnboundParameter.Value)) { typeSpecified = argumentValue.GetType(); } if (cpi.ParameterNameSpecified) { exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, base.GetParameterErrorExtent(cpi), cpi.ParameterName, null, typeSpecified, "ParameterBinderStrings", "NamedParameterNotFound", new object[0]); } else if (originalBindingException != null) { exception = originalBindingException; } else { string parameterName = "$null"; if (cpi.ArgumentValue != null) { try { parameterName = cpi.ArgumentValue.ToString(); } catch (Exception exception2) { CommandProcessorBase.CheckForSevereException(exception2); exception = new ParameterBindingArgumentTransformationException(exception2, ErrorCategory.InvalidData, base.InvocationInfo, null, null, null, cpi.ArgumentValue.GetType(), "ParameterBinderStrings", "ParameterArgumentTransformationErrorMessageOnly", new object[] { exception2.Message }); if (!base.DefaultParameterBindingInUse) { throw exception; } base.ThrowElaboratedBindingException(exception); } } exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, parameterName, null, typeSpecified, "ParameterBinderStrings", "PositionalParameterNotFound", new object[0]); } if (!base.DefaultParameterBindingInUse) { throw exception; } base.ThrowElaboratedBindingException(exception); } }
private void ThrowAmbiguousParameterSetException(int parameterSetFlags, MergedCommandParameterMetadata bindableParameters) { ParameterBindingException pbex = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, null, "ParameterBinderStrings", "AmbiguousParameterSet", new object[0]); for (int i = 1; parameterSetFlags != 0; i = i << 1) { int num2 = parameterSetFlags & 1; if (num2 == 1) { string parameterSetName = bindableParameters.GetParameterSetName(i); if (!string.IsNullOrEmpty(parameterSetName)) { ParameterBinderBase.bindingTracer.WriteLine("Remaining valid parameter set: {0}", new object[] { parameterSetName }); } } parameterSetFlags = parameterSetFlags >> 1; } if (!base.DefaultParameterBindingInUse) { throw pbex; } base.ThrowElaboratedBindingException(pbex); }
private void RestoreDefaultParameterValues(IEnumerable<MergedCompiledCommandParameter> parameters) { if (parameters == null) { throw PSTraceSource.NewArgumentNullException("parameters"); } foreach (MergedCompiledCommandParameter parameter in parameters) { if (parameter == null) { continue; } CommandParameterInternal argumentToBind = null; foreach (CommandParameterInternal internal3 in this._defaultParameterValues.Values) { if (string.Equals(parameter.Parameter.Name, internal3.ParameterName, StringComparison.OrdinalIgnoreCase)) { argumentToBind = internal3; break; } } if (argumentToBind != null) { Exception innerException = null; try { this.RestoreParameter(argumentToBind, parameter); } catch (SetValueException exception2) { innerException = exception2; } if (innerException != null) { Type typeSpecified = (argumentToBind.ArgumentValue == null) ? null : argumentToBind.ArgumentValue.GetType(); ParameterBindingException exception3 = new ParameterBindingException(innerException, ErrorCategory.WriteError, base.InvocationInfo, base.GetErrorExtent(argumentToBind), parameter.Parameter.Name, parameter.Parameter.Type, typeSpecified, "ParameterBinderStrings", "ParameterBindingFailed", new object[] { innerException.Message }); throw exception3; } if (base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { base.BoundParameters.Remove(parameter.Parameter.Name); } if (!base.UnboundParameters.Contains(parameter)) { base.UnboundParameters.Add(parameter); } if (base.BoundArguments.ContainsKey(parameter.Parameter.Name)) { base.BoundArguments.Remove(parameter.Parameter.Name); } } else { if (!base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { base.BoundParameters.Add(parameter.Parameter.Name, parameter); } base.UnboundParameters.Remove(parameter); } } }
private Dictionary<string, PSObject> PromptForMissingMandatoryParameters(Collection<FieldDescription> fieldDescriptionList, Collection<MergedCompiledCommandParameter> missingMandatoryParameters) { Dictionary<string, PSObject> dictionary = null; Exception exception = null; try { ParameterBinderBase.bindingTracer.WriteLine("PROMPTING for missing mandatory parameters using the host", new object[0]); string promptMessage = ParameterBinderStrings.PromptMessage; InvocationInfo myInvocation = this.Command.MyInvocation; string caption = StringUtil.Format(ParameterBinderStrings.PromptCaption, myInvocation.MyCommand.Name, myInvocation.PipelinePosition); dictionary = base.Context.EngineHostInterface.UI.Prompt(caption, promptMessage, fieldDescriptionList); } catch (NotImplementedException exception2) { exception = exception2; } catch (HostException exception3) { exception = exception3; } catch (PSInvalidOperationException exception4) { exception = exception4; } if (exception != null) { ParameterBinderBase.bindingTracer.WriteLine("ERROR: host does not support prompting for missing mandatory parameters", new object[0]); string str3 = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException exception5 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, str3, null, null, "ParameterBinderStrings", "MissingMandatoryParameter", new object[0]); throw exception5; } if ((dictionary != null) && (dictionary.Count != 0)) { return dictionary; } ParameterBinderBase.bindingTracer.WriteLine("ERROR: still missing mandatory parameters after PROMPTING", new object[0]); string parameterName = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException exception6 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, parameterName, null, null, "ParameterBinderStrings", "MissingMandatoryParameter", new object[0]); throw exception6; }
private bool InvokeAndBindDelayBindScriptBlock(PSObject inputToOperateOn, out bool thereWasSomethingToBind) { thereWasSomethingToBind = false; bool flag = true; foreach (KeyValuePair<MergedCompiledCommandParameter, DelayedScriptBlockArgument> pair in this._delayBindScriptBlocks) { thereWasSomethingToBind = true; CommandParameterInternal cpi = pair.Value._argument; MergedCompiledCommandParameter key = pair.Key; ScriptBlock argumentValue = cpi.ArgumentValue as ScriptBlock; Collection<PSObject> collection = null; Exception innerException = null; using (ParameterBinderBase.bindingTracer.TraceScope("Invoking delay-bind ScriptBlock", new object[0])) { if (pair.Value._parameterBinder == this) { try { collection = argumentValue.DoInvoke(inputToOperateOn, inputToOperateOn, new object[0]); pair.Value._evaluatedArgument = collection; } catch (RuntimeException exception2) { innerException = exception2; } } else { collection = pair.Value._evaluatedArgument; } } if (innerException != null) { ParameterBindingException exception3 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.Command.MyInvocation, base.GetErrorExtent(cpi), key.Parameter.Name, null, null, "ParameterBinderStrings", "ScriptBlockArgumentInvocationFailed", new object[] { innerException.Message }); throw exception3; } if ((collection == null) || (collection.Count == 0)) { ParameterBindingException exception4 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.Command.MyInvocation, base.GetErrorExtent(cpi), key.Parameter.Name, null, null, "ParameterBinderStrings", "ScriptBlockArgumentNoOutput", new object[0]); throw exception4; } object obj2 = collection; if (collection.Count == 1) { obj2 = collection[0]; } CommandParameterInternal argument = CommandParameterInternal.CreateParameterWithArgument(cpi.ParameterExtent, cpi.ParameterName, "-" + cpi.ParameterName + ":", cpi.ArgumentExtent, obj2, false); if (!this.BindParameter(argument, key, ParameterBindingFlags.ShouldCoerceType)) { flag = false; } } return flag; }
/// <summary> /// Binds the actual arguments to only the formal parameters /// for only the parameters in the specified parameter set /// </summary> /// /// <param name="parameterSets"> /// The parameter set used to bind the arguments. /// </param> /// <param name="arguments"> /// The arguments that should be attempted to bind to the parameters of the specified /// parameter binder. /// </param> /// /// <exception cref="ParameterBindingException"> /// if multiple parameters are found matching the name. /// or /// if no match could be found. /// or /// If argument transformation fails. /// or /// The argument could not be coerced to the appropriate type for the parameter. /// or /// The parameter argument transformation, prerequisite, or validation failed. /// or /// If the binding to the parameter fails. /// </exception> private Collection<CommandParameterInternal> BindParameters(uint parameterSets, Collection<CommandParameterInternal> arguments) { Collection<CommandParameterInternal> result = new Collection<CommandParameterInternal>(); foreach (CommandParameterInternal argument in arguments) { if (!argument.ParameterNameSpecified) { result.Add(argument); continue; } // We don't want to throw an exception yet because // the parameter might be a positional argument or it // might match up to a dynamic parameter MergedCompiledCommandParameter parameter = BindableParameters.GetMatchingParameter( argument.ParameterName, false, true, new InvocationInfo(this.InvocationInfo.MyCommand, argument.ParameterExtent)); // If the parameter is not in the specified parameter set, // throw a binding exception if (parameter != null) { // Now check to make sure it hasn't already been // bound by looking in the boundParameters collection if (BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.InvocationInfo, GetParameterErrorExtent(argument), argument.ParameterName, null, null, ParameterBinderStrings.ParameterAlreadyBound, "ParameterAlreadyBound"); // Multiple values assigned to the same parameter. // Not caused by default parameter binding throw bindingException; } if ((parameter.Parameter.ParameterSetFlags & parameterSets) == 0 && !parameter.Parameter.IsInAllSets) { string parameterSetName = BindableParameters.GetParameterSetName(parameterSets); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, argument.ParameterName, null, null, ParameterBinderStrings.ParameterNotInParameterSet, "ParameterNotInParameterSet", parameterSetName); // Might be caused by default parameter binding if (!DefaultParameterBindingInUse) { throw bindingException; } else { ThrowElaboratedBindingException(bindingException); } } try { BindParameter(parameterSets, argument, parameter, ParameterBindingFlags.ShouldCoerceType | ParameterBindingFlags.DelayBindScriptBlock); } catch (ParameterBindingException pbex) { if (!DefaultParameterBindingInUse) { throw; } ThrowElaboratedBindingException(pbex); } } else if (argument.ParameterName.Equals(Parser.VERBATIM_PARAMETERNAME, StringComparison.Ordinal)) { // We sometimes send a magic parameter from a remote machine with the values referenced via // a using expression ($using:x). We then access these values via PSBoundParameters, so // "bind" them here. DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(argument.ArgumentValue); } else { result.Add(argument); } } return result; } // BindParameters
private bool BindPositionalParametersInSet(int validParameterSets, Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> nextPositionalParameters, CommandParameterInternal argument, ParameterBindingFlags flags, out ParameterBindingException bindingException) { bool flag = false; bindingException = null; foreach (PositionalCommandParameter parameter in nextPositionalParameters.Values) { foreach (ParameterSetSpecificMetadata metadata in parameter.ParameterSetData) { if (((validParameterSets & metadata.ParameterSetFlag) != 0) || metadata.IsInAllSets) { bool flag2 = false; string name = parameter.Parameter.Parameter.Name; ParameterBindingException pbex = null; try { CommandParameterInternal internal2 = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, name, "-" + name + ":", argument.ArgumentExtent, argument.ArgumentValue, false); flag2 = this.BindParameter(validParameterSets, internal2, parameter.Parameter, flags); } catch (ParameterBindingArgumentTransformationException exception2) { pbex = exception2; } catch (ParameterBindingValidationException exception3) { if (exception3.SwallowException) { flag2 = false; bindingException = exception3; } else { pbex = exception3; } } catch (ParameterBindingParameterDefaultValueException exception4) { pbex = exception4; } catch (ParameterBindingException exception5) { flag2 = false; bindingException = exception5; } if (pbex != null) { if (!this.DefaultParameterBindingInUse) { throw pbex; } this.ThrowElaboratedBindingException(pbex); } if (flag2) { flag = true; this.CommandLineParameters.MarkAsBoundPositionally(name); break; } } } } return(flag); }
/// <summary> /// Binds the remaining arguments to an unbound ValueFromRemainingArguments parameter (Varargs) /// </summary> /// /// <exception cref="ParameterBindingException"> /// If there was an error binding the arguments to the parameters. /// </exception> /// private void HandleRemainingArguments() { if (UnboundArguments.Count > 0) { // Find the parameters that take the remaining args, if there are more // than one and the parameter set has not been defined, this is an error MergedCompiledCommandParameter varargsParameter = null; foreach (MergedCompiledCommandParameter parameter in UnboundParameters) { ParameterSetSpecificMetadata parameterSetData = parameter.Parameter.GetParameterSetData(_currentParameterSetFlag); if (parameterSetData == null) { continue; } // If the parameter takes the remaining arguments, bind them. if (parameterSetData.ValueFromRemainingArguments) { if (varargsParameter != null) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.MetadataError, this.Command.MyInvocation, null, parameter.Parameter.Name, parameter.Parameter.Type, null, ParameterBinderStrings.AmbiguousParameterSet, "AmbiguousParameterSet"); // Might be caused by the default parameter binding if (!DefaultParameterBindingInUse) { throw bindingException; } else { ThrowElaboratedBindingException(bindingException); } } varargsParameter = parameter; } } if (varargsParameter != null) { using (ParameterBinderBase.bindingTracer.TraceScope( "BIND REMAININGARGUMENTS cmd line args to param: [{0}]", varargsParameter.Parameter.Name)) { // Accumulate the unbound arguments in to an list and then bind it to the parameter List<object> valueFromRemainingArguments = new List<object>(); foreach (CommandParameterInternal argument in UnboundArguments) { if (argument.ParameterNameSpecified) { Diagnostics.Assert(!string.IsNullOrEmpty(argument.ParameterText), "Don't add a null argument"); valueFromRemainingArguments.Add(argument.ParameterText); } if (argument.ArgumentSpecified) { object argumentValue = argument.ArgumentValue; if (argumentValue != AutomationNull.Value && argumentValue != UnboundParameter.Value) { valueFromRemainingArguments.Add(argumentValue); } } } // If there are multiple arguments, it's not clear how best to represent the extent as the extent // may be disjoint, as in 'echo a -verbose b', we have 'a' and 'b' in UnboundArguments. IScriptExtent argumentExtent = UnboundArguments.Count == 1 ? UnboundArguments[0].ArgumentExtent : PositionUtilities.EmptyExtent; var cpi = CommandParameterInternal.CreateParameterWithArgument( PositionUtilities.EmptyExtent, varargsParameter.Parameter.Name, "-" + varargsParameter.Parameter.Name + ":", argumentExtent, valueFromRemainingArguments, false); try { BindParameter(cpi, varargsParameter, ParameterBindingFlags.ShouldCoerceType); } catch (ParameterBindingException pbex) { // To make all of the following work similarly (the first is handled elsewhere, but second and third are // handled here): // Set-ClusterOwnerNode -Owners foo,bar // Set-ClusterOwnerNode foo bar // Set-ClusterOwnerNode foo,bar // we make one additional attempt at converting, but only if there is a single argument of type object[]. if (valueFromRemainingArguments.Count == 1 && valueFromRemainingArguments[0] is object[]) { cpi.SetArgumentValue(UnboundArguments[0].ArgumentExtent, valueFromRemainingArguments[0]); BindParameter(cpi, varargsParameter, ParameterBindingFlags.ShouldCoerceType); } else { if (!DefaultParameterBindingInUse) { throw; } else { ThrowElaboratedBindingException(pbex); } } } UnboundArguments.Clear(); } } } } // HandleRemainingArguments
internal MergedCompiledCommandParameter GetMatchingParameter(string name, bool throwOnParameterNotFound, bool tryExactMatching, InvocationInfo invocationInfo) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } Collection<MergedCompiledCommandParameter> collection = new Collection<MergedCompiledCommandParameter>(); if ((name.Length > 0) && SpecialCharacters.IsDash(name[0])) { name = name.Substring(1); } foreach (string str in this.bindableParameters.Keys) { if (nameCompareInfo.IsPrefix(str, name, CompareOptions.IgnoreCase)) { if (tryExactMatching && string.Equals(str, name, StringComparison.OrdinalIgnoreCase)) { return this.bindableParameters[str]; } collection.Add(this.bindableParameters[str]); } } foreach (string str2 in this.aliasedParameters.Keys) { if (nameCompareInfo.IsPrefix(str2, name, CompareOptions.IgnoreCase)) { if (tryExactMatching && string.Equals(str2, name, StringComparison.OrdinalIgnoreCase)) { return this.aliasedParameters[str2]; } if (!collection.Contains(this.aliasedParameters[str2])) { collection.Add(this.aliasedParameters[str2]); } } } if (collection.Count > 1) { StringBuilder builder = new StringBuilder(); foreach (MergedCompiledCommandParameter parameter in collection) { builder.AppendFormat(" -{0}", parameter.Parameter.Name); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, "ParameterBinderStrings", "AmbiguousParameter", new object[] { builder }); throw exception; } if ((collection.Count == 0) && throwOnParameterNotFound) { ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, "ParameterBinderStrings", "NamedParameterNotFound", new object[0]); throw exception2; } MergedCompiledCommandParameter parameter2 = null; if (collection.Count > 0) { parameter2 = collection[0]; } return parameter2; }
private void ThrowAmbiguousParameterSetException(uint parameterSetFlags, MergedCommandParameterMetadata bindableParameters) { ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, null, ParameterBinderStrings.AmbiguousParameterSet, "AmbiguousParameterSet"); // Trace the parameter sets still active uint currentParameterSet = 1; while (parameterSetFlags != 0) { uint currentParameterSetActive = parameterSetFlags & 0x1; if (currentParameterSetActive == 1) { string parameterSetName = bindableParameters.GetParameterSetName(currentParameterSet); if (!String.IsNullOrEmpty(parameterSetName)) { ParameterBinderBase.bindingTracer.WriteLine("Remaining valid parameter set: {0}", parameterSetName); } } parameterSetFlags >>= 1; currentParameterSet <<= 1; } if (!DefaultParameterBindingInUse) { throw bindingException; } else { ThrowElaboratedBindingException(bindingException); } }
private object CoerceTypeAsNeeded(CommandParameterInternal argument, string parameterName, Type toType, ParameterCollectionTypeInformation collectionTypeInfo, object currentValue) { if (argument == null) { throw PSTraceSource.NewArgumentNullException("argument"); } if (toType == null) { throw PSTraceSource.NewArgumentNullException("toType"); } if (collectionTypeInfo == null) { collectionTypeInfo = new ParameterCollectionTypeInformation(toType); } object result = currentValue; using (bindingTracer.TraceScope("COERCE arg to [{0}]", new object[] { toType })) { Type c = null; try { if (IsNullParameterValue(currentValue)) { return this.HandleNullParameterForSpecialTypes(argument, parameterName, toType, currentValue); } c = currentValue.GetType(); if (toType.IsAssignableFrom(c)) { bindingTracer.WriteLine("Parameter and arg types the same, no coercion is needed.", new object[0]); return currentValue; } bindingTracer.WriteLine("Trying to convert argument value from {0} to {1}", new object[] { c, toType }); if (toType == typeof(PSObject)) { if ((this.command != null) && (currentValue == this.command.CurrentPipelineObject.BaseObject)) { currentValue = this.command.CurrentPipelineObject; } bindingTracer.WriteLine("The parameter is of type [{0}] and the argument is an PSObject, so the parameter value is the argument value wrapped into an PSObject.", new object[] { toType }); return LanguagePrimitives.AsPSObjectOrNull(currentValue); } if ((toType == typeof(string)) && (c == typeof(PSObject))) { PSObject obj3 = (PSObject) currentValue; if (obj3 == AutomationNull.Value) { bindingTracer.WriteLine("CONVERT a null PSObject to a null string.", new object[0]); return null; } } if (((toType == typeof(bool)) || (toType == typeof(SwitchParameter))) || (toType == typeof(bool?))) { Type type = null; if (c == typeof(PSObject)) { PSObject obj4 = (PSObject) currentValue; currentValue = obj4.BaseObject; if (currentValue is SwitchParameter) { SwitchParameter parameter = (SwitchParameter) currentValue; currentValue = parameter.IsPresent; } type = currentValue.GetType(); } else { type = c; } if (type == typeof(bool)) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject((bool) currentValue); } return new SwitchParameter((bool) currentValue); } if (type == typeof(int)) { if (((int) LanguagePrimitives.ConvertTo(currentValue, typeof(int), CultureInfo.InvariantCulture)) != 0) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(true); } return new SwitchParameter(true); } if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(false); } return new SwitchParameter(false); } if (LanguagePrimitives.IsNumeric(Type.GetTypeCode(type))) { double num = (double) LanguagePrimitives.ConvertTo(currentValue, typeof(double), CultureInfo.InvariantCulture); if (num == 0.0) { if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(false); } return new SwitchParameter(false); } if (LanguagePrimitives.IsBooleanType(toType)) { return ParserOps.BoolToObject(true); } return new SwitchParameter(true); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { type, "" }); throw exception; } if ((collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.ICollectionGeneric) || (collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.IList)) { object obj5 = PSObject.Base(currentValue); if (obj5 != null) { ConversionRank conversionRank = LanguagePrimitives.GetConversionRank(obj5.GetType(), toType); if ((((conversionRank == ConversionRank.Constructor) || (conversionRank == ConversionRank.ImplicitCast)) || (conversionRank == ConversionRank.ExplicitCast)) && LanguagePrimitives.TryConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture, out result)) { return result; } } } if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection) { bindingTracer.WriteLine("ENCODING arg into collection", new object[0]); bool coercionRequired = false; return this.EncodeCollection(argument, parameterName, collectionTypeInfo, toType, currentValue, collectionTypeInfo.ElementType != null, out coercionRequired); } if (((((GetIList(currentValue) != null) && (toType != typeof(object))) && ((toType != typeof(PSObject)) && (toType != typeof(PSListModifier)))) && ((!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(PSListModifier<>))) && (!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(FlagsExpression<>))))) && !toType.IsEnum) { throw new NotSupportedException(); } bindingTracer.WriteLine("CONVERT arg type to param type using LanguagePrimitives.ConvertTo", new object[0]); bool flag2 = false; if (this.context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { object obj6 = PSObject.Base(currentValue); bool flag3 = obj6 is PSObject; bool flag4 = (obj6 != null) && typeof(IDictionary).IsAssignableFrom(obj6.GetType()); flag2 = ((((PSLanguageMode) this.Command.CommandInfo.DefiningLanguageMode) == PSLanguageMode.FullLanguage) && !flag3) && !flag4; } try { if (flag2) { this.context.LanguageMode = PSLanguageMode.FullLanguage; } result = LanguagePrimitives.ConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture); } finally { if (flag2) { this.context.LanguageMode = PSLanguageMode.ConstrainedLanguage; } } bindingTracer.WriteLine("CONVERT SUCCESSFUL using LanguagePrimitives.ConvertTo: [{0}]", new object[] { (result == null) ? "null" : result.ToString() }); return result; } catch (NotSupportedException exception2) { bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", new object[] { (result == null) ? "null" : result, toType }); ParameterBindingException exception3 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { (result == null) ? "null" : result, exception2.Message }); throw exception3; } catch (PSInvalidCastException exception4) { object[] args = new object[] { result ?? "null", toType }; bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", args); ParameterBindingException exception5 = new ParameterBindingException(exception4, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgumentNoMessage", new object[] { exception4.Message }); throw exception5; } } return result; }
} // HandleUnboundMandatoryParameters private Dictionary<string, PSObject> PromptForMissingMandatoryParameters( Collection<FieldDescription> fieldDescriptionList, Collection<MergedCompiledCommandParameter> missingMandatoryParameters) { Dictionary<string, PSObject> parameters = null; Exception error = null; // Prompt try { ParameterBinderBase.bindingTracer.WriteLine( "PROMPTING for missing mandatory parameters using the host"); string msg = ParameterBinderStrings.PromptMessage; InvocationInfo invoInfo = Command.MyInvocation; string caption = StringUtil.Format(ParameterBinderStrings.PromptCaption, invoInfo.MyCommand.Name, invoInfo.PipelinePosition); parameters = Context.EngineHostInterface.UI.Prompt(caption, msg, fieldDescriptionList); } catch (NotImplementedException notImplemented) { error = notImplemented; } catch (HostException hostException) { error = hostException; } catch (PSInvalidOperationException invalidOperation) { error = invalidOperation; } if (error != null) { ParameterBinderBase.bindingTracer.WriteLine( "ERROR: host does not support prompting for missing mandatory parameters"); string missingParameters = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, missingParameters, null, null, ParameterBinderStrings.MissingMandatoryParameter, "MissingMandatoryParameter"); throw bindingException; } if ((parameters == null) || (parameters.Count == 0)) { ParameterBinderBase.bindingTracer.WriteLine( "ERROR: still missing mandatory parameters after PROMPTING"); string missingParameters = BuildMissingParamsString(missingMandatoryParameters); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, missingParameters, null, null, ParameterBinderStrings.MissingMandatoryParameter, "MissingMandatoryParameter"); throw bindingException; } return parameters; }
private object CoerceTypeAsNeeded(CommandParameterInternal argument, string parameterName, Type toType, ParameterCollectionTypeInformation collectionTypeInfo, object currentValue) { if (argument == null) { throw PSTraceSource.NewArgumentNullException("argument"); } if (toType == null) { throw PSTraceSource.NewArgumentNullException("toType"); } if (collectionTypeInfo == null) { collectionTypeInfo = new ParameterCollectionTypeInformation(toType); } object result = currentValue; using (bindingTracer.TraceScope("COERCE arg to [{0}]", new object[] { toType })) { Type c = null; try { if (IsNullParameterValue(currentValue)) { return(this.HandleNullParameterForSpecialTypes(argument, parameterName, toType, currentValue)); } c = currentValue.GetType(); if (toType.IsAssignableFrom(c)) { bindingTracer.WriteLine("Parameter and arg types the same, no coercion is needed.", new object[0]); return(currentValue); } bindingTracer.WriteLine("Trying to convert argument value from {0} to {1}", new object[] { c, toType }); if (toType == typeof(PSObject)) { if ((this.command != null) && (currentValue == this.command.CurrentPipelineObject.BaseObject)) { currentValue = this.command.CurrentPipelineObject; } bindingTracer.WriteLine("The parameter is of type [{0}] and the argument is an PSObject, so the parameter value is the argument value wrapped into an PSObject.", new object[] { toType }); return(LanguagePrimitives.AsPSObjectOrNull(currentValue)); } if ((toType == typeof(string)) && (c == typeof(PSObject))) { PSObject obj3 = (PSObject)currentValue; if (obj3 == AutomationNull.Value) { bindingTracer.WriteLine("CONVERT a null PSObject to a null string.", new object[0]); return(null); } } if (((toType == typeof(bool)) || (toType == typeof(SwitchParameter))) || (toType == typeof(bool?))) { Type type = null; if (c == typeof(PSObject)) { PSObject obj4 = (PSObject)currentValue; currentValue = obj4.BaseObject; if (currentValue is SwitchParameter) { SwitchParameter parameter = (SwitchParameter)currentValue; currentValue = parameter.IsPresent; } type = currentValue.GetType(); } else { type = c; } if (type == typeof(bool)) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject((bool)currentValue)); } return(new SwitchParameter((bool)currentValue)); } if (type == typeof(int)) { if (((int)LanguagePrimitives.ConvertTo(currentValue, typeof(int), CultureInfo.InvariantCulture)) != 0) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(true)); } return(new SwitchParameter(true)); } if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(false)); } return(new SwitchParameter(false)); } if (LanguagePrimitives.IsNumeric(Type.GetTypeCode(type))) { double num = (double)LanguagePrimitives.ConvertTo(currentValue, typeof(double), CultureInfo.InvariantCulture); if (num == 0.0) { if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(false)); } return(new SwitchParameter(false)); } if (LanguagePrimitives.IsBooleanType(toType)) { return(ParserOps.BoolToObject(true)); } return(new SwitchParameter(true)); } ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { type, "" }); throw exception; } if ((collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.ICollectionGeneric) || (collectionTypeInfo.ParameterCollectionType == ParameterCollectionType.IList)) { object obj5 = PSObject.Base(currentValue); if (obj5 != null) { ConversionRank conversionRank = LanguagePrimitives.GetConversionRank(obj5.GetType(), toType); if ((((conversionRank == ConversionRank.Constructor) || (conversionRank == ConversionRank.ImplicitCast)) || (conversionRank == ConversionRank.ExplicitCast)) && LanguagePrimitives.TryConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture, out result)) { return(result); } } } if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection) { bindingTracer.WriteLine("ENCODING arg into collection", new object[0]); bool coercionRequired = false; return(this.EncodeCollection(argument, parameterName, collectionTypeInfo, toType, currentValue, collectionTypeInfo.ElementType != null, out coercionRequired)); } if (((((GetIList(currentValue) != null) && (toType != typeof(object))) && ((toType != typeof(PSObject)) && (toType != typeof(PSListModifier)))) && ((!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(PSListModifier <>))) && (!toType.IsGenericType || (toType.GetGenericTypeDefinition() != typeof(FlagsExpression <>))))) && !toType.IsEnum) { throw new NotSupportedException(); } bindingTracer.WriteLine("CONVERT arg type to param type using LanguagePrimitives.ConvertTo", new object[0]); bool flag2 = false; if (this.context.LanguageMode == PSLanguageMode.ConstrainedLanguage) { object obj6 = PSObject.Base(currentValue); bool flag3 = obj6 is PSObject; bool flag4 = (obj6 != null) && typeof(IDictionary).IsAssignableFrom(obj6.GetType()); flag2 = ((((PSLanguageMode)this.Command.CommandInfo.DefiningLanguageMode) == PSLanguageMode.FullLanguage) && !flag3) && !flag4; } try { if (flag2) { this.context.LanguageMode = PSLanguageMode.FullLanguage; } result = LanguagePrimitives.ConvertTo(currentValue, toType, Thread.CurrentThread.CurrentCulture); } finally { if (flag2) { this.context.LanguageMode = PSLanguageMode.ConstrainedLanguage; } } bindingTracer.WriteLine("CONVERT SUCCESSFUL using LanguagePrimitives.ConvertTo: [{0}]", new object[] { (result == null) ? "null" : result.ToString() }); return(result); } catch (NotSupportedException exception2) { bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", new object[] { (result == null) ? "null" : result, toType }); ParameterBindingException exception3 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgument", new object[] { (result == null) ? "null" : result, exception2.Message }); throw exception3; } catch (PSInvalidCastException exception4) { object[] args = new object[] { result ?? "null", toType }; bindingTracer.TraceError("ERROR: COERCE FAILED: arg [{0}] could not be converted to the parameter type [{1}]", args); ParameterBindingException exception5 = new ParameterBindingException(exception4, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, c, "ParameterBinderStrings", "CannotConvertArgumentNoMessage", new object[] { exception4.Message }); throw exception5; } } return(result); }
/// <summary> /// Replaces the values of the parameters with their initial value for the /// parameters specified. /// </summary> /// /// <param name="parameters"> /// The parameters that should have their default values restored. /// </param> /// /// <exception cref="ArgumentNullException"> /// If <paramref name="parameters"/> is null. /// </exception> /// private void RestoreDefaultParameterValues(IEnumerable<MergedCompiledCommandParameter> parameters) { if (parameters == null) { throw PSTraceSource.NewArgumentNullException("parameters"); } // Get all the matching arguments from the defaultParameterValues collection // and bind those that had parameters that were bound via pipeline input foreach (MergedCompiledCommandParameter parameter in parameters) { if (parameter == null) { continue; } CommandParameterInternal argumentToBind = null; // If the argument was found then bind it to the parameter // and manage the bound and unbound parameter list if (_defaultParameterValues.TryGetValue(parameter.Parameter.Name, out argumentToBind)) { // Don't go through the normal binding routine to run data generation, // type coercion, validation, or prerequisites since we know the // type is already correct, and we don't want data generation to // run when resetting the default value. Exception error = null; try { // We shouldn't have to coerce the type here so its // faster to pass false bool bindResult = RestoreParameter(argumentToBind, parameter); Diagnostics.Assert( bindResult, "Restoring the default value should not require type coercion"); } catch (SetValueException setValueException) { error = setValueException; } if (error != null) { Type specifiedType = (argumentToBind.ArgumentValue == null) ? null : argumentToBind.ArgumentValue.GetType(); ParameterBindingException bindingException = new ParameterBindingException( error, ErrorCategory.WriteError, this.InvocationInfo, GetErrorExtent(argumentToBind), parameter.Parameter.Name, parameter.Parameter.Type, specifiedType, ParameterBinderStrings.ParameterBindingFailed, "ParameterBindingFailed", error.Message); throw bindingException; } // Since the parameter was returned to its original value, // ensure that it is not in the boundParameters list but // is in the unboundParameters list BoundParameters.Remove(parameter.Parameter.Name); if (!UnboundParameters.Contains(parameter)) { UnboundParameters.Add(parameter); } BoundArguments.Remove(parameter.Parameter.Name); } else { // Since the parameter was not reset, ensure that the parameter // is in the bound parameters list and not in the unbound // parameters list if (!BoundParameters.ContainsKey(parameter.Parameter.Name)) { BoundParameters.Add(parameter.Parameter.Name, parameter); } // Ensure the parameter is not in the unboundParameters list UnboundParameters.Remove(parameter); } } }
private object HandleNullParameterForSpecialTypes(CommandParameterInternal argument, string parameterName, Type toType, object currentValue) { if (toType == typeof(bool)) { bindingTracer.WriteLine("ERROR: No argument is specified for parameter and parameter type is BOOL", new object[0]); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "ParameterArgumentValidationErrorNullNotAllowed", new object[] { "" }); throw exception; } if (toType == typeof(SwitchParameter)) { bindingTracer.WriteLine("Arg is null or not present, parameter type is SWITCHPARAMTER, value is true.", new object[0]); return SwitchParameter.Present; } if (currentValue == UnboundParameter.Value) { bindingTracer.TraceError("ERROR: No argument was specified for the parameter and the parameter is not of type bool", new object[0]); ParameterBindingException exception2 = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetParameterErrorExtent(argument), parameterName, toType, null, "ParameterBinderStrings", "MissingArgument", new object[0]); throw exception2; } bindingTracer.WriteLine("Arg is null, parameter type not bool or SwitchParameter, value is null.", new object[0]); return null; }
internal Collection <CommandParameterInternal> BindPositionalParameters(Collection <CommandParameterInternal> unboundArguments, int validParameterSets, int defaultParameterSet, out ParameterBindingException outgoingBindingException) { Collection <CommandParameterInternal> nonPositionalArguments = new Collection <CommandParameterInternal>(); outgoingBindingException = null; if (unboundArguments.Count > 0) { SortedDictionary <int, Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> > dictionary; List <CommandParameterInternal> unboundArgumentsCollection = new List <CommandParameterInternal>(unboundArguments); try { dictionary = EvaluateUnboundPositionalParameters(this.UnboundParameters, this._currentParameterSetFlag); } catch (InvalidOperationException) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, this.InvocationInfo, null, null, null, null, "ParameterBinderStrings", "AmbiguousPositionalParameterNoName", new object[0]); throw exception; } if (dictionary.Count <= 0) { return(unboundArguments); } int unboundArgumentsIndex = 0; foreach (Dictionary <MergedCompiledCommandParameter, PositionalCommandParameter> dictionary2 in dictionary.Values) { if (dictionary2.Count != 0) { CommandParameterInternal argument = GetNextPositionalArgument(unboundArgumentsCollection, nonPositionalArguments, ref unboundArgumentsIndex); if (argument == null) { break; } bool flag = false; if ((defaultParameterSet != 0) && ((validParameterSets & defaultParameterSet) != 0)) { flag = this.BindPositionalParametersInSet(defaultParameterSet, dictionary2, argument, ParameterBindingFlags.DelayBindScriptBlock, out outgoingBindingException); } if (!flag) { flag = this.BindPositionalParametersInSet(validParameterSets, dictionary2, argument, ParameterBindingFlags.DelayBindScriptBlock, out outgoingBindingException); } if ((!flag && (defaultParameterSet != 0)) && ((validParameterSets & defaultParameterSet) != 0)) { flag = this.BindPositionalParametersInSet(defaultParameterSet, dictionary2, argument, ParameterBindingFlags.DelayBindScriptBlock | ParameterBindingFlags.ShouldCoerceType, out outgoingBindingException); } if (!flag) { flag = this.BindPositionalParametersInSet(validParameterSets, dictionary2, argument, ParameterBindingFlags.DelayBindScriptBlock | ParameterBindingFlags.ShouldCoerceType, out outgoingBindingException); } if (!flag) { nonPositionalArguments.Add(argument); } else if (validParameterSets != this._currentParameterSetFlag) { validParameterSets = this._currentParameterSetFlag; UpdatePositionalDictionary(dictionary, validParameterSets); } } } for (int i = unboundArgumentsIndex; i < unboundArgumentsCollection.Count; i++) { nonPositionalArguments.Add(unboundArgumentsCollection[i]); } } return(nonPositionalArguments); }
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 object EncodeCollection(CommandParameterInternal argument, string parameterName, ParameterCollectionTypeInformation collectionTypeInformation, Type toType, object currentValue, bool coerceElementTypeIfNeeded, out bool coercionRequired) { object obj2 = null; coercionRequired = false; bindingTracer.WriteLine("Binding collection parameter {0}: argument type [{1}], parameter type [{2}], collection type {3}, element type [{4}], {5}", new object[] { parameterName, (currentValue == null) ? "null" : currentValue.GetType().Name, toType, collectionTypeInformation.ParameterCollectionType, collectionTypeInformation.ElementType, coerceElementTypeIfNeeded ? "coerceElementType" : "no coerceElementType" }); if (currentValue != null) { int length = 1; Type elementType = collectionTypeInformation.ElementType; IList iList = GetIList(currentValue); if (iList != null) { length = iList.Count; tracer.WriteLine("current value is an IList with {0} elements", new object[] { length }); bindingTracer.WriteLine("Arg is IList with {0} elements", new object[] { length }); } object obj3 = null; IList list2 = null; MethodInfo info = null; bool flag = toType == typeof(Array); if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { if (flag) { elementType = typeof(object); } bindingTracer.WriteLine("Creating array with element type [{0}] and {1} elements", new object[] { elementType, length }); obj3 = list2 = Array.CreateInstance(elementType, length); } else { if ((collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.IList) && (collectionTypeInformation.ParameterCollectionType != ParameterCollectionType.ICollectionGeneric)) { return obj2; } bindingTracer.WriteLine("Creating collection [{0}]", new object[] { toType }); bool flag2 = false; Exception innerException = null; try { obj3 = Activator.CreateInstance(toType, BindingFlags.Default, null, new object[0], CultureInfo.InvariantCulture); if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { list2 = (IList) obj3; } else { Type type2 = collectionTypeInformation.ElementType; BindingFlags bindingAttr = BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance; Exception exception2 = null; try { info = toType.GetMethod("Add", bindingAttr, null, new Type[] { type2 }, null); } catch (AmbiguousMatchException exception3) { bindingTracer.WriteLine("Ambiguous match to Add(T) for type " + toType.FullName + ": " + exception3.Message, new object[0]); exception2 = exception3; } catch (ArgumentException exception4) { bindingTracer.WriteLine("ArgumentException matching Add(T) for type " + toType.FullName + ": " + exception4.Message, new object[0]); exception2 = exception4; } if (null == info) { ParameterBindingException exception5 = new ParameterBindingException(exception2, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotExtractAddMethod", new object[] { (exception2 == null) ? "" : exception2.Message }); throw exception5; } } } catch (ArgumentException exception6) { flag2 = true; innerException = exception6; } catch (NotSupportedException exception7) { flag2 = true; innerException = exception7; } catch (TargetInvocationException exception8) { flag2 = true; innerException = exception8; } catch (MethodAccessException exception9) { flag2 = true; innerException = exception9; } catch (MemberAccessException exception10) { flag2 = true; innerException = exception10; } catch (InvalidComObjectException exception11) { flag2 = true; innerException = exception11; } catch (COMException exception12) { flag2 = true; innerException = exception12; } catch (TypeLoadException exception13) { flag2 = true; innerException = exception13; } if (flag2) { ParameterBindingException exception14 = new ParameterBindingException(innerException, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj2 == null) ? "null" : obj2, (innerException == null) ? "" : innerException.Message }); throw exception14; } } if (iList != null) { int num2 = 0; bindingTracer.WriteLine("Argument type {0} is IList", new object[] { currentValue.GetType() }); foreach (object obj4 in iList) { object obj5 = PSObject.Base(obj4); if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("COERCE collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); obj5 = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, obj4); } else if ((null != elementType) && (obj5 != null)) { Type type = obj5.GetType(); Type c = elementType; if ((type != c) && !type.IsSubclassOf(c)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not attempt to coerce collection element from type {0} to type {1}", new object[] { (obj4 == null) ? "null" : obj4.GetType().Name, elementType }); coercionRequired = true; break; } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding element of type {0} to array position {1}", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name, num2 }); list2[num2++] = obj5; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding element of type {0} via IList.Add", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); list2.Add(obj5); } else { bindingTracer.WriteLine("Adding element of type {0} via ICollection<T>::Add()", new object[] { (obj5 == null) ? "null" : obj5.GetType().Name }); info.Invoke(obj3, new object[] { obj5 }); } } catch (Exception exception15) { CommandProcessorBase.CheckForSevereException(exception15); if ((exception15 is TargetInvocationException) && (exception15.InnerException != null)) { exception15 = exception15.InnerException; } ParameterBindingException exception16 = new ParameterBindingException(exception15, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (obj5 == null) ? null : obj5.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (obj5 == null) ? "null" : obj5, exception15.Message }); throw exception16; } } } else { bindingTracer.WriteLine("Argument type {0} is not IList, treating this as scalar", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); if (elementType != null) { if (coerceElementTypeIfNeeded) { bindingTracer.WriteLine("Coercing scalar arg value to type {0}", new object[] { elementType }); currentValue = this.CoerceTypeAsNeeded(argument, parameterName, elementType, null, currentValue); } else { Type type5 = currentValue.GetType(); Type type6 = elementType; if ((type5 != type6) && !type5.IsSubclassOf(type6)) { bindingTracer.WriteLine("COERCION REQUIRED: Did not coerce scalar arg value to type {1}", new object[] { elementType }); coercionRequired = true; return obj2; } } } try { if ((collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.Array) || flag) { bindingTracer.WriteLine("Adding scalar element of type {0} to array position {1}", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name, 0 }); list2[0] = currentValue; } else if (collectionTypeInformation.ParameterCollectionType == ParameterCollectionType.IList) { bindingTracer.WriteLine("Adding scalar element of type {0} via IList.Add", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); list2.Add(currentValue); } else { bindingTracer.WriteLine("Adding scalar element of type {0} via ICollection<T>::Add()", new object[] { (currentValue == null) ? "null" : currentValue.GetType().Name }); info.Invoke(obj3, new object[] { currentValue }); } } catch (Exception exception17) { CommandProcessorBase.CheckForSevereException(exception17); if ((exception17 is TargetInvocationException) && (exception17.InnerException != null)) { exception17 = exception17.InnerException; } ParameterBindingException exception18 = new ParameterBindingException(exception17, ErrorCategory.InvalidArgument, this.InvocationInfo, this.GetErrorExtent(argument), parameterName, toType, (currentValue == null) ? null : currentValue.GetType(), "ParameterBinderStrings", "CannotConvertArgument", new object[] { (currentValue == null) ? "null" : currentValue, exception17.Message }); throw exception18; } } if (!coercionRequired) { obj2 = obj3; } } return obj2; }
private void HandleRemainingArguments() { if (base.UnboundArguments.Count > 0) { MergedCompiledCommandParameter parameter = null; foreach (MergedCompiledCommandParameter parameter2 in base.UnboundParameters) { ParameterSetSpecificMetadata parameterSetData = parameter2.Parameter.GetParameterSetData(base._currentParameterSetFlag); if ((parameterSetData != null) && parameterSetData.ValueFromRemainingArguments) { if (parameter != null) { ParameterBindingException pbex = new ParameterBindingException(ErrorCategory.MetadataError, this.Command.MyInvocation, null, parameter2.Parameter.Name, parameter2.Parameter.Type, null, "ParameterBinderStrings", "AmbiguousParameterSet", new object[0]); if (!base.DefaultParameterBindingInUse) { throw pbex; } base.ThrowElaboratedBindingException(pbex); } parameter = parameter2; } } if (parameter != null) { using (ParameterBinderBase.bindingTracer.TraceScope("BIND REMAININGARGUMENTS cmd line args to param: [{0}]", new object[] { parameter.Parameter.Name })) { ArrayList list = new ArrayList(); foreach (CommandParameterInternal internal2 in base.UnboundArguments) { if (internal2.ParameterNameSpecified) { list.Add(internal2.ParameterText); } if (internal2.ArgumentSpecified) { object argumentValue = internal2.ArgumentValue; if ((argumentValue != AutomationNull.Value) && (argumentValue != UnboundParameter.Value)) { list.Add(argumentValue); } } } IScriptExtent argumentExtent = (base.UnboundArguments.Count == 1) ? base.UnboundArguments[0].ArgumentExtent : PositionUtilities.EmptyExtent; CommandParameterInternal argument = CommandParameterInternal.CreateParameterWithArgument(PositionUtilities.EmptyExtent, parameter.Parameter.Name, "-" + parameter.Parameter.Name + ":", argumentExtent, list, false); try { this.BindParameter(argument, parameter, ParameterBindingFlags.ShouldCoerceType); } catch (ParameterBindingException exception2) { if ((list.Count == 1) && (list[0] is object[])) { argument.SetArgumentValue(base.UnboundArguments[0].ArgumentExtent, list[0]); this.BindParameter(argument, parameter, ParameterBindingFlags.ShouldCoerceType); } else { if (!base.DefaultParameterBindingInUse) { throw; } base.ThrowElaboratedBindingException(exception2); } } base.UnboundArguments.Clear(); } } } }
private Collection<CommandParameterInternal> BindParameters(int parameterSets, Collection<CommandParameterInternal> arguments) { Collection<CommandParameterInternal> collection = new Collection<CommandParameterInternal>(); foreach (CommandParameterInternal internal2 in arguments) { if (!internal2.ParameterNameSpecified) { collection.Add(internal2); } else { MergedCompiledCommandParameter parameter = base.BindableParameters.GetMatchingParameter(internal2.ParameterName, false, true, new InvocationInfo(base.InvocationInfo.MyCommand, internal2.ParameterExtent)); if (parameter != null) { if (base.BoundParameters.ContainsKey(parameter.Parameter.Name)) { ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, base.InvocationInfo, base.GetParameterErrorExtent(internal2), internal2.ParameterName, null, null, "ParameterBinderStrings", "ParameterAlreadyBound", new object[0]); throw exception; } if (((parameter.Parameter.ParameterSetFlags & parameterSets) == 0) && !parameter.Parameter.IsInAllSets) { string parameterSetName = base.BindableParameters.GetParameterSetName(parameterSets); ParameterBindingException pbex = new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, internal2.ParameterName, null, null, "ParameterBinderStrings", "ParameterNotInParameterSet", new object[] { parameterSetName }); if (!base.DefaultParameterBindingInUse) { throw pbex; } base.ThrowElaboratedBindingException(pbex); } try { this.BindParameter(parameterSets, internal2, parameter, ParameterBindingFlags.DelayBindScriptBlock | ParameterBindingFlags.ShouldCoerceType); } catch (ParameterBindingException exception3) { if (!base.DefaultParameterBindingInUse) { throw; } base.ThrowElaboratedBindingException(exception3); } } else if (internal2.ParameterName.Equals("-%", StringComparison.Ordinal)) { base.DefaultParameterBinder.CommandLineParameters.SetImplicitUsingParameters(internal2.ArgumentValue); } else { collection.Add(internal2); } } } return collection; }
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; } }
/// <summary> /// Gets the parameters by matching its name. /// </summary> /// <param name="name"> /// The name of the parameter. /// </param> /// <param name="throwOnParameterNotFound"> /// If true and a matching parameter is not found, an exception will be /// throw. If false and a matching parameter is not found, null is returned. /// </param> /// <param name="tryExactMatching"> /// If true we do exact matching, otherwise we do not. /// </param> /// <param name="invocationInfo"> /// The invocation information about the code being run. /// </param> /// <returns> /// The a collection of the metadata associated with the parameters that /// match the specified name. If no matches were found, an empty collection /// is returned. /// </returns> /// <exception cref="ArgumentException"> /// If <paramref name="name"/> is null or empty. /// </exception> internal MergedCompiledCommandParameter GetMatchingParameter( string name, bool throwOnParameterNotFound, bool tryExactMatching, InvocationInfo invocationInfo) { if (string.IsNullOrEmpty(name)) { throw PSTraceSource.NewArgumentException("name"); } Collection <MergedCompiledCommandParameter> matchingParameters = new Collection <MergedCompiledCommandParameter>(); // Skip the leading '-' if present if (name.Length > 0 && CharExtensions.IsDash(name[0])) { name = name.Substring(1); } // First try to match the bindable parameters foreach (string parameterName in _bindableParameters.Keys) { if (CultureInfo.InvariantCulture.CompareInfo.IsPrefix(parameterName, name, CompareOptions.IgnoreCase)) { // If it is an exact match then only return the exact match // as the result if (tryExactMatching && string.Equals(parameterName, name, StringComparison.OrdinalIgnoreCase)) { return(_bindableParameters[parameterName]); } else { matchingParameters.Add(_bindableParameters[parameterName]); } } } // Now check the aliases foreach (string parameterName in _aliasedParameters.Keys) { if (CultureInfo.InvariantCulture.CompareInfo.IsPrefix(parameterName, name, CompareOptions.IgnoreCase)) { // If it is an exact match then only return the exact match // as the result if (tryExactMatching && string.Equals(parameterName, name, StringComparison.OrdinalIgnoreCase)) { return(_aliasedParameters[parameterName]); } else { if (!matchingParameters.Contains(_aliasedParameters[parameterName])) { matchingParameters.Add(_aliasedParameters[parameterName]); } } } } if (matchingParameters.Count > 1) { // Prefer parameters in the cmdlet over common parameters Collection <MergedCompiledCommandParameter> filteredParameters = new Collection <MergedCompiledCommandParameter>(); foreach (MergedCompiledCommandParameter matchingParameter in matchingParameters) { if ((matchingParameter.BinderAssociation == ParameterBinderAssociation.DeclaredFormalParameters) || (matchingParameter.BinderAssociation == ParameterBinderAssociation.DynamicParameters)) { filteredParameters.Add(matchingParameter); } } if (tryExactMatching && filteredParameters.Count == 1) { matchingParameters = filteredParameters; } else { StringBuilder possibleMatches = new StringBuilder(); foreach (MergedCompiledCommandParameter matchingParameter in matchingParameters) { possibleMatches.Append(" -"); possibleMatches.Append(matchingParameter.Parameter.Name); } ParameterBindingException exception = new ParameterBindingException( ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, ParameterBinderStrings.AmbiguousParameter, "AmbiguousParameter", possibleMatches); throw exception; } } else if (matchingParameters.Count == 0) { if (throwOnParameterNotFound) { ParameterBindingException exception = new ParameterBindingException( ErrorCategory.InvalidArgument, invocationInfo, null, name, null, null, ParameterBinderStrings.NamedParameterNotFound, "NamedParameterNotFound"); throw exception; } } MergedCompiledCommandParameter result = null; if (matchingParameters.Count > 0) { result = matchingParameters[0]; } return(result); }
internal MergedCompiledCommandParameter GetMatchingParameter( string name, bool throwOnParameterNotFound, InvocationInfo invocationInfo) { if (string.IsNullOrEmpty(name)) { throw MergedCommandParameterMetadata.tracer.NewArgumentException(nameof(name)); } Collection <MergedCompiledCommandParameter> collection = new Collection <MergedCompiledCommandParameter>(); if (name.Length > 0 && SpecialCharacters.IsDash(name[0])) { name = name.Substring(1); } foreach (string key in this.bindableParameters.Keys) { if (this.nameCompareInfo.IsPrefix(key, name, CompareOptions.IgnoreCase)) { MergedCommandParameterMetadata.tracer.WriteLine("Found match: {0}", (object)key); if (string.Equals(key, name, StringComparison.OrdinalIgnoreCase)) { return(this.bindableParameters[key]); } collection.Add(this.bindableParameters[key]); } } foreach (string key in this.aliasedParameters.Keys) { if (this.nameCompareInfo.IsPrefix(key, name, CompareOptions.IgnoreCase)) { MergedCommandParameterMetadata.tracer.WriteLine("Found match: {0}", (object)key); if (string.Equals(key, name, StringComparison.OrdinalIgnoreCase)) { return(this.aliasedParameters[key]); } if (!collection.Contains(this.aliasedParameters[key])) { collection.Add(this.aliasedParameters[key]); } } } if (collection.Count > 1) { StringBuilder stringBuilder = new StringBuilder(); foreach (MergedCompiledCommandParameter commandParameter in collection) { stringBuilder.AppendFormat(" -{0}", (object)commandParameter.Parameter.Name); } ParameterBindingException bindingException = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, (Token)null, name, (Type)null, (Type)null, "ParameterBinderStrings", "AmbiguousParameter", new object[1] { (object)stringBuilder }); MergedCommandParameterMetadata.tracer.TraceException((Exception)bindingException); throw bindingException; } if (collection.Count == 0 && throwOnParameterNotFound) { ParameterBindingException bindingException = new ParameterBindingException(ErrorCategory.InvalidArgument, invocationInfo, (Token)null, name, (Type)null, (Type)null, "ParameterBinderStrings", "NamedParameterNotFound", new object[0]); MergedCommandParameterMetadata.tracer.TraceException((Exception)bindingException); throw bindingException; } MergedCompiledCommandParameter commandParameter1 = (MergedCompiledCommandParameter)null; if (collection.Count > 0) { commandParameter1 = collection[0]; } return(commandParameter1); }