public ForeignKey(CustomAttributeData data) { TableName = (string)data.ConstructorArguments[0].Value; ColumnName = (string)data.ConstructorArguments[1].Value; FullName = TableName + "." + ColumnName; Index = (int)data.ConstructorArguments[2].Value; }
private static string GetCustomAttributeData(CustomAttributeData cad, Type attrType, out Type typeValue, bool allowTypeAlso, bool noArgs, bool zeroArgsAllowed) { string assemblyQualifiedName = null; typeValue = null; if (!(cad.Constructor.ReflectedType == attrType)) { return assemblyQualifiedName; } IList<CustomAttributeTypedArgument> constructorArguments = cad.ConstructorArguments; if ((constructorArguments.Count == 1) && !noArgs) { CustomAttributeTypedArgument argument = constructorArguments[0]; assemblyQualifiedName = argument.Value as string; if (((assemblyQualifiedName == null) && allowTypeAlso) && (argument.ArgumentType == typeof(Type))) { typeValue = argument.Value as Type; assemblyQualifiedName = typeValue.AssemblyQualifiedName; } if (assemblyQualifiedName == null) { throw new ArgumentException(System.Xaml.SR.Get("ParserAttributeArgsLow", new object[] { attrType.Name })); } return assemblyQualifiedName; } if (constructorArguments.Count != 0) { throw new ArgumentException(System.Xaml.SR.Get("ParserAttributeArgsHigh", new object[] { attrType.Name })); } if (!noArgs && !zeroArgsAllowed) { throw new ArgumentException(System.Xaml.SR.Get("ParserAttributeArgsLow", new object[] { attrType.Name })); } return string.Empty; }
public Dictionary<string, object> Convert(string propertyName, CustomAttributeData attr) { var validations = new Dictionary<string, object>(); var minimum = GetConstructorArgumentValue(attr, 0); var maximum = GetConstructorArgumentValue(attr, 1); if (!string.IsNullOrWhiteSpace(minimum) && !string.IsNullOrWhiteSpace(maximum)) { validations.Add("min", minimum); var displayName = base.GetNamedArgumentValue(propertyName, attr, DataAnnotationConstants.Display); if (!string.IsNullOrWhiteSpace(displayName)) { var msg = GetErrorMessage(propertyName, attr); if (msg != null) { validations.Add("min-msg", msg); validations.Add("max-msg", msg); } validations.Add("max", maximum); } } return validations; }
public CommonAttribute GetCommonAttribute(CustomAttributeData customAttributeData) { var positionalArguments = customAttributeData.ConstructorArguments.Select(GetCommonPositionalArgument); var namedArguments = customAttributeData.NamedArguments.AssertNotNull().Select(GetCommonNamedArgument); return new CommonAttribute(GetCommonType(customAttributeData.Constructor.DeclaringType), positionalArguments, namedArguments); }
public static IList<CustomAttributeData> GetCustomAttributes(MemberInfo target) { if (target == null) throw new ArgumentNullException("target"); IList<CustomAttributeData> cad = GetCustomAttributes(target.Module, target.MetadataToken); int pcaCount = 0; Attribute[] a = null; if (target is RuntimeType) a = PseudoCustomAttribute.GetCustomAttributes((RuntimeType)target, typeof(object), false, out pcaCount); else if (target is RuntimeMethodInfo) a = PseudoCustomAttribute.GetCustomAttributes((RuntimeMethodInfo)target, typeof(object), false, out pcaCount); else if (target is RuntimeFieldInfo) a = PseudoCustomAttribute.GetCustomAttributes((RuntimeFieldInfo)target, typeof(object), out pcaCount); if (pcaCount == 0) return cad; CustomAttributeData[] pca = new CustomAttributeData[cad.Count + pcaCount]; cad.CopyTo(pca, pcaCount); for (int i = 0; i < pcaCount; i++) { if (PseudoCustomAttribute.IsSecurityAttribute(a[i].GetType())) continue; pca[i] = new CustomAttributeData(a[i]); } return Array.AsReadOnly(pca); }
public static string Translate(Attribute a, CustomAttributeData d, Type context) { if (a is EcoElementAttribute) return TranslateEcoElementAttribute((EcoElementAttribute)a); else return d.ToString(); }
public string FormatErrorMessage(string propertyName, CustomAttributeData attr) { try { var message = ErrorMessages[attr.AttributeType.Name]; var arguments = new List<object>(); arguments.Add(propertyName); if(attr.AttributeType.Name == "StringLengthAttribute") { arguments.Add(attr.NamedArguments.Where(x => x.MemberName == "MinimumLength").Select(x => x.TypedValue.Value).First()); } arguments.AddRange(attr.ConstructorArguments.Select(x => x.Value).Cast<object>()); return String.Format(message, arguments.ToArray()); } catch (KeyNotFoundException) { try { return String.Format(ErrorMessages["Default"], propertyName); } catch (KeyNotFoundException) { return String.Format("{0} incorrect", propertyName); } } }
/// <summary> /// This methods creates an attribute instance from the attribute data /// information /// </summary> /// <param name="data"></param> /// <returns></returns> private static Attribute CreateAttribute(CustomAttributeData data) { var arguments = from arg in data.ConstructorArguments select arg.Value; var attribute = data.Constructor.Invoke(arguments.ToArray()) as Attribute; if (data.NamedArguments != null) { foreach (var namedArgument in data.NamedArguments) { var propertyInfo = namedArgument.MemberInfo as PropertyInfo; if (propertyInfo != null) { propertyInfo.SetValue(attribute, namedArgument.TypedValue.Value, null); } else { var fieldInfo = namedArgument.MemberInfo as FieldInfo; if (fieldInfo != null) { fieldInfo.SetValue(attribute, namedArgument.TypedValue.Value); } } } } return attribute; }
public static void CustomAttributeData_NamedArguments(CustomAttributeData customAttributeData) { String attributeTypeName = customAttributeData.AttributeTypeNameString(); if (attributeTypeName == null) return; ReflectionEventSource.Log.CustomAttributeData_NamedArguments(attributeTypeName); }
public Dictionary<string, object> Convert(string propertyName, CustomAttributeData attr) { var validations = new Dictionary<string, object>(); var length = GetConstructorArgumentValue(attr, 0); return SetMinLengthAAValidation(propertyName, attr, length); }
public static bool IsSamplePageByCategory(this Page self, CustomAttributeData attr, string category) { if(attr == null) { throw new ArgumentNullException("attr"); } return attr.NamedArguments.Any(arg => attr.AttributeType == typeof(SamplePageAttribute) && arg.MemberName == "Category" && arg.TypedValue.Value.ToString() == category); }
public Dictionary<string, object> Convert(string propertyName, CustomAttributeData attr) { var pattern = GetConstructorArgumentValue(attr, 0); if (!string.IsNullOrWhiteSpace(pattern)) { return SetRegularExpressionAAValidation(propertyName, attr, pattern); } return new Dictionary<string, object>(); }
public CustomAttributeInfo(CustomAttributeData data) { attributeType = new QualifiedTypeNameInfo(data.Constructor.DeclaringType); constructorArguments = data.Constructor.GetParameters().OrderBy(p => p.Position).Select(p => new KeyValuePair<QualifiedTypeNameInfo, object>(new QualifiedTypeNameInfo(p.ParameterType), GetSimpleValue(data.ConstructorArguments[p.Position].Value))).ToArray(); if (data.NamedArguments == null) { namedArguments = new KeyValuePair<TypeMemberInfo, object>[0]; } else { namedArguments = data.NamedArguments.Select(argument => new KeyValuePair<TypeMemberInfo, object>(new TypeMemberInfo(argument.MemberInfo), GetSimpleValue(argument.TypedValue.Value))).ToArray(); } }
public FileInstallStep(IManifest manifest, CustomAttributeData rawData) : base(manifest, rawData) { //[assembly: InstallFile(RepositoryPath = "/Root/Test/asdf.css", ResourcePath = "/res.asdf.css")] var repositoryPath = GetParameterValue<string>("RepositoryPath"); var contentName = ContentManager.Path.GetFileName(repositoryPath); var containerPath = ContentManager.Path.GetParentPath(repositoryPath); ContainerPath = containerPath; ContentName = contentName; RawAttachments = "Binary:" + ResourceName; }
public static string Translate(Attribute a, CustomAttributeData d, FieldInfo context) { var ecoAttr = a as EcoFieldAttribute; if (ecoAttr != null && !ecoAttr.ApplyToGeneratedClass) return null; if (a is KnownTypesAttribute) return TranslateKnownTypesAttribute((KnownTypesAttribute)a); else if (a is DefaultAttribute) return TranslateDefaultAttribute((DefaultAttribute)a); else return d.ToString(); }
internal static object GetRawConstant(CustomAttributeData attr) { foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments) { if (namedArgument.MemberInfo.Name.Equals("Value")) return namedArgument.TypedValue.Value; } // Return DBNull to indicate that no default value is available. // Not to be confused with a null return which indicates a null default value. return DBNull.Value; }
public static TagBuilder GetRequiredSpan(CustomAttributeData cs, MemberInfo member) { CustomAttributeNamedArgument namedArg = cs.NamedArguments.Where(p => p.MemberName == "ErrorMessage").First(); string errorMsg = string.Empty; if (namedArg != null) errorMsg = namedArg.TypedValue.Value.ToString(); else errorMsg = "Please enter " + member.Name.ToLower(); return GetSpan(errorMsg, member.Name.ToLower(), "required"); }
public string FormatErrorMessage(string propertyName, CustomAttributeData attr) { string value = null; if (attr.NamedArguments != null && attr.NamedArguments.Count > 0) { var namedArg = attr.NamedArguments.FirstOrDefault(na => na.MemberName == NameOfArgument); if (namedArg != null && namedArg.TypedValue != null && namedArg.TypedValue.Value != null) { value = namedArg.TypedValue.Value.ToString(); } } return value; }
internal static DateTime GetRawDateTimeConstant(CustomAttributeData attr) { Contract.Requires(attr.Constructor.DeclaringType == typeof(DateTimeConstantAttribute)); Contract.Requires(attr.ConstructorArguments.Count == 1); foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments) { if (namedArgument.MemberInfo.Name.Equals("Value")) { return new DateTime((long)namedArgument.TypedValue.Value); } } // Look at the ctor argument if the "Value" property was not explicitly defined. return new DateTime((long)attr.ConstructorArguments[0].Value); }
private XElement fillPropElementJSON(System.Reflection.PropertyInfo prop, System.Reflection.CustomAttributeData attrib, Type classType) { string name, alias; GetNameAndAlias(attrib, prop.Name, out name, out alias); var propElement = new XElement(name); propElement.Add(new XElement("name", name)); propElement.Add(new XElement("name_en", alias)); var access = findAccess(attrib, prop); AppendXmlDocsJSON(propElement, "P:" + classType.FullName + "." + prop.Name); buildAccessProperty(access["canRead"], access["canWrite"], propElement); return(propElement); }
public static TypeInfo GetType(Assembly asm, Func<CustomAttributeData, bool> match, out CustomAttributeData matchingAttributeData) { matchingAttributeData = null; foreach (var type in asm.DefinedTypes) { foreach (var attribute in type.CustomAttributes) { if (match(attribute)) { matchingAttributeData = attribute; return type; } } } return null; }
public Dictionary<string, object> Convert(string propertyName, CustomAttributeData attr) { var validations = new Dictionary<string, object>(); validations.Add("required", true); var displayName = GetNamedArgumentValue(propertyName, attr, DataAnnotationConstants.Display); if (!string.IsNullOrWhiteSpace(displayName)) { var msg = GetErrorMessage(propertyName, attr); if (msg != null) { validations.Add("required-msg", msg); } } return validations; }
public TestFixture(TypeInfo testType, CustomAttributeData testFixtureAttribute) { Type = testType; Tests = new List<Test>(); // Tesztesetek meghatározása foreach (var method in TestHelper.GetMethods(Type, attribute => attribute.AttributeType.FullName == TestAttributes.Test)) { Tests.Add(new Test(this, method)); } TestFixtureAttribute = testFixtureAttribute; Instance = TestHelper.CreateTestFixture(Type.AsType(), testFixtureAttribute); FindSetUpFixture(out _setUpFixture, out _setUpMethod); FindTearDownFixture(out _tearDownFixture, out _tearDownMethod); }
public CustomAttributeData(System.Reflection.CustomAttributeData data) { var dataDynamic = data as dynamic; this.AttributeType = dataDynamic.AttributeType.FullName; this.ConstructorArguments = new List <CustomAttributeTypedArgument>(); this.NamedArguments = new List <CustomAttributeNamedArgument>(); foreach (var arg in ((IList <System.Reflection.CustomAttributeTypedArgument>)dataDynamic.ConstructorArguments)) { this.ConstructorArguments.Add(new CustomAttributeTypedArgument(arg)); } foreach (var arg in ((IList <System.Reflection.CustomAttributeNamedArgument>)dataDynamic.NamedArguments)) { this.NamedArguments.Add(new CustomAttributeNamedArgument(arg)); } }
private XElement fillPropElement(System.Reflection.PropertyInfo prop, System.Reflection.CustomAttributeData attrib, Type classType) { var propElement = new XElement("property"); string name, alias; GetNameAndAlias(attrib, prop.Name, out name, out alias); propElement.Add(new XAttribute("clr-name", classType.FullName + "." + prop.Name)); propElement.Add(new XElement("name", name)); propElement.Add(new XElement("alias", alias)); var access = findAccess(attrib, prop); propElement.Add(new XElement("readable", access["canRead"])); propElement.Add(new XElement("writeable", access["canWrite"])); AppendXmlDocs(propElement, "P:" + classType.FullName + "." + prop.Name); return(propElement); }
internal static Decimal GetRawDecimalConstant(CustomAttributeData attr) { Contract.Requires(attr.Constructor.DeclaringType == typeof(DecimalConstantAttribute)); foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments) { if (namedArgument.MemberInfo.Name.Equals("Value")) { // This is not possible because Decimal cannot be represented directly in the metadata. Contract.Assert(false, "Decimal cannot be represented directly in the metadata."); return (Decimal)namedArgument.TypedValue.Value; } } ParameterInfo[] parameters = attr.Constructor.GetParameters(); Contract.Assert(parameters.Length == 5); System.Collections.Generic.IList<CustomAttributeTypedArgument> args = attr.ConstructorArguments; Contract.Assert(args.Count == 5); if (parameters[2].ParameterType == typeof(uint)) { // DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low) int low = (int)(UInt32)args[4].Value; int mid = (int)(UInt32)args[3].Value; int hi = (int)(UInt32)args[2].Value; byte sign = (byte)args[1].Value; byte scale = (byte)args[0].Value; return new System.Decimal(low, mid, hi, (sign != 0), scale); } else { // DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low) int low = (int)args[4].Value; int mid = (int)args[3].Value; int hi = (int)args[2].Value; byte sign = (byte)args[1].Value; byte scale = (byte)args[0].Value; return new System.Decimal(low, mid, hi, (sign != 0), scale); } }
static private void AppendCustomAttributeData(CustomAttributeData attribute, StringBuilder sb) { sb.Append("["); AppendType(attribute.Constructor.DeclaringType, sb); sb.Append("("); foreach (var positionalArgument in attribute.ConstructorArguments) { AppendValue(positionalArgument.Value, sb, false); AppendComma(sb); } foreach (var namedArgument in attribute.NamedArguments) { sb.Append(namedArgument.MemberInfo.Name); AppendValue(namedArgument.TypedValue.Value, sb); AppendComma(sb); } RemoveTrailingComma(sb); sb.Append(")]"); }
public Dictionary<string, object> Convert(string propertyName, CustomAttributeData attr) { var validations = new Dictionary<string, object>(); var maxLength = GetConstructorArgumentValue(attr, 0); if (!string.IsNullOrWhiteSpace(maxLength)) { var maxValidations = SetMaxLengthAAValidation(propertyName, attr, maxLength); validations = validations.Concat(maxValidations).ToDictionary(x => x.Key, x => x.Value); } var minLength = base.GetNamedArgumentValue(propertyName, attr, DataAnnotationConstants.MinimumLength, false); if (!string.IsNullOrWhiteSpace(minLength)) { var minValidations = SetMinLengthAAValidation(propertyName, attr, minLength); validations = validations.Concat(minValidations).ToDictionary(x => x.Key, x => x.Value); } return validations; }
private XElement GenerateAttributeReference(CustomAttributeData attribute) { var attributeElement = new XElement ( "HasAttribute", new XAttribute ("ref", _attributeIdentifierGenerator.GetIdentifier (attribute.Constructor.DeclaringType))); for (int i = 0; i < attribute.ConstructorArguments.Count; i++) { var constructorArgument = attribute.ConstructorArguments[i]; var parameterName = attribute.Constructor.GetParameters()[i].Name; attributeElement.Add (GenerateParameterElement ("constructor", constructorArgument.ArgumentType, parameterName, constructorArgument.Value)); } foreach (var namedArgument in attribute.NamedArguments) { attributeElement.Add ( GenerateParameterElement ("named", namedArgument.TypedValue.ArgumentType, namedArgument.MemberInfo.Name, namedArgument.TypedValue.Value)); } return attributeElement; }
[System.Security.SecuritySafeCritical] // auto-generated internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeType target) { Contract.Assert(target != null); IList<CustomAttributeData> cad = GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken); int pcaCount = 0; Attribute[] a = PseudoCustomAttribute.GetCustomAttributes((RuntimeType)target, typeof(object) as RuntimeType, true, out pcaCount); if (pcaCount == 0) return cad; CustomAttributeData[] pca = new CustomAttributeData[cad.Count + pcaCount]; cad.CopyTo(pca, pcaCount); for (int i = 0; i < pcaCount; i++) { pca[i] = new CustomAttributeData(a[i]); } return Array.AsReadOnly(pca); }
public AttributeDetail(RootDetail parent, CustomAttributeData cad) : base(parent, cad.Constructor.DeclaringType.FullName) { _declaration = cad.ToString(); CodeStringBuilder csb = new CodeStringBuilder(); AppendAttributesDeclaration(csb); csb.AppendType(cad.Constructor.DeclaringType); if (cad.ConstructorArguments.Count > 0) { csb.AppendText("("); csb.AppendQuotedValue(cad.ConstructorArguments[0].Value); csb.AppendText(")"); } _declaration = csb.ToString(); _declarationHtml = csb.ToHtmlString(); }
private Dictionary <string, bool?> findAccess(System.Reflection.CustomAttributeData attrib, System.Reflection.PropertyInfo prop) { bool?canRead = null; bool?canWrite = null; if (attrib.NamedArguments != null) { foreach (var attributeNamedArgument in attrib.NamedArguments) { if (attributeNamedArgument.MemberName == "CanRead") { canRead = (bool)attributeNamedArgument.TypedValue.Value; } if (attributeNamedArgument.MemberName == "CanWrite") { canWrite = (bool)attributeNamedArgument.TypedValue.Value; } } } if (canRead == null) { canRead = prop.GetMethod != null; } if (canWrite == null) { canWrite = prop.SetMethod != null; } var result = new Dictionary <string, bool?>(); result.Add("canRead", canRead); result.Add("canWrite", canWrite); return(result); }
private static IList<CustomAttributeData> GetCustomAttributes(Module module, int tkTarget) { CustomAttributeRecord[] customAttributeRecords = GetCustomAttributeRecords(module, tkTarget); CustomAttributeData[] array = new CustomAttributeData[customAttributeRecords.Length]; for (int i = 0; i < customAttributeRecords.Length; i++) { array[i] = new CustomAttributeData(module, customAttributeRecords[i]); } return Array.AsReadOnly<CustomAttributeData>(array); }
public static IList<CustomAttributeData> GetCustomAttributes(ParameterInfo target) { if (target == null) { throw new ArgumentNullException("target"); } IList<CustomAttributeData> customAttributes = GetCustomAttributes(target.Member.Module, target.MetadataToken); int count = 0; Attribute[] attributeArray = PseudoCustomAttribute.GetCustomAttributes(target, typeof(object), out count); if (count == 0) { return customAttributes; } CustomAttributeData[] array = new CustomAttributeData[customAttributes.Count + count]; customAttributes.CopyTo(array, count); for (int i = 0; i < count; i++) { array[i] = new CustomAttributeData(attributeArray[i]); } return Array.AsReadOnly<CustomAttributeData>(array); }
public override IList <CustomAttributeData> GetCustomAttributesData() { return(CustomAttributeData.GetCustomAttributes(this)); }
public virtual IList <CustomAttributeData> GetCustomAttributesData() { return(CustomAttributeData.GetCustomAttributes(this)); }
internal CustomAttributeData(ConstructorInfo ctorInfo, object[] ctorArgs, object[] namedArgs) { this.ctorInfo = ctorInfo; this.ctorArgs = Array.AsReadOnly <CustomAttributeTypedArgument>((ctorArgs == null) ? new CustomAttributeTypedArgument[0] : CustomAttributeData.UnboxValues <CustomAttributeTypedArgument>(ctorArgs)); this.namedArgs = Array.AsReadOnly <CustomAttributeNamedArgument>((namedArgs == null) ? new CustomAttributeNamedArgument[0] : CustomAttributeData.UnboxValues <CustomAttributeNamedArgument>(namedArgs)); }
// returns DBNull.Value if the parameter doesn't have a default value private Object GetDefaultValueInternal(bool raw) { Debug.Assert(!m_noMetadata); if (m_noDefaultValue) { return(DBNull.Value); } object defaultValue = null; // Why check the parameter type only for DateTime and only for the ctor arguments? // No check on the parameter type is done for named args and for Decimal. // We should move this after MdToken.IsNullToken(m_tkParamDef) and combine it // with the other custom attribute logic. But will that be a breaking change? // For a DateTime parameter on which both an md constant and a ca constant are set, // which one should win? if (ParameterType == typeof(DateTime)) { if (raw) { CustomAttributeTypedArgument value = CustomAttributeData.Filter( CustomAttributeData.GetCustomAttributes(this), typeof(DateTimeConstantAttribute), 0); if (value.ArgumentType != null) { return(new DateTime((long)value.Value)); } } else { object[] dt = GetCustomAttributes(typeof(DateTimeConstantAttribute), false); if (dt != null && dt.Length != 0) { return(((DateTimeConstantAttribute)dt[0]).Value); } } } #region Look for a default value in metadata if (!MdToken.IsNullToken(m_tkParamDef)) { // This will return DBNull.Value if no constant value is defined on m_tkParamDef in the metadata. defaultValue = MdConstant.GetValue(m_scope, m_tkParamDef, ParameterType.GetTypeHandleInternal(), raw); } #endregion if (defaultValue == DBNull.Value) { #region Look for a default value in the custom attributes if (raw) { foreach (CustomAttributeData attr in CustomAttributeData.GetCustomAttributes(this)) { Type attrType = attr.Constructor.DeclaringType; if (attrType == typeof(DateTimeConstantAttribute)) { defaultValue = DateTimeConstantAttribute.GetRawDateTimeConstant(attr); } else if (attrType == typeof(DecimalConstantAttribute)) { defaultValue = DecimalConstantAttribute.GetRawDecimalConstant(attr); } else if (attrType.IsSubclassOf(s_CustomConstantAttributeType)) { defaultValue = CustomConstantAttribute.GetRawConstant(attr); } } } else { Object[] CustomAttrs = GetCustomAttributes(s_CustomConstantAttributeType, false); if (CustomAttrs.Length != 0) { defaultValue = ((CustomConstantAttribute)CustomAttrs[0]).Value; } else { CustomAttrs = GetCustomAttributes(s_DecimalConstantAttributeType, false); if (CustomAttrs.Length != 0) { defaultValue = ((DecimalConstantAttribute)CustomAttrs[0]).Value; } } } #endregion } if (defaultValue == DBNull.Value) { m_noDefaultValue = true; } return(defaultValue); }
internal static unsafe object[] GetCustomAttributes(Module decoratedModule, int decoratedMetadataToken, int pcaCount, RuntimeType attributeFilterType, bool mustBeInheritable, IList derivedAttributes) { if (decoratedModule.Assembly.ReflectionOnly) { throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyCA")); } MetadataImport metadataImport = decoratedModule.MetadataImport; CustomAttributeRecord[] customAttributeRecords = CustomAttributeData.GetCustomAttributeRecords(decoratedModule, decoratedMetadataToken); Type elementType = (((attributeFilterType == null) || attributeFilterType.IsValueType) || attributeFilterType.ContainsGenericParameters) ? typeof(object) : attributeFilterType; if ((attributeFilterType == null) && (customAttributeRecords.Length == 0)) { return(Array.CreateInstance(elementType, 0) as object[]); } object[] attributes = Array.CreateInstance(elementType, customAttributeRecords.Length) as object[]; int length = 0; SecurityContextFrame frame = new SecurityContextFrame(); frame.Push(decoratedModule.Assembly.InternalAssembly); Assembly lastAptcaOkAssembly = null; for (int i = 0; i < customAttributeRecords.Length; i++) { bool flag2; bool flag3; object obj2 = null; CustomAttributeRecord caRecord = customAttributeRecords[i]; RuntimeMethodHandle ctor = new RuntimeMethodHandle(); RuntimeType attributeType = null; int namedArgs = 0; IntPtr signature = caRecord.blob.Signature; IntPtr blobEnd = (IntPtr)(((void *)signature) + caRecord.blob.Length); if (FilterCustomAttributeRecord(caRecord, metadataImport, ref lastAptcaOkAssembly, decoratedModule, decoratedMetadataToken, attributeFilterType, mustBeInheritable, attributes, derivedAttributes, out attributeType, out ctor, out flag2, out flag3)) { if (!ctor.IsNullHandle()) { ctor.CheckLinktimeDemands(decoratedModule, decoratedMetadataToken); } RuntimeConstructorInfo.CheckCanCreateInstance(attributeType, flag3); if (flag2) { obj2 = CreateCaObject(decoratedModule, ctor, ref signature, blobEnd, out namedArgs); } else { obj2 = attributeType.TypeHandle.CreateCaInstance(ctor); if (Marshal.ReadInt16(signature) != 1) { throw new CustomAttributeFormatException(); } signature = (IntPtr)(((void *)signature) + 2); namedArgs = Marshal.ReadInt16(signature); signature = (IntPtr)(((void *)signature) + 2); } for (int j = 0; j < namedArgs; j++) { string str; bool flag4; Type type3; object obj3; IntPtr ptr1 = caRecord.blob.Signature; GetPropertyOrFieldData(decoratedModule, ref signature, blobEnd, out str, out flag4, out type3, out obj3); try { if (flag4) { if ((type3 == null) && (obj3 != null)) { type3 = (obj3.GetType() == typeof(RuntimeType)) ? typeof(Type) : obj3.GetType(); } RuntimePropertyInfo property = null; if (type3 == null) { property = attributeType.GetProperty(str) as RuntimePropertyInfo; } else { property = attributeType.GetProperty(str, type3, Type.EmptyTypes) as RuntimePropertyInfo; } RuntimeMethodInfo setMethod = property.GetSetMethod(true) as RuntimeMethodInfo; if (setMethod.IsPublic) { setMethod.MethodHandle.CheckLinktimeDemands(decoratedModule, decoratedMetadataToken); setMethod.Invoke(obj2, BindingFlags.Default, null, new object[] { obj3 }, null, true); } } else { (attributeType.GetField(str) as RtFieldInfo).InternalSetValue(obj2, obj3, BindingFlags.Default, Type.DefaultBinder, null, false); } } catch (Exception exception) { throw new CustomAttributeFormatException(string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString(flag4 ? "RFLCT.InvalidPropFail" : "RFLCT.InvalidFieldFail"), new object[] { str }), exception); } } if (!signature.Equals(blobEnd)) { throw new CustomAttributeFormatException(); } attributes[length++] = obj2; } } frame.Pop(); if ((length == customAttributeRecords.Length) && (pcaCount == 0)) { return(attributes); } if (length == 0) { Array.CreateInstance(elementType, 0); } object[] destinationArray = Array.CreateInstance(elementType, (int)(length + pcaCount)) as object[]; Array.Copy(attributes, 0, destinationArray, 0, length); return(destinationArray); }
public void Intercept(IInvocation invocation) { ServiceRquestInfo rquestInfo = new ServiceRquestInfo(); IList <System.Reflection.CustomAttributeData> customAttributeDatas = invocation.Method.GetCustomAttributesData(); for (int j = 0; j < customAttributeDatas.Count; j++) { System.Reflection.CustomAttributeData customAttribute = customAttributeDatas[j]; if (customAttribute.AttributeType == typeof(POSTAttribute)) { rquestInfo.HttpMethod = HttpMethod.Post; if (customAttribute.ConstructorArguments[0].Value is string) { rquestInfo.Url = customAttribute.ConstructorArguments[0].Value as string; } } else if (customAttribute.AttributeType == typeof(GETAttribute)) { rquestInfo.HttpMethod = HttpMethod.Get; if (customAttribute.ConstructorArguments[0].Value is string) { rquestInfo.Url = customAttribute.ConstructorArguments[0].Value as string; } } else if (customAttribute.AttributeType == typeof(HeaderAttribute)) { if (customAttribute.ConstructorArguments[0].Value is string) { rquestInfo.Header.Add(customAttribute.ConstructorArguments[0].Value as string); } } else if (customAttribute.AttributeType == typeof(UploadFileAttribute)) { rquestInfo.IsUploadFile = true; } } if (invocation.Arguments.Count() > 0)//这个请求方法有传参 { //获取参数 ParameterInfo[] parameterInfos = invocation.Method.GetParameters(); for (int j = 0; j < parameterInfos.Length; j++) { ParameterInfo parameter = parameterInfos[j]; IEnumerable <Attribute> attributes = parameter.GetCustomAttributes(); if (attributes.Count() == 0)//这个参数没有使用我们的特性,过滤掉这个参数值 { continue; } string paramName = parameter.Name; //参数原始名字 object paramValue = invocation.Arguments[j]; //参数值 for (int z = 0; z < attributes.Count(); z++) { Attribute a = attributes.ElementAt(z); //Query属性 if (a is QueryAttribute) { if (!(paramValue is string)) { throw new Exception("Query的请求非String"); } QueryAttribute query = a as QueryAttribute; string cfgParamName = query.ParamName; //在自定义特性中定义的属性名 if (string.IsNullOrEmpty(cfgParamName)) //如果没有配置Query的参数名,默认使用参数的㡳名称 { rquestInfo.Param.Add(paramName, paramValue as string); } else { rquestInfo.Param.Add(cfgParamName, paramValue as string); } } else if (a is BodyAttribute) { BodyAttribute body = a as BodyAttribute; //将这个参数序列化成json string json = Newtonsoft.Json.JsonConvert.SerializeObject(paramValue); rquestInfo.Body = json; } else if (a is DynamicHeaderAttribute) { DynamicHeaderAttribute dynamicHeader = a as DynamicHeaderAttribute; string headername = dynamicHeader.Header; if (string.IsNullOrEmpty(headername))//如果没有配置Header的参数名,默认使用参数的㡳名称 { rquestInfo.Header.Add(paramName + ":" + paramValue); } else { rquestInfo.Header.Add(headername + ":" + paramValue); } } else if (a is FilePathAttribute) { rquestInfo.FilePath = paramValue as string; } } } } Console.WriteLine("拦截了"); Call call = new Call(); call.RquestInfo = rquestInfo; call.Msg = "测试"; call.Client = RetrofitClientCache.Instance.GetClient(invocation.Proxy.GetHashCode()); invocation.ReturnValue = call; //不用实现方法 //invocation.Proceed(); }
internal static IList <CustomAttributeData> GetCustomAttributesData(ICustomAttributeProvider obj, Type attributeType, bool inherit) { if (obj == null) { throw new ArgumentNullException(nameof(obj)); } if (attributeType == null) { throw new ArgumentNullException(nameof(attributeType)); } if (attributeType == typeof(CustomAttribute)) { attributeType = null; } const string Message = "Invalid custom attribute data format"; IList <CustomAttributeData> r; IList <CustomAttributeData> res = GetCustomAttributesDataBase(obj, attributeType, false); // shortcut if (!inherit && res.Count == 1) { if (res[0] == null) { throw new CustomAttributeFormatException(Message); } if (attributeType != null) { if (attributeType.IsAssignableFrom(res[0].AttributeType)) { r = new CustomAttributeData[] { res[0] } } ; else { r = Array.Empty <CustomAttributeData>(); } } else { r = new CustomAttributeData[] { res[0] }; } return(r); } if (inherit && GetBase(obj) == null) { inherit = false; } // if AttributeType is sealed, and Inherited is set to false, then // there's no use in scanning base types if ((attributeType != null && attributeType.IsSealed) && inherit) { AttributeUsageAttribute?usageAttribute = RetrieveAttributeUsage(attributeType); if (!usageAttribute.Inherited) { inherit = false; } } int initialSize = Math.Max(res.Count, 16); List <CustomAttributeData> a = null; ICustomAttributeProvider btype = obj; /* Non-inherit case */ if (!inherit) { if (attributeType == null) { foreach (CustomAttributeData attrData in res) { if (attrData == null) { throw new CustomAttributeFormatException(Message); } } var result = new CustomAttributeData[res.Count]; res.CopyTo(result, 0); return(result); } else { a = new List <CustomAttributeData>(initialSize); foreach (CustomAttributeData attrData in res) { if (attrData == null) { throw new CustomAttributeFormatException(Message); } if (!attributeType.IsAssignableFrom(attrData.AttributeType)) { continue; } a.Add(attrData); } return(a.ToArray()); } } /* Inherit case */ var attributeInfos = new Dictionary <Type, AttributeInfo>(initialSize); int inheritanceLevel = 0; a = new List <CustomAttributeData>(initialSize); do { foreach (CustomAttributeData attrData in res) { AttributeUsageAttribute usage; if (attrData == null) { throw new CustomAttributeFormatException(Message); } Type attrType = attrData.AttributeType; if (attributeType != null) { if (!attributeType.IsAssignableFrom(attrType)) { continue; } } AttributeInfo firstAttribute; if (attributeInfos.TryGetValue(attrType, out firstAttribute)) { usage = firstAttribute.Usage; } else { usage = RetrieveAttributeUsage(attrType); } // The same as for CustomAttributes. // // Only add attribute to the list of attributes if // - we are on the first inheritance level, or the attribute can be inherited anyway // and ( // - multiple attributes of the type are allowed // or ( // - this is the first attribute we've discovered // or // - the attribute is on same inheritance level than the first // attribute that was discovered for this attribute type )) if ((inheritanceLevel == 0 || usage.Inherited) && (usage.AllowMultiple || (firstAttribute == null || (firstAttribute != null && firstAttribute.InheritanceLevel == inheritanceLevel)))) { a.Add(attrData); } if (firstAttribute == null) { attributeInfos.Add(attrType, new AttributeInfo(usage, inheritanceLevel)); } } if ((btype = GetBase(btype)) != null) { inheritanceLevel++; res = GetCustomAttributesDataBase(btype, attributeType, true); } } while (inherit && btype != null); return(a.ToArray()); }
private object GetDefaultValueInternal(bool raw) { if (this.m_noDefaultValue) { return((object)DBNull.Value); } object obj = (object)null; if (this.ParameterType == typeof(DateTime)) { if (raw) { CustomAttributeTypedArgument attributeTypedArgument = CustomAttributeData.Filter(CustomAttributeData.GetCustomAttributes((ParameterInfo)this), typeof(DateTimeConstantAttribute), 0); if (attributeTypedArgument.ArgumentType != (Type)null) { return((object)new DateTime((long)attributeTypedArgument.Value)); } } else { object[] customAttributes = this.GetCustomAttributes(typeof(DateTimeConstantAttribute), false); if (customAttributes != null && customAttributes.Length != 0) { return(((CustomConstantAttribute)customAttributes[0]).Value); } } } if (!System.Reflection.MetadataToken.IsNullToken(this.m_tkParamDef)) { obj = MdConstant.GetValue(this.m_scope, this.m_tkParamDef, this.ParameterType.GetTypeHandleInternal(), raw); } if (obj == DBNull.Value) { if (raw) { foreach (CustomAttributeData customAttribute in (IEnumerable <CustomAttributeData>)CustomAttributeData.GetCustomAttributes((ParameterInfo)this)) { Type declaringType = customAttribute.Constructor.DeclaringType; if (declaringType == typeof(DateTimeConstantAttribute)) { obj = (object)DateTimeConstantAttribute.GetRawDateTimeConstant(customAttribute); } else if (declaringType == typeof(DecimalConstantAttribute)) { obj = (object)DecimalConstantAttribute.GetRawDecimalConstant(customAttribute); } else if (declaringType.IsSubclassOf(RuntimeParameterInfo.s_CustomConstantAttributeType)) { obj = CustomConstantAttribute.GetRawConstant(customAttribute); } } } else { object[] customAttributes1 = this.GetCustomAttributes(RuntimeParameterInfo.s_CustomConstantAttributeType, false); if (customAttributes1.Length != 0) { obj = ((CustomConstantAttribute)customAttributes1[0]).Value; } else { object[] customAttributes2 = this.GetCustomAttributes(RuntimeParameterInfo.s_DecimalConstantAttributeType, false); if (customAttributes2.Length != 0) { obj = (object)((DecimalConstantAttribute)customAttributes2[0]).Value; } } } } if (obj == DBNull.Value) { this.m_noDefaultValue = true; } return(obj); }