System.Reflection.Emit.UnmanagedMarshal.DefineByValArray C# (CSharp) Method

        public static UnmanagedMarshal DefineByValArray(int elemCount)
        {
            return new UnmanagedMarshal(UnmanagedType.ByValArray, Guid.Empty, elemCount, (UnmanagedType) 0);
        }
    

        internal static UnmanagedMarshal get_umarshal(CustomAttributeBuilder customBuilder, bool is_field)
        {
            byte[]        data           = customBuilder.Data;
            UnmanagedType subtype        = (UnmanagedType)0x50;      /* NATIVE_MAX */
            int           sizeConst      = -1;
            int           sizeParamIndex = -1;
            bool          hasSize        = false;
            int           value;
            int           utype;   /* the (stupid) ctor takes a short or an enum ... */
            string        marshalTypeName = null;
            Type          marshalTypeRef  = null;
            string        marshalCookie   = String.Empty;

            utype  = (int)data [2];
            utype |= ((int)data [3]) << 8;

            string first_type_name = customBuilder.Ctor.GetParameters()[0].ParameterType.FullName;
            int    pos             = 6;

            if (first_type_name == "System.Int16")
            {
                pos = 4;
            }
            int nnamed = (int)data [pos++];

            nnamed |= ((int)data [pos++]) << 8;

            for (int i = 0; i < nnamed; ++i)
            {
                int paramType;                 // What is this ?
                paramType  = (int)data [pos++];
                paramType |= ((int)data [pos++]) << 8;
                int    len        = decode_len(data, pos, out pos);
                string named_name = string_from_bytes(data, pos, len);
                pos += len;

                switch (named_name)
                {
                case "ArraySubType":
                    value   = (int)data [pos++];
                    value  |= ((int)data [pos++]) << 8;
                    value  |= ((int)data [pos++]) << 16;
                    value  |= ((int)data [pos++]) << 24;
                    subtype = (UnmanagedType)value;
                    break;

                case "SizeConst":
                    value     = (int)data [pos++];
                    value    |= ((int)data [pos++]) << 8;
                    value    |= ((int)data [pos++]) << 16;
                    value    |= ((int)data [pos++]) << 24;
                    sizeConst = value;
                    hasSize   = true;
                    break;

                case "SizeParamIndex":
                    value          = (int)data [pos++];
                    value         |= ((int)data [pos++]) << 8;
                    sizeParamIndex = value;
                    hasSize        = true;
                    break;

                case "MarshalType":
                    len             = decode_len(data, pos, out pos);
                    marshalTypeName = string_from_bytes(data, pos, len);
                    pos            += len;
                    break;

                case "MarshalTypeRef":
                    len             = decode_len(data, pos, out pos);
                    marshalTypeName = string_from_bytes(data, pos, len);
                    marshalTypeRef  = Type.GetType(marshalTypeName);
                    pos            += len;
                    break;

                case "MarshalCookie":
                    len           = decode_len(data, pos, out pos);
                    marshalCookie = string_from_bytes(data, pos, len);
                    pos          += len;
                    break;

                default:
                    len = decode_len(data, pos, out pos);
                    string_from_bytes(data, pos, len);
                    pos += len;
                    break;
                }
            }

            switch ((UnmanagedType)utype)
            {
            case UnmanagedType.LPArray:
                if (hasSize)
                {
                    return(UnmanagedMarshal.DefineLPArrayInternal(subtype, sizeConst, sizeParamIndex));
                }
                else
                {
                    return(UnmanagedMarshal.DefineLPArray(subtype));
                }

            case UnmanagedType.SafeArray:
                return(UnmanagedMarshal.DefineSafeArray(subtype));

            case UnmanagedType.ByValArray:
                return(UnmanagedMarshal.DefineByValArray(sizeConst));

            case UnmanagedType.ByValTStr:
                return(UnmanagedMarshal.DefineByValTStr(sizeConst));

            case UnmanagedType.CustomMarshaler:
                return(UnmanagedMarshal.DefineCustom(marshalTypeRef, marshalCookie, marshalTypeName, Guid.Empty));

            default:
                return(UnmanagedMarshal.DefineUnmanagedMarshal((UnmanagedType)utype));
            }
        }