CODEWITHSUNDEEP
c#properties
William Lew
William Lew

Reputation: 485

What's so special about properties?

I have the basics down with properties, but I don't see a real use for them. Doesn't it just return the value of an equation? I mean there is no point in using a property if you could just write down a simple equation for it.

For example:

int currentValue;

public int CurrentValue
{
    get { return currentValue; }
    set { currentValue = value; }
}

Is the same thing as just:

currentValue;

Another example:

    int currentValue;

public int CurrentValue
{
    get { return currentValue * 5; }
    set { currentValue = value; }
}

Is the same thing as:

currentValue = currentValue * 5;

Upvotes: 0

Views: 121

Answers (3)

BradleyDotNET
BradleyDotNET

Reputation: 61379

Properties are also used in a number of other .NET technologies, WPF doesn't work without them (with a PropertyChanged event invoke in the setter) and WCF uses them extensively in data contracts.

Especially relating to WPF, the power of properties is that both the "get" and "set" fields are functions and so can do lots of things besides just returning or setting the backing private member. This comes in handy more times than you may think.

Example property (for WPF)

public String UIDisplayedString
{
   get { return _member; }
   set 
   { 
      _member = value;
      PropertyChanged(new PropertyChangedEventArgs("UIDisplayedString"));
   }

Upvotes: 0

Tim S.
Tim S.

Reputation: 56566

In your first example, Public Fields versus Automatic Properties is a good answer. Basically, you should use always properties instead of fields for non-private things. This lets you do things like modify the code later without breaking things, and make a private set. Properties can also do things like notify code when they're changed or provide default or calculated values easily. And you can use auto-properties to cut down on extraneous code:

public int CurrentValue { get; set; }

Your second example is not a good use of properties, since it breaks the assumptions of how properties work. E.g. if I set the property to 3 and no exception is thrown, I'd expect it to be 3 when I get it, not 15. currentValue = currentValue * 5;, which could make sense working with a field, property, or local variable, makes the value 5 times larger. Maybe you meant something like this:

int currentBackingValue;

public int CurrentValue
{
    get { return currentBackingValue * 5; }
}

Without a set, this can work nicely, and without breaking any conventions and assumptions: CurrentValue is calculated based on currentBackingValue.

(as an aside, you should note that the getters and setters of a property are, in fact, methods, just used with a field-like syntax to replace something like Java's getX/setX standard)

Upvotes: 4

ArthurChamz
ArthurChamz

Reputation: 2049

Getters and setters properties are handy if you want to add some extra functionality to your code, centralizing your function so you can change it only in one place. You almost never know when you're going to have to change something, but you can prepare.

This, along with the concepts of encapsulation and information hiding, are basic OOP concepts but very important...

V E R Y     I M P O R T A N T

Don't underestimate this tremendous power D:

Its so... powerful...

Upvotes: 1

Related Questions