internal CommandMetadata(ScriptBlock scriptblock, string commandName, ExecutionContext context)
{
this._commandName = string.Empty;
this._defaultParameterSetName = "__AllParameterSets";
this._positionalBinding = true;
this._helpUri = string.Empty;
this._remotingCapability = System.Management.Automation.RemotingCapability.PowerShell;
this._confirmImpact = System.Management.Automation.ConfirmImpact.Medium;
this._otherAttributes = new Collection <Attribute>();
if (scriptblock == null)
{
throw PSTraceSource.NewArgumentException("scriptblock");
}
CmdletBindingAttribute cmdletBindingAttribute = scriptblock.CmdletBindingAttribute;
if (cmdletBindingAttribute != null)
{
this.ProcessCmdletAttribute(cmdletBindingAttribute);
}
else
{
this._defaultParameterSetName = null;
}
this._commandName = commandName;
this.CommandType = typeof(PSScriptCmdlet);
if (scriptblock.HasDynamicParameters)
{
this._implementsDynamicParameters = true;
}
InternalParameterMetadata parameterMetadata = InternalParameterMetadata.Get(scriptblock.RuntimeDefinedParameters, false, scriptblock.UsesCmdletBinding);
this.staticCommandParameterMetadata = this.MergeParameterMetadata(context, parameterMetadata, scriptblock.UsesCmdletBinding);
this._defaultParameterSetFlag = this.staticCommandParameterMetadata.GenerateParameterSetMappingFromMetadata(this._defaultParameterSetName);
this.staticCommandParameterMetadata.MakeReadOnly();
}
private MergedCommandParameterMetadata MergeParameterMetadata(ExecutionContext context, InternalParameterMetadata parameterMetadata, bool shouldGenerateCommonParameters)
{
MergedCommandParameterMetadata metadata = new MergedCommandParameterMetadata();
metadata.AddMetadataForBinder(parameterMetadata, ParameterBinderAssociation.DeclaredFormalParameters);
if (shouldGenerateCommonParameters)
{
InternalParameterMetadata metadata2 = InternalParameterMetadata.Get(typeof(CommonParameters), context, false);
metadata.AddMetadataForBinder(metadata2, ParameterBinderAssociation.CommonParameters);
if (this.SupportsShouldProcess)
{
InternalParameterMetadata metadata3 = InternalParameterMetadata.Get(typeof(ShouldProcessParameters), context, false);
metadata.AddMetadataForBinder(metadata3, ParameterBinderAssociation.ShouldProcessParameters);
}
if (this.SupportsPaging)
{
InternalParameterMetadata metadata4 = InternalParameterMetadata.Get(typeof(PagingParameters), context, false);
metadata.AddMetadataForBinder(metadata4, ParameterBinderAssociation.PagingParameters);
}
if (this.SupportsTransactions)
{
InternalParameterMetadata metadata5 = InternalParameterMetadata.Get(typeof(TransactionParameters), context, false);
metadata.AddMetadataForBinder(metadata5, ParameterBinderAssociation.TransactionParameters);
}
}
return(metadata);
}
internal Collection <MergedCompiledCommandParameter> AddMetadataForBinder(
InternalParameterMetadata parameterMetadata,
ParameterBinderAssociation binderAssociation)
{
if (parameterMetadata == null)
{
throw MergedCommandParameterMetadata.tracer.NewArgumentNullException(nameof(parameterMetadata));
}
Collection <MergedCompiledCommandParameter> collection = new Collection <MergedCompiledCommandParameter>();
foreach (KeyValuePair <string, CompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters)
{
if (this.bindableParameters.ContainsKey(bindableParameter.Key))
{
MetadataException metadataException = new MetadataException("ParameterNameAlreadyExistsForCommand", (Exception)null, "Metadata", "ParameterNameAlreadyExistsForCommand", new object[1]
{
(object)bindableParameter.Key
});
MergedCommandParameterMetadata.tracer.TraceException((Exception)metadataException);
throw metadataException;
}
if (this.aliasedParameters.ContainsKey(bindableParameter.Key))
{
MetadataException metadataException = new MetadataException("ParameterNameConflictsWithAlias", (Exception)null, "Metadata", "ParameterNameConflictsWithAlias", new object[2]
{
(object)bindableParameter.Key,
(object)this.RetrieveParameterNameForAlias(bindableParameter.Key, this.aliasedParameters)
});
MergedCommandParameterMetadata.tracer.TraceException((Exception)metadataException);
throw metadataException;
}
MergedCompiledCommandParameter commandParameter = new MergedCompiledCommandParameter(bindableParameter.Value, binderAssociation);
this.bindableParameters.Add(bindableParameter.Key, commandParameter);
collection.Add(commandParameter);
foreach (string alias in bindableParameter.Value.Aliases)
{
if (this.aliasedParameters.ContainsKey(alias))
{
MetadataException metadataException = new MetadataException("AliasParameterNameAlreadyExistsForCommand", (Exception)null, "Metadata", "AliasParameterNameAlreadyExistsForCommand", new object[1]
{
(object)alias
});
MergedCommandParameterMetadata.tracer.TraceException((Exception)metadataException);
throw metadataException;
}
if (this.bindableParameters.ContainsKey(alias))
{
MetadataException metadataException = new MetadataException("ParameterNameConflictsWithAlias", (Exception)null, "Metadata", "ParameterNameConflictsWithAlias", new object[2]
{
(object)this.RetrieveParameterNameForAlias(alias, this.bindableParameters),
(object)bindableParameter.Value.Name
});
MergedCommandParameterMetadata.tracer.TraceException((Exception)metadataException);
throw metadataException;
}
this.aliasedParameters.Add(alias, commandParameter);
}
}
return(collection);
}
private void Init(Type commandType, bool shouldGenerateCommonParameters)
{
this.type = commandType != null ? commandType : throw CommandMetadata.tracer.NewArgumentNullException("cmdletType");
InternalParameterMetadata parameterMetadata = InternalParameterMetadata.Get(commandType, (ExecutionContext)null, false);
this.ConstructCmdletMetadataUsingReflection();
this.externalParameterMetadata = ParameterMetadata.GetParameterMetadata(this.MergeParameterMetadata((ExecutionContext)null, parameterMetadata, shouldGenerateCommonParameters));
this.wrappedCommand = this.commandName;
this.wrappedCommandType = CommandTypes.Cmdlet;
this.wrappedAnyCmdlet = true;
}
internal CommandMetadata(string commandName, Type cmdletType, ExecutionContext context)
{
if (string.IsNullOrEmpty(commandName))
{
throw CommandMetadata.tracer.NewArgumentException(nameof(commandName));
}
if (cmdletType == null)
{
throw CommandMetadata.tracer.NewArgumentNullException(nameof(cmdletType));
}
this.commandName = commandName;
this.type = cmdletType;
InternalParameterMetadata parameterMetadata = InternalParameterMetadata.Get(cmdletType, context, false);
this.ConstructCmdletMetadataUsingReflection();
this.staticCommandParameterMetadata = this.MergeParameterMetadata(context, parameterMetadata, true);
this.defaultParameterSetFlag = this.staticCommandParameterMetadata.GenerateParameterSetMappingFromMetadata(this.defaultParameterSetName);
}
private void ConstructCompiledParametersUsingReflection(bool processingDynamicParameters)
{
PropertyInfo[] properties = this.type.GetProperties(InternalParameterMetadata.metaDataBindingFlags);
FieldInfo[] fields = this.type.GetFields(InternalParameterMetadata.metaDataBindingFlags);
foreach (PropertyInfo propertyInfo in properties)
{
if (InternalParameterMetadata.IsMemberAParameter((MemberInfo)propertyInfo))
{
this.AddParameter((MemberInfo)propertyInfo, processingDynamicParameters);
}
}
foreach (FieldInfo fieldInfo in fields)
{
if (InternalParameterMetadata.IsMemberAParameter((MemberInfo)fieldInfo))
{
this.AddParameter((MemberInfo)fieldInfo, processingDynamicParameters);
}
}
}
internal static InternalParameterMetadata Get(Type type, ExecutionContext context, bool processingDynamicParameters)
{
if (type == null)
{
throw PSTraceSource.NewArgumentNullException("type");
}
InternalParameterMetadata metadata = null;
if ((context != null) && ParameterMetadataCache.ContainsKey(type.AssemblyQualifiedName))
{
return(ParameterMetadataCache[type.AssemblyQualifiedName]);
}
metadata = new InternalParameterMetadata(type, processingDynamicParameters);
if (context != null)
{
ParameterMetadataCache.TryAdd(type.AssemblyQualifiedName, metadata);
}
return(metadata);
}
internal Collection <MergedCompiledCommandParameter> AddMetadataForBinder(InternalParameterMetadata parameterMetadata, ParameterBinderAssociation binderAssociation)
{
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
Collection <MergedCompiledCommandParameter> collection = new Collection <MergedCompiledCommandParameter>();
foreach (KeyValuePair <string, CompiledCommandParameter> pair in parameterMetadata.BindableParameters)
{
if (this.bindableParameters.ContainsKey(pair.Key))
{
System.Management.Automation.MetadataException exception = new System.Management.Automation.MetadataException("ParameterNameAlreadyExistsForCommand", null, Metadata.ParameterNameAlreadyExistsForCommand, new object[] { pair.Key });
throw exception;
}
if (this.aliasedParameters.ContainsKey(pair.Key))
{
System.Management.Automation.MetadataException exception2 = new System.Management.Automation.MetadataException("ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, new object[] { pair.Key, RetrieveParameterNameForAlias(pair.Key, this.aliasedParameters) });
throw exception2;
}
MergedCompiledCommandParameter parameter = new MergedCompiledCommandParameter(pair.Value, binderAssociation);
this.bindableParameters.Add(pair.Key, parameter);
collection.Add(parameter);
foreach (string str in pair.Value.Aliases)
{
if (this.aliasedParameters.ContainsKey(str))
{
System.Management.Automation.MetadataException exception3 = new System.Management.Automation.MetadataException("AliasParameterNameAlreadyExistsForCommand", null, Metadata.AliasParameterNameAlreadyExistsForCommand, new object[] { str });
throw exception3;
}
if (this.bindableParameters.ContainsKey(str))
{
System.Management.Automation.MetadataException exception4 = new System.Management.Automation.MetadataException("ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, new object[] { RetrieveParameterNameForAlias(str, this.bindableParameters), pair.Value.Name });
throw exception4;
}
this.aliasedParameters.Add(str, parameter);
}
}
return(collection);
}
internal Collection<MergedCompiledCommandParameter> AddMetadataForBinder(InternalParameterMetadata parameterMetadata, ParameterBinderAssociation binderAssociation)
{
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
Collection<MergedCompiledCommandParameter> collection = new Collection<MergedCompiledCommandParameter>();
foreach (KeyValuePair<string, CompiledCommandParameter> pair in parameterMetadata.BindableParameters)
{
if (this.bindableParameters.ContainsKey(pair.Key))
{
System.Management.Automation.MetadataException exception = new System.Management.Automation.MetadataException("ParameterNameAlreadyExistsForCommand", null, Metadata.ParameterNameAlreadyExistsForCommand, new object[] { pair.Key });
throw exception;
}
if (this.aliasedParameters.ContainsKey(pair.Key))
{
System.Management.Automation.MetadataException exception2 = new System.Management.Automation.MetadataException("ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, new object[] { pair.Key, RetrieveParameterNameForAlias(pair.Key, this.aliasedParameters) });
throw exception2;
}
MergedCompiledCommandParameter parameter = new MergedCompiledCommandParameter(pair.Value, binderAssociation);
this.bindableParameters.Add(pair.Key, parameter);
collection.Add(parameter);
foreach (string str in pair.Value.Aliases)
{
if (this.aliasedParameters.ContainsKey(str))
{
System.Management.Automation.MetadataException exception3 = new System.Management.Automation.MetadataException("AliasParameterNameAlreadyExistsForCommand", null, Metadata.AliasParameterNameAlreadyExistsForCommand, new object[] { str });
throw exception3;
}
if (this.bindableParameters.ContainsKey(str))
{
System.Management.Automation.MetadataException exception4 = new System.Management.Automation.MetadataException("ParameterNameConflictsWithAlias", null, Metadata.ParameterNameConflictsWithAlias, new object[] { RetrieveParameterNameForAlias(str, this.bindableParameters), pair.Value.Name });
throw exception4;
}
this.aliasedParameters.Add(str, parameter);
}
}
return collection;
}
internal CommandMetadata(ScriptBlock scriptblock, string commandName, ExecutionContext context)
{
CmdletBindingAttribute bindingAttribute = scriptblock != null ? scriptblock.CmdletBindingAttribute : throw CommandMetadata.tracer.NewArgumentException(nameof(scriptblock));
if (bindingAttribute != null)
{
this.ProcessCmdletAttribute((CmdletCommonMetadataAttribute)bindingAttribute);
}
else
{
this.defaultParameterSetName = (string)null;
}
this.commandName = commandName;
this.type = typeof(PSScriptCmdlet);
if (scriptblock.DynamicParams != null)
{
this.implementsDynamicParameters = true;
}
InternalParameterMetadata parameterMetadata = InternalParameterMetadata.Get(scriptblock.RuntimeDefinedParameters, false, scriptblock.UsesCmdletBinding);
this.staticCommandParameterMetadata = this.MergeParameterMetadata(context, parameterMetadata, scriptblock.UsesCmdletBinding);
this.defaultParameterSetFlag = this.staticCommandParameterMetadata.GenerateParameterSetMappingFromMetadata(this.defaultParameterSetName);
}
internal static InternalParameterMetadata Get(
Type type,
ExecutionContext context,
bool processingDynamicParameters)
{
if (type == null)
{
throw InternalParameterMetadata.tracer.NewArgumentNullException(nameof(type));
}
InternalParameterMetadata parameterMetadata;
if (context != null && context.ParameterMetadataCache.ContainsKey(type.AssemblyQualifiedName))
{
parameterMetadata = context.ParameterMetadataCache[type.AssemblyQualifiedName];
InternalParameterMetadata.tracer.WriteLine("The type metadata was found in the cache", new object[0]);
}
else
{
InternalParameterMetadata.tracer.WriteLine("The type metadata must be constructed from the type", new object[0]);
parameterMetadata = new InternalParameterMetadata(type, processingDynamicParameters);
context?.ParameterMetadataCache.Add(type.AssemblyQualifiedName, parameterMetadata);
}
return(parameterMetadata);
}
internal CommandMetadata(string commandName, Type cmdletType, ExecutionContext context)
{
this._commandName = string.Empty;
this._defaultParameterSetName = "__AllParameterSets";
this._positionalBinding = true;
this._helpUri = string.Empty;
this._remotingCapability = System.Management.Automation.RemotingCapability.PowerShell;
this._confirmImpact = System.Management.Automation.ConfirmImpact.Medium;
this._otherAttributes = new Collection <Attribute>();
if (string.IsNullOrEmpty(commandName))
{
throw PSTraceSource.NewArgumentException("commandName");
}
this._commandName = commandName;
this.CommandType = cmdletType;
if (cmdletType != null)
{
InternalParameterMetadata parameterMetadata = InternalParameterMetadata.Get(cmdletType, context, false);
this.ConstructCmdletMetadataUsingReflection();
this.staticCommandParameterMetadata = this.MergeParameterMetadata(context, parameterMetadata, true);
this._defaultParameterSetFlag = this.staticCommandParameterMetadata.GenerateParameterSetMappingFromMetadata(this._defaultParameterSetName);
this.staticCommandParameterMetadata.MakeReadOnly();
}
}
private Dictionary<string, ParameterMetadata> GetCommonParameters()
{
Dictionary<string, ParameterMetadata> commonParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
InternalParameterMetadata internalParameterMetadata = new InternalParameterMetadata(_objectModelWrapper, false);
foreach (CompiledCommandParameter compiledCommandParameter in internalParameterMetadata.BindableParameters.Values)
{
ParameterMetadata parameterMetadata = new ParameterMetadata(compiledCommandParameter);
foreach (ParameterSetMetadata psetMetadata in parameterMetadata.ParameterSets.Values)
{
if (psetMetadata.ValueFromPipeline)
{
string message = string.Format(
CultureInfo.InvariantCulture,
CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata,
_objectModelWrapper.FullName,
parameterMetadata.Name,
"ValueFromPipeline");
throw new XmlException(message);
}
if (psetMetadata.ValueFromPipelineByPropertyName)
{
string message = string.Format(
CultureInfo.InvariantCulture,
CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata,
_objectModelWrapper.FullName,
parameterMetadata.Name,
"ValueFromPipelineByPropertyName");
throw new XmlException(message);
}
if (psetMetadata.ValueFromRemainingArguments)
{
string message = string.Format(
CultureInfo.InvariantCulture,
CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata,
_objectModelWrapper.FullName,
parameterMetadata.Name,
"ValueFromRemainingArguments");
throw new XmlException(message);
}
psetMetadata.ValueFromPipeline = false;
psetMetadata.ValueFromPipelineByPropertyName = false;
psetMetadata.ValueFromRemainingArguments = false;
}
commonParameters.Add(parameterMetadata.Name, parameterMetadata);
}
List<string> commonParameterSets = GetCommonParameterSets(commonParameters);
if (commonParameterSets.Count > 1)
{
string message = string.Format(
CultureInfo.InvariantCulture,
CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperDefinesMultipleParameterSets,
_objectModelWrapper.FullName);
throw new XmlException(message);
}
foreach (ParameterMetadata parameter in commonParameters.Values)
{
if ((parameter.ParameterSets.Count == 1) && (parameter.ParameterSets.ContainsKey(ParameterAttribute.AllParameterSets)))
{
ParameterSetMetadata oldParameterSetMetadata = parameter.ParameterSets[ParameterAttribute.AllParameterSets];
parameter.ParameterSets.Clear();
foreach (string parameterSetName in commonParameterSets)
{
parameter.ParameterSets.Add(parameterSetName, oldParameterSetMetadata);
}
}
}
return commonParameters;
}
private void Init(ScriptBlock scriptBlock, string name, bool shouldGenerateCommonParameters)
{
if (scriptBlock.UsesCmdletBinding)
{
this.wrappedAnyCmdlet = true;
}
else
{
shouldGenerateCommonParameters = false;
}
CmdletBindingAttribute bindingAttribute = scriptBlock.CmdletBindingAttribute;
if (bindingAttribute != null)
{
this.ProcessCmdletAttribute((CmdletCommonMetadataAttribute)bindingAttribute);
}
else if (scriptBlock.UsesCmdletBinding)
{
this.defaultParameterSetName = (string)null;
}
this.externalParameterMetadata = ParameterMetadata.GetParameterMetadata(this.MergeParameterMetadata((ExecutionContext)null, InternalParameterMetadata.Get(scriptBlock.RuntimeDefinedParameters, false, scriptBlock.UsesCmdletBinding), shouldGenerateCommonParameters));
this.wrappedCommand = this.commandName = name;
}
internal static InternalParameterMetadata Get(Type type, ExecutionContext context, bool processingDynamicParameters)
{
if (type == null)
{
throw PSTraceSource.NewArgumentNullException("type");
}
InternalParameterMetadata metadata = null;
if ((context != null) && ParameterMetadataCache.ContainsKey(type.AssemblyQualifiedName))
{
return ParameterMetadataCache[type.AssemblyQualifiedName];
}
metadata = new InternalParameterMetadata(type, processingDynamicParameters);
if (context != null)
{
ParameterMetadataCache.TryAdd(type.AssemblyQualifiedName, metadata);
}
return metadata;
}
/// <summary>
/// Gets or constructs an instance of the InternalParameterMetadata for the specified type.
/// </summary>
///
/// <param name="type">
/// The type to get the metadata for.
/// </param>
///
/// <param name="context">
/// The current engine context.
/// </param>
///
/// <param name="processingDynamicParameters">
/// True if dynamic parameters are being processed, or false otherwise.
/// </param>
///
/// <returns>
/// An instance of the TypeMetadata for the specified type. The metadata may get
/// constructed on-demand or may be retrieved from the cache.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="type"/> is null.
/// </exception>
///
/// <exception cref="MetadataException">
/// If a parameter defines the same parameter-set name multiple times.
/// If the attributes could not be read from a property or field.
/// </exception>
///
internal static InternalParameterMetadata Get(Type type, ExecutionContext context, bool processingDynamicParameters)
{
if (type == null)
{
throw PSTraceSource.NewArgumentNullException("type");
}
InternalParameterMetadata result;
if (context == null || !s_parameterMetadataCache.TryGetValue(type.AssemblyQualifiedName, out result))
{
result = new InternalParameterMetadata(type, processingDynamicParameters);
if (context != null)
{
s_parameterMetadataCache.TryAdd(type.AssemblyQualifiedName, result);
}
}
return result;
} // GetMetadata
} // ReplaceMetadata
/// <summary>
/// Merges the specified metadata with the other metadata already defined
/// in this object.
/// </summary>
///
/// <param name="parameterMetadata">
/// The compiled metadata for the type to be merged.
/// </param>
///
/// <param name="binderAssociation">
/// The type of binder that the CommandProcessor will use to bind
/// the parameters for <paramref name="parameterMetadata"/>
/// </param>
///
/// <returns>
/// A collection of the merged parameter metadata that was added.
/// </returns>
///
/// <exception cref="MetadataException">
/// If a parameter name or alias described in the <paramref name="parameterMetadata"/> already
/// exists.
/// </exception>
///
internal Collection<MergedCompiledCommandParameter> AddMetadataForBinder(
InternalParameterMetadata parameterMetadata,
ParameterBinderAssociation binderAssociation)
{
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
Collection<MergedCompiledCommandParameter> result =
new Collection<MergedCompiledCommandParameter>();
// Merge in the bindable parameters
foreach (KeyValuePair<string, CompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters)
{
if (_bindableParameters.ContainsKey(bindableParameter.Key))
{
MetadataException exception =
new MetadataException(
"ParameterNameAlreadyExistsForCommand",
null,
Metadata.ParameterNameAlreadyExistsForCommand,
bindableParameter.Key);
throw exception;
}
// NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN
if (_aliasedParameters.ContainsKey(bindableParameter.Key))
{
MetadataException exception =
new MetadataException(
"ParameterNameConflictsWithAlias",
null,
Metadata.ParameterNameConflictsWithAlias,
bindableParameter.Key,
RetrieveParameterNameForAlias(bindableParameter.Key, _aliasedParameters));
throw exception;
}
MergedCompiledCommandParameter mergedParameter =
new MergedCompiledCommandParameter(bindableParameter.Value, binderAssociation);
_bindableParameters.Add(bindableParameter.Key, mergedParameter);
result.Add(mergedParameter);
// Merge in the aliases
foreach (string aliasName in bindableParameter.Value.Aliases)
{
if (_aliasedParameters.ContainsKey(aliasName))
{
MetadataException exception =
new MetadataException(
"AliasParameterNameAlreadyExistsForCommand",
null,
Metadata.AliasParameterNameAlreadyExistsForCommand,
aliasName);
throw exception;
}
// NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN
if (_bindableParameters.ContainsKey(aliasName))
{
MetadataException exception =
new MetadataException(
"ParameterNameConflictsWithAlias",
null,
Metadata.ParameterNameConflictsWithAlias,
RetrieveParameterNameForAlias(aliasName, _bindableParameters),
bindableParameter.Value.Name);
throw exception;
}
_aliasedParameters.Add(aliasName, mergedParameter);
}
}
return result;
}
private Dictionary<string, ParameterMetadata> GetCommonParameters()
{
Dictionary<string, ParameterMetadata> commonParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
InternalParameterMetadata metadata = new InternalParameterMetadata(this.objectModelWrapper, false);
foreach (CompiledCommandParameter parameter in metadata.BindableParameters.Values)
{
ParameterMetadata metadata2 = new ParameterMetadata(parameter);
foreach (ParameterSetMetadata metadata3 in metadata2.ParameterSets.Values)
{
if (metadata3.ValueFromPipeline)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata, new object[] { this.objectModelWrapper.FullName, metadata2.Name, "ValueFromPipeline" }));
}
if (metadata3.ValueFromPipelineByPropertyName)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata, new object[] { this.objectModelWrapper.FullName, metadata2.Name, "ValueFromPipelineByPropertyName" }));
}
if (metadata3.ValueFromRemainingArguments)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperUsesIgnoredParameterMetadata, new object[] { this.objectModelWrapper.FullName, metadata2.Name, "ValueFromRemainingArguments" }));
}
metadata3.ValueFromPipeline = false;
metadata3.ValueFromPipelineByPropertyName = false;
metadata3.ValueFromRemainingArguments = false;
}
commonParameters.Add(metadata2.Name, metadata2);
}
List<string> commonParameterSets = GetCommonParameterSets(commonParameters);
if (commonParameterSets.Count > 1)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperDefinesMultipleParameterSets, new object[] { this.objectModelWrapper.FullName }));
}
foreach (ParameterMetadata metadata4 in commonParameters.Values)
{
if ((metadata4.ParameterSets.Count == 1) && metadata4.ParameterSets.ContainsKey("__AllParameterSets"))
{
ParameterSetMetadata metadata5 = metadata4.ParameterSets["__AllParameterSets"];
metadata4.ParameterSets.Clear();
foreach (string str5 in commonParameterSets)
{
metadata4.ParameterSets.Add(str5, metadata5);
}
}
}
return commonParameters;
}
} // ProcessCmdletAttribute
/// <summary>
/// Merges parameter metadata from different sources: those that are coming from Type,
/// CommonParameters, should process etc.
/// </summary>
/// <param name="context"></param>
/// <param name="parameterMetadata"></param>
/// <param name="shouldGenerateCommonParameters">
/// true if metadata info about Verbose,Debug etc needs to be generated.
/// false otherwise.
/// </param>
private MergedCommandParameterMetadata MergeParameterMetadata(ExecutionContext context, InternalParameterMetadata parameterMetadata, bool shouldGenerateCommonParameters)
{
// Create an instance of the static metadata class
MergedCommandParameterMetadata staticCommandParameterMetadata =
new MergedCommandParameterMetadata();
// First add the metadata for the formal cmdlet parameters
staticCommandParameterMetadata.AddMetadataForBinder(
parameterMetadata,
ParameterBinderAssociation.DeclaredFormalParameters);
// Now add the common parameters metadata
if (shouldGenerateCommonParameters)
{
InternalParameterMetadata commonParametersMetadata =
InternalParameterMetadata.Get(typeof(CommonParameters), context, false);
staticCommandParameterMetadata.AddMetadataForBinder(
commonParametersMetadata,
ParameterBinderAssociation.CommonParameters);
// If the command supports ShouldProcess, add the metadata for
// those parameters
if (this.SupportsShouldProcess)
{
InternalParameterMetadata shouldProcessParametersMetadata =
InternalParameterMetadata.Get(typeof(ShouldProcessParameters), context, false);
staticCommandParameterMetadata.AddMetadataForBinder(
shouldProcessParametersMetadata,
ParameterBinderAssociation.ShouldProcessParameters);
}
// If the command supports paging, add the metadata for
// those parameters
if (this.SupportsPaging)
{
InternalParameterMetadata pagingParametersMetadata =
InternalParameterMetadata.Get(typeof(PagingParameters), context, false);
staticCommandParameterMetadata.AddMetadataForBinder(
pagingParametersMetadata,
ParameterBinderAssociation.PagingParameters);
}
// If the command supports transactions, add the metadata for
// those parameters
if (this.SupportsTransactions)
{
InternalParameterMetadata transactionParametersMetadata =
InternalParameterMetadata.Get(typeof(TransactionParameters), context, false);
staticCommandParameterMetadata.AddMetadataForBinder(
transactionParametersMetadata,
ParameterBinderAssociation.TransactionParameters);
}
}
return staticCommandParameterMetadata;
} // MergeParameterMetadata
/// <summary>
/// Merges the specified metadata with the other metadata already defined
/// in this object.
/// </summary>
/// <param name="parameterMetadata">
/// The compiled metadata for the type to be merged.
/// </param>
/// <param name="binderAssociation">
/// The type of binder that the CommandProcessor will use to bind
/// the parameters for <paramref name="parameterMetadata"/>
/// </param>
/// <returns>
/// A collection of the merged parameter metadata that was added.
/// </returns>
/// <exception cref="MetadataException">
/// If a parameter name or alias described in the <paramref name="parameterMetadata"/> already
/// exists.
/// </exception>
internal Collection <MergedCompiledCommandParameter> AddMetadataForBinder(
InternalParameterMetadata parameterMetadata,
ParameterBinderAssociation binderAssociation)
{
if (parameterMetadata == null)
{
throw PSTraceSource.NewArgumentNullException("parameterMetadata");
}
Collection <MergedCompiledCommandParameter> result =
new Collection <MergedCompiledCommandParameter>();
// Merge in the bindable parameters
foreach (KeyValuePair <string, CompiledCommandParameter> bindableParameter in parameterMetadata.BindableParameters)
{
if (_bindableParameters.ContainsKey(bindableParameter.Key))
{
MetadataException exception =
new MetadataException(
"ParameterNameAlreadyExistsForCommand",
null,
Metadata.ParameterNameAlreadyExistsForCommand,
bindableParameter.Key);
throw exception;
}
// NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN
if (_aliasedParameters.ContainsKey(bindableParameter.Key))
{
MetadataException exception =
new MetadataException(
"ParameterNameConflictsWithAlias",
null,
Metadata.ParameterNameConflictsWithAlias,
bindableParameter.Key,
RetrieveParameterNameForAlias(bindableParameter.Key, _aliasedParameters));
throw exception;
}
MergedCompiledCommandParameter mergedParameter =
new MergedCompiledCommandParameter(bindableParameter.Value, binderAssociation);
_bindableParameters.Add(bindableParameter.Key, mergedParameter);
result.Add(mergedParameter);
// Merge in the aliases
foreach (string aliasName in bindableParameter.Value.Aliases)
{
if (_aliasedParameters.ContainsKey(aliasName))
{
MetadataException exception =
new MetadataException(
"AliasParameterNameAlreadyExistsForCommand",
null,
Metadata.AliasParameterNameAlreadyExistsForCommand,
aliasName);
throw exception;
}
// NTRAID#Windows Out Of Band Releases-926371-2005/12/27-JonN
if (_bindableParameters.ContainsKey(aliasName))
{
MetadataException exception =
new MetadataException(
"ParameterNameConflictsWithAlias",
null,
Metadata.ParameterNameConflictsWithAlias,
RetrieveParameterNameForAlias(aliasName, _bindableParameters),
bindableParameter.Value.Name);
throw exception;
}
_aliasedParameters.Add(aliasName, mergedParameter);
}
}
return(result);
}
private MergedCommandParameterMetadata MergeParameterMetadata(ExecutionContext context, InternalParameterMetadata parameterMetadata, bool shouldGenerateCommonParameters)
{
MergedCommandParameterMetadata metadata = new MergedCommandParameterMetadata();
metadata.AddMetadataForBinder(parameterMetadata, ParameterBinderAssociation.DeclaredFormalParameters);
if (shouldGenerateCommonParameters)
{
InternalParameterMetadata metadata2 = InternalParameterMetadata.Get(typeof(CommonParameters), context, false);
metadata.AddMetadataForBinder(metadata2, ParameterBinderAssociation.CommonParameters);
if (this.SupportsShouldProcess)
{
InternalParameterMetadata metadata3 = InternalParameterMetadata.Get(typeof(ShouldProcessParameters), context, false);
metadata.AddMetadataForBinder(metadata3, ParameterBinderAssociation.ShouldProcessParameters);
}
if (this.SupportsPaging)
{
InternalParameterMetadata metadata4 = InternalParameterMetadata.Get(typeof(PagingParameters), context, false);
metadata.AddMetadataForBinder(metadata4, ParameterBinderAssociation.PagingParameters);
}
if (this.SupportsTransactions)
{
InternalParameterMetadata metadata5 = InternalParameterMetadata.Get(typeof(TransactionParameters), context, false);
metadata.AddMetadataForBinder(metadata5, ParameterBinderAssociation.TransactionParameters);
}
}
return metadata;
}
