Notice that these member variables are declared using the public access

modifier. Public members of a class are directly accessible once an object of

this type has been created. Recall the term object is used to describe an
instance of a given class type created using the new keyword.
Field data of a class should seldom (if ever) be defined as public. To preserve
the integrity of your state data, it is a far better design to define data as
private (or possibly protected) and allow controlled access to the data via
properties (as shown later in this chapter). However, to keep this first
example as simple as possible, public data fits the bill.
objects must be allocated into memory using the new keyword.
an object using the new keyword. However, unlike a normal method,
constructors never have a return value (not even void) and are always named
identically to the class they are constructing
However, as soon as you define a custom constructor with any number of
parameters, the default constructor is silently removed from the class and is
no longer available! Think of it this way: if you do not define a custom
constructor, the C# compiler grants you a default in order to allow the object
user to allocate an instance of your type with field data set to the correct
default values. However , when you define a unique constructor, the compiler
assumes you have taken matters into your own hands.
Therefore, if you wish to allow the object user to create an instance of your
type with the default constructor, as well as your custom constructor, you
must explicitly redefine the default. To this end, understand that in a vast
majority of cases, the implementation of the default constructor of a class is
intentionally empty, as all you require is the ability to create an object with
default values. Consider the following update to the Motorcycle class:
Now that you better understand the role of class constructors, here is a nice
short cut. The Visual Studio IDE provides the ctor code snippet. When you
type ctor and press the Tab key twice, the IDE will automatically define a
custom default constructor! You can then add custom parameters and
implementation logic. Give it a try.
C# supplies a this keyword that provides access to the current class instance.
One possible use of the this keyword is to resolve scope ambiguity, which can
arise when an incoming parameter is named identically to a data field of the
class. Of course, ideally you would simply adopt a naming convention that
does not result in such ambiguity; however, to illustrate this use of the this
keyword, update your Motorcycle class with a new string field (named name)
to represent the drivers name. Next, add a method named SetDriverName()
implemented
A cleaner approach is to designate the constructor that takes the greatest
number of arguments as the master constructor and have its
implementation perform the required validation logic. The remaining
constructors can make use of the this keyword to forward the incoming
arguments to the master constructor and provide any additional parameters
as necessary. In this way, you only need to worry about maintaining a single
constructor for the entire class, while the remaining constructors are basically
empty.

 Here is the final iteration of the Motorcycle class (with one additional
constructor for the sake ofillustration). When chaining constructors, note how
the this keyword is dangling off the constructors eclaration (via a colon
operator) outside the scope of the constructor itself:
class Motorcycle
{
public int driverIntensity;
public string driverName;
// Constructor chaining.
public Motorcycle() {}
public Motorcycle(int intensity)
: this(intensity, "") {}
public Motorcycle(string name)
: this(0, name) {}
// This is the 'master' constructor that does all the real work.
public Motorcycle(int intensity, string name)
using the this keyword to chain constructor calls is never mandatory.
However, when you make use of this technique, you do tend to end up with a
more maintainable and concise class definition.
this keyword to chain constructor calls is never mandatory. However, when
you make use of this technique, you do tend to end up with a more
maintainable and concise class definition. Again, using this technique you can
simplify your programming tasks, as the real work is delegated to a single
constructor (typically the constructor that has the most parameters),
By definition, a utility class is a class that does not maintain any object-level
state and is not created with the new keyword. Rather, a utility class exposes
all functionality as class-level (a.k.a., static) members.
Under the .NET platform, System.Object is always the topmost parent in any
class hierarchy, which defines some general functionality for all types
There is another form of code reuse in the world of OOP: the
containment/delegation model also known as the has-a relationship or
aggregation. This form of reuse is not used to establish parent/child
relationships. Rather, the has-a relationship allows one class to define a
member variable of another class and expose its functionality (if required) to
the object user indirectly
The final pillar of OOP is polymorphism. This trait captures a languages
ability to treat related objects in a similar manner. Specifically, this tenant of
an object-oriented language allows a base class to define a set of members
(formally termed the polymorphic interface) that are available to all
descendents. A classs polymorphic interface is constructed using any
number of virtual or abstract members (see Chapter 6 for full details).
Within a set scope of a property, you use a token named value, which is
used to represent the incoming value used to assign the property by the
caller. This token is not a true C# keyword, ut is whatis known as a contextual
keyword.
// Read-only property? Error!
public int MyReadOnlyProp { get; }

