Is a .NET structure with a String Field (or Byte Array) (non-value type) can be memory efficient?

Question

The other day (actually let's say a long long time ago) I was reading the excellent CLR via C# book (4th Edition) which I strongly recommend to anybody who is doing some C# development to better understand the underlying mechanisms and explains the magic behind the scenes.

Since that reading I started to become over-worry about whether I should use structs over classes in my design decisions.

I have a situation that would make a perfect use of the structs (fast communication of temporary data chunks(aka the structures)).

However, I'm still struggling about using the structs in this scenario since I've seen so many rules of the thumb. For instance, the instance must be smaller than 16 bytes or the fact that I'm willing to carry an array or a string (which at least is immutable) as one of the structure fields while the String need somehow to be garbage collected later on, etc.

It seems like that the use of structs is then really more than limited.

Here is below an oversimplified C# 6 example, I guess the answer about memory efficiency is here: no, please don't use struct cause you're going to end up with a lot wasted memory and passing that as argument is going to be really greedy, performance-wise.

public enum ChunkHeader : ushort
{
    Unknown = 0x00,
    Transmitted = 0x01,
    Received = 0x02,
}

public struct Chunk
{
    public static Chunk Empty = new Chunk(ChunkHeader.Unknown, new Byte[0]);

    public Chunk(ChunkHeader header, Byte[] data)
    {
        this.Header = header;
        this.Data = ExceptionHelpers.ThrowIfNull(data, nameof(data))
    }

    // C# 6 read-only >>auto<<-properties        
    public ChunkHeader Header { get; }
    public Byte[] Data { get; }
}

public static class ExceptionHelpers
{
    public static T ThrowIfNull<T>(T parameterValue, String parameterName)
    {
        if ((Object)parameterValue == null)
        {
            throw new ArgumentNullException(parameterName);
        }
        else
        {
            return parameterValue;
        }
    }
}

My question is fairly simple, do you think that the structure above can be memory efficient in terms of Garbage Collection? Or is it still better to go with a class definition considering the underlying reference type field in the structure?

If so, any workarounds or general guidelines for dealing with a lot of chunks of data in order to prevent massive garbage collections?

Please consider that those chunks of data are intended to be used only for a short amount of time.

Answer 1

Here is the article you want to read. It is called exactly "Choosing Between Class and Struct".

You know, I think in the example that you have given it makes sense to create the struct. Your Chunk seems to represent a single value, similar to primitive types (int, double, etc.).

As the article itself says, there are three important aspects to keep in mind-

1. Allocation: Your struct will be allocated on stack while a class will be allocated on heap;
2. Boxing/Unboxing: If you will make Chunk implement some interface, then this value type will be boxed/unboxed which will have a negative impact on performance. This is not a case with reference types;
3. Value vs Reference: Struct data will be passed as value while class' object will be passed as reference. Therefore a change made to a struct that was passed will not be reflected in all other copies unlike a referenced type.

To summarize:

√ CONSIDER defining a struct instead of a class if instances of the type are small and commonly short-lived or are commonly embedded in other objects.

X AVOID defining a struct unless the type has all of the following characteristics: It logically represents a single value, similar to primitive types (int, double, etc.). It has an instance size under 16 bytes. It is immutable. It will not have to be boxed frequently.

---

Regarding two points about AVOIDING structs

16 bytes size guideline - (answer is taken from here): The 16 bytes guideline is just a performance rule of thumb.The point is that because value types are passed by value, the entire size of the struct has to be copied if it is passed to a function, whereas for a reference type, only the reference (4 bytes) has to be copied. A struct might save a bit of time though because you remove a layer of indirection, so even if it is larger than these 4 bytes, it might still be more efficient than passing a reference around. But at some point, it becomes so big that the cost of copying becomes noticeable. And a common rule of thumb is that this typically happens around 16 bytes.

Immutability: The aspect of immutability means that whatever value you are putting in the struct, you will set them only once and they will be final. Like for example if you give the chunk a name, then the name will be permanent for its lifetime. If the chunk is going to have many names throughout its life, you better create a class. Apply same logic to your Data to decide struct vs class.

In all other cases, you should define your types as classes.