C# Structured List

Question

I am having problems with this bit of code

I have this structure

public struct bounds
{
        public int xmax = 0;
        public int xmin = 0;
        public int ymax = 0;
        public int ymin = 0;        
};

and I make a list out of it

List<bounds> map = new List<bounds>();

I am trying to store the boundaries of a space (or object) in a 2D array (its xmax, xmin, ymin, & ymax) I have this integer y variable which is going to be some number when it gets to this code, but I keep getting red lines under the code associated with my list "map" (i and j are counters for going through the 2D array)

if(!(map.Contains(y)))  //if the list doesn't already have this number
{    
   map.Add(y);
   map[y].xmax = i;    //and set its xmax, xmin, ymax, ymin
   map[y].xmin = i;
   map[y].ymax = j;
   map[y].ymin = j;
}

if(map[y].xmax < j)     // if its already in the list look at the current 
   map[y].xmax = j;    //  boundaries and decide if new ones should be set

if(map[y].xmin > j)
   map[y].xmin = j;

if (map[y].ymax < j)
    map[y].ymax = i;

if(map[y].ymin > j)
   map[y].ymin = i;

See [Why are mutable structs evil](http://stackoverflow.com/questions/441309/why-are-mutable-structs-evil). — Jeppe Stig Nielsen, Jul 06 '13 at 18:51

Lasse V. Karlsen · Answer 1 · 2013-07-06T18:57:06.137

The reason for this is a struct is a value type.

When you're reading out the struct from the list, you're getting a copy.

As such, this line of code (and all that looks like it):

map[y].xmax = i;

is modifying the copy you got out from the list.

You can counter this by manually retrieving the copy, modifying it, and placing it back into the list.

Note: Mutable structs generates all sorts of problems. The problem you're having is just one of them, but you should not make them mutable.

Also note: You're using the struct value itself as an indexer into the list, I assume this is an error, and that you're actually using an index variable, otherwise you're really having problems.

Here's a general tip though. If Visual Studio is drawing red squigglies under your code, you can hover the mouse over it to get a tooltip telling you what is wrong. It may cryptic to you, but the error message can be googled much easier:

example of red squigglies

Sure, it won't compile to say `MethodWhoseReturnTypeIsAMutableStruct().ChangeableMemberOfStruct = assignThis;`, if I remember correctly. Edit: Not sure if it matters if the struct member is a field or a property here(?). — Jeppe Stig Nielsen, Jul 06 '13 at 19:01

score 0 · Answer 2 · answered Jul 06 '13 at 18:46

0

To use the List indexer, you need to pass an int. You're passing a bounds struct here

map[y].xmax = i;

y has to be an int representing the index you want to access. I'm guessing y is a bounds struct because you've used

map.Add(y);

and your map is of type List<bounds>.

answered Jul 06 '13 at 18:46

keyboardP

68,824
13
156
205

2

Then `map.Add(y)` shouldn't work. Your `map` list expects a `bounds` struct to be added, not an integer. – keyboardP Jul 06 '13 at 18:48
`y` cannot *both* be an integer and an element of the `map` list, unless the code you've posted is not the real code at all. – Lasse V. Karlsen Jul 06 '13 at 18:49
O i see what your saying, let me change y to make it a bounds y not int y – DebareDaDauntless Jul 06 '13 at 18:51
If you literally mean just change the word from `int` to `bounds`, that won't work. You have to create a new `bounds` struct and fill its fields. – keyboardP Jul 06 '13 at 18:52
so how can i say in the list, at at the index[interger] add this number, could i cast y which is an interger into a bounds type – DebareDaDauntless Jul 06 '13 at 18:55
@user2521432 `bound y = new bound();` create a struct like this and fill its all fields, then you can add it to list. (you can also add without filling up the fields cause they will have default values as well). – Shaharyar Jul 06 '13 at 18:57
You can't convert an integer (which is essentially one whole number) into a struct object because they're two different things. A struct has fields (`xmax`, `xmin` etc... in your case) and you need to fill them out. Also, your `struct` declaration won't compile because you can't set default values (you've set `0`). If you want default values, consider a class instead. [Here's a tutorial](http://msdn.microsoft.com/en-us/library/aa288471%28v=vs.71%29.aspx) on structs you can read through to get a better understanding of what they are and how to use them. – keyboardP Jul 06 '13 at 19:00

score 0 · Answer 3 · answered Jul 08 '13 at 15:38

If the purpose of a data type is to encapsulate a fixed set of related but independent values (such as the coordinates of a point), an exposed-field structure meets that description better than any other data type. Such structures should not have many instance methods other than overrides of ToString(), Equals(), and GetHashCode(); it's generally better for structures to use static utility methods than instance methods. For example, this would be problematical:

public void UpdateRange(Point pt)
{
   if (pt.X > xmax) xmax = pt.X;
   if (pt.Y > ymax) ymax = pt.Y;
   if (pt.X < xmin) xmin = pt.X;
   if (pt.Y < ymin) ymin = pt.Y;
}

but this would not:

public void UpdateRange(ref bounds it, Point pt)
{
   if (pt.X > it.xmax) it.xmax = pt.X;
   if (pt.Y > it.ymax) it.ymax = pt.Y;
   if (pt.X < it.xmin) it.xmin = pt.X;
   if (pt.Y < it.ymin) it.ymin = pt.Y;
}

Note that when classes expose properties of a structure type, it is not possible to modify such properties directly. One cannot use something like:

bounds.UpdateRange(ref myList[4], newPoint);

nor, if UpdateRange were an instance method, could one use:

myList[4].UpdateRange(newPoint);

In the latter situation, the code would compile, but wouldn't work. Instead, one has to use something like:

var temp = myList[4];
bounds.UpdateRange(ref temp, newPoint);
mylist[4] = temp;

Note that the instance method and the static method with a ref parameter are semantically identical in the cases where both will compile. The difference between them is that the static method with a ref parameter will only compile in cases where the ref parameter is a modifiable variable, but calling the instance method on a property will cause the compiler to copy that property to a temporary variable, call the instance method on that, and discard the result.

I would suggest that your type is almost a perfect example of something that should be a structure. If it were a mutable class type, it would be unclear when code which passed a reference to an instance was really passing the instantaneous values the instance happened to hold at the time of a call, or was passing a reference to a "live" entity. Using an immutable class type or a so-called immutable struct type [note that there isn't really any such thing as an immutable value type] would make methods like UpdateRange slower to write and to run, while offering no particular benefit.

The one essential thing to note about the structure type is that each field (e.g. xmin) has no meaning other than "the last value that something stored in "xmin", or zero if nothing has been stored there yet. If code writes 256 to xmin and -234 to xmax, then xmin will hold 256 and xmax -234. Any code which takes abounds` and does anything with it should be prepared for such values just as it would be if it took those fields as four separate parameters.

C# Structured List

3 Answers3