Marshal.SizeOf（typeof（T））和Marshal.SizeOf（default（T））之间有什么区别？

Question

Is there any difference in the purpose, result, and/or performance (across all types) of:

Marshal.SizeOf(typeof(T))

and

Marshal.SizeOf(default(T))

?

Answer 1

The first method takes a type, the second method takes an instance. They both return the size of the associated structure.

The latter method calls the former. This is backed up by the source in coreclr:

public static int SizeOf(Object structure)
{
    if (structure == null)
        throw new ArgumentNullException(nameof(structure));
    // we never had a check for generics here
    Contract.EndContractBlock();

    return SizeOfHelper(structure.GetType(), true);
}

public static int SizeOf(Type t)
{
    if (t == null)
        throw new ArgumentNullException(nameof(t));
    if (!(t is RuntimeType))
        throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t));
    if (t.IsGenericType)
        throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(t));
    Contract.EndContractBlock();

    return SizeOfHelper(t, true);
}

An important distinction is that when using reference types one of your calls will raise an exception the other wont:

This will succeed:

Marshal.SizeOf(typeof(AReferenceType))

This will error (null passed to method)

Marshal.SizeOf(default(AReferenceType))

Answer 2

Beware of reference types: Marshal.SizeOf<T> Method (T) :

ArgumentNullException The structure parameter is null.

For a reference type, default(T) will be null , so thats not a good idea.

Answer 3

In the first call you pass an instance of type Type, which is a reference type. Its size will be always the same as the size of all reference types.

In the second call, however, you pass a value, which can be of : 1. A reference type, and will be the same size as in the first call. 2. A value type, and now this can vary. For example, .SizeOf(default(byte)) will return 1, .SizeOf(default(int)) will return 4, .SizeOf(default(long)) will return 8.

Answer 4

The difference is the same as between Marshal.SizeOf(typeof(int)) , Marshal.SizeOf<int>() and Marshal.SizeOf(0) .

Internally, they all do the same:

• Marshal.SizeOf(object structure) gets type of object at runtime:

   Marshal.SizeOfHelper(structure.GetType(), true) 

• Marshal.SizeOf(Type t) just calls the same method with known type:

   Marshal.SizeOfHelper(t, true) 

• Marshal.SizeOf<T>() calls the previous overload:

   Marshal.SizeOfHelper(typeof(T)) 

As for me, I would prefer generic version whenever type is known at compile time or generic ; Type overload whenever type will be known at runtime; and object overload when you have an object, not a type. It looks like it is what every method was designed for.

Moreover, Marshal.SizeOf(default(T))` makes its purpose less clear and readable.