C# 3.0 auto-properties — useful or not? [closed]

Answer 1

The three big downsides to using fields instead of properties are:

1. You can't databind to a field whereas you can to a property
2. If you start off using a field, you can't later (easily) change them to a property
3. There are some attributes that you can add to a property that you can't add to a field

Answer 2

I use auto-properties all the time. Before C#3 I couldn't be bothered with all the typing and just used public variables instead.

The only thing I miss is being able to do this:

public string Name = "DefaultName";

You have to shift the defaults into your constructors with properties. tedious :-(

Answer 3

One thing to note here is that, to my understanding, this is just syntactic sugar on the C# 3.0 end, meaning that the IL generated by the compiler is the same. I agree about avoiding black magic, but all the same, fewer lines for the same thing is usually a good thing.

Answer 4

One thing nobody seems to have mentioned is how auto-properties are unfortunately not useful for immutable objects (usually immutable structs). Because for that you really should do:

private readonly string title;
public string Title
{
    get { return this.title; }
}

(where the field is initialized in the constructor via a passed parameter, and then is read only.)

So this has advantages over a simple get/private set autoproperty.

Answer 5

I use CodeRush, it's faster than auto-properties.

To do this:

 private string title;
public string Title
{
    get { return title;  }
    set { title = value;  }
}

Requires eight keystrokes total.

Answer 6

Yes, it does just save code. It's miles easier to read when you have loads of them. They're quicker to write and easier to maintain. Saving code is always a good goal.

You can set different scopes:

public string PropertyName { get; private set; }

So that the property can only be changed inside the class. This isn't really immutable as you can still access the private setter through reflection.

As of C#6 you can also create true readonly properties - i.e. immutable properties that cannot be changed outside of the constructor:

public string PropertyName { get; }

public MyClass() { this.PropertyName = "whatever"; }

At compile time that will become:

readonly string pName;
public string PropertyName { get { return this.pName; } }

public MyClass() { this.pName = "whatever"; }

In immutable classes with a lot of members this saves a lot of excess code.