Structures should be used ONLY for very small value types, so if the
struct refers to an object, it's likely not a valid candidate to be a
struct.

    Structs have the disadvantage that if you store them in an arraylist
or List<T>, manipulating them isn't as convenient as you'd think:

myList[index].MyProperty = value;
won't work, as you're manipulating the value you get from the indexer,
not the value INSIDE the list. This can lead to bugs you only encouter
at runtime, and therefore most people opt for classes instead, which is
in general the right thing to do.

        FB

The only time I use structures is when two or more related simple data types
(int, boolean, string, etc.) need to be grouped together.  Even in this
case, I tend to use classes because I can easily change a public property
into a private property with a public property SET/GET block of code that
cleans up the data.  Also, structures don't have a constructor to allow for
default value setting.

Mike Ober.

Pros:
1. Greater perf as it takes less time to allocate memory on the stack that
the heap - this is miniscule, so don't use this as a reason, unless other
perf tweaks have failed and you are at the end of your rope (even then, I
might hang myself before switching to a struct system)
2. More deterministic clean up. The stack is guaranteed to die when the
appDomain is unloaded, while the heap, technically, can live on - this is a
minor benefit in most cases, as you are not in control of memory either way

Cons
1. Cannot code the default constructor. If you need to spin up an object
with some instantiation work, you have to have at least one parameter. This
has to do with a default construct already hard wired.
2. When you use interfaces, the struct is boxed and you have to explicitly
unbox it if you desire to use it as a value type. This means you lose one of
the benefits of structs.

Implications (neither pro or con):
1. Structs are passed, as parameters, by value. This means a new “object” is
created internally. Classes are passed by reference. Depending on your
system, this can be a big deal.

Overall, structs are good for small "collections" of value types
(implemented as properties or fields), when you do not need to add methods or
adhere to an interface, like a User Defined Type (UDF), and when passing by
reference does not make sense.

Small point - structures don't always sit on the stack. They sit
wherever the variable lives (for variables). See
http://www.pobox.com/~skeet/csharp/memory.html

I would suggest that you don't bother trying to change the standard
until you've got a really good candidate for a value type. They do
exist, but they're few and far between in my experience.