CODEWITHSUNDEEP
c#.netproperties
svbnet
svbnet

Reputation: 1090

What's the difference between a property with a private setter and a property with no setter?

If I want a read-only property, I write it like:

public int MyProperty { get { //Code goes here } }

However, the Microsoft example (and a few other examples I've seen) are written like:

public int MyProperty { get; private set; }

Is there any difference between these two, and should I start writing properties like this?

Upvotes: 6

Views: 2143

Answers (5)

Vozzie
Vozzie

Reputation: 455

There is a difference when you access the object with reflection. 

public class Foo
{
    public string Bar { get; private set; }
}

// .....
    internal static void Main()
    {

        Foo foo = new Foo();
        foo.GetType().GetProperty("Bar").SetValue(foo, "private?", null);
        Console.WriteLine(foo.Bar);
    }

Upvotes: 1

xlecoustillier
xlecoustillier

Reputation: 16351

If you don't use an explicit member assignment in the property, you'll have to declare a private set at least in order to be able to set a value to this property. Otherwise, you'll get a warning at compile-time saying that your property cannot be assigned.

If you use an explicit member, you'll be able to assign a value to this member directly, without needing to add a private set:

private int member ;

public int MyProperty {
    get { return member; }
}

// ...

member = 2;
int anotherVariable = MyProperty; // anotherVariable == 2

Upvotes: 4

Thorsten Dittmar
Thorsten Dittmar

Reputation: 56697

As you can see in your second sample, you can leave out the implementation for a property. .NET will then automatically create a local variable for the property and implement simple getting and setting.

public int MyProperty { get; private set; }

is actually equivalent to

private int _myProperty;

public int MyProperty { 
    get { return _myProperty; }
    private set { _myProperty = value; }
}

Writing

public int MyProperty { get; }

does not work at all, as automatic properties need to implement a getter and a setter, while

public int MyProperty { get; private set; }

leaves you with a property that may return any int, but can only be changed within the current class.

public int MyProperty { get { ... } }

creates a read-only property.

Question is: what do you need? If you already have a member variable that's used within your class and you only want to return the current value using a property, you're perfectly fine with

public int MyProperty { get { return ...; }}

However, if you want a read-only property, which you need to set within your code (but not from other classes) without explicitly declaring a member variable, you have to go with the private set approach.

Upvotes: 9

Grimace of Despair
Grimace of Despair

Reputation: 3506

public int MyProperty
{
  get
  {
    // Your own logic, like lazy loading
    return _myProperty ?? (_myProperty = GetMyProperty());
  }
}

A property with only a getter is very useful if you need your own logic behind the access of that property, in particular when you need the property to be lazy loaded.

public int MyProperty { get; private set; }

A property with a private setter is useful if you need the property not te be changed from the outside, but still maintained from within the class.

In both cases, you can have a backing data field for the actual value, but in the former, you'll have to maintain that yourself, and in the latter, it is maintained for you by the generated code.

Upvotes: 2

gzaxx
gzaxx

Reputation: 17590

With private setter you can only assign property value inside of instance when property is without setter you can't set its value anywhere.

Upvotes: 8

Related Questions