const int X { get { ... } set { ... } } // compile-time error in Visual Studio .NET

Printing PDF-417 2d barcode in Visual Studio .NET const int X { get { ... } set { ... } } // compile-time error

Properties are a powerful feature with a clean, eldlike syntax. Used in the correct manner, properties help to make code easier to understand and maintain. However, they are no substitute for careful object-oriented design that focuses on the behavior of objects rather than on the properties of objects. Accessing private elds through regular methods or through properties does not, by itself, make your code welldesigned. For example, a bank account holds a balance. You might therefore be tempted to create a Balance property on a BankAccount class, like this:

class BankAccount { ... public money Balance { get { ... } set { ... } } private money balance; }

This would be a poor design. It fails to represent the functionality required when withdrawing money from and depositing money into an account. (If you know of a bank that allows you to set the balance of your account directly without depositing money, please let me know!) When you re programming, try to express the problem you are solving in the solution and don t get lost in a mass of low-level syntax:

class BankAccount { ... public money Balance { get { ... } } public void Deposit(money amount) { ... } public bool Withdraw(money amount) { ... } private money balance; }

You encountered interfaces in 13, Creating Interfaces and De ning Abstract Classes. Interfaces can de ne properties as well as methods. To do this, you specify the get or set keyword, or both, but replace the body of the get or set accessor with a semicolon. For example:

interface IScreenPosition { int X { get; set; } int Y { get; set; } }

Any class or structure that implements this interface must implement the X and Y properties with get and set accessor methods. For example:

struct ScreenPosition : IScreenPosition { ... public int X { get { ... } set { ... } } public int Y { get { ... } set { ... } } ... }

If you implement the interface properties in a class, you can declare the property implementations as virtual, which enables derived classes to override the implementations. For example:

class ScreenPosition : IScreenPosition { ... public virtual int X { get { ... } set { ... } } public virtual int Y { get { ... } set { ... } } ... }

15

You can also choose to implement a property by using the explicit interface implementation syntax covered in 13. An explicit implementation of a property is nonpublic and nonvirtual (and cannot be overridden). For example:

struct ScreenPosition : IScreenPosition { ... int IScreenPosition.X { get { ... } set { ... } } int IScreenPosition.Y { get { ... } set { ... } } ... private int x, y; }

When you set property values of objects such as TextBox controls, Windows, and Button controls by using the Properties window in Microsoft Visual Studio 2008, you are actually generating code that sets the values of these properties at run time. Some components have a large number of properties, although some properties are more commonly used than others. You can write your own code to modify many of these properties at run time by using the same syntax you have seen throughout this chapter. In the following exercise, you will use some prede ned properties of the TextBox controls and the Window class to create a simple application that continually displays the size of its main window, even when the window is resized.

1. Start Visual Studio 2008 if it is not already running. 2. Open the WindowProperties project, located in the \Microsoft Press\Visual CSharp Step by Step\ 15\WindowProperties folder in your Documents folder. 3. On the Debug menu, click Start Without Debugging.