private GetCmdletParameters GetGetCmdletParameters(InstanceCmdletMetadata instanceCmdlet)
{
if (instanceCmdlet == null)
{
if ((this.cmdletizationMetadata.Class.InstanceCmdlets.GetCmdlet != null) && (this.cmdletizationMetadata.Class.InstanceCmdlets.GetCmdlet.GetCmdletParameters != null))
{
return this.cmdletizationMetadata.Class.InstanceCmdlets.GetCmdlet.GetCmdletParameters;
}
}
else if (instanceCmdlet.GetCmdletParameters != null)
{
return instanceCmdlet.GetCmdletParameters;
}
return this.cmdletizationMetadata.Class.InstanceCmdlets.GetCmdletParameters;
}
private List<string> GetMethodParameterSets(InstanceCmdletMetadata instanceCmdlet)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
InstanceMethodMetadata method = instanceCmdlet.Method;
string methodParameterSet = this.GetMethodParameterSet(method);
dictionary.Add(methodParameterSet, null);
return new List<string>(dictionary.Keys);
}
private void GenerateMethodParametersProcessing(InstanceCmdletMetadata instanceCmdlet, IEnumerable<string> commonParameterSets, IEnumerable<string> queryParameterSets, out string scriptCode, out Dictionary<string, ParameterMetadata> methodParameters, out string outputTypeAttributeDeclaration)
{
methodParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
outputTypeAttributeDeclaration = string.Empty;
StringWriter output = new StringWriter(CultureInfo.InvariantCulture);
output.WriteLine(@" $__cmdletization_methodParameters = Microsoft.PowerShell.Utility\New-Object System.Collections.Generic.List[Microsoft.PowerShell.Cmdletization.MethodParameter]");
output.WriteLine(" switch -exact ($PSCmdlet.ParameterSetName) { ");
InstanceMethodMetadata method = instanceCmdlet.Method;
output.Write(" { @(");
bool flag = true;
foreach (string str in MultiplyParameterSets(this.GetMethodParameterSet(method), "{2}", new IEnumerable<string>[] { commonParameterSets, queryParameterSets }))
{
if (!flag)
{
output.Write(", ");
}
flag = false;
output.Write("'{0}'", CommandMetadata.EscapeSingleQuotedString(str));
}
output.WriteLine(") -contains $_ } {");
List<Type> list = new List<Type>();
List<string> list2 = new List<string>();
if (method.Parameters != null)
{
foreach (InstanceMethodParameterMetadata metadata2 in method.Parameters)
{
string cmdletParameterName = null;
if (metadata2.CmdletParameterMetadata != null)
{
ParameterMetadata metadata3 = this.GetParameter(this.GetMethodParameterSet(method), metadata2.ParameterName, metadata2.Type, metadata2.CmdletParameterMetadata);
cmdletParameterName = metadata3.Name;
try
{
methodParameters.Add(metadata3.Name, metadata3);
}
catch (ArgumentException exception)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName, new object[] { "<InstanceCmdlets>...<Cmdlet>", metadata3.Name }), exception);
}
}
MethodParameterBindings methodParameterKind = GetMethodParameterKind(metadata2);
Type dotNetType = this.GetDotNetType(metadata2.Type);
GenerateSingleMethodParameterProcessing(output, " ", cmdletParameterName, dotNetType, metadata2.Type.ETSType, metadata2.DefaultValue, metadata2.ParameterName, methodParameterKind);
if (MethodParameterBindings.Out == (methodParameterKind & MethodParameterBindings.Out))
{
list.Add(dotNetType);
list2.Add(metadata2.Type.ETSType);
}
}
}
if (method.ReturnValue != null)
{
MethodParameterBindings bindings2 = GetMethodParameterKind(method.ReturnValue);
Type item = this.GetDotNetType(method.ReturnValue.Type);
output.WriteLine(@" $__cmdletization_returnValue = Microsoft.PowerShell.Utility\New-Object Microsoft.PowerShell.Cmdletization.MethodParameter -Property @{{ Name = 'ReturnValue'; ParameterType = '{0}'; Bindings = '{1}'; Value = $null; IsValuePresent = $false }}", CommandMetadata.EscapeSingleQuotedString(item.FullName), CommandMetadata.EscapeSingleQuotedString(bindings2.ToString()));
if (!string.IsNullOrEmpty(method.ReturnValue.Type.ETSType))
{
output.WriteLine(" $__cmdletization_methodParameter.ParameterTypeName = '{0}'", CommandMetadata.EscapeSingleQuotedString(method.ReturnValue.Type.ETSType));
}
if (MethodParameterBindings.Out == (bindings2 & MethodParameterBindings.Out))
{
list.Add(item);
list2.Add(method.ReturnValue.Type.ETSType);
}
}
else
{
output.WriteLine(" $__cmdletization_returnValue = $null");
}
output.WriteLine(@" $__cmdletization_methodInvocationInfo = Microsoft.PowerShell.Utility\New-Object Microsoft.PowerShell.Cmdletization.MethodInvocationInfo @('{0}', $__cmdletization_methodParameters, $__cmdletization_returnValue)", CommandMetadata.EscapeSingleQuotedString(method.MethodName));
if (list.Count == 0)
{
output.WriteLine(" $__cmdletization_passThru = $PSBoundParameters.ContainsKey('PassThru') -and $PassThru");
}
else
{
output.WriteLine(" $__cmdletization_passThru = $false");
}
output.WriteLine(" if ($PSBoundParameters.ContainsKey('InputObject')) {");
output.WriteLine(" foreach ($x in $InputObject) { $__cmdletization_objectModelWrapper.ProcessRecord($x, $__cmdletization_methodInvocationInfo, $__cmdletization_PassThru) }");
output.WriteLine(" } else {");
output.WriteLine(" $__cmdletization_objectModelWrapper.ProcessRecord($__cmdletization_queryBuilder, $__cmdletization_methodInvocationInfo, $__cmdletization_PassThru)");
output.WriteLine(" }");
output.WriteLine(" }");
output.WriteLine(" }");
scriptCode = output.ToString();
if (list.Count == 0)
{
outputTypeAttributeDeclaration = this.GetOutputAttributeForGetCmdlet();
}
else if (list.Count == 1)
{
outputTypeAttributeDeclaration = string.Format(CultureInfo.InvariantCulture, "[OutputType([{0}])]", new object[] { list[0].FullName });
if ((list2.Count == 1) && !string.IsNullOrEmpty(list2[0]))
{
outputTypeAttributeDeclaration = outputTypeAttributeDeclaration + string.Format(CultureInfo.InvariantCulture, "[OutputType('{0}')]", new object[] { CommandMetadata.EscapeSingleQuotedString(list2[0]) });
}
}
}
private void GenerateQueryParametersProcessing(InstanceCmdletMetadata instanceCmdlet, IEnumerable<string> commonParameterSets, IEnumerable<string> queryParameterSets, IEnumerable<string> methodParameterSets, out string scriptCode, out Dictionary<string, ParameterMetadata> queryParameters)
{
queryParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
StringWriter output = new StringWriter(CultureInfo.InvariantCulture);
output.WriteLine(" $__cmdletization_queryBuilder = $__cmdletization_objectModelWrapper.GetQueryBuilder()");
GetCmdletParameters getCmdletParameters = this.GetGetCmdletParameters(instanceCmdlet);
if (getCmdletParameters.QueryableProperties != null)
{
foreach (PropertyMetadata metadata in from p in getCmdletParameters.QueryableProperties
where p.Items != null
select p)
{
for (int i = 0; i < metadata.Items.Length; i++)
{
string str;
switch (metadata.ItemsElementName[i])
{
case ItemsChoiceType.ExcludeQuery:
str = "ExcludeByProperty";
break;
case ItemsChoiceType.MaxValueQuery:
str = "FilterByMaxPropertyValue";
break;
case ItemsChoiceType.MinValueQuery:
str = "FilterByMinPropertyValue";
break;
case ItemsChoiceType.RegularQuery:
str = "FilterByProperty";
break;
default:
str = "NotAValidMethod";
break;
}
ParameterMetadata metadata2 = this.GenerateQueryClause(commonParameterSets, queryParameterSets, methodParameterSets, str, metadata, metadata.Items[i], output);
switch (metadata.ItemsElementName[i])
{
case ItemsChoiceType.ExcludeQuery:
case ItemsChoiceType.RegularQuery:
metadata2.Attributes.Add(new ValidateNotNullAttribute());
break;
}
try
{
queryParameters.Add(metadata2.Name, metadata2);
}
catch (ArgumentException exception)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName, new object[] { "<GetCmdletParameters>", metadata2.Name }), exception);
}
}
}
}
if (getCmdletParameters.QueryableAssociations != null)
{
foreach (Association association in from a in getCmdletParameters.QueryableAssociations
where a.AssociatedInstance != null
select a)
{
ParameterMetadata metadata3 = this.GenerateAssociationClause(commonParameterSets, queryParameterSets, methodParameterSets, association, association.AssociatedInstance, output);
try
{
queryParameters.Add(metadata3.Name, metadata3);
}
catch (ArgumentException exception2)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName, new object[] { "<GetCmdletParameters>", metadata3.Name }), exception2);
}
}
}
if (getCmdletParameters.QueryOptions != null)
{
foreach (QueryOption option in getCmdletParameters.QueryOptions)
{
ParameterMetadata metadata4 = this.GenerateOptionClause(commonParameterSets, queryParameterSets, methodParameterSets, option, output);
try
{
queryParameters.Add(metadata4.Name, metadata4);
}
catch (ArgumentException exception3)
{
throw new XmlException(string.Format(CultureInfo.InvariantCulture, CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName, new object[] { "<GetCmdletParameters>", metadata4.Name }), exception3);
}
}
}
if (instanceCmdlet != null)
{
string str5;
ParameterMetadata metadata5 = new ParameterMetadata("InputObject", this.objectInstanceType.MakeArrayType());
ParameterSetMetadata.ParameterFlags valueFromPipeline = ParameterSetMetadata.ParameterFlags.ValueFromPipeline;
if (queryParameters.Count > 0)
{
valueFromPipeline |= ParameterSetMetadata.ParameterFlags.Mandatory;
}
if (this.objectModelWrapper.FullName.Equals("Microsoft.PowerShell.Cmdletization.Cim.CimCmdletAdapter"))
{
int num2 = this.cmdletizationMetadata.Class.ClassName.LastIndexOf('\\');
int num3 = this.cmdletizationMetadata.Class.ClassName.LastIndexOf('/');
int num4 = Math.Max(num2, num3);
string str6 = this.cmdletizationMetadata.Class.ClassName.Substring(num4 + 1, (this.cmdletizationMetadata.Class.ClassName.Length - num4) - 1);
str5 = string.Format(CultureInfo.InvariantCulture, "{0}#{1}", new object[] { this.objectInstanceType.FullName, str6 });
}
else
{
str5 = string.Format(CultureInfo.InvariantCulture, "{0}#{1}", new object[] { this.objectInstanceType.FullName, this.cmdletizationMetadata.Class.ClassName });
}
metadata5.Attributes.Add(new PSTypeNameAttribute(str5));
metadata5.Attributes.Add(new ValidateNotNullAttribute());
metadata5.ParameterSets.Clear();
ParameterSetMetadata metadata6 = new ParameterSetMetadata(-2147483648, valueFromPipeline, null);
metadata5.ParameterSets.Add("InputObject (cdxml)", metadata6);
queryParameters.Add(metadata5.Name, metadata5);
}
output.WriteLine();
scriptCode = output.ToString();
}
private static void AddPassThruParameter(IDictionary<string, ParameterMetadata> commonParameters, InstanceCmdletMetadata instanceCmdletMetadata)
{
bool flag = false;
if (instanceCmdletMetadata.Method.Parameters != null)
{
foreach (InstanceMethodParameterMetadata metadata in instanceCmdletMetadata.Method.Parameters)
{
if ((metadata.CmdletOutputMetadata != null) && (metadata.CmdletOutputMetadata.ErrorCode == null))
{
flag = true;
break;
}
}
}
if (((instanceCmdletMetadata.Method.ReturnValue != null) && (instanceCmdletMetadata.Method.ReturnValue.CmdletOutputMetadata != null)) && (instanceCmdletMetadata.Method.ReturnValue.CmdletOutputMetadata.ErrorCode == null))
{
flag = true;
}
if (!flag)
{
ParameterMetadata metadata2 = new ParameterMetadata("PassThru", typeof(SwitchParameter));
metadata2.ParameterSets.Clear();
ParameterSetMetadata metadata3 = new ParameterSetMetadata(-2147483648, 0, null);
metadata2.ParameterSets.Add("__AllParameterSets", metadata3);
commonParameters.Add(metadata2.Name, metadata2);
}
}
private void WriteCmdlet(TextWriter output, InstanceCmdletMetadata instanceCmdlet)
{
Dictionary<string, ParameterMetadata> dictionary2;
string str;
Dictionary<string, ParameterMetadata> dictionary3;
string str2;
string str3;
this.WriteCmdletAliases(output, instanceCmdlet.CmdletMetadata);
Dictionary<string, ParameterMetadata> commonParameters = this.GetCommonParameters();
List<string> commonParameterSets = GetCommonParameterSets(commonParameters);
List<string> methodParameterSets = this.GetMethodParameterSets(instanceCmdlet);
List<string> queryParameterSets = this.GetQueryParameterSets(instanceCmdlet);
this.GenerateQueryParametersProcessing(instanceCmdlet, commonParameterSets, queryParameterSets, methodParameterSets, out str, out dictionary2);
this.GenerateMethodParametersProcessing(instanceCmdlet, commonParameterSets, queryParameterSets, out str2, out dictionary3, out str3);
CommandMetadata commandMetadata = this.GetCommandMetadata(instanceCmdlet.CmdletMetadata);
GetCmdletParameters getCmdletParameters = this.GetGetCmdletParameters(instanceCmdlet);
if (!string.IsNullOrEmpty(getCmdletParameters.DefaultCmdletParameterSet))
{
commandMetadata.DefaultParameterSetName = getCmdletParameters.DefaultCmdletParameterSet;
}
else if (queryParameterSets.Count == 1)
{
commandMetadata.DefaultParameterSetName = queryParameterSets.Single<string>();
}
AddPassThruParameter(commonParameters, instanceCmdlet);
MultiplyParameterSets(commonParameters, "{1}", new IEnumerable<string>[] { queryParameterSets, methodParameterSets });
MultiplyParameterSets(dictionary2, "{0}", new IEnumerable<string>[] { commonParameterSets, methodParameterSets });
MultiplyParameterSets(dictionary3, "{2}", new IEnumerable<string>[] { commonParameterSets, queryParameterSets });
EnsureOrderOfPositionalParameters(commonParameters, dictionary2);
EnsureOrderOfPositionalParameters(dictionary2, dictionary3);
this.SetParameters(commandMetadata, new Dictionary<string, ParameterMetadata>[] { dictionary2, dictionary3, commonParameters });
output.WriteLine("\r\nfunction {0}\r\n{{\r\n {1}\r\n {2}\r\n param(\r\n {3})\r\n\r\n DynamicParam {{\r\n try \r\n {{\r\n if (-not $__cmdletization_exceptionHasBeenThrown)\r\n {{\r\n $__cmdletization_objectModelWrapper = Microsoft.PowerShell.Utility\\New-Object $script:ObjectModelWrapper\r\n $__cmdletization_objectModelWrapper.Initialize($PSCmdlet, $script:ClassName, $script:ClassVersion, $script:ModuleVersion, $script:PrivateData)\r\n\r\n if ($__cmdletization_objectModelWrapper -is [System.Management.Automation.IDynamicParameters])\r\n {{\r\n ([System.Management.Automation.IDynamicParameters]$__cmdletization_objectModelWrapper).GetDynamicParameters()\r\n }}\r\n }}\r\n }}\r\n catch\r\n {{\r\n $__cmdletization_exceptionHasBeenThrown = $true\r\n throw\r\n }}\r\n }}\r\n\r\n Begin {{\r\n $__cmdletization_exceptionHasBeenThrown = $false\r\n try \r\n {{\r\n __cmdletization_BindCommonParameters $__cmdletization_objectModelWrapper $PSBoundParameters\r\n $__cmdletization_objectModelWrapper.BeginProcessing()\r\n }}\r\n catch\r\n {{\r\n $__cmdletization_exceptionHasBeenThrown = $true\r\n throw\r\n }}\r\n }}\r\n ", new object[] { commandMetadata.Name, ProxyCommand.GetCmdletBindingAttribute(commandMetadata), str3, ProxyCommand.GetParamBlock(commandMetadata) });
output.WriteLine("\r\n Process {{\r\n try \r\n {{\r\n if (-not $__cmdletization_exceptionHasBeenThrown)\r\n {{\r\n{0}\r\n }}\r\n }}\r\n catch\r\n {{\r\n $__cmdletization_exceptionHasBeenThrown = $true\r\n throw\r\n }}\r\n }}\r\n ", str + "\r\n" + str2);
output.WriteLine("\r\n End {{\r\n try\r\n {{\r\n if (-not $__cmdletization_exceptionHasBeenThrown)\r\n {{\r\n $__cmdletization_objectModelWrapper.EndProcessing()\r\n }}\r\n }}\r\n catch\r\n {{\r\n throw\r\n }}\r\n }}\r\n\r\n {0}\r\n}}\r\nMicrosoft.PowerShell.Core\\Export-ModuleMember -Function '{1}'\r\n ", this.GetHelpDirectiveForExternalHelp(), CommandMetadata.EscapeSingleQuotedString(commandMetadata.Name));
this.functionsToExport.Add(commandMetadata.Name);
}
private InstanceCmdletMetadata Read30_InstanceCmdletMetadata(bool isNullable, bool checkType)
{
XmlQualifiedName type = checkType ? base.GetXsiType() : null;
bool flag = false;
if (isNullable)
{
flag = base.ReadNull();
}
if ((checkType && (type != null)) && ((type.Name != this.id33_InstanceCmdletMetadata) || (type.Namespace != this.id2_Item)))
{
throw base.CreateUnknownTypeException(type);
}
if (flag)
{
return null;
}
InstanceCmdletMetadata o = new InstanceCmdletMetadata();
bool[] flagArray = new bool[3];
while (base.Reader.MoveToNextAttribute())
{
if (!base.IsXmlnsAttribute(base.Reader.Name))
{
base.UnknownNode(o);
}
}
base.Reader.MoveToElement();
if (base.Reader.IsEmptyElement)
{
base.Reader.Skip();
return o;
}
base.Reader.ReadStartElement();
base.Reader.MoveToContent();
int whileIterations = 0;
int readerCount = base.ReaderCount;
while ((base.Reader.NodeType != XmlNodeType.EndElement) && (base.Reader.NodeType != XmlNodeType.None))
{
if (base.Reader.NodeType == XmlNodeType.Element)
{
if ((!flagArray[0] && (base.Reader.LocalName == this.id81_CmdletMetadata)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.CmdletMetadata = this.Read20_CommonCmdletMetadata(false, true);
flagArray[0] = true;
}
else if ((!flagArray[1] && (base.Reader.LocalName == this.id82_Method)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Method = this.Read29_InstanceMethodMetadata(false, true);
flagArray[1] = true;
}
else if ((!flagArray[2] && (base.Reader.LocalName == this.id6_GetCmdletParameters)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.GetCmdletParameters = this.Read18_GetCmdletParameters(false, true);
flagArray[2] = true;
}
else
{
base.UnknownNode(o, "http://schemas.microsoft.com/cmdlets-over-objects/2009/11:CmdletMetadata, http://schemas.microsoft.com/cmdlets-over-objects/2009/11:Method, http://schemas.microsoft.com/cmdlets-over-objects/2009/11:GetCmdletParameters");
}
}
else
{
base.UnknownNode(o, "http://schemas.microsoft.com/cmdlets-over-objects/2009/11:CmdletMetadata, http://schemas.microsoft.com/cmdlets-over-objects/2009/11:Method, http://schemas.microsoft.com/cmdlets-over-objects/2009/11:GetCmdletParameters");
}
base.Reader.MoveToContent();
base.CheckReaderCount(ref whileIterations, ref readerCount);
}
base.ReadEndElement();
return o;
}
private List<string> GetQueryParameterSets(InstanceCmdletMetadata instanceCmdlet)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
List<CmdletParameterMetadataForGetCmdletParameter> list = new List<CmdletParameterMetadataForGetCmdletParameter>();
bool flag = false;
GetCmdletParameters getCmdletParameters = this.GetGetCmdletParameters(instanceCmdlet);
if (getCmdletParameters.QueryableProperties != null)
{
foreach (PropertyMetadata metadata in getCmdletParameters.QueryableProperties)
{
if (metadata.Items != null)
{
foreach (PropertyQuery query in metadata.Items)
{
flag = true;
if (query.CmdletParameterMetadata != null)
{
list.Add(query.CmdletParameterMetadata);
}
}
}
}
}
if (getCmdletParameters.QueryableAssociations != null)
{
foreach (Association association in getCmdletParameters.QueryableAssociations)
{
if (association.AssociatedInstance != null)
{
flag = true;
if (association.AssociatedInstance.CmdletParameterMetadata != null)
{
list.Add(association.AssociatedInstance.CmdletParameterMetadata);
}
}
}
}
if (getCmdletParameters.QueryOptions != null)
{
foreach (QueryOption option in getCmdletParameters.QueryOptions)
{
flag = true;
if (option.CmdletParameterMetadata != null)
{
list.Add(option.CmdletParameterMetadata);
}
}
}
foreach (CmdletParameterMetadataForGetCmdletParameter parameter in list)
{
if (parameter.CmdletParameterSets != null)
{
foreach (string str in parameter.CmdletParameterSets)
{
dictionary[str] = null;
}
}
}
if (flag && (dictionary.Count == 0))
{
dictionary.Add("Query (cdxml)", null);
getCmdletParameters.DefaultCmdletParameterSet = "Query (cdxml)";
}
if (instanceCmdlet != null)
{
dictionary.Add("InputObject (cdxml)", null);
}
return new List<string>(dictionary.Keys);
}
private List<string> GetQueryParameterSets(InstanceCmdletMetadata instanceCmdlet)
{
Dictionary<string, object> parameterSetNames = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
var parameters = new List<CmdletParameterMetadataForGetCmdletParameter>();
bool anyQueryParameters = false;
GetCmdletParameters getCmdletParameters = GetGetCmdletParameters(instanceCmdlet);
if (getCmdletParameters.QueryableProperties != null)
{
foreach (PropertyMetadata property in getCmdletParameters.QueryableProperties)
{
if (property.Items != null)
{
foreach (PropertyQuery query in property.Items)
{
anyQueryParameters = true;
if (query.CmdletParameterMetadata != null)
{
parameters.Add(query.CmdletParameterMetadata);
}
}
}
}
}
if (getCmdletParameters.QueryableAssociations != null)
{
foreach (Association association in getCmdletParameters.QueryableAssociations)
{
if (association.AssociatedInstance != null)
{
anyQueryParameters = true;
if (association.AssociatedInstance.CmdletParameterMetadata != null)
{
parameters.Add(association.AssociatedInstance.CmdletParameterMetadata);
}
}
}
}
if (getCmdletParameters.QueryOptions != null)
{
foreach (QueryOption option in getCmdletParameters.QueryOptions)
{
anyQueryParameters = true;
if (option.CmdletParameterMetadata != null)
{
parameters.Add(option.CmdletParameterMetadata);
}
}
}
foreach (CmdletParameterMetadataForGetCmdletParameter parameter in parameters)
{
if (parameter.CmdletParameterSets != null)
{
foreach (string parameterSetName in parameter.CmdletParameterSets)
{
parameterSetNames[parameterSetName] = null;
}
}
}
if (anyQueryParameters && (parameterSetNames.Count == 0))
{
parameterSetNames.Add(ScriptWriter.SingleQueryParameterSetName, null);
getCmdletParameters.DefaultCmdletParameterSet = ScriptWriter.SingleQueryParameterSetName;
}
if (instanceCmdlet != null)
{
parameterSetNames.Add(ScriptWriter.InputObjectQueryParameterSetName, null);
}
return new List<string>(parameterSetNames.Keys);
}
private void Write30_InstanceCmdletMetadata(string n, string ns, InstanceCmdletMetadata o, bool isNullable, bool needType)
{
if (o == null)
{
if (isNullable)
{
base.WriteNullTagLiteral(n, ns);
}
}
else
{
if (!needType && !(o.GetType() == typeof(InstanceCmdletMetadata)))
{
throw base.CreateUnknownTypeException(o);
}
base.WriteStartElement(n, ns, o, false, null);
if (needType)
{
base.WriteXsiType("InstanceCmdletMetadata", "http://schemas.microsoft.com/cmdlets-over-objects/2009/11");
}
this.Write20_CommonCmdletMetadata("CmdletMetadata", "http://schemas.microsoft.com/cmdlets-over-objects/2009/11", o.CmdletMetadata, false, false);
this.Write29_InstanceMethodMetadata("Method", "http://schemas.microsoft.com/cmdlets-over-objects/2009/11", o.Method, false, false);
this.Write18_GetCmdletParameters("GetCmdletParameters", "http://schemas.microsoft.com/cmdlets-over-objects/2009/11", o.GetCmdletParameters, false, false);
base.WriteEndElement(o);
}
}
private List<string> GetMethodParameterSets(InstanceCmdletMetadata instanceCmdlet)
{
Dictionary<string, object> parameterSetNames = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
InstanceMethodMetadata method = instanceCmdlet.Method;
string parameterSetName = GetMethodParameterSet(method);
parameterSetNames.Add(parameterSetName, null);
return new List<string>(parameterSetNames.Keys);
}
private void WriteCmdlet(TextWriter output, InstanceCmdletMetadata instanceCmdlet)
{
string attributeString = this.GetCmdletAttributes(instanceCmdlet.CmdletMetadata);
Dictionary<string, ParameterMetadata> commonParameters = this.GetCommonParameters();
List<string> commonParameterSets = GetCommonParameterSets(commonParameters);
List<string> methodParameterSets = GetMethodParameterSets(instanceCmdlet);
List<string> queryParameterSets = GetQueryParameterSets(instanceCmdlet);
Dictionary<string, ParameterMetadata> queryParameters;
string queryProcessingScript;
GenerateQueryParametersProcessing(instanceCmdlet, commonParameterSets, queryParameterSets, methodParameterSets, out queryProcessingScript, out queryParameters);
Dictionary<string, ParameterMetadata> methodParameters;
string methodProcessingScript;
string outputTypeAttributeDeclaration;
GenerateMethodParametersProcessing(instanceCmdlet, commonParameterSets, queryParameterSets, out methodProcessingScript, out methodParameters, out outputTypeAttributeDeclaration);
CommandMetadata commandMetadata = this.GetCommandMetadata(instanceCmdlet.CmdletMetadata);
GetCmdletParameters getCmdletParameters = this.GetGetCmdletParameters(instanceCmdlet);
if (!string.IsNullOrEmpty(getCmdletParameters.DefaultCmdletParameterSet))
{
commandMetadata.DefaultParameterSetName = getCmdletParameters.DefaultCmdletParameterSet;
}
else if (queryParameterSets.Count == 1)
{
commandMetadata.DefaultParameterSetName = queryParameterSets.Single();
}
AddPassThruParameter(commonParameters, instanceCmdlet);
MultiplyParameterSets(commonParameters, InstanceCommonParameterSetTemplate, queryParameterSets, methodParameterSets);
MultiplyParameterSets(queryParameters, InstanceQueryParameterSetTemplate, commonParameterSets, methodParameterSets);
MultiplyParameterSets(methodParameters, InstanceMethodParameterSetTemplate, commonParameterSets, queryParameterSets);
EnsureOrderOfPositionalParameters(commonParameters, queryParameters);
EnsureOrderOfPositionalParameters(queryParameters, methodParameters);
SetParameters(commandMetadata, queryParameters, methodParameters, commonParameters);
Dbg.Assert(
Regex.IsMatch(commandMetadata.Name, @"[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Lm}]{1,100}-[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Lm}\p{Nd}]{1,100}"),
"Command name doesn't need escaping - validated via xsd");
output.WriteLine(
CmdletBeginBlockTemplate,
/* 0 */ commandMetadata.Name,
/* 1 */ ProxyCommand.GetCmdletBindingAttribute(commandMetadata),
/* 2 */ attributeString,
/* 3 */ outputTypeAttributeDeclaration,
/* 4 */ ProxyCommand.GetParamBlock(commandMetadata));
output.WriteLine(
CmdletProcessBlockTemplate,
queryProcessingScript + "\r\n" + methodProcessingScript);
output.WriteLine(
CmdletEndBlockTemplate,
/* 0 */ this.GetHelpDirectiveForExternalHelp(),
/* 1 */ CodeGeneration.EscapeSingleQuotedStringContent(commandMetadata.Name));
_functionsToExport.Add(commandMetadata.Name);
}
private static void AddPassThruParameter(IDictionary<string, ParameterMetadata> commonParameters, InstanceCmdletMetadata instanceCmdletMetadata)
{
Dbg.Assert(commonParameters != null, "Caller should verify commonParameters != null");
Dbg.Assert(instanceCmdletMetadata != null, "Caller should verify instanceCmdletMetadata != null");
bool outParametersArePresent = false;
if (instanceCmdletMetadata.Method.Parameters != null)
{
foreach (InstanceMethodParameterMetadata parameter in instanceCmdletMetadata.Method.Parameters)
{
if ((parameter.CmdletOutputMetadata != null) && (parameter.CmdletOutputMetadata.ErrorCode == null))
{
outParametersArePresent = true;
break;
}
}
}
if (instanceCmdletMetadata.Method.ReturnValue != null)
{
if ((instanceCmdletMetadata.Method.ReturnValue.CmdletOutputMetadata != null) &&
(instanceCmdletMetadata.Method.ReturnValue.CmdletOutputMetadata.ErrorCode == null))
{
outParametersArePresent = true;
}
}
if (!outParametersArePresent)
{
ParameterMetadata passThruParameter = new ParameterMetadata("PassThru", typeof(SwitchParameter));
passThruParameter.ParameterSets.Clear();
ParameterSetMetadata passThruPSet = new ParameterSetMetadata(int.MinValue, 0, null);
passThruParameter.ParameterSets.Add(ParameterAttribute.AllParameterSets, passThruPSet);
commonParameters.Add(passThruParameter.Name, passThruParameter);
}
}
private void GenerateQueryParametersProcessing(
InstanceCmdletMetadata instanceCmdlet,
IEnumerable<string> commonParameterSets,
IEnumerable<string> queryParameterSets,
IEnumerable<string> methodParameterSets,
out string scriptCode,
out Dictionary<string, ParameterMetadata> queryParameters)
{
queryParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
StringWriter output = new StringWriter(CultureInfo.InvariantCulture);
output.WriteLine(" $__cmdletization_queryBuilder = $__cmdletization_objectModelWrapper.GetQueryBuilder()");
GetCmdletParameters getCmdletParameters = GetGetCmdletParameters(instanceCmdlet);
if (getCmdletParameters.QueryableProperties != null)
{
foreach (PropertyMetadata property in getCmdletParameters.QueryableProperties.Where(p => p.Items != null))
{
for (int i = 0; i < property.Items.Length; i++)
{
string methodName;
switch (property.ItemsElementName[i])
{
case ItemsChoiceType.RegularQuery:
methodName = "FilterByProperty";
break;
case ItemsChoiceType.ExcludeQuery:
methodName = "ExcludeByProperty";
break;
case ItemsChoiceType.MinValueQuery:
methodName = "FilterByMinPropertyValue";
break;
case ItemsChoiceType.MaxValueQuery:
methodName = "FilterByMaxPropertyValue";
break;
default:
Dbg.Assert(false, "Unrecognize query xml element");
methodName = "NotAValidMethod";
break;
}
ParameterMetadata parameterMetadata = GenerateQueryClause(
commonParameterSets, queryParameterSets, methodParameterSets, methodName, property, property.Items[i], output);
switch (property.ItemsElementName[i])
{
case ItemsChoiceType.RegularQuery:
case ItemsChoiceType.ExcludeQuery:
parameterMetadata.Attributes.Add(new ValidateNotNullAttribute());
break;
default:
// do nothing
break;
}
try
{
queryParameters.Add(parameterMetadata.Name, parameterMetadata);
}
catch (ArgumentException e)
{
string message = string.Format(
CultureInfo.InvariantCulture, // xml element names and parameter names are culture-agnostic
CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName,
"<GetCmdletParameters>",
parameterMetadata.Name);
throw new XmlException(message, e);
}
}
}
}
if (getCmdletParameters.QueryableAssociations != null)
{
foreach (Association association in getCmdletParameters.QueryableAssociations.Where(a => a.AssociatedInstance != null))
{
ParameterMetadata parameterMetadata = GenerateAssociationClause(
commonParameterSets, queryParameterSets, methodParameterSets, association, association.AssociatedInstance, output);
try
{
queryParameters.Add(parameterMetadata.Name, parameterMetadata);
}
catch (ArgumentException e)
{
string message = string.Format(
CultureInfo.InvariantCulture, // xml element names and parameter names are culture-agnostic
CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName,
"<GetCmdletParameters>",
parameterMetadata.Name);
throw new XmlException(message, e);
}
}
}
if (getCmdletParameters.QueryOptions != null)
{
foreach (QueryOption queryOption in getCmdletParameters.QueryOptions)
{
ParameterMetadata parameterMetadata = GenerateOptionClause(
commonParameterSets, queryParameterSets, methodParameterSets, queryOption, output);
try
{
queryParameters.Add(parameterMetadata.Name, parameterMetadata);
}
catch (ArgumentException e)
{
string message = string.Format(
CultureInfo.InvariantCulture, // xml element names and parameter names are culture-agnostic
CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName,
"<GetCmdletParameters>",
parameterMetadata.Name);
throw new XmlException(message, e);
}
}
}
if (instanceCmdlet != null)
{
ParameterMetadata inputObjectParameter = new ParameterMetadata("InputObject", _objectInstanceType.MakeArrayType());
ParameterSetMetadata.ParameterFlags inputObjectFlags = ParameterSetMetadata.ParameterFlags.ValueFromPipeline;
if (queryParameters.Count > 0)
{
inputObjectFlags |= ParameterSetMetadata.ParameterFlags.Mandatory;
}
string psTypeNameOfInputObjectElements;
if (_objectModelWrapper.FullName.Equals("Microsoft.PowerShell.Cmdletization.Cim.CimCmdletAdapter"))
{
int indexOfLastBackslash = _cmdletizationMetadata.Class.ClassName.LastIndexOf('\\');
int indexOfLastForwardSlash = _cmdletizationMetadata.Class.ClassName.LastIndexOf('/');
int indexOfLastSeparator = Math.Max(indexOfLastBackslash, indexOfLastForwardSlash);
string cimClassName = _cmdletizationMetadata.Class.ClassName.Substring(
indexOfLastSeparator + 1,
_cmdletizationMetadata.Class.ClassName.Length - indexOfLastSeparator - 1);
psTypeNameOfInputObjectElements = string.Format(
CultureInfo.InvariantCulture,
"{0}#{1}",
_objectInstanceType.FullName,
cimClassName);
}
else
{
psTypeNameOfInputObjectElements = string.Format(
CultureInfo.InvariantCulture,
"{0}#{1}",
_objectInstanceType.FullName,
_cmdletizationMetadata.Class.ClassName);
}
inputObjectParameter.Attributes.Add(new PSTypeNameAttribute(psTypeNameOfInputObjectElements));
inputObjectParameter.Attributes.Add(new ValidateNotNullAttribute());
inputObjectParameter.ParameterSets.Clear();
ParameterSetMetadata inputObjectPSet = new ParameterSetMetadata(
int.MinValue, // non-positional
inputObjectFlags,
null); // no help message
inputObjectParameter.ParameterSets.Add(ScriptWriter.InputObjectQueryParameterSetName, inputObjectPSet);
queryParameters.Add(inputObjectParameter.Name, inputObjectParameter);
}
output.WriteLine();
scriptCode = output.ToString();
}
private void GenerateMethodParametersProcessing(
InstanceCmdletMetadata instanceCmdlet,
IEnumerable<string> commonParameterSets,
IEnumerable<string> queryParameterSets,
out string scriptCode,
out Dictionary<string, ParameterMetadata> methodParameters,
out string outputTypeAttributeDeclaration)
{
methodParameters = new Dictionary<string, ParameterMetadata>(StringComparer.OrdinalIgnoreCase);
outputTypeAttributeDeclaration = string.Empty;
StringWriter output = new StringWriter(CultureInfo.InvariantCulture);
output.WriteLine(" $__cmdletization_methodParameters = [System.Collections.Generic.List[Microsoft.PowerShell.Cmdletization.MethodParameter]]::new()");
output.WriteLine(" switch -exact ($PSCmdlet.ParameterSetName) { ");
InstanceMethodMetadata method = instanceCmdlet.Method;
output.Write(" { @(");
bool firstParameterSet = true;
foreach (string parameterSetName in MultiplyParameterSets(GetMethodParameterSet(method), InstanceMethodParameterSetTemplate, commonParameterSets, queryParameterSets))
{
if (!firstParameterSet) output.Write(", ");
firstParameterSet = false;
output.Write("'{0}'", CodeGeneration.EscapeSingleQuotedStringContent(parameterSetName));
}
output.WriteLine(") -contains $_ } {");
List<Type> typesOfOutParameters = new List<Type>();
List<string> etsTypesOfOutParameters = new List<string>();
if (method.Parameters != null)
{
foreach (InstanceMethodParameterMetadata methodParameter in method.Parameters)
{
string cmdletParameterName = null;
if (methodParameter.CmdletParameterMetadata != null)
{
ParameterMetadata parameterMetadata = GetParameter(
GetMethodParameterSet(method),
methodParameter.ParameterName,
methodParameter.Type,
methodParameter.CmdletParameterMetadata);
cmdletParameterName = parameterMetadata.Name;
try
{
methodParameters.Add(parameterMetadata.Name, parameterMetadata);
}
catch (ArgumentException e)
{
string message = string.Format(
CultureInfo.InvariantCulture, // xml element names and parameter names are culture-agnostic
CmdletizationCoreResources.ScriptWriter_DuplicateQueryParameterName,
"<InstanceCmdlets>...<Cmdlet>",
parameterMetadata.Name);
throw new XmlException(message, e);
}
}
MethodParameterBindings methodParameterBindings = GetMethodParameterKind(methodParameter);
Type dotNetTypeOfParameter = GetDotNetType(methodParameter.Type);
GenerateSingleMethodParameterProcessing(
output,
" ",
cmdletParameterName,
dotNetTypeOfParameter,
methodParameter.Type.ETSType,
methodParameter.DefaultValue,
methodParameter.ParameterName,
methodParameterBindings);
if (MethodParameterBindings.Out == (methodParameterBindings & MethodParameterBindings.Out))
{
typesOfOutParameters.Add(dotNetTypeOfParameter);
etsTypesOfOutParameters.Add(methodParameter.Type.ETSType);
}
}
}
if (method.ReturnValue != null)
{
MethodParameterBindings methodParameterBindings = GetMethodParameterKind(method.ReturnValue);
Type dotNetTypeOfParameter = GetDotNetType(method.ReturnValue.Type);
output.WriteLine(
" $__cmdletization_returnValue = [Microsoft.PowerShell.Cmdletization.MethodParameter]@{{ Name = 'ReturnValue'; ParameterType = '{0}'; Bindings = '{1}'; Value = $null; IsValuePresent = $false }}",
CodeGeneration.EscapeSingleQuotedStringContent(dotNetTypeOfParameter.FullName),
CodeGeneration.EscapeSingleQuotedStringContent(methodParameterBindings.ToString()));
if (!string.IsNullOrEmpty(method.ReturnValue.Type.ETSType))
{
output.WriteLine(
" $__cmdletization_methodParameter.ParameterTypeName = '{0}'",
CodeGeneration.EscapeSingleQuotedStringContent(method.ReturnValue.Type.ETSType));
}
if (MethodParameterBindings.Out == (methodParameterBindings & MethodParameterBindings.Out))
{
typesOfOutParameters.Add(dotNetTypeOfParameter);
etsTypesOfOutParameters.Add(method.ReturnValue.Type.ETSType);
}
}
else
{
output.WriteLine(" $__cmdletization_returnValue = $null");
}
output.WriteLine(
" $__cmdletization_methodInvocationInfo = [Microsoft.PowerShell.Cmdletization.MethodInvocationInfo]::new('{0}', $__cmdletization_methodParameters, $__cmdletization_returnValue)",
CodeGeneration.EscapeSingleQuotedStringContent(method.MethodName));
if (typesOfOutParameters.Count == 0)
{
output.WriteLine(
" $__cmdletization_passThru = $PSBoundParameters.ContainsKey('PassThru') -and $PassThru");
}
else
{
output.WriteLine(
" $__cmdletization_passThru = $false");
}
output.WriteLine(" if ($PSBoundParameters.ContainsKey('InputObject')) {");
output.WriteLine(" foreach ($x in $InputObject) { $__cmdletization_objectModelWrapper.ProcessRecord($x, $__cmdletization_methodInvocationInfo, $__cmdletization_PassThru) }");
output.WriteLine(" } else {");
output.WriteLine(" $__cmdletization_objectModelWrapper.ProcessRecord($__cmdletization_queryBuilder, $__cmdletization_methodInvocationInfo, $__cmdletization_PassThru)");
output.WriteLine(" }");
output.WriteLine(" }");
output.WriteLine(" }");
scriptCode = output.ToString();
if (typesOfOutParameters.Count == 0)
{
// -PassThru case
outputTypeAttributeDeclaration = GetOutputAttributeForGetCmdlet();
}
else if (typesOfOutParameters.Count == 1)
{
outputTypeAttributeDeclaration = string.Format(
CultureInfo.InvariantCulture,
"[OutputType([{0}])]",
typesOfOutParameters[0].FullName);
if ((etsTypesOfOutParameters.Count == 1) && (!string.IsNullOrEmpty(etsTypesOfOutParameters[0])))
{
outputTypeAttributeDeclaration += string.Format(
CultureInfo.InvariantCulture,
"[OutputType('{0}')]",
CodeGeneration.EscapeSingleQuotedStringContent(etsTypesOfOutParameters[0]));
}
}
}
