.NET ：如何计算引用类型所占用的空间

引用类型是在堆上面分配的，与值类型不同的是，.NET没有办法直接计算得到它们所占用的大小。下面是一个解决方法。

using System;
using System.Reflection;


namespace Sample
{

    public class Customer {
        public int Id { get; set; }
        public string CompanyName { get; set; }

    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(SizeOf
  
  
   
   ());
            Console.Read();
        }

        
   
   public 
   
   static 
   
   int SizeOf
   
   
    
    ()
        {
            
    
    return SizeOf(
    
    typeof(T));
        }

        
    
    public 
    
    unsafe 
    
    static 
    
    int SizeOf(Type targetType)
        {
            
    
    if (targetType == 
    
    null) 
    
    return 0;
            var result = 0;
            
    
    foreach (var fld 
    
    in targetType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
                
    
    switch (Type.GetTypeCode(fld.FieldType))
                {
                    
    
    case TypeCode.Boolean: result += 
    
    sizeof(
    
    bool); 
    
    break;
                    
    
    case TypeCode.Byte: result += 
    
    sizeof(
    
    byte); 
    
    break;
                    
    
    case TypeCode.Char: result += 
    
    sizeof(
    
    char); 
    
    break;
                    
    
    case TypeCode.DateTime: result += 
    
    sizeof(DateTime); 
    
    break;
                    
    
    case TypeCode.String:
                    
    
    case TypeCode.DBNull: result += IntPtr.Size; 
    
    break;
                    
    
    case TypeCode.Decimal: result += 
    
    sizeof(
    
    decimal); 
    
    break;
                    
    
    case TypeCode.Double: result += 
    
    sizeof(
    
    double); 
    
    break;
                    
    
    case TypeCode.Int16: result += 
    
    sizeof(Int16); 
    
    break;
                    
    
    case TypeCode.Int32: result += 
    
    sizeof(Int32); 
    
    break;
                    
    
    case TypeCode.Int64: result += 
    
    sizeof(Int64); 
    
    break;
                    
    
    case TypeCode.SByte: result += 
    
    sizeof(SByte); 
    
    break;
                    
    
    case TypeCode.Single: result += 
    
    sizeof(
    
    float); 
    
    break;
                    
    
    case TypeCode.UInt16: result += 
    
    sizeof(UInt16); 
    
    break;
                    
    
    case TypeCode.UInt32: result += 
    
    sizeof(UInt32); 
    
    break;
                    
    
    case TypeCode.UInt64: result += 
    
    sizeof(UInt64); 
    
    break;
                    
    
    case TypeCode.Object:
                        
    
    if (fld.FieldType.Equals(
    
    typeof(UIntPtr)))
                        {
                            result += UIntPtr.Size;
                            
    
    break;
                        }
                        
    
    if (fld.FieldType.Equals(
    
    typeof(IntPtr)))
                        {
                            result += IntPtr.Size;
                            
    
    break;
                        }
                        
    
    if (fld.FieldType.IsValueType)
                        {
                            result += SizeOf(fld.FieldType);
                            
    
    break;
                        }
                        
    
    if (fld.FieldType.IsEnum)
                        {
                            result += SizeOf(Enum.GetUnderlyingType(fld.FieldType));
                            
    
    break;
                        }
                        result += IntPtr.Size; 
    
    break;
                    
    
    default: 
    
    continue;
                }
            
    
    return result + SizeOf(targetType.BaseType);
        } 
    }


}

   
   
  
  

注意：选中下图中的“允许不安全代码”