8

I like using structs a lot.

So after reading this article, are there any other concerns I should have against using them all the time?

See Also:

Improve this question
5
  • Here's a dup which links to three more dups... Commented Mar 12, 2009 at 21:44
  • @Sasha: stackoverflow.com/questions/39323/… Commented Mar 12, 2009 at 21:53
  • Whoops, here are a few: stackoverflow.com/questions/543515/structs-vs-classes-in-c stackoverflow.com/questions/85553/… Commented Mar 12, 2009 at 21:54
  • 1
    I added some references which are extremely similar. I didn't call them duplicates because it's not exactly the same question, but it's close enough that I voted to close. Commented Mar 12, 2009 at 22:02
  • 1
    @Dana: The link to the C++ question is irrelevant. Structs in C++ is quite different from structs in C#. Commented Mar 12, 2009 at 22:10

7 Answers 7

Reset to default
11

You should make the following considerations about structs:

  • structs should be immutable (mutable structs are not intuitive and unpredictable)
  • structs always have a default (public parameterless) constructor that cannot be changed
  • struct size should not exceed 16 bytes
  • the Equals and GetHashCode methods should be overriden for better performance
  • implementing the IEquatable<T> interface is recommended
  • redefining and == and the != operators is also recommended
Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

What is the reason for limiting the size to 16 bytes?
As far as I am aware, 16 bytes is the size of the reference to a reference type. Therefor you get no memory benefits when passing structs around or using them. Although I will say. I dont understand all this <em>you should use</em> immutable struct stuff. Structs are just structs and if they are what you need, I think they are what you should use.
Mutable structs: consider the following multable struct Point { public int X, public int Y }. When it's used in a collection (e.g. List<Point>) iterating and modifying it would not update the value in the collection: foreach(var p in points /* points is Point[] */) { p.X = 3 }, because getting an element from the collection just gives you a copy (or a clone) of the element. The same is valid for passing struct values as method arguments.
Hi Michael, it's not that I dont understand the issues (if you can call them that) with structs. What you have stated to me, is what I consider expected behaviour. Therefor, if it is expected I wouldn't expect the values to be modified and wouldn't be supriprised if they were not.
@Barry: Suppose ClearX() takes a Point by reference and clears the X component, and PointList is a List<Struct>. Even though the compiler won't allow one to write PointList[5].X=0, it will allow ClearX(PointList[5]); the latter code, however, will have no useful effect. IMHO, the expected behavior would probably be to disallow such code in the first place, but such code is permitted as a trap to the unawary.
|
11

I almost never define custom structs. There just aren't that many natural value types around, IMO.

In particular, I would think very, very carefully before defining a mutable struct, especially if it mutates via an interface implementation. Mutable structs behave in ways which people don't expect at all, leading to code which is hard to understand.

I think it's worth reading "Choosing Between Classes and Structures" from "Design Guidelines For Developing Class Libraries".

In particular:

Do not define a structure unless the type has all of the following characteristics:

  • It logically represents a single value, similar to primitive types (integer, double, and so on).

  • It has an instance size smaller than 16 bytes.

  • It is immutable.

  • It will not have to be boxed frequently.

Do you really develop types with all of those characteristics frequently?

Improve this answer

Comments

4

They don't fit into an Object Oriented programming paradigm like classes do. They are good for small data structures, but I use classes for anything beyond that.

Improve this answer

Comments

0

I think main purpose of a struct - to keep only variable types. If you keep some classes into struct - you're wrong.

Improve this answer

Comments

0

Ask yourself the following questions about the set of data you're modeling with a struct:

  • Might it ever need to have any get/set logic?
  • Might it ever need to store ANY logic that is endemic to the data?
  • Might it need to inherit another set of data?
  • Might another set of data need to inherit this one?

I think if you can heartily answer "no" to all these questions, then there's no good reason not to use a struct. I think people use static subclasses in certain situations where a struct would be more than good enough.

Improve this answer

2 Comments

Could you go into more detail about point 2? There's nothing wrong with a struct having logic associated with it.
Well, the key word here is "endemic" vs. associated. I guess this isn't that clear, but what I meant was: might your struct need methods? I mean, classes are basically structs + endemic actions (well, ok, they're more than that, but that's what I was getting at)
0

A class is a lot simpler to implement correctly than a struct. If you implement a struct incorrectly it can give you some unexpected errors.

A struct should not be larger than 16 bytes, or you lose most of the performance benefits.

A struct is intended to be a value type, representing a single entity of some kind.

A struct should be immutable. That means that you never change one of the properties in a struct. If you want a struct value that is different you create a new value.

Improve this answer

13 Comments

Actually, a struct is very easy to implement correctly. If what one needs is a group of three int called Moe, Larry, and Curly, public struct Stooge { public int Moe, Larry, Curly; }. Maybe for convenience add a constructor: public Stooge(int newMoe, int newLarry, int newCurly) {Moe = newMoe; Larry = newLarry; Curly = newCurly;}. Trying to put too much logic into a struct can be problematic, but there's a simple solution: don't. Someone who tries to pound nails with a screwdriver will find it to be an inferior hammer, but that doesn't mean a screwdriver isn't a good tool.
@supercat: That's not a correctly implemented struct, that's just a struct that should be a class instead. A struct should represent a single entity, not be a container for several entities.
If instances of Stooge should have no identity outside of the values they contain, such that an array of 100 Stooge instances would hold precisely the same information as 300 integers, then Stooge must be either a struct or an immutable class; while there are some cases where an exposed-field struct would be usable but an immutable class would be better, I would regard those as the exception rather than the rule. Given Stooges[] Stooge, if Stooge was a class, how would one change Stooges[3].Moe without affecting AnyOtherStooge.Moe? How much code would one have to examine...
...to confirm that one was doing so correctly? If Stooge is defined as above, Stooges[3].Moe = 27; would do the job quite simply; knowing that Stooges[] is a Stooge, and Moe is a field of Stooge would be sufficient to define the behavior. If Stooge is an immutable class, one might be able to do Stooges[3] = Stooges[3].WithMoe(27);, but one would have to examine the WithMoe mehtod to confirm what it does, and examine the entire Stooge class to ensure it really is immutable, and that WithMoe copies all of its fields correctly. That's somehow an improvement?
If a structure is going to behave as something other than a group of variables bound together with duct tape, then it should probably be immutable. If, however, what one needs a group of variables stuck together with duct tape, which can be passed around as a group when convenient, but also accessed singly (e.g. the coordinates of a point), it seems much more reasonable to use a group of variables stuck together with duct tape (i.e. an exposed-field struct) than to try to make a class that kinda sorta behaves like one, or to bog down a struct so it behaves like such a class.
|
0

Use of structs should be limited to when all you really need is a small data structure. (as you read). I would only really use them for the smallest of datastructures like coordinates, offsets, and sometimes for graphics.

In many ways, you can think of structs in C# as being like scaled - down classes. They are basically the same as classes but designed more for cases where you simply want to group some data together. They differ from classes in the following ways: Some things to keep in mind

  • Structs are value types, not reference types. This means they are stored either in the stack or in- line (if they are part of another object that is stored on the heap) and have the same lifetime re-strictions as the simple data types.
  • Structs do not support inheritance.
  • There are some differences in the way constructors work for structs. In particular, the compiler always supplies a default no - parameter constructor, which you are not permitted to replace.
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.