This print for content only-size & color not accurate 7" X 9-1/4" / casebound / malloy

// A class with a single public field.

class Book

{

public int numberOfPages;

}

The problem with public field data is that the items have no ability to intrinsically “under-

stand” whether the current value to which they are assigned is valid with regard to the current

business rules of the system. As you know, the upper range of a C# int is quite large (2,147,483,647).

Therefore, the compiler allows the following assignment:

// Humm. That is one heck of a mini-novel!

static void Main(string[] args)

{

Book miniNovel = new Book();

miniNovel.numberOfPages = 30000000;

}

Although you have not overflowed the boundaries of an int data type, it should be clear that a

mini-novel with a page count of 30,000,000 pages is a bit unreasonable. As you can see, public fields

do not provide a way to trap logical upper (or lower) limits. If your current system has a business

rule that states a book must be between 1 and 1,000 pages, you are at a loss to enforce this program-

matically. Because of this, public fields typically have no place in a production-level class definition.

Encapsulation provides a way to preserve the integrity of an object’s state data. Rather than

defining public fields (which can easily foster data corruption), you should get in the habit of defin-

ing 

private data, which is indirectly manipulated using one of two main techniques:

• Define a pair of accessor (get) and mutator (set) methods.

• Define a type property.

Additionally, C# provides the readonly keyword, which also delivers a level of data protection.

Whichever technique you choose, the point is that a well-encapsulated class should hide the details

of how it operates from the prying eyes of the outside world. This is often termed 

black box pro-

gramming. The beauty of this approach is that an object is free to change how a given method is

implemented under the hood. It does this without breaking any existing code making use of it, pro-

vided that the signature of the method remains constant.