Structs versus classes

by

Is it faster to create these objects as class or as struct?

You are the only person who can determine the answer to that question. Try it both ways, measure a meaningful, user-focused, relevant performance metric, and then you’ll know whether the change has a meaningful effect on real users in relevant scenarios.

Structs consume less heap memory (because they are smaller and more easily compacted, not because they are “on the stack”). But they take longer to copy than a reference copy. I don’t know what your performance metrics are for memory usage or speed; there’s a tradeoff here and you’re the person who knows what it is.

Is it better to create these objects as class or as struct?

Maybe class, maybe struct. As a rule of thumb:
If the object is :
1. Small
2. Logically an immutable value
3. There’s a lot of them
Then I’d consider making it a struct. Otherwise I’d stick with a reference type.

If you need to mutate some field of a struct it is usually better to build a constructor that returns an entire new struct with the field set correctly. That’s perhaps slightly slower (measure it!) but logically much easier to reason about.

Are objects on the heap and the stack processed equally by the garbage collector?

No, they are not the same because objects on the stack are the roots of the collection. The garbage collector does not need to ever ask “is this thing on the stack alive?” because the answer to that question is always “Yes, it’s on the stack”. (Now, you can’t rely on that to keep an object alive because the stack is an implementation detail. The jitter is allowed to introduce optimizations that, say, enregister what would normally be a stack value, and then it’s never on the stack so the GC doesn’t know that it is still alive. An enregistered object can have its descendents collected aggressively, as soon as the register holding onto it is not going to be read again.)

But the garbage collector does have to treat objects on the stack as alive, the same way that it treats any object known to be alive as alive. The object on the stack can refer to heap-allocated objects that need to be kept alive, so the GC has to treat stack objects like living heap-allocated objects for the purposes of determining the live set. But obviously they are not treated as “live objects” for the purposes of compacting the heap, because they’re not on the heap in the first place.

Is that clear?

More Related Contents:

  1. Why are mutable structs “evil”?
  2. When should I use a struct rather than a class in C#?
  3. How to convert a structure to a byte array in C#?
  4. Error: “Cannot modify the return value” c#
  5. Changing the value of an element in a list of structs
  6. Non-unique enum values
  7. Generic constraints, where T : struct and where T : class
  8. How does native implementation of ValueType.GetHashCode work?
  9. Structs, Interfaces and Boxing [duplicate]
  10. Modify Struct variable in a Dictionary
  11. What does the keyword “new” do to a struct in C#?
  12. Struct constructor: “fields must be fully assigned before control is returned to the caller.”
  13. Are Structs always stack allocated or sometimes heap allocated?
  14. Read binary file into a struct
  15. Can structs contain fields of reference types
  16. Why is 16 byte the recommended size for struct in C#?
  17. Is it safe for structs to implement interfaces?
  18. Initializing an Array of Structs in C#
  19. Which is best for data store Struct/Classes?
  20. Non-read only alternative to anonymous types
  21. Marshal C++ struct array into C#
  22. Why does struct alignment depend on whether a field type is primitive or user-defined?
  23. C# Structs: Unassigned local variable?
  24. Does using public readonly fields for immutable structs work?
  25. Why are public fields faster than properties?
  26. Why is it possible to instantiate a struct without the new keyword?
  27. Cycle in the struct layout that doesn’t exist
  28. C# – Value Type Equals method – why does the compiler use reflection?
  29. Are structs ‘pass-by-value’?
  30. Problem with struct and property in c#

Leave a Comment