Initializing C# auto-properties

Question

I'm used to writing classes like this:

public class foo {
  private string mBar = "bar";
  public string Bar {
    get { return mBar; }
    set { mBar = value; }
  }
  //... other methods, no constructor ...
}

Converting Bar to an auto-property seems convenient and concise, but how can I retain the initialization without adding a constructor and putting the initialization in there?

public class foo2theRevengeOfFoo {
  //private string mBar = "bar";
  public string Bar { get; set; }
  //... other methods, no constructor ...
  //behavior has changed.
}

You could see that adding a constructor isn't inline with the effort savings I'm supposed to be getting from auto-properties.

Something like this would make more sense to me:

public string Bar { get; set; } = "bar";

Answer 1

In the default constructor (and any non-default ones if you have any too of course):

public foo() {
    Bar = "bar";
}

This is no less performant that your original code I believe, since this is what happens behind the scenes anyway.

Answer 2

You can do it 2 ways, either via the constructor of your class:

public class foo {
  public foo(){
    Bar = "bar";
  }
  public string Bar {get;set;}
}

Or you can use the DefaultValue attribute (http://msdn.microsoft.com/en-us/library/system.componentmodel.defaultvalueattribute.aspx):

public class foo {
  [DefaultValue("bar")]
  public string Bar {get;set;}
}

I much prefer the first option as DefaultValueAttribute requires reflection to get the value (or at least, so I've found).

If you've got another constructor (ie, one that takes paramters) or a bunch of constructors you can always have this:

public class foo {
  private foo(){
    Bar = "bar";
  }
  public foo(int something) : this(){
    //do normal constructor stuff
  }
  public string Bar {get;set;}
}

If you always call the "default" constructor you can have all initalisers set up in that nicely and you're acutal constructors as you want

Answer 3

It's unfortunate that there's no way of doing this right now. You have to set the value in the constructor. (Using constructor chaining can help to avoid duplication.)

Automatically implemented properties are handy right now, but could certainly be nicer. I don't find myself wanting this sort of initialization as often as a read-only automatically implemented property which could only be set in the constructor and would be backed by a read-only field. It's possible that both of these will be fixed in C# 5, which I strongly hope will address immutability concerns. (I don't think either of them are scheduled for C# 4.)