I've been wondering about this for a while and haven't been able to find much commentary on the subject and haven't been able to come on a conclusion by myself.

When creating objects, it's accepted best practice to make the object as limited as possible in terms of exposing data and allowing that data to manipulated. If you can make an object immutable, especially in multi-threaded applications, then it is best to do so.

Having said that, C# seems to favor the developer who doesn't follow this rule by allowing the definition of a class to be much more simple, and more importantly, easier to maintain.

Take the following read-only immutable class:

```
public class ActiveDirectoryUser
{
    private readonly string firstName, lastName, office, username, email;

    public ActiveDirectoryUser(string firstName, string lastName, string office, string username, string email)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.office = office;
        this.username = username;
        this.email = email;
    }

    public string FirstName
    {
        get { return firstName; }
    }

    public string LastName
    {
        get { return lastName; }
    }

    ...

    public string Email
    {
        get { return email; }
    }
}

```

And compare it to the much more simple example as below, which isn't read-only.

```
public class ActiveDirectoryUser
{
    public string FirstName
    {
        get;
        set;
    }

    public string LastName
    {
        get;
        set;
    }

    ...

    public string Email
    {
        get;
        set;
    }
}

```

Which can be instantiated with the following is:

```
ActiveDirectoryUser user = 
    new ActiveDirectoryUser
       { FirstName= "Sam", LastName = "Shiles", ..., Email ="Sam@shiles.com" };

```

Given the simpler definition, the fewer lines of code, the less chance for developer error and the ease with which another developer can understand the code (especially with examples that are more true to life than our simple example), is the value of creating proper read-only, immutable objects, worth the cost? 

Also, do other people believe that making immutable objects in C# should be made easier with an automatic-esq syntax such as:

```
public string FirstName {get; readonly set;}

```