With a struct that is a property, what is the standard for updating a value in the struct?

Question

I'm new to C#, and I'm working with a class that has a Rectangle field. I've read that Properties are the most accepted way to declare public fields, so I tried something like this:

public class MyClass
{
  public Rectangle MyBox { get; set; }

  public UpdateBox(int x, int y)
  {
    MyBox.X = x;
    MyBox.Y = y;
  }
}

It won't let me do MyBox.X = x because (from what I've read), Rectangle is a struct, and the getter returns a copy of the Rectangle, so I would not be modifying the value I want.

What is the standard for updating fields like this? I've found two solutions so far:

Creating a new Rectangle to store in the variable:

public class MyClass
{
  public Rectangle MyBox { get; set; }

  public UpdateBox(int x, int y)
  {
    MyBox = new Rectangle(x, y, MyBox.Width, MyBox.Height);
  }
}

but this seems like it would not be very memory efficient. Then there is just not making Rectangle a property:

public class MyClass
{
  public Rectangle MyBox;

  public UpdateBox(int x, int y)
  {
    MyBox.X = x;
    MyBox.Y = y;
  }
}

What is the standard for this kind of functionality?

What *exactly* do you mean by "but this seems like it would not be very memory efficient" (bearing in mind that Rectangle is a struct)? And which Rectangle struct are you talking about? Ideally, don't use mutable structs... or public fields... — Jon Skeet, Mar 26 '15 at 19:06
The standard is to not use mutable structs. The alternative is to create a new struct instance (your first solution). — D Stanley, Mar 26 '15 at 19:07
When you set your property to a new `Rectangle` you are not creating a new object and orphaning an old one to be garbage collected. You are literally overwriting the memory of the old rectangle with the new one. — juharr, Mar 26 '15 at 19:13
"When you set your property to a new Rectangle you are not creating a new object." That is what I thought was happening, and what I meant by "not be very memory efficient." "You are literally overwriting the memory of the old rectangle with the new one." Cool, then I think that would be the solution for me! The Rectangle struct is from Monogame. — justindao, Mar 26 '15 at 20:04

Felype · Answer 1 · 2015-03-26T19:15:21.573

By convention you can use a struct as a field and access its internal fields directly, if you want to use it as a property, then make a proper setter for it.

I, personally only use struct types as fields other than properties, maybe a read only property for public access (for encapsulation purposes), grants me safety and general organization of my code.

Your 3rd block of example code is the most correct form in my view, and no its not memory inefficient, Rectangle MyBox is already allocated in memory and already consuming its most by the time the constructor is called.

Also, let us keep in mind here, a property is a "shortcut" function to access some data, but if this data ought to be stored somewhere and wont likely change (default get/set accessors), then it's not any different from a normal field.

This is my favorite way of dealing with this:

public class MyClass
{
  private Rectangle _MyBox; // or protected idk.
  // This is public and read only.
  public Rectangle MyBox { get { return _MyBox; } }

  public UpdateBox(int x, int y)
  {
    _MyBox.X = x;
    _MyBox.Y = y;
  }
}

score 0 · Answer 2 · answered Mar 26 '15 at 19:40

The clearest approach for non-speed-critical applications is to use the pattern:

var temp=myThing.TheProperty;
temp.X = whatever;
temp.Y = whatever;
myThing.TheProperty = temp;

If the structure behaves as a bunch of independent variables fastened together with duct tape, the above approach will avoid having to either have the client code know about all of its fields, or have the struct include lots of boilerplate WithX, WithY, etc. factory methods.

If speed is important, then one should either have structures exposed in fields or arrays [as opposed to other collection types], or--if one wants to retain encapsulation--include accessor methods:

delegate void ActionRR<T1,T2>(ref T1 p1, ref T2 p2);

void ActOnBounds<TExtra>(ref Rectangle bounds, ActionRR<Rectangle, TExtra>proc, ref TExtra extra)
{
  proc(ref _bounds, ref extra);
}

Note that generating delegates to call ActOnBounds will make it slow, but it may be used efficiently by passing a static delegate and a ref valuetype. Unfortunately, while C# includes lots of nice syntactic sugar for closures, it does not provide such help with constructs like the above.

With a struct that is a property, what is the standard for updating a value in the struct?

2 Answers2