CODEWITHSUNDEEP
c#
Szabolcs Antal
Szabolcs Antal

Reputation: 957

Property with getter only vs. with getter and private setter

Are these the same?

public string MyProp { get; }

vs.

public string MyProp { get; private set; }

I mean in both versions the property can be set in its own class but is readonly for other classes?

Upvotes: 35

Views: 32316

Answers (5)

Udit Gandhi
Udit Gandhi

Reputation: 357

Case 1: With no setter, an auto-implemented property can only be set while declaring the property or inside the constructor as a backing property is created. Therefore, acting as a read-only field.
Case 2: With no setter, a property that is not auto-implemented, can only be set while declaring the property as no backing field is created.
Case 3: With a private setter, a property can be set anywhere inside the class.

Upvotes: 0

Farhad Jabiyev
Farhad Jabiyev

Reputation: 26665

public string MyProp { get; } - This is introduced in C# 6.0. And such properties are called read-only auto-properties. Assignments to such members can only occur as part of the declaration or in a constructor in the same class. You can read detailed explanation about it in that MSDN article or in Jon Skeet blog. As explained in that article, such property solves four problem automatically:

  • A read-only-defined backing field
  • Initialization of the backing field from within the constructor
  • Explicit implementation of the property (rather than using an auto-property)
  • An explicit getter implementation that returns the backing field

public string MyProp { get; private set; } - This means that the property is read-only in the outside of this class, but you can change it's value inside of this class.

By the way, you can set read-only auto-properties value using new auto-initialize syntax which is again introduced in C# 6.0:

public string MyProp { get; } = "You cannot change me";

It is equal to this code for the previous versions of C#:

private readonly string myProp = "You cannot change me"
public string MyProp { get { return myProp ; } }

Or, this in C# 6.0:

public string MyProp { get; }
protected MyClass(string myProp, ...)
{
    this.MyProp = myProp;
    ...
}

is equal to this in the previous versions:

private readonly string myProp;
public string MyProp { get { return myProp; } }
protected MyClass(string myProp, ...)
{
    this.myProp = myProp;
    ...
}

Upvotes: 48

Dennis
Dennis

Reputation: 37790

Values of these properties could be defined inside constructor only:

// C#, all versions
private readonly int _foo;
public int Foo
{
    get { return _foo; }
}

// C#, version 6+
// actually, this is the same as above, but backing field is generated 
// for you by compiler
public int Foo { get; }

Note, that if you know the name of backing field, you can change its value through reflection, thus, this will change result of property getter, but this code will fail, because there is no setter:

typeof(SomeType).GetProperty("Foo").SetValue(bar, 1)

Value of this property could be defined inside any method of declaring type, but also one can easily change it using reflection, without knowledge about backing field, because there is setter:

// this will work fine: typeof(SomeType).GetProperty("Foo").SetValue(bar, 1)
public int Foo { get; private set; }

In other words: the main difference, that first one has get-method only, while the second one has both get- and set- methods.

Upvotes: 1

Andriy Buday
Andriy Buday

Reputation: 1989

In C# 6.0:

public class MyClass
{
    public int MyProp1 { get; }
    public int MyProp2 { get; private set; }

    public MyClass()
    {
        // OK
        MyProp1 = 1;
        // OK
        MyProp2 = 2;
    }

    public void MyMethod()
    {
        // Error CS0200  Property or indexer 'MyClass.MyProp1' cannot be assigned to --it is read only
        MyProp1 = 1;
        // OK
        MyProp2 = 2;
    }
}

In earlier versions of C# the first property does not even compile for this reason:

Error 1 'MyClass.MyProp1.get' must declare a body because it is not marked abstract or extern. Automatically implemented properties must define both get and set accessors.

Upvotes: 1

MakePeaceGreatAgain
MakePeaceGreatAgain

Reputation: 37113

In the first one no-one can set the properties value, in the second case at least the class itself can change it. Having said this only the first one is a real "read-only"-property.

However consider combining it with a readonly-backend-field:

private readonly string field;
public string MyProp { get { return this.field; } }

Now any attemp to change the value of either the property itself or the backing-field will fail. This is identical to the syntax introduced in C#6 where the baking-field is automatically added to be reradonly:

public string MyProp { get; }

However as you already assumed for other classes both properties work same, meaning are not ment to be modified in any way.

Upvotes: 1

Related Questions