protected static bool AddDynamicParameter(Type type, string name, ref RuntimeDefinedParameterDictionary dic, bool valueFromPipeline)
{
bool paramAdded = false;
if (dic == null || !dic.ContainsKey(name))
{
var attrib = new ParameterAttribute
{
Mandatory = false,
ValueFromPipeline = valueFromPipeline,
};
var param = new RuntimeDefinedParameter
{
IsSet = false,
Name = name,
ParameterType = type
};
param.Attributes.Add(attrib);
if (dic == null)
{
dic = new RuntimeDefinedParameterDictionary();
}
dic.Add(name, param);
paramAdded = true;
}
return paramAdded;
}
public override void VisitParameter(ParameterAttribute parameter)
{
_parameterInfo = new ParameterInfo(CurrentProperty, parameter);
_cmdletInfo.AddParameter(_parameterInfo);
base.VisitParameter(parameter);
}
protected override object NewDriveDynamicParameters()
{
try{
WriteVerbose("TmxProvider::NewDriveDynamicParameters()");
dynamicParameters =
new RuntimeDefinedParameterDictionary();
var atts1 = new Collection<Attribute>();
var parameterAttribute1 = new ParameterAttribute {Mandatory = true};
//ParameterAttribute parameterAttribute1 = new ParameterAttribute();
//parameterAttribute1.Mandatory = true;
//parameterAttribute2.ParameterSetName = "WindowNameParameterSet";
atts1.Add(parameterAttribute1);
var attr1 = new AllowEmptyStringAttribute();
atts1.Add(attr1);
dynamicParameters.Add(
"windowName",
new RuntimeDefinedParameter(
"windowName",
typeof(string),
atts1));
var atts2 = new Collection<Attribute>();
var parameterAttribute2 = new ParameterAttribute {Mandatory = true};
//ParameterAttribute parameterAttribute2 = new ParameterAttribute();
//parameterAttribute2.Mandatory = true;
//parameterAttribute2.ParameterSetName = "ProcessNameParameterSet";
atts2.Add(parameterAttribute2);
var attr2 = new AllowEmptyStringAttribute();
atts2.Add(attr2);
dynamicParameters.Add(
"processName",
new RuntimeDefinedParameter(
"processName",
typeof(string),
atts2));
var atts3 = new Collection<Attribute>();
var parameterAttribute3 = new ParameterAttribute {Mandatory = true};
//ParameterAttribute parameterAttribute3 = new ParameterAttribute();
//parameterAttribute3.Mandatory = true;
//parameterAttribute3.ParameterSetName = "ProcessIdParameterSet";
atts3.Add(parameterAttribute3);
var attr3 = new AllowEmptyStringAttribute();
atts3.Add(attr3);
dynamicParameters.Add(
"processId",
new RuntimeDefinedParameter(
"processId",
typeof(int),
atts3));
return dynamicParameters;
}
catch (Exception e) {
WriteVerbose(e.Message);
WriteVerbose("TmxProvider::NewDriveDynamicParameters()");
return null;
}
}
public static void IsParameter(Expression<Func<object>> member, ParameterAttribute param, ValidateArgumentsAttribute validator)
{
AttributeAssert.Has(member, param);
if (validator != null)
{
AttributeAssert.Has(member, validator);
}
}
// internals
//internal CommandParameterInfo(System.Management.Automation.CompiledCommandParameter parameter, uint parameterSetFlag);
internal CommandParameterInfo(string name, Type paramType, ParameterAttribute paramAttr)
{
Name = name;
ParameterType = paramType;
Position = paramAttr.Position;
ValueFromPipeline = paramAttr.ValueFromPipeline;
ValueFromPipelineByPropertyName = paramAttr.ValueFromPipelineByPropertyName;
ValueFromRemainingArguments = paramAttr.ValueFromRemainingArguments;
IsMandatory = paramAttr.Mandatory;
// TODO: fill in aliases
}
public ParameterInfo(PropertyInfo pi, ParameterAttribute pa)
{
Name = pi.Name;
Type = pi.PropertyType;
ValueType = Type.Name;
Position = pa.Position;
Required = pa.Mandatory;
ParameterSetName = pa.ParameterSetName;
ValueFromPipeline = pa.ValueFromPipeline;
ValueFromPipelineByPropertyName = pa.ValueFromPipelineByPropertyName;
if(Position < 0)
Position = -1;
}
internal RuntimeDefinedParameter GetRuntimeDefinedParameter(bool isCmdlet)
{
TypeLiteral lastType = ParameterNode.GetLastType(this._parameter.TypeConstraint);
Collection <Attribute> attributes = new Collection <Attribute>();
bool flag = false;
foreach (AttributeNode attribute1 in this._attributes)
{
Attribute attribute2 = attribute1.GetAttribute();
if (attribute2 != null)
{
if (attribute2 is ParameterAttribute)
{
flag = true;
}
attributes.Add(attribute2);
}
}
if (isCmdlet && !flag)
{
ParameterAttribute parameterAttribute = new ParameterAttribute();
attributes.Insert(0, (Attribute)parameterAttribute);
}
RuntimeDefinedParameter definedParameter = lastType != null ? new RuntimeDefinedParameter(this._parameter.VariableName, lastType, attributes) : new RuntimeDefinedParameter(this._parameter.VariableName, typeof(object), attributes);
if (this._initializer != null)
{
definedParameter.Value = (object)this._initializer;
}
else if (definedParameter.ParameterType == typeof(string))
{
definedParameter.Value = (object)"";
}
else if (definedParameter.ParameterType == typeof(bool))
{
definedParameter.Value = (object)false;
}
else if (definedParameter.ParameterType == typeof(SwitchParameter))
{
definedParameter.Value = (object)new SwitchParameter(false);
}
else if (LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(definedParameter.ParameterType)))
{
definedParameter.Value = (object)0;
}
return(definedParameter);
}
public sealed override void VisitMember(MemberInfo member)
{
currentParameter = GetAttribute<ParameterAttribute>(member, false);
if (currentParameter != null)
{
try
{
VisitParameter(currentParameter);
base.VisitMember(member);
}
finally
{
currentParameter = null;
}
}
}
internal ParameterSetSpecificMetadata(ParameterAttribute attribute)
{
this.position = -2147483648;
if (attribute == null)
{
throw PSTraceSource.NewArgumentNullException("attribute");
}
this.attribute = attribute;
this.isMandatory = attribute.Mandatory;
this.position = attribute.Position;
this.valueFromRemainingArguments = attribute.ValueFromRemainingArguments;
this.valueFromPipeline = attribute.ValueFromPipeline;
this.valueFromPipelineByPropertyName = attribute.ValueFromPipelineByPropertyName;
this.helpMessage = attribute.HelpMessage;
this.helpMessageBaseName = attribute.HelpMessageBaseName;
this.helpMessageResourceId = attribute.HelpMessageResourceId;
}
internal ParameterSetSpecificMetadata(ParameterAttribute attribute)
{
this.position = -2147483648;
if (attribute == null)
{
throw PSTraceSource.NewArgumentNullException("attribute");
}
this.attribute = attribute;
this.isMandatory = attribute.Mandatory;
this.position = attribute.Position;
this.valueFromRemainingArguments = attribute.ValueFromRemainingArguments;
this.valueFromPipeline = attribute.ValueFromPipeline;
this.valueFromPipelineByPropertyName = attribute.ValueFromPipelineByPropertyName;
this.helpMessage = attribute.HelpMessage;
this.helpMessageBaseName = attribute.HelpMessageBaseName;
this.helpMessageResourceId = attribute.HelpMessageResourceId;
}
public object GetDynamicParameters()
{
if (_runtimeParamsDict == null)
{
ParameterAttribute paramAttribute = new ParameterAttribute();
paramAttribute.Mandatory = true;
Collection<Attribute> nameAttributes = new Collection<Attribute>(new Attribute[] {
new ValidateSetAttribute(Enum.GetNames(typeof(HistoricalData.HistoricalDataType))),
new ValidateNotNullOrEmptyAttribute(),
paramAttribute
});
_runtimeParamsDict = new RuntimeDefinedParameterDictionary();
_runtimeParamsDict.Add("HistoricalDataType",
new RuntimeDefinedParameter("HistoricalDataType", typeof(string), nameAttributes));
}
return _runtimeParamsDict;
}
public object GetDynamicParameters()
{
if (_runtimeParamsDict == null)
{
ParameterAttribute paramAttribute = new ParameterAttribute();
paramAttribute.Mandatory = true;
string[] validNames = IndicatorAndStrategyContainer.Instance.Indicators.Select(indicator => indicator.Name).ToArray();
Collection<Attribute> nameAttributes = new Collection<Attribute>(new Attribute[] {
new ValidateSetAttribute(validNames),
new ValidateNotNullOrEmptyAttribute(),
paramAttribute
});
var nameParam = new RuntimeDefinedParameter("Name", typeof(string), nameAttributes);
_runtimeParamsDict = new RuntimeDefinedParameterDictionary();
_runtimeParamsDict.Add("Name", nameParam);
}
return _runtimeParamsDict;
}
internal CommandParameterInfo(MemberInfo info, Type paramType, ParameterAttribute paramAttr)
{
MemberInfo = info;
Name = info.Name;
ParameterType = paramType;
Position = paramAttr.Position;
ValueFromPipeline = paramAttr.ValueFromPipeline;
ValueFromPipelineByPropertyName = paramAttr.ValueFromPipelineByPropertyName;
ValueFromRemainingArguments = paramAttr.ValueFromRemainingArguments;
IsMandatory = paramAttr.Mandatory;
HelpMessage = paramAttr.HelpMessage;
ParameterSetName = paramAttr.ParameterSetName ?? ParameterAttribute.AllParameterSets;
List <Attribute> attributes = new List <Attribute>(1);
attributes.Add(paramAttr);
// Reflect Aliases from field/property
AliasAttribute aliasAttr = (AliasAttribute)info.GetCustomAttributes(false).FirstOrDefault(i => i is AliasAttribute);
if (aliasAttr != null)
{
List <string> aliases = new List <string>(aliasAttr.AliasNames);
Aliases = new ReadOnlyCollection <string>(aliases);
attributes.Add(aliasAttr);
}
else
{
Aliases = new ReadOnlyCollection <string>(new List <string>());
}
var transformationAttrs = info.GetCustomAttributes(true).OfType <ArgumentTransformationAttribute>().ToList();
TransformationAttributes = new ReadOnlyCollection <ArgumentTransformationAttribute>(transformationAttrs);
Attributes = new ReadOnlyCollection <Attribute>(attributes);
}
// internals
//internal CommandParameterInfo(System.Management.Automation.CompiledCommandParameter parameter, uint parameterSetFlag);
internal CommandParameterInfo(MemberInfo info, Type paramType, ParameterAttribute paramAttr)
{
Name = info.Name;
ParameterType = paramType;
Position = paramAttr.Position;
ValueFromPipeline = paramAttr.ValueFromPipeline;
ValueFromPipelineByPropertyName = paramAttr.ValueFromPipelineByPropertyName;
ValueFromRemainingArguments = paramAttr.ValueFromRemainingArguments;
IsMandatory = paramAttr.Mandatory;
List<Attribute> attributes = new List<Attribute>(1);
attributes.Add(paramAttr);
// Reflect Aliases from field/property
AliasAttribute aliasAttr = (AliasAttribute)info.GetCustomAttributes(false).Where(i => i is AliasAttribute).FirstOrDefault();
if (aliasAttr != null)
{
List<string> aliases = new List<string>(aliasAttr.AliasNames);
Aliases = new ReadOnlyCollection<string>(aliases);
attributes.Add(aliasAttr);
}
Attributes = new ReadOnlyCollection<Attribute>(attributes);
}
private RuntimeDefinedParameter CreateCacheMemoryDynamicParameter(CacheServiceSkuType sku)
{
var parameter = new RuntimeDefinedParameter
{
Name = MemoryParameterName,
ParameterType = typeof(string),
};
// add the [parameter] attribute
var parameterAttribute = new ParameterAttribute
{
Mandatory = false,
};
parameter.Attributes.Add(parameterAttribute);
string[] values = (new CacheSkuCountConvert(sku)).GetValueList();
parameter.Attributes.Add(new ValidateSetAttribute(values)
{
IgnoreCase = true
});
return parameter;
}
/// <summary>
/// Extracts the data from the ParameterAttribute and creates the member data as necessary.
/// </summary>
///
/// <param name="parameterName">
/// The name of the parameter.
/// </param>
///
/// <param name="parameter">
/// The instance of the ParameterAttribute to extract the data from.
/// </param>
///
/// <exception cref="MetadataException">
/// If a parameter set name has already been declared on this parameter.
/// </exception>
///
private void ProcessParameterAttribute(
string parameterName,
ParameterAttribute parameter)
{
// If the parameter set name already exists on this parameter and the set name is the default parameter
// set name, it is an error.
if (ParameterSetData.ContainsKey(parameter.ParameterSetName))
{
MetadataException e =
new MetadataException(
"ParameterDeclaredInParameterSetMultipleTimes",
null,
DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes,
parameterName,
parameter.ParameterSetName);
throw e;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
IsPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
IsMandatoryInSomeParameterSet = true;
}
// Construct an instance of the parameter set specific data
ParameterSetSpecificMetadata parameterSetSpecificData = new ParameterSetSpecificMetadata(parameter);
ParameterSetData.Add(parameter.ParameterSetName, parameterSetSpecificData);
}
private void AddParameter(MemberInfo info, Type parameterType, ParameterAttribute paramAttribute)
{
var paramInfo = new CommandParameterInfo(info, parameterType, paramAttribute);
if (!NamedParameters.ContainsKey(paramInfo.Name))
{
NamedParameters[paramInfo.Name] = paramInfo;
}
AllParameters.Add(paramInfo);
}
public static void IsParameter(Expression<Func<object>> member, ParameterAttribute param)
{
IsParameter(member, param, validator: null);
}
private void ProcessParameterAttribute(string parameterName, ParameterAttribute parameter)
{
if (this._parameterSetData.ContainsKey(parameter.ParameterSetName))
{
System.Management.Automation.MetadataException exception = new System.Management.Automation.MetadataException("ParameterDeclaredInParameterSetMultipleTimes", null, DiscoveryExceptions.ParameterDeclaredInParameterSetMultipleTimes, new object[] { parameterName, parameter.ParameterSetName });
throw exception;
}
if (parameter.ValueFromPipeline || parameter.ValueFromPipelineByPropertyName)
{
this._isPipelineParameterInSomeParameterSet = true;
}
if (parameter.Mandatory)
{
this._isMandatoryInSomeParameterSet = true;
}
ParameterSetSpecificMetadata metadata = new ParameterSetSpecificMetadata(parameter);
this._parameterSetData.Add(parameter.ParameterSetName, metadata);
}
public virtual void VisitParameter(ParameterAttribute parameter)
{
}
// internals
//internal CmdletInfo CreateGetCommandCopy(CmdletInfo cmdletInfo, object[] arguments);
//internal object[] Arguments { set; get; }
//internal string FullName { get; }
//internal bool IsGetCommandCopy { set; get; }
private CommandParameterInfo AddParameterToParameterSet(Dictionary<string, Collection<CommandParameterInfo>> paramSets,
MemberInfo memberInfo, Type type, ParameterAttribute paramAttr)
{
CommandParameterInfo pi = new CommandParameterInfo(memberInfo, type, paramAttr);
var paramSetName = paramAttr.ParameterSetName;
// Determine if this parameter is uniquely defined for one set and rember it
paramSetName = paramSetName ?? ParameterAttribute.AllParameterSets;
if (!paramSets.ContainsKey(paramSetName))
{
paramSets.Add(paramSetName, new Collection<CommandParameterInfo>());
}
Collection<CommandParameterInfo> paramSet = paramSets[paramSetName];
paramSet.Add(pi);
return pi;
}
// internals
//internal CmdletInfo CreateGetCommandCopy(CmdletInfo cmdletInfo, object[] arguments);
//internal object[] Arguments { set; get; }
//internal string FullName { get; }
//internal bool IsGetCommandCopy { set; get; }
private CommandParameterInfo AddParameterToParameterSet(Dictionary <string, Collection <CommandParameterInfo> > paramSets,
MemberInfo memberInfo, Type type, ParameterAttribute paramAttr)
{
CommandParameterInfo pi = new CommandParameterInfo(memberInfo, type, paramAttr);
var paramSetName = paramAttr.ParameterSetName;
// Determine if this parameter is uniquely defined for one set and rember it
paramSetName = paramSetName ?? ParameterAttribute.AllParameterSets;
if (!paramSets.ContainsKey(paramSetName))
{
paramSets.Add(paramSetName, new Collection <CommandParameterInfo>());
}
Collection <CommandParameterInfo> paramSet = paramSets[paramSetName];
paramSet.Add(pi);
return(pi);
}
private static string GetPipelineInputString(ParameterAttribute paramAttrib)
{
ArrayList list = new ArrayList();
if (paramAttrib.ValueFromPipeline)
{
list.Add(StringUtil.Format(HelpDisplayStrings.PipelineByValue, new object[0]));
}
if (paramAttrib.ValueFromPipelineByPropertyName)
{
list.Add(StringUtil.Format(HelpDisplayStrings.PipelineByPropertyName, new object[0]));
}
if (paramAttrib.ValueFromRemainingArguments)
{
list.Add(StringUtil.Format(HelpDisplayStrings.PipelineFromRemainingArguments, new object[0]));
}
if (list.Count == 0)
{
return StringUtil.Format(HelpDisplayStrings.FalseShort, new object[0]);
}
StringBuilder builder = new StringBuilder();
builder.Append(StringUtil.Format(HelpDisplayStrings.TrueShort, new object[0]));
builder.Append(" (");
for (int i = 0; i < list.Count; i++)
{
builder.Append((string) list[i]);
if (i != (list.Count - 1))
{
builder.Append(", ");
}
}
builder.Append(")");
return builder.ToString();
}
/// <summary>
/// This function is part of the IDynamicParameters interface.
/// PowerShell uses it to generate parameters dynamically.
/// We have to generate -ResourceType parameter dynamically because the array
/// of resources that we used to validate against are not generated before compile time,
/// i.e. [ValidateSet(ArrayGeneratedAtRunTime)] will throw an error for parameters
/// that are not generated dynamically.
/// </summary>
public object GetDynamicParameters()
{
if (_dynamicParameters == null)
{
ParameterAttribute paramAttribute = new ParameterAttribute()
{
Mandatory = true
};
ValidateSetAttribute validateSetAttribute = new ValidateSetAttribute(AllResourceTypes);
validateSetAttribute.IgnoreCase = true;
Collection<Attribute> attributes =
new Collection<Attribute>(new Attribute[] { validateSetAttribute, paramAttribute });
// This parameter can now be thought of as:
// [Parameter(Mandatory = true)]
// [ValidateSet(validTypeValues)]
// public string { get; set; }
RuntimeDefinedParameter typeParameter = new RuntimeDefinedParameter("ResourceType", typeof(string), attributes);
_dynamicParameters = new RuntimeDefinedParameterDictionary();
_dynamicParameters.Add("ResourceType", typeParameter);
}
return _dynamicParameters;
}
// internals
//internal CmdletInfo CreateGetCommandCopy(CmdletInfo cmdletInfo, object[] arguments);
//internal object[] Arguments { set; get; }
//internal string FullName { get; }
//internal bool IsGetCommandCopy { set; get; }
private CommandParameterInfo AddParameterToParameterSet(Dictionary<string, Collection<CommandParameterInfo>> paramSets,
MemberInfo memberInfo, Type type, ParameterAttribute paramAttr)
{
CommandParameterInfo pi = new CommandParameterInfo(memberInfo, type, paramAttr);
var paramSetName = paramAttr.ParameterSetName;
// Determine if this parameter is uniquely defined for one set and rember it
if (!String.IsNullOrEmpty(paramSetName) && !paramSetName.Equals(ParameterAttribute.AllParameterSets))
{
var parameterName = pi.Name;
// check if we already defined that parameter for another set
if (UniqueSetParameters.ContainsKey(parameterName))
{
UniqueSetParameters[parameterName] = null;
}
else
{
// not yet in any set, it's a candidate for a unique parameter
UniqueSetParameters[parameterName] = paramSetName;
}
}
paramSetName = paramSetName ?? ParameterAttribute.AllParameterSets;
if (!paramSets.ContainsKey(paramSetName))
{
paramSets.Add(paramSetName, new Collection<CommandParameterInfo>());
}
Collection<CommandParameterInfo> paramSet = paramSets[paramSetName];
paramSet.Add(pi);
return pi;
}
