public Argument(object target, ParameterInfo mi)
: base(target, mi)
{
_default = null;
_required = true;
_allArguments = Parameter.IsDefined(typeof (AllArgumentsAttribute), true);
if (Parameter.DefaultValue != DBNull.Value)
{
_default = Parameter.DefaultValue;
_required = false;
}
foreach (DefaultValueAttribute a in mi.GetCustomAttributes(typeof (DefaultValueAttribute), true))
{
_default = a.Value;
_required = false;
}
foreach (ArgumentAttribute a in mi.GetCustomAttributes(typeof (ArgumentAttribute), true))
{
if (a.HasDefault)
{
_required = false;
_default = a.DefaultValue;
}
}
if (Visible && _description == mi.ToString())
{
if (IsFlag)
{
if (Required)
_description = String.Format("Required flag can be \"/{0}\" or \"/{0}:false\".", base.DisplayName);
else
_description = String.Format("Optional flag of \"/{0}\" or \"/{0}:false\".", base.DisplayName);
}
else
{
if (Required)
_description = String.Format("Specifies the required value for \"{0}\" of type {1}.", base.DisplayName,
UnderlyingType.Name);
else
_description = String.Format("Specifies an optional value for \"{0}\" of type {1}.", base.DisplayName,
UnderlyingType.Name);
}
}
}
private static void BuildParameter(ParameterBuilder builder, System.Reflection.ParameterInfo paramInfo, int position, int count, CommandService service)
{
var attributes = paramInfo.GetCustomAttributes();
var paramType = paramInfo.ParameterType;
builder.Name = paramInfo.Name;
builder.IsOptional = paramInfo.IsOptional;
builder.DefaultValue = paramInfo.HasDefaultValue ? paramInfo.DefaultValue : null;
foreach (var attribute in attributes)
{
// TODO: C#7 type switch
if (attribute is SummaryAttribute)
{
builder.Summary = (attribute as SummaryAttribute).Text;
}
else if (attribute is OverrideTypeReaderAttribute)
{
builder.TypeReader = GetTypeReader(service, paramType, (attribute as OverrideTypeReaderAttribute).TypeReader);
}
else if (attribute is ParameterPreconditionAttribute)
{
builder.AddPrecondition(attribute as ParameterPreconditionAttribute);
}
else if (attribute is ParamArrayAttribute)
{
builder.IsMultiple = true;
paramType = paramType.GetElementType();
}
else if (attribute is RemainderAttribute)
{
if (position != count - 1)
{
throw new InvalidOperationException("Remainder parameters must be the last parameter in a command.");
}
builder.IsRemainder = true;
}
}
builder.ParameterType = paramType;
if (builder.TypeReader == null)
{
var readers = service.GetTypeReaders(paramType);
TypeReader reader = null;
if (readers != null)
{
reader = readers.FirstOrDefault().Value;
}
else
{
reader = service.GetDefaultTypeReader(paramType);
}
builder.TypeReader = reader;
}
}
public static bool TryGetDefaultValue(ParameterInfo parameterInfo, out object value)
{
// this will get the default value as seen by the VB / C# compilers
// if no value was baked in, RawDefaultValue returns DBNull.Value
object rawDefaultValue = null;
try {
rawDefaultValue = parameterInfo.RawDefaultValue;
}
catch (NotImplementedException) {
rawDefaultValue = null;
}
if (rawDefaultValue != DBNull.Value) {
value = rawDefaultValue;
return true;
}
// if the compiler did not bake in a default value, check the [DefaultValue] attribute
DefaultValueAttribute[] attrs = (DefaultValueAttribute[])parameterInfo.GetCustomAttributes(typeof(DefaultValueAttribute), false);
if (attrs == null || attrs.Length == 0) {
value = default(object);
return false;
}
else {
value = attrs[0].Value;
return true;
}
}
internal static object GetCustomAttribute(Type type, ParameterInfo pi)
{
object [] attributes = pi.GetCustomAttributes (type, true);
if (attributes.Length < 1)
return null;
return attributes [0];
}
public virtual string GetARDataBindPrefix(ParameterInfo p)
{
var db = p.GetCustomAttributes<ARDataBindAttribute>();
if (db.Length == 0)
return null;
return db[0].Prefix;
}
public virtual string GetARFetch(ParameterInfo p)
{
var db = p.GetCustomAttributes<ARFetchAttribute>();
if (db.Length == 0)
return null;
return db[0].RequestParameterName ?? p.Name;
}
private static void AppendParameterInfo(StringBuilder toolTipText, ParameterInfo parameterInfo, bool isLastParameter)
{
System.Type parameterType = parameterInfo.ParameterType;
if (parameterType != null)
{
if (parameterType.IsByRef)
{
if (parameterInfo.IsOut)
{
toolTipText.Append("out ");
}
else
{
toolTipText.Append("ref ");
}
parameterType = parameterType.GetElementType();
}
else if (isLastParameter && parameterType.IsArray)
{
object[] customAttributes = parameterInfo.GetCustomAttributes(typeof(ParamArrayAttribute), false);
if ((customAttributes != null) && (customAttributes.Length > 0))
{
toolTipText.Append("params ");
}
}
toolTipText.Append(RuleDecompiler.DecompileType(parameterType));
toolTipText.Append(" ");
}
toolTipText.Append(parameterInfo.Name);
}
/// <summary>
/// Resolves the value for the parameter.
/// </summary>
/// <param name="value">The initial value.</param>
/// <param name="parameter">The parameter.</param>
/// <returns>The new value.</returns>
protected override object ResolveValue(object value, ParameterInfo parameter)
{
SitecoreConfigurationMapAttribute mapping = parameter.GetCustomAttributes(typeof(SitecoreConfigurationMapAttribute)).Cast<SitecoreConfigurationMapAttribute>().SingleOrDefault(map => map.ArgumentType == parameter.ParameterType);
if (mapping == null)
{
mapping = parameter.Member.GetCustomAttributes(typeof(SitecoreConfigurationMapAttribute)).Cast<SitecoreConfigurationMapAttribute>().SingleOrDefault(map => map.ArgumentType == parameter.ParameterType);
}
if (mapping == null)
{
mapping = parameter.Member.ReflectedType.GetCustomAttributes(typeof(SitecoreConfigurationMapAttribute)).Cast<SitecoreConfigurationMapAttribute>().SingleOrDefault(map => map.ArgumentType == parameter.ParameterType);
}
if (mapping == null)
{
mapping = parameter.Member.ReflectedType.Assembly.GetCustomAttributes(typeof(SitecoreConfigurationMapAttribute)).Cast<SitecoreConfigurationMapAttribute>().SingleOrDefault(map => map.ArgumentType == parameter.ParameterType);
}
if (mapping == null)
{
return null;
}
return Factory.CreateObject(mapping.ConfigurationNode, true);
}
public static CustomPropertyInfo GetFromParamInfo(System.Reflection.ParameterInfo info)
{
if (info == null)
{
return(null);
}
CustomPropertyInfo retInfo = new CustomPropertyInfo();
retInfo.PropertyName = info.Name;
if (info.IsOut || info.ParameterType.IsByRef)
{
retInfo.PropertyType = EngineNS.Rtti.RttiHelper.GetTypeFromTypeFullName(info.ParameterType.FullName.Remove(info.ParameterType.FullName.Length - 1));
}
else
{
//retInfo.PropertyType = CSUtility.Program.GetTypeFromTypeFullName(info.ParameterType.FullName);
retInfo.PropertyType = info.ParameterType;
}
foreach (var att in info.GetCustomAttributes(true))
{
retInfo.PropertyAttributes.Add(att as Attribute);
}
retInfo.DefaultValue = CodeGenerateSystem.Program.GetDefaultValueFromType(retInfo.PropertyType);
retInfo.CurrentValue = retInfo.DefaultValue;
return(retInfo);
}
/// <summary>
/// Resolves the value for the parameter.
/// </summary>
/// <param name="value">The initial value.</param>
/// <param name="parameter">The parameter.</param>
/// <returns>The new value.</returns>
protected override object ResolveValue(object value, ParameterInfo parameter)
{
IEnumerable<string> configurationNodes = parameter.GetCustomAttributes(typeof(SitecoreConfigurationReferenceAttribute)).Cast<SitecoreConfigurationReferenceAttribute>().Select(attribute => attribute.ConfigurationNode);
if (!configurationNodes.Any())
{
configurationNodes = parameter.Member.GetCustomAttributes(typeof(SitecoreConfigurationReferenceAttribute)).Cast<SitecoreConfigurationReferenceAttribute>().Select(attribute => attribute.ConfigurationNode);
if (parameter.Member.ReflectedType != null)
{
configurationNodes = configurationNodes.Union(parameter.Member.ReflectedType.GetCustomAttributes(typeof(SitecoreConfigurationReferenceAttribute)).Cast<SitecoreConfigurationReferenceAttribute>().Select(attribute => attribute.ConfigurationNode));
configurationNodes = configurationNodes.Union(parameter.Member.ReflectedType.Assembly.GetCustomAttributes(typeof(SitecoreConfigurationReferenceAttribute)).Cast<SitecoreConfigurationReferenceAttribute>().Select(attribute => attribute.ConfigurationNode));
}
}
XmlNode targetNode = null;
foreach (string configurationNode in configurationNodes)
{
XmlNode nodeCandidate = Factory.GetConfigNode(configurationNode, true);
if (parameter.ParameterType.IsAssignableFrom(Factory.CreateType(nodeCandidate, true)))
{
if (targetNode != null)
{
throw new InvalidOperationException(string.Format("Cannot resolve value for argument '{0}'. There are several configuration nodes applicable to this argument.", parameter.Name));
}
targetNode = nodeCandidate;
}
}
return Factory.CreateObject(targetNode, true);
}
/// <summary>
/// Gets the service name based on the given <paramref name="parameter"/>.
/// </summary>
/// <param name="parameter">The <see cref="ParameterInfo"/> for which to get the service name.</param>
/// <returns>The name of the service for the given <paramref name="parameter"/>.</returns>
private string GetServiceName(ParameterInfo parameter)
{
var injectAttribute =
(InjectAttribute)
parameter.GetCustomAttributes(typeof(InjectAttribute), true).FirstOrDefault();
return injectAttribute != null ? injectAttribute.ServiceName : parameter.Name;
}
/// <summary>
/// Provide the list of attributes applied to the specified parameter.
/// </summary>
/// <param name="reflectedType">The reflectedType the type used to retrieve the parameterInfo.</param>
/// <param name="parameter">The parameter to supply attributes for.</param>
/// <returns>The list of applied attributes.</returns>
public override IEnumerable <Attribute> GetCustomAttributes(Type reflectedType, System.Reflection.ParameterInfo parameter)
{
Requires.NotNull(parameter, nameof(parameter));
var attributes = parameter.GetCustomAttributes <Attribute>(false);
List <Attribute> cachedAttributes = ReadParameterCustomAttributes(reflectedType, parameter);
return(cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes));
}
/// <summary>
/// Gets the attributes for the given <paramref name="parameter"/>.
/// </summary>
/// <param name="parameter">A <see cref="ParameterInfo"/> for which attributes need to be resolved.
/// </param>
/// <returns>An <see cref="IEnumerable{object}"/> containing the attributes on the
/// <paramref name="parameter"/> before the attributes on the <paramref name="parameter"/> type.</returns>
public static IEnumerable<object> GetAttributesForParameter(ParameterInfo parameter)
{
// Return the parameter attributes first.
var parameterAttributes = parameter.GetCustomAttributes();
var typeAttributes = parameter.ParameterType.GetTypeInfo().GetCustomAttributes();
return parameterAttributes.Concat(typeAttributes);
}
// allowing Custom Marshaling to be injected
public XlParameterInfo(ParameterInfo paramInfo)
{
// Add Name and Description
// CONSIDER: Override Marshaler for row/column arrays according to some attribute
// Some pre-checks
if (paramInfo.ParameterType.IsByRef)
throw new DnaMarshalException("Parameter is ByRef: " + paramInfo.Name);
// Default Name and Description
Name = paramInfo.Name;
Description = "";
AllowReference = false;
// Get Description
object[] attribs = paramInfo.GetCustomAttributes(false);
// Search through attribs for Description
foreach (object attrib in attribs)
{
System.ComponentModel.DescriptionAttribute desc =
attrib as System.ComponentModel.DescriptionAttribute;
if (desc != null)
{
Description = desc.Description;
}
//// HACK: Some problem with library references -
//// For now relax the assembly reference and use late-bound
Type attribType = attrib.GetType();
if (TypeHelper.TypeHasAncestorWithFullName(attribType, "ExcelDna.Integration.ExcelArgumentAttribute"))
{
string name = (string)attribType.GetField("Name").GetValue(attrib);
string description = (string)attribType.GetField("Description").GetValue(attrib);
object allowReference = attribType.GetField("AllowReference").GetValue(attrib);
if (name != null)
Name = name;
if (description != null)
Description = description;
if (allowReference != null)
AllowReference = (bool)allowReference;
}
// HACK: Here is the other code:
//ExcelArgumentAttribute xlparam = attrib as ExcelArgumentAttribute;
//if (xlparam != null)
//{
// if (xlparam.Name != null)
// {
// Name = xlparam.Name;
// }
// if (xlparam.Description != null)
// {
// Description = xlparam.Description;
// }
// AllowReference = xlparam.AllowReference;
//}
}
SetTypeInfo(paramInfo.ParameterType, false, false);
}
private static void BuildParameter(ParameterBuilder builder, System.Reflection.ParameterInfo paramInfo, int position, int count, CommandService service, IServiceProvider services)
{
var attributes = paramInfo.GetCustomAttributes();
var paramType = paramInfo.ParameterType;
builder.Name = paramInfo.Name;
builder.IsOptional = paramInfo.IsOptional;
builder.DefaultValue = paramInfo.HasDefaultValue ? paramInfo.DefaultValue : null;
foreach (var attribute in attributes)
{
switch (attribute)
{
case SummaryAttribute summary:
builder.Summary = summary.Text;
break;
case OverrideTypeReaderAttribute typeReader:
builder.TypeReader = GetTypeReader(service, paramType, typeReader.TypeReader, services);
break;
case ParamArrayAttribute _:
builder.IsMultiple = true;
paramType = paramType.GetElementType();
break;
case ParameterPreconditionAttribute precon:
builder.AddPrecondition(precon);
break;
case NameAttribute name:
builder.Name = name.Text;
break;
case RemainderAttribute _:
if (position != count - 1)
{
throw new InvalidOperationException($"Remainder parameters must be the last parameter in a command. Parameter: {paramInfo.Name} in {paramInfo.Member.DeclaringType.Name}.{paramInfo.Member.Name}");
}
builder.IsRemainder = true;
break;
default:
builder.AddAttributes(attribute);
break;
}
}
builder.ParameterType = paramType;
if (builder.TypeReader == null)
{
builder.TypeReader = service.GetDefaultTypeReader(paramType)
?? service.GetTypeReaders(paramType)?.FirstOrDefault().Value;
}
}
/// <summary>
/// Converts an object to a type compatible with a given parameter.
/// </summary>
/// <param name="value">The object value to convert.</param>
/// <param name="destinationType">The destination <see cref="Type"/> to which <paramref name="value"/> should be converted.</param>
/// <param name="memberInfo">The parameter for which the <paramref name="value"/> is being converted.</param>
/// <returns>
/// An <see cref="Object"/> of type <paramref name="destinationType"/>, converted using
/// type converters specified on <paramref name="memberInfo"/> if available. If <paramref name="value"/>
/// is <see langword="null"/> then the output will be <see langword="null"/> for reference
/// types and the default value for value types.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Thrown if conversion of the value fails.
/// </exception>
public static object ChangeToCompatibleType(object value, Type destinationType, ParameterInfo memberInfo)
{
TypeConverterAttribute attrib = null;
if (memberInfo != null)
{
attrib = memberInfo.GetCustomAttributes(typeof(TypeConverterAttribute), true).Cast<TypeConverterAttribute>().FirstOrDefault();
}
return ChangeToCompatibleType(value, destinationType, attrib);
}
public static string DescribeParameter(ParameterInfo parameter)
{
var result = string.Empty;
if (parameter.IsOut) result += "out ";
if (parameter.IsRetval) result += "ref ";
if (parameter.GetCustomAttributes(typeof(ParamArrayAttribute), true).Length > 0) result += "params ";
result += DescribeType(parameter.ParameterType);
return result.Trim();
}
public static TemplateDefaultValueAttribute GetFromParameter(ParameterInfo parameter)
{
object[] attributes = parameter.GetCustomAttributes(typeof(TemplateDefaultValueAttribute), true);
if (attributes == null || attributes.Length == 0)
return null;
return (TemplateDefaultValueAttribute)attributes[0];
}
internal void AddRulesForParameterInfo(ParameterInfo parameterInfo)
{
var parameterAttributes = parameterInfo.GetCustomAttributes(RuleAttributeType, true);
for (var parameterRuleIndex = 0; parameterRuleIndex < parameterAttributes.Length; parameterRuleIndex++)
{
var parameterRuleAttribute = (IRuleAttribute)parameterAttributes[parameterRuleIndex];
var parameterRule = parameterRuleAttribute.CreateRule(this);
Rules.Add(parameterRule);
}
}
public ParameterData(ParameterInfo parameterInfo)
{
Type = parameterInfo.ParameterType;
Attribute[] attributes = parameterInfo.GetCustomAttributes(typeof(ServiceKeyAttribute)).ToArray();
if (attributes.Length > 0)
ServiceKey = ((ServiceKeyAttribute)attributes.First()).Key;
InjectableAttribute = parameterInfo.GetCustomAttribute<InjectableAttribute>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterDescriptor" /> class.
/// </summary>
/// <param name="pi">A ParameterInfo taken from reflection.</param>
public ParameterDescriptor(ParameterInfo pi)
{
Name = pi.Name;
Type = pi.ParameterType;
HasDefaultValue = !(pi.DefaultValue.IsDbNull());
DefaultValue = pi.DefaultValue;
IsOut = pi.IsOut;
IsRef = pi.ParameterType.IsByRef;
IsVarArgs = (pi.ParameterType.IsArray && pi.GetCustomAttributes(typeof (ParamArrayAttribute), true).Any());
}
public Consolery.OptionalData GetOptional(ParameterInfo info)
{
if (info.IsOptional)
{
return new Consolery.OptionalData { Default = info.DefaultValue };
}
object[] attributes = info.GetCustomAttributes(typeof(OptionalAttribute), false);
var attribute = (OptionalAttribute)attributes[0];
return new Consolery.OptionalData { AltNames = attribute.AltNames, Default = attribute.Default };
}
public static bool MarkedAuthenticationIgnore(ParameterInfo parameterInfo)
{
var result = parameterInfo.GetCustomAttributes(typeof(AuthenticationIgnoreAttribute), false).Length > 0;
if (false == result) return false;
if (NeverIgnoreParameter(parameterInfo.Name))
throw new ArgumentException(string.Format("Parameter: {0} can not be marked ignore.", parameterInfo.Name));
return true;
}
public ReflectedParameterModel(ParameterInfo parameterInfo)
{
ParameterInfo = parameterInfo;
// CoreCLR returns IEnumerable<Attribute> from GetCustomAttributes - the OfType<object>
// is needed to so that the result of ToList() is List<object>
Attributes = parameterInfo.GetCustomAttributes(inherit: true).OfType<object>().ToList();
ParameterName = parameterInfo.Name;
IsOptional = ParameterInfo.HasDefaultValue;
}
/// <summary>
/// Provide the list of attributes applied to the specified parameter.
/// </summary>
/// <param name="reflectedType">The reflectedType the type used to retrieve the parameterInfo.</param>
/// <param name="parameter">The parameter to supply attributes for.</param>
/// <returns>The list of applied attributes.</returns>
public override IEnumerable <Attribute> GetCustomAttributes(Type reflectedType, System.Reflection.ParameterInfo parameter)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
IEnumerable <Attribute> attributes = parameter.GetCustomAttributes <Attribute>(false);
List <Attribute> cachedAttributes = ReadParameterCustomAttributes(reflectedType, parameter);
return(cachedAttributes == null ? attributes : attributes.Concat(cachedAttributes));
}
/// <summary>
/// Return an IEnumerable providing data for use with the
/// supplied parameter.
/// </summary>
/// <param name="parameter">A ParameterInfo representing one
/// argument to a parameterized test</param>
/// <returns>
/// An IEnumerable providing the required data
/// </returns>
public IEnumerable GetDataFor(ParameterInfo parameter)
{
var data = new List<object>();
foreach (IParameterDataSource source in parameter.GetCustomAttributes(typeof(IParameterDataSource), false))
{
foreach (object item in source.GetData(parameter))
data.Add(item);
}
return data;
}
private static IModelBinder GetModelBinder(ParameterInfo parameter)
{
ModelBinderAttribute[] attrs = parameter.GetCustomAttributes<ModelBinderAttribute>().ToArray();
switch (attrs.Length)
{
case 0:
return null;
case 1:
return attrs[0].GetBinder();
default:
throw Error.MultipleModelBinderAttributes(parameter);
}
}
public string GetMethodParamName(ParameterInfo parameterInfo)
{
var modelNameProvider = parameterInfo.GetCustomAttributes()
.OfType<IModelNameProvider>()
.FirstOrDefault();
if (modelNameProvider == null)
{
return parameterInfo.Name;
}
return modelNameProvider.Name;
}
private object[] GenerateParameterValueSet(ParameterInfo parameterInfo)
{
var valueSet = new List<object>();
foreach (var attribute in parameterInfo.GetCustomAttributes())
{
var valueGenerator = attribute as IValueGeneratorAttribute;
if (valueGenerator != null)
{
valueSet.AddRange(valueGenerator.GenerateValues());
}
}
return valueSet.ToArray();
}
//--- Methods ---
public ReflectedParameterInfo BuildParameter(ParameterInfo parameter) {
var isByRef = parameter.ParameterType.IsByRef;
var type = isByRef ? parameter.ParameterType.GetElementType() : parameter.ParameterType;
var parameterInfo = new ReflectedParameterInfo {
Name = parameter.Name,
ParameterPosition = parameter.Position,
IsOut = parameter.IsOut,
IsRef = !parameter.IsOut && isByRef,
IsParams = parameter.GetCustomAttributes(typeof(ParamArrayAttribute), false).Any(),
Type = BuildType(type)
};
return parameterInfo;
}
public Argument(object target, ParameterInfo mi)
: base(target, mi)
{
_default = null;
_required = true;
_allArguments = Parameter.IsDefined(typeof(AllArgumentsAttribute), true);
foreach (DefaultValueAttribute a in mi.GetCustomAttributes(typeof(DefaultValueAttribute), true))
{
_default = a.Value;
_required = false;
}
foreach (ArgumentAttribute a in mi.GetCustomAttributes(typeof(ArgumentAttribute), true))
{
if (a.HasDefault)
{
_required = false;
_default = a.DefaultValue;
}
}
}
/// <summary>
/// Return an IEnumerable providing data for use with the
/// supplied parameter.
/// </summary>
/// <param name="parameter">A ParameterInfo representing one
/// argument to a parameterized test</param>
/// <returns>
/// An IEnumerable providing the required data
/// </returns>
public IEnumerable GetDataFor(ParameterInfo parameter)
{
ObjectList data = new ObjectList();
foreach (Attribute attr in parameter.GetCustomAttributes(typeof(DataAttribute), false))
{
IParameterDataSource source = attr as IParameterDataSource;
if (source != null)
foreach (object item in source.GetData(parameter))
data.Add(item);
}
return data;
}
public ParameterInfoWrapper(ParameterInfo parameter)
{
Name = parameter.Name;
Type = parameter.ParameterType;
var attributes = parameter.GetCustomAttributes(typeof(CommandParameterAttribute), true);
if (attributes.Length > 0)
{
var commandParameter = (CommandParameterAttribute)attributes.First();
Prototype = commandParameter.Prototype;
Description = Description.GetNewIfValid(commandParameter.Description);
DefaultValue = commandParameter.DefaultValue;
IsRequired = commandParameter.IsRequired;
}
IsValueRequiredWhenOptionIsPresent = parameter.ParameterType != typeof(bool);
}
static Attribute[] InternalParamGetCustomAttributes (ParameterInfo parameter, Type attributeType, bool inherit)
{
if (parameter.Member.MemberType != MemberTypes.Method)
return null;
var method = (MethodInfo) parameter.Member;
var definition = method.GetBaseDefinition ();
if (attributeType == null)
attributeType = typeof (Attribute);
if (method == definition)
return (Attribute []) parameter.GetCustomAttributes (attributeType, inherit);
var types = new List<Type> ();
var custom_attributes = new List<Attribute> ();
while (true) {
var param = method.GetParametersInternal () [parameter.Position];
var param_attributes = (Attribute []) param.GetCustomAttributes (attributeType, false);
foreach (var param_attribute in param_attributes) {
var param_type = param_attribute.GetType ();
if (types.Contains (param_type))
continue;
types.Add (param_type);
custom_attributes.Add (param_attribute);
}
var base_method = method.GetBaseMethod ();
if (base_method == method)
break;
method = base_method;
}
var attributes = (Attribute []) Array.CreateInstance (attributeType, custom_attributes.Count);
custom_attributes.CopyTo (attributes, 0);
return attributes;
}
public static bool TryGetDefaultValue(ParameterInfo parameterInfo, out object value)
{
object defaultValue = parameterInfo.DefaultValue;
if (defaultValue != DBNull.Value)
{
value = defaultValue;
return true;
}
DefaultValueAttribute[] attrs = (DefaultValueAttribute[])parameterInfo.GetCustomAttributes(typeof(DefaultValueAttribute), false);
if (attrs == null || attrs.Length == 0)
{
value = default(object);
return false;
}
else
{
value = attrs[0].Value;
return true;
}
}
public static bool HasAttribute <T>(this ParameterInfo member) where T : Attribute
{
return(member.GetCustomAttributes <T>().Any());
}
public static IEnumerable <Attribute> GetCustomAttributes(this ParameterInfo parameter) => parameter.GetCustomAttributes(false).Cast <Attribute>();
public static Attribute GetCustomAttribute(this ParameterInfo info, Type type)
{
return(info.GetCustomAttributes(type, true)
.Cast <Attribute>()
.FirstOrDefault());
}