 // Write only property? Error!

public int MyWriteOnlyProp { set; }
this will result in a compiler error. When you are defining an automatic
property, it must support both
read and write functionality. Recall the following:
// Automatic properties must be read and write.
public string PetName { get; set; }
which always indicates a derived constructor is passing data to the
immediate parent constructor. In this situation, you are explicitly calling the
five-parameter constructor defined by Employee and saving yourself
unnecessary calls during the creation of the child class.
While this is a fine example of defensive programming, C# provides the as
keyword to quickly determine at runtime whether a given type is compatible
with another. When you use the as keyword, you are able to determine
compatibility by checking against a null return value
// Use "as" to test compatability.
Hexagon hex2 = frank as Hexagon;
if (hex2 == null)
Console.WriteLine("Sorry, frank is not a Hexagon...");
In addition to the as keyword, the C# language provides the is keyword to
determine whether two items are compatible. Unlike the as keyword,
however, the is keyword returns false, rather than a null reference, if the
types are incompatible. Consider the following implementation of the
GivePromotion() method:
static void GivePromotion(Employee emp)
{
Console.WriteLine("{0} was promoted!", emp.Name);
if (emp is SalesPerson)
{
Console.WriteLine("{0} made {1} sale(s)!", emp.Name,
((SalesPerson)emp).SalesNumber);
Console.WriteLine();
}
if (emp is Manager)
{
Console.WriteLine("{0} had {1} stock options...", emp.Name,
((Manager)emp).StockOptions);
Console.WriteLine();
}
}
Here, you are performing a runtime check to determine what the incoming
base class reference is actually pointing to in memory. After you determine
whether you received a SalesPerson or Manager type, you are able to perform
an explicit cast to gain access to the specialized members of the class. Also
notice that you are not required to wrap your casting operations within a
try/catch construct, as you know that the cast is safe if you enter either if
scope, given your conditional check

