Beispiel #1
0
        public unsafe static int SizeOf(Type type)
        {
            if (type is null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            if (type is TypeBuilder)
            {
                throw new NotSupportedException(nameof(type));
            }

            if (type.IsGenericTypeDefinition)
            {
                throw new NotSupportedException(nameof(type));
            }

            if (type.IsByRefLike())
            {
                // TODO: ref struct 的大小是所有字段大小的和。
                throw new NotSupportedException(nameof(type));
            }

            if (type.IsByRef || type.IsPointer || !type.IsValueType || type.IsClass || type.IsInterface || type.IsArray)
            {
                return(IntPtr.Size);
            }

            return((Type.GetTypeCode(type)) switch
            {
                TypeCode.Boolean => sizeof(bool),
                TypeCode.Char => sizeof(char),
                TypeCode.SByte => sizeof(sbyte),
                TypeCode.Byte => sizeof(byte),
                TypeCode.Int16 => sizeof(short),
                TypeCode.UInt16 => sizeof(ushort),
                TypeCode.Int32 => sizeof(int),
                TypeCode.UInt32 => sizeof(uint),
                TypeCode.Int64 => sizeof(long),
                TypeCode.UInt64 => sizeof(ulong),
                TypeCode.Single => sizeof(float),
                TypeCode.Double => sizeof(double),
                TypeCode.Decimal => sizeof(decimal),
                TypeCode.DateTime => sizeof(DateTime),
                _ => GenericInvokerHelper.SizeOf(type),
            });
Beispiel #2
0
        public unsafe static int SizeOf(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            if (type is TypeBuilder)
            {
                throw new ArgumentException("Unable get size of a TypeBuilder.", nameof(type));
            }

            if (type.IsGenericTypeDefinition)
            {
                throw new ArgumentException("Unable get size of a generic definition type.", nameof(type));
            }

            switch (Type.GetTypeCode(type))
            {
            case TypeCode.Boolean:
                return(sizeof(bool));

            case TypeCode.Char:
                return(sizeof(char));

            case TypeCode.SByte:
                return(sizeof(sbyte));

            case TypeCode.Byte:
                return(sizeof(byte));

            case TypeCode.Int16:
                return(sizeof(short));

            case TypeCode.UInt16:
                return(sizeof(ushort));

            case TypeCode.Int32:
                return(sizeof(int));

            case TypeCode.UInt32:
                return(sizeof(uint));

            case TypeCode.Int64:
                return(sizeof(long));

            case TypeCode.UInt64:
                return(sizeof(ulong));

            case TypeCode.Single:
                return(sizeof(float));

            case TypeCode.Double:
                return(sizeof(double));

            case TypeCode.Decimal:
                return(sizeof(decimal));

            case TypeCode.DateTime:
                return(sizeof(DateTime));
            }

            if (type.IsPointer ||
                type.IsInterface ||
                type.IsByRef ||
                typeof(object) == type ||
                typeof(IntPtr) == type)
            {
                return(IntPtr.Size);
            }

            return(GenericInvokerHelper.SizeOf(type));
        }