Struct or Classes For This Specific case

Question

With all the knowledge I possess at this very moment I cannot decide which shall I use for my use case.

This is now example with struct.

The first class looks like this:

class Owner
{
  public A[] Kids;

  public Owner(int count)
  {
    Kids = new A [count];

    // If I would use classes I would need to create new class for each item, right?
    // It would look like below and my worries are memory impacts because of new A()
    // for(int i = 0; i < count; Kids[i++] = new A());
  }
}

The second class looks like this:

class Node
{
  private Owner o;
  private int num;
  private A[] kids;

  public Node(Owner o, int num)
  {
   this.o = o;
   this.num = num;
  }

  public A[] Kids
  {
    get
    {
      this.kids = o.Kids[num].NextList;
      return this.kids;
    }
  }
}

The type A looks like this

<struct or class> A
{
  public int Value;
  public A[] NextList;
}

The question is now when using structs would the access run faster than when using classes?

Would I get memory overhead when using classes since I would need to initalize each class.

Would I need to take care of killing references when using classes?

Which would you use guys in this case?

I apologize in case this is a duplicate or if i did something wrong. Please tell me what I did wrong before downgrading the question. I am still new to this forum.

Answer 1

TL;DR: Use a class.

Since you are using an array and you are worried about memory, there is one thing to bear in mind:

If you have an array of structs, then the total bytes allocated for the array will be sizeof(your struct) * number of elements

If you have an array of classes, then the total bytes allocated for the array will be sizeof(reference) * number of elements (where the size of a reference is 32 bits for x86 and 64 bits for x64).

This could make a big difference in some cases.

If the total size of an array exceeds 85,000 bytes then it will be placed onto the Large Object Heap. Otherwise, it goes on the normal heap. It could mean that using a struct will cause some of your arrays to exceed the 85,000 byte threshold, while they would not reach that threshold if you used a class instead.

Items on the Large Object Heap are not compacted during Garbage Collection (*), so you can get problems with memory fragmentation if you have too many large objects.

Note that this also applies to many other collections (such as List<T>), because they use an array in their implementation.

The overhead of using a class instead of a struct is pretty negligible in most cases, and in any case you should instrument the code to be sure, if you think it is causing an issue.

Therefore, you should generally just use a class.

There is another thing to be aware of:

If you have a List of structs, you cannot change the properties of individual elements in the List without replacing the entire element with an updated one.

So this isn't possible:

List<MyStruct> list = new List<MyStruct>();
... init list
list[0].Value = 1; // Compile error for structs, no error for classes.

This shouldn't be an issue though - because your structs are always immutable so you wouldn't try to do that in the first place, right? ;)

---

(*) This isn't strictly true any more. .Net 4.51 introduces a way of allowing the next garbage collection to move large objects, but this has to be programmatically instigated.

http://blogs.msdn.com/b/mariohewardt/archive/2013/06/26/no-more-memory-fragmentation-on-the-large-object-heap.aspx