 The Master Parent Class: System.Object To wrap up this chapter, Id like to

examine the details of the master parent class in the .NET platform: Object
In the .NET universe, every type ultimately derives from a base class named
System.Object (which can be represented by the C# object keyword
[lowercase o]). The Object class defines a set of common members for
every type in the framework. In fact, when you do build a class that does not
explicitly define its parent, the compiler automatically derives your type from
Object. If you want to be very clear in your intentions, you are free to define
classes that derive from Object as follows:
// Here we are explicitly deriving from System.Object.
class Car : object
{...}
Like any class, System.Object defines a set of members. In the following
formal C# definition, note that some of these items are declared virtual,
which specifies that a given member may be overridden by a subclass, while
others are marked with static (and are therefore called at the class level):
public class Object
{
// Virtual members.
public virtual bool Equals(object obj);
protected virtual void Finalize();
public virtual int GetHashCode();
public virtual string ToString();
// Instance-level, nonvirtual members.
public Type GetType();
protected object MemberwiseClone();
// Static members.
public static bool Equals(object objA, object objB);
public static bool ReferenceEquals(object objA, object objB);
}
Table 6-1. Core Members of System.Object

Instance Method of Object Class Meaning in Life

Equals() By default, this method returns true only if the items being
compared refer to the exact same item in memory. Thus,
Equals() is used to compare object references, not the state of
the object. Typically, this method is overridden to return true
only if the objects being compared have the same internal state
values (that is, value-based semantics).
Be aware that if you override Equals(), you should also override
GetHashCode(), as these methods are used internally by
Hashtable types to retrieve subobjects from the container.
Also recall from Chapter 4, that the ValueType class overrides
this method for all structures, so they work with value-based
comparisons.
Finalize() For the time being, you can understand this method (when
overridden) is called to free any allocated resources before the
object is destroyed. I talk more about the CLR garbage collection
services in Chapter 9.
GetHashCode() This method returns an int that identifies a specific object
instance.
ToString() This method returns a string representation of this object, using

the <namespace>.<type name> format (termed the fully qualified

name). This method will often be overridden by a subclass to
return a tokenized string of name/value pairs that represent the
objects internal state, rather than its fully qualified name.
GetType() This method returns a Type object that fully describes the object
you are currently referencing. In short, this is a Runtime Type
Identification (RTTI) method available to all objects (discussed
in greater detail in Chapter 15).
MemberwiseClone() This method exists to return a member-by-member copy of the
current object, which is often used when cloning an object (see
Chapter 8).

Exceptions that are thrown by the .NET platform are (appropriately) called system exceptions.
These exceptions are generally regarded as nonrecoverable, fatal errors. System exceptions
derive directly from a base class named System.SystemException, which in turn derives from
System.Exception (which derives from System.Object):
such as ArgumentOutOfRangeException, IndexOutOfRangeException, StackOverflowException,
and so forth. Other namespaces define exceptions that reflect the behavior of that namespace.
For example, System.Drawing.Printing defines printing exceptions, System.IO defines
input/output-based exceptions, System.Data defines database-centric exceptions, and so forth.

System-Level Exceptions (System.SystemException)

Application-Level Exceptions
(System.ApplicationException)
Given that all .NET exceptions are class types, you are free to create your own applicationspecific exceptions. However, due to the fact that the System.SystemException base class
represents exceptions thrown from the CLR, you might naturally assume that you should derive
your custom exceptions from the System.Exception type. You could do this, but you could
instead derive from the System.ApplicationException class:
public class ApplicationException : Exception
{
// Various constructors.
}
As a rule, all custom exception classes should be defined as public classes (recall, the default
access modifier of a non-nested type is internal). The reason is that exceptions are often
passed outside of ssembly boundaries, and should therefore be accessible to the calling code
base.
The rule of thumb to keep in mind is to make sure your catch blocks are structured such that
the
very first catch is the most specific exception (i.e., the most derived type in an exception-type
inheritance chain), leaving the final catch for the most general (i.e., the base class of a given
exception inheritance chain, in this case System.Exception).
The reason you need to allocate a new object of the exception being handled is that the only
way to document an inner exception is via a constructor parameter. Consider the following
code:
catch (CarIsDeadException e)
{
try
{
FileStream fs = File.Open(@"C:\carErrors.txt", FileMode.Open);
...
}
catch (Exception e2)
{
// Throw an exception that records the new exception,
// as well as the message of the first exception.
throw new CarIsDeadException(e.Message, e2);

}
}

The finally Block

A try/catch scope may also define an optional finally block. The purpose of a finally block is to ensure
that a set of code statements will always execute, exception (of any type) or not. To illustrate, assume
you want to always power down the cars radio before exiting Main(), regardless of any handled
exception:
If you did not include a finally block, the radio would not be turned off if an exception is
encountered (which might or might not be problematic). In a more real-world scenario, when you need
to dispose of objects, close a file, or detach from a database (or whatever), a finally block ensures a
location for proper cleanup.

If you fail to handle an exception thrown by a method in the .NET base class libraries, the
Visual Studio
debugger breaks at the statement that called the offending method.
catch keyword and an optional finally scope.
When you are creating your own custom exceptions, you ultimately create a class type deriving from
System.ApplicationException, which denotes an exception thrown from the currently executing
application. In contrast, error objects deriving from System.SystemException represent critical (and
fatal)
errors thrown by the CLR.