What's the size of this C# struct?

Question

Is it 12 bytes or 16 bytes when stored in a List<DataPoint> ?

public struct DataPoint
{
    DateTime time_utc;
    float value;
}

Is there any sizeof function in C#?

Answer 1

Take a look at @Hans Passant's answer here for interesting background on this issue, esp. with regard to the limitations of Marshal.Sizeof .

Answer 2

Marshal.SizeOf()

http://msdn.microsoft.com/en-us/library/y3ybkfb3.aspx

Answer 3

The CLR is free to lay out types in memory as it sees fit. So it's not possible to directly give "the" size.

However, for structures it's possible to restrict the freedom of the CLR using the StructLayout Attribute :

• Auto : The runtime automatically chooses an appropriate layout.
• Sequential : The members of the object are laid out sequentially and are aligned according to the StructLayoutAttribute.Pack value.
• Explicit : The precise position of each member is explicitly controlled.

The C# compiler automatically applies the Sequential layout kind to any struct. The Pack value defaults to 4 or 8 on x86 or x64 machines respectively. So the size of your struct is 8+4=12 (both x86 and x64).

---

Unrelated from how a type is laid out in memory, it's also possible to marshal a type in .NET using the Marshal Class . The marshaller applies several transformations when marshalling a type, so the result is not always the same as the way the CLR laid out the type. (For example, a bool takes 1 byte in memory plus alignment, while the marshaller marshals a bool to 4 bytes.)

Answer 4

It will be 12 bytes (4 for float, 8 for DateTime); Marshal.SizeOf will return 16 because the default packing is 8 bytes aligned. This is a good article on structs and packing. It gives a full description of whats actually happening.

Answer 5

试试Marshal.SizeOf（typeof（DataPoint））

Answer 6

The following code is based on this StackOverflow question and answers :

        /// <summary>
        /// Computes the size of the given managed type. Slow, but reliable. Does not give the same result as Marshal.SizeOf
        /// NOTE: this is not the same as what is the distance between these types in an array. That varies depending on alignment.
        /// </summary>
        public static int ComputeSizeOf(Type t)
        {
            // all this just to invoke one opcode with no arguments!
            var method = new DynamicMethod("ComputeSizeOfImpl", typeof(int), Type.EmptyTypes, typeof(Util), false);
            var gen = method.GetILGenerator();
            gen.Emit(OpCodes.Sizeof, t);
            gen.Emit(OpCodes.Ret);
            var func = (Func<int>)method.CreateDelegate(typeof(Func<int>));
            return func();
        }

I think the question you are probably wondering, is not what is the size of the type but what is the distance between two contiguous elements in the List. This is because alignment can play a role, as mentioned by others.

I believe the solution to that problem would best be achieved using Marshal.UnsafeAddrOfPinnedArrayElement() , but is very difficult to use correctly, particularly because the List does not expose publicly the backing array.