FieldBuilder.cs

using System.Globalization;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;

namespace System.Reflection.Emit
{
    [ClassInterface(ClassInterfaceType.None)]
    [ComDefaultInterface(typeof(_FieldBuilder))]
    [ComVisible(true)]
    [HostProtection(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
    public sealed class FieldBuilder : FieldInfo, _FieldBuilder
    {
        private int m_fieldTok;

        private FieldToken m_tkField;

        private TypeBuilder m_typeBuilder;

        private string m_fieldName;

        private FieldAttributes m_Attributes;

        private Type m_fieldType;

        internal int MetadataTokenInternal => m_fieldTok;

        public override Module Module => m_typeBuilder.Module;

        public override string Name => m_fieldName;

        public override Type DeclaringType
        {
            get
            {
                if (m_typeBuilder.m_isHiddenGlobalType)
                {
                    return null;
                }
                return m_typeBuilder;
            }
        }

        public override Type ReflectedType
        {
            get
            {
                if (m_typeBuilder.m_isHiddenGlobalType)
                {
                    return null;
                }
                return m_typeBuilder;
            }
        }

        public override Type FieldType => m_fieldType;

        public override RuntimeFieldHandle FieldHandle
        {
            get
            {
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
            }
        }

        public override FieldAttributes Attributes => m_Attributes;

        [SecurityCritical]
        internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
        {
            if (fieldName == null)
            {
                throw new ArgumentNullException("fieldName");
            }
            if (fieldName.Length == 0)
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "fieldName");
            }
            if (fieldName[0] == '\0')
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_IllegalName"), "fieldName");
            }
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }
            if (type == typeof(void))
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldType"));
            }
            m_fieldName = fieldName;
            m_typeBuilder = typeBuilder;
            m_fieldType = type;
            m_Attributes = (attributes & ~FieldAttributes.ReservedMask);
            SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper(m_typeBuilder.Module);
            fieldSigHelper.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers);
            int length;
            byte[] signature = fieldSigHelper.InternalGetSignature(out length);
            m_fieldTok = TypeBuilder.DefineField(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), typeBuilder.TypeToken.Token, fieldName, signature, length, m_Attributes);
            m_tkField = new FieldToken(m_fieldTok, type);
        }

        [SecurityCritical]
        internal void SetData(byte[] data, int size)
        {
            ModuleBuilder.SetFieldRVAContent(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), m_tkField.Token, data, size);
        }

        internal TypeBuilder GetTypeBuilder()
        {
            return m_typeBuilder;
        }

        public override object GetValue(object obj)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
        }

        public override void SetValue(object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            throw new NotSupportedException(Environment.GetResourceString("NotSupported_DynamicModule"));
        }

        public FieldToken GetToken()
        {
            return m_tkField;
        }

        [SecuritySafeCritical]
        public void SetOffset(int iOffset)
        {
            m_typeBuilder.ThrowIfCreated();
            TypeBuilder.SetFieldLayoutOffset(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, iOffset);
        }

        [SecuritySafeCritical]
        [Obsolete("An alternate API is available: Emit the MarshalAs custom attribute instead. http://go.microsoft.com/fwlink/?linkid=14202")]
        public void SetMarshal(UnmanagedMarshal unmanagedMarshal)
        {
            if (unmanagedMarshal == null)
            {
                throw new ArgumentNullException("unmanagedMarshal");
            }
            m_typeBuilder.ThrowIfCreated();
            byte[] array = unmanagedMarshal.InternalGetBytes();
            TypeBuilder.SetFieldMarshal(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, array, array.Length);
        }

        [SecuritySafeCritical]
        public void SetConstant(object defaultValue)
        {
            m_typeBuilder.ThrowIfCreated();
            TypeBuilder.SetConstantValue(m_typeBuilder.GetModuleBuilder(), GetToken().Token, m_fieldType, defaultValue);
        }

        [SecuritySafeCritical]
        [ComVisible(true)]
        public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
        {
            if (con == null)
            {
                throw new ArgumentNullException("con");
            }
            if (binaryAttribute == null)
            {
                throw new ArgumentNullException("binaryAttribute");
            }
            ModuleBuilder moduleBuilder = m_typeBuilder.Module as ModuleBuilder;
            m_typeBuilder.ThrowIfCreated();
            TypeBuilder.DefineCustomAttribute(moduleBuilder, m_tkField.Token, moduleBuilder.GetConstructorToken(con).Token, binaryAttribute, toDisk: false, updateCompilerFlags: false);
        }

        [SecuritySafeCritical]
        public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
        {
            if (customBuilder == null)
            {
                throw new ArgumentNullException("customBuilder");
            }
            m_typeBuilder.ThrowIfCreated();
            ModuleBuilder mod = m_typeBuilder.Module as ModuleBuilder;
            customBuilder.CreateCustomAttribute(mod, m_tkField.Token);
        }

        void _FieldBuilder.GetTypeInfoCount(out uint pcTInfo)
        {
            throw new NotImplementedException();
        }

        void _FieldBuilder.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
        {
            throw new NotImplementedException();
        }

        void _FieldBuilder.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
        {
            throw new NotImplementedException();
        }

        void _FieldBuilder.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
        {
            throw new NotImplementedException();
        }
    }
}