C# FieldBuilder.SetCustomAttribute方法代码示例

 public static void SetCustomAttributes(FieldBuilder fb, IPersistentMap attributes)
 {
     for (ISeq s = RT.seq(attributes); s != null; s = s.next())
         fb.SetCustomAttribute(CreateCustomAttributeBuilder((IMapEntry)(s.first())));
 }

            private static void MarkAsNotSerializable(FieldBuilder field)
            {
                var emptyArray = new object[0];

                field.SetCustomAttribute(new CustomAttributeBuilder(_nonSerializedAttributeConstructor, emptyArray));

                if (field.IsPublic)
                {
                    field.SetCustomAttribute(new CustomAttributeBuilder(_ignoreDataMemberAttributeConstructor, emptyArray));
                    field.SetCustomAttribute(new CustomAttributeBuilder(_xmlIgnoreAttributeConstructor, emptyArray));

                    if (_scriptIgnoreAttributeConstructor != null)
                    {
                        field.SetCustomAttribute(new CustomAttributeBuilder(_scriptIgnoreAttributeConstructor, emptyArray));
                    }
                }
            }

		internal static void DefineCustomAttributes(PhpMemberAttributes attrs, FieldBuilder/*!*/ fieldBuilder)
		{
			Debug.Assert(fieldBuilder != null);

			// AppStatic == Static on Silverlight
#if !SILVERLIGHT
			// static but not app-static => thread static
			if ((attrs & PhpMemberAttributes.AppStatic) == PhpMemberAttributes.Static)
				fieldBuilder.SetCustomAttribute(AttributeBuilders.ThreadStatic);
#endif
		}

		public void EmitAttribute (FieldBuilder builder, TypeSpec type)
		{
			if (ResolveTransformationCtor ()) {
				var cab = new CustomAttributeBuilder ((ConstructorInfo) tctor.GetMetaInfo (), new object[] { GetTransformationFlags (type) });
				builder.SetCustomAttribute (cab);
			}
		}

		public void EmitAttribute (FieldBuilder builder)
		{
			if (ResolveBuilder ())
				builder.SetCustomAttribute (cab);
		}

 public static void SetCustomAttributes(FieldBuilder fb, IPersistentMap attributes)
 {
     foreach (CustomAttributeBuilder cab in CreateCustomAttributeBuilders(attributes))
         fb.SetCustomAttribute(cab);
 }

 private void EmitCustomAttributes(FieldBuilder fieldBuilder, IEnumerable<Cci.ICustomAttribute> attributes)
 {
     foreach (var attribute in attributes)
     {
         fieldBuilder.SetCustomAttribute(CreateCustomAttributeBuilder(attribute));
     }
 }

 private void DefinePosition()
 {
     var ctor = typeof(VaryingAttribute).GetConstructor(new[] { typeof(UsageSemantic) });
     var positionOutAttrib = new CustomAttributeBuilder(ctor, new object[] { UsageSemantic.Position0 });
     _position = _type.DefineField("position", typeof(ShaderDefinition.vec4), FieldAttributes.Public);
     _position.SetCustomAttribute(positionOutAttrib);
 }

 private void add_possible_type_attribute(FieldBuilder fb, ITypeNode type)
 {
     if (comp_opt.target != TargetType.Dll)
         return;
     if (type.type_special_kind == type_special_kind.typed_file)
     {
         Type elem_type = helper.GetTypeReference(type.element_type).tp;
         CustomAttributeBuilder cust_bldr = null;
         if (type.element_type is ICompiledTypeNode || type.element_type is IRefTypeNode && (type.element_type as IRefTypeNode).pointed_type is ICompiledTypeNode)
             cust_bldr = new CustomAttributeBuilder(this.FileOfAttributeConstructor, new object[1] { elem_type });
         else
             cust_bldr = new CustomAttributeBuilder(this.FileOfAttributeConstructor, new object[1] { elem_type.FullName });
         fb.SetCustomAttribute(cust_bldr);
     }
     else if (type.type_special_kind == type_special_kind.set_type)
     {
         Type elem_type = helper.GetTypeReference(type.element_type).tp;
         CustomAttributeBuilder cust_bldr = null;
         if (type.element_type is ICompiledTypeNode || type.element_type is IRefTypeNode && (type.element_type as IRefTypeNode).pointed_type is ICompiledTypeNode)
             cust_bldr = new CustomAttributeBuilder(this.SetOfAttributeConstructor, new object[1] { elem_type });
         else
             cust_bldr = new CustomAttributeBuilder(this.SetOfAttributeConstructor, new object[1] { elem_type.FullName });
         fb.SetCustomAttribute(cust_bldr);
     }
     else if (type.type_special_kind == type_special_kind.short_string)
     {
         int len = (type as IShortStringTypeNode).Length;
         CustomAttributeBuilder cust_bldr = new CustomAttributeBuilder(this.ShortStringAttributeConstructor, new object[1] { len });
         fb.SetCustomAttribute(cust_bldr);
     }
 }

        /// <summary>
        /// Apply the custom attribute to fields
        /// </summary>
        public void ApplyAttributes(FieldBuilder fieldBuilder)
        {
            if (m_attribute != null)
                fieldBuilder.SetCustomAttribute(m_attribute);

            if (m_typeInfo != null)
                ConvCommon.HandleAlias(m_info, m_typeInfo, m_typeDesc, fieldBuilder);
        }

 private void DefineOutput()
 {
     var ctor = typeof(FragmentOutAttribute).GetConstructor(new[] { typeof(UsageSemantic) });
     var fragmentOutAttrib = new CustomAttributeBuilder(ctor, new object[] { UsageSemantic.Color0 });
     _output = _type.DefineField("output", typeof(ShaderDefinition.vec4), FieldAttributes.Public);
     _output.SetCustomAttribute(fragmentOutAttrib);
 }

 public static void HandleAlias(ConverterInfo info, TypeInfo typeInfo, TypeDesc typeDesc, FieldBuilder builder)
 {
     string aliasName = GetAliasName(info, typeInfo, typeDesc);
     if (aliasName != null)
         builder.SetCustomAttribute(CustomAttributeHelper.GetBuilderForComAliasName(aliasName));
 }

        /// <summary>
        /// Provide implementation for setting default value 
        /// </summary>
        private static void SetDefaultValueInternal(IntPtr ipVariant, Type type, ParameterBuilder paramBuilder, FieldBuilder fieldBuilder, short typeVt)
        {
            if (type == null) throw new ArgumentNullException(nameof(type));
            // Use the element type for normalization if the type is a ByRef
            while (type.IsByRef)
                type = type.GetElementType();

            short defaultValueVt = Marshal.ReadInt16(ipVariant);
            object defaultValue = GetNormalizedDefaultValueFromVariant(ipVariant, type, defaultValueVt, typeVt);

            if (type.IsEnum && (defaultValueVt == (short)VarEnum.VT_I4 || defaultValueVt == (short)VarEnum.VT_UI4))
            {
                // 1) I can't dynamically create the enum in a ReflectionOnlyContext
                // 2) In pre-4.0, SetConstant(1) won't work for enum types.
                // After talking with team members we decided that this is a minor functionality that
                // we can live without in pre-4.0
                // return;
            }

            // Currently ParameterBuilder.SetConstant doesn't emit the custom attributes so certain types of constants
            // so we need to do that by ourselves
            CustomAttributeBuilder builder = null;
            if (type == typeof(Decimal))
            {
                DECIMAL realDecimal;
                IntPtr pDecimal = IntPtr.Zero;

                // Unfortunate we cannot directly access the fields in the decimal struct and we need to rely on the fact
                // that the internal representation of decimal & DECIMAL are the same, which will most likely remain true in the future
                // because CLR internally does the same thing
                Debug.Assert(sizeof(decimal) == Marshal.SizeOf(typeof(DECIMAL)));

                try
                {
                    pDecimal = Marshal.AllocCoTaskMem(sizeof(decimal));

                    // We convert it to unmanaged then back to managed to avoid unsafe code, so that we won't crash immediately in partial trust
                    Marshal.StructureToPtr(defaultValue, pDecimal, false);
                    realDecimal = (DECIMAL)Marshal.PtrToStructure(pDecimal, typeof(DECIMAL));
                }
                finally
                {
                    if (pDecimal != IntPtr.Zero)
                        Marshal.FreeCoTaskMem(pDecimal);
                }

                builder = CustomAttributeHelper.GetBuilderForDecimalConstant(
                    realDecimal.scale,
                    realDecimal.sign,
                    realDecimal.hi32,
                    realDecimal.mid32,
                    realDecimal.low32);
            }
            else if (type == typeof(DateTime) && defaultValueVt == (short)VarEnum.VT_DATE)
            {
                builder = CustomAttributeHelper.GetBuilderForDateTimeConstant(((DateTime)defaultValue).Ticks);
            }
            else if (defaultValueVt == (short)VarEnum.VT_UNKNOWN)
            {
                // Currently ParameterBuilder.SetConstant doesn't emit the IUnknownConstantAttribute
                // for IUnknown so we need to do that by ourselves
                builder = CustomAttributeHelper.GetBuilderForIUnknownConstant();
            }
            else if (defaultValueVt == (short)VarEnum.VT_DISPATCH)
            {
                // Currently ParameterBuilder.SetConstant doesn't emit the IDispatchConstantAttribute
                // for IDispatch so we need to do that by ourselves
                builder = CustomAttributeHelper.GetBuilderForIDispatchConstant();
            }

            if (builder != null)
            {
                if (paramBuilder != null)
                    paramBuilder.SetCustomAttribute(builder);
                if (fieldBuilder != null)
                    fieldBuilder.SetCustomAttribute(builder);
            }
            else
            {
                try
                {
                    if (paramBuilder != null)
                        paramBuilder.SetConstant(defaultValue);
                    if (fieldBuilder != null)
                        fieldBuilder.SetConstant(defaultValue);
                }
                catch (Exception)
                {
                    // Debug.Assert(type.IsEnum, "We should avoid failing for non-Enum default values");
                }
            }
        }

        /// <summary>
        /// Add Metadata attribute
        /// </summary>
        /// <param name="xmlField"></param>
        /// <param name="fieldBuilder"></param>
        private void CreateRTMetadataAttribute(XmlStructFieldLayout xmlField, FieldBuilder fieldBuilder)
        {
            // Find MarshalAsAttribute's constructor by signature, then invoke
            var metadataType = typeof(MetadataHelpAttribute);
            var ctorInfo = metadataType.GetConstructor(Type.EmptyTypes);

            List<PropertyInfo> lstPropInfo = new List<PropertyInfo>();
            List<object> lstPropValues = new List<object>();
            if(string.IsNullOrEmpty(xmlField.Metadata.Description) == false)
            {
                lstPropInfo.Add(metadataType.GetProperty("Description"));
                lstPropValues.Add(xmlField.Metadata.Description);
            }
            if (string.IsNullOrEmpty(xmlField.Metadata.DisplayName) == false)
            {
                lstPropInfo.Add(metadataType.GetProperty("DisplayName"));
                lstPropValues.Add(xmlField.Metadata.DisplayName);
            }

            var fields = metadataType.GetFields(BindingFlags.Public | BindingFlags.Instance);
            var marshalAsAttr = new CustomAttributeBuilder(ctorInfo,
                new object[] { },
                lstPropInfo.ToArray(),
                lstPropValues.ToArray());

            fieldBuilder.SetCustomAttribute(marshalAsAttr);
        }

        /// <summary>
        /// Add MarshalAs attribute
        /// </summary>
        /// <param name="xmlField"></param>
        /// <param name="fieldBuilder"></param>
        private void CreateRTMarshalAsAttribute(XmlStructFieldLayout xmlField, FieldBuilder fieldBuilder)
        {
            // Find MarshalAsAttribute's constructor by signature, then invoke
            var ctorParameters = new Type[] { typeof(UnmanagedType) };
            var ctorInfo = typeof(MarshalAsAttribute).GetConstructor(ctorParameters);

            var fields = typeof(MarshalAsAttribute).GetFields(BindingFlags.Public | BindingFlags.Instance);
            var sizeConst = (from f in fields
                             where f.Name == "SizeConst"
                             select f).ToArray();
            var marshalAsAttr = new CustomAttributeBuilder(ctorInfo,
                new object[] { xmlField.MarshalAsUnmanagedType }, sizeConst, new object[] { xmlField.MarshalAsSizeConst });

            fieldBuilder.SetCustomAttribute(marshalAsAttr);
        }