If we are looking for a way to get the size of a data type in C#, mastering the sizeof() operator is just what we need. This operator returns the accurate memory size that any data type occupies. In this article, we will dive into understanding how to use this operator and apply it in various scenarios. 

To download the source code for this article, you can visit our GitHub repository.

Without further ado, let’s get started!

Why It Is Important to Know the Size of a Datatype

There are various reasons why we might want to know the size of a given datatype. Let’s look at some of them.

Support Code Maze on Patreon to get rid of ads and get the best discounts on our products!
Become a patron at Patreon!

Memory allocation: The size of a datatype is critical when allocating memory to variables, structures, and arrays. Knowing the size of a datatype enables the compiler to determine the memory we need to store variables, which is necessary when managing memory in C#.

Performance optimization: The size of a datatype also plays a role in optimizing code performance. For instance, using a smaller datatype where possible can help reduce memory usage and improve performance. Similarly, using a larger datatype than necessary can waste memory and reduce performance.

Serialization and deserialization: When serializing and deserializing data in C#, it is essential to know the size of the datatype as it helps ensure that the serialized data matches the size of the corresponding datatype in the deserialized object. This prevents errors and data loss.

Network communication: When sending data over a network, the size of a datatype helps determine the amount of data to transmit, which is vital in optimizing network communication and reducing bandwidth usage.

Now that we understand some of the important reasons we would want to know the size of a datatype, let’s learn how to implement the sizeof() operator in C#.

How to Use the sizeof() Operator in C#?

We initialize the operator as:


Here,  dataType represents the data type we are checking.

Usually, the sizeof() operator needs an unsafe context, but we do not need it in our examples, as we evaluate their sizes during compile time.

Let’s learn how it works with different datatypes in C#:

Assert.AreEqual(1, sizeof(byte)); // true
Assert.AreEqual(2, sizeof(short)); // true
Assert.AreEqual(4, sizeof(int)); // true
Assert.AreEqual(8, sizeof(long)); // true
Assert.AreEqual(2, sizeof(char)); // true
Assert.AreEqual(4, sizeof(float)); // true
Assert.AreEqual(8, sizeof(double)); // true
Assert.AreEqual(16, sizeof(decimal)); // true
Assert.AreEqual(1, sizeof(bool)); // true

This operator only supports primitive data types; hence, we cannot use it to evaluate complex and user-defined types. 

In addition to returning the size of a specific data type, we can use it to compare two different primitive types.

Let’s verify we can compare some primitive types:

Assert.IsTrue(sizeof(byte) < sizeof(short)); // true
Assert.IsTrue(sizeof(int) == sizeof(float)); // true
Assert.IsTrue(sizeof(long) == sizeof(double)); // true
Assert.IsTrue(sizeof(decimal) > sizeof(bool)); // true

Also, we cannot use the sizeof() operator with variables or values, only with data types. As such, it’s impossible to query an individual variable’s size or value.

Marshal.SizeOf() Operator in C#

What if we need to determine the size of an unmanaged type such as a struct? That’s where the Marshal.SizeOf() method comes in. An unmanaged type is a type that is not managed by the .NET runtime, such as a struct or an operating system data structure. The Marshal.SizeOf(typeof()) is part of the System.Runtime.InteropServices namespace and takes a System.Type parameter that represents the type whose size we want to evaluate. 

Let’s create a struct whose size we want to determine:

public struct MyStruct 
    public byte byteVar; // 1
    public int intVar; // 4
    public long longVar; // 8
    public double doubleVar; // 8
    public float floatVar; // 4
    public short shortVar; // 2
    public char charVar; // 2
    public decimal decimalVar; // 16
    public bool boolVar; // 1

Finally, we can proceed to validate its size:

var expected = 56;
var actual = Marshal.SizeOf(typeof(MyStruct));

Assert.AreEqual(expected, actual); // true
Assert.IsInstanceOfType(actual, typeof(int)); // true

The sum of the sizes of our data types is 46.  When using the Marshal.SizeOf() method, the sum of a struct is usually more than the sum of its data type components because of the padding the compiler adds for performance reasons. 

The compiler may add padding to ensure that the struct aligns on a memory boundary that is optimal for the processor architecture. For example, on a 32-bit system, the compiler might add 4 bytes of padding after a 2-byte short integer to align it on a 4-byte boundary. Similarly, on a 64-bit system, the compiler might add 8 bytes of padding after a 4-byte integer to align it on an 8-byte boundary.


In this article, we learned how to use the sizeof() operator in C#. Also, we compared it to the unmanaged variant, the Marshal.SizeOf() method. Knowing the size of a datatype is critical for proper memory management, performance optimization, serialization and deserialization, and network communication.

Liked it? Take a second to support Code Maze on Patreon and get the ad free reading experience!
Become a patron at Patreon!