What Are Properties?

Using Properties When you use a property in an expression, you use it either in a read context when you are not modifying its value or in a write context when you are modifying its value

What Are Properties?

A property is a cross between a logical field and a physical method You use a property in exactly the same way that you use a field Logically, a property looks like a field

However, the compiler automatically translates this field-like syntax into calls to special method-like accessors A property declaration looks like this:

AccessModifier

Type PropertyName

{

get

{

// read accessor code

}

set

{

// write accessor code

}

}

A property can contain two blocks of code, starting with the get and set keywords The get block contains statements that execute when the property is read, and the set block contains statements that run when the property is written to The type of the property specifies the type of data read and written to by the get and set accessors

The next code segment shows the ScreenPosition struct rewritten by using properties When reading this code, notice the following:

• Lowercase x and y are private fields

• Uppercase X and Y are public properties

• All set accessors are passed the data to be written, by using a hidden parameter

called value

TIP

The fields and properties follow the standard Microsoft Visual C# public/private naming convention Public fields and properties should start with an uppercase letter but private fields and properties should start with a lowercase letter

struct ScreenPosition

{

public ScreenPosition(int X, int Y)

{

this.x = rangeCheckedX(X);

this.y = rangeCheckedY(Y);

}

public int X

{

get { return this.x; }

set { this.x = rangeCheckedX(value); }

}

public int Y

{

get { return this.y; }

set { this.y = rangeCheckedY(value); }

}

private static int rangeCheckedX(int x) { }

private static int rangeCheckedY(int y) { }

private int x, y;

}

In this example, a private field directly implements each property This is only one way

to implement a property All that is required is that a get accessor returns a value of the specified type Such a value could easily be calculated, in which case there would be no need for a physical field

NOTE

Although the examples in this chapter show how to define properties for a struct, they are equally applicable to classes; the syntax is the same

Using Properties

When you use a property in an expression, you use it either in a read context (when you are not modifying its value) or in a write context (when you are modifying its value) The following example shows how to read values from the X and Y properties of a

ScreenPosition struct:

ScreenPosition origin = new ScreenPosition(0, 0);

int xpos = origin.X;

int ypos = origin.Y;

Notice that you access properties and fields by using the same syntax When you use a property in a read context, the compiler automatically translates your field-like code into

a call to the get accessor of that property Similarly, if you use a property in a write

context, the compiler automatically translates your field-like code into a call to the set accessor of that property:

origin.X = 40;

origin.Y = 100;

The values being assigned are passed in to the set accessors by using the value variable,

as described earlier The runtime does this automatically

It's also possible to use a property in a read/write context In this case, both the get

accessor and the set accessor are used For example, the compiler automatically translates statements such as the following into calls to the get and set accessors:

origin.X += 10;

TIP

You can declare static properties, in the same way that you can declare static fields and methods Static properties are accessed by using the name of the class or struct rather than an instance of the class or struct

Read-Only Properties

You're allowed to declare a property that contains only a get accessor In this case, you can use the property only in a read context For example, here's the X property of the ScreenPosition struct declared as a read-only property:

struct ScreenPosition

{

public int X

{

get { return this.x; }

}

}

The X property does not contain a set accessor; therefore, any attempt to use X in a write context will fail For example:

origin.X = 140; // compile-time error

Write-Only Properties

Similarly, you're allowed to declare a property that contains only a set accessor In this case, you can use the property only in a write context For example, here's the X property

of the ScreenPosition struct declared as a write-only property:

struct ScreenPosition

{

public int X

{

set { this.x = rangeCheckedX(value); }

}

}

The X property does not contain a get accessor; any attempt to use X in a read context will fail For example:

Console.WriteLine(origin.X); // compile-time error

origin.X = 200; // compiles ok

origin.X += 10; // compile-time error

NOTE

Write-only properties are useful for secure data such as passwords Ideally, an application that implements security should allow you to set your password but should never allow you to read it back A login method should only compare a user-supplied string with the stored password, and return an indication of whether they match

Property Accessibility

The accessibility of a property (public, private, or protected) is specified when you

declare the property However, it is possible to specify different accessibilities for get and set accessors For example, the version of the ScreenPosition struct shown below defines the set accessors of the X and Y properties as private (the get accessors remain public): struct ScreenPosition

{

public int X

{

get { return this.x; }

private set { this.x = rangeCheckedX(value); }

}

public int Y

{

get { return this.y; }

private set { this.y = rangeCheckedY(value); }

}

private int x, y;

}

You must observe some rules when defining accessors with different accessibility from each other:

• You can change the accessibility of only one of the accessors when you define it

It wouldn't make much sense to define a property as public only to change the accessibility of both accessors to private anyway!

• The modifier must not specify an accessibility that is less restrictive than that of

the property For example, if the property is declared as private, you cannot specify the read accessor as public (in this example, you would make the property public, and make the read accessor private)