Classes are declared by using the keyword class followed by the class
name and a set of class members surrounded by curly braces. Every class
has a constructor, which is called automatically any time an instance of a class
is created. The purpose of constructors is to initialize class members
when an instance of the class is created. Constructors do not have return
values and always have the same name as the class.
// Namespace Declaration
using System;
// helper class
class OutputClass
{
string
myString;
// Constructor
public
OutputClass(string inputString)
{
myString = inputString;
}
// Instance Method
public
void printString()
{
Console.WriteLine("{0}", myString);
}
// Destructor
~OutputClass()
{
//
Some resource cleanup routines
}
}
// Program start class
class ExampleClass
{
// Main begins program execution.
public
static void Main()
{
//
Instance of OutputClass
OutputClass outCl =
new OutputClass("This is
printed by the output class.");
// Call Output class' method
outCl.printString();
}
}
Constructors are not mandatory, as indicated by the implementation of ExampleClass.
In this case, a default constructor is provided. A default constructor is simply
a constructor with no arguments. However, a constructor with no arguments is not
always useful. To make default constructors more useful, you can implement them
with initializers. Here is an example:
public OutputClass()
: this("Default Constructor
String") { }
Imagine this constructor was included in class OutputClass. This default constructor is followed by an initializer. The colon,
":", marks the beginning of the initializer, followed by the this keyword.
The this keyword refers to this particular object. It effectively makes
a call to the constructor of the same object it is defined in. After the this
keyword is a parameter list with a string. The action taken by the initializer
above is to invoke the OutputClass constructor that takes a string
type as an argument. The initializer helps you to ensure your class fields
are initialized when a class is instantiated.
The example above illustrates how a class can have multiple constructors. The specific
constructor called depends on the number of parameters and the type of each parameter.
In C#, there are two types of class members, instance and static.
Instance class members belong to a specific occurrence of a class.
Every time you declare an object of a certain class, you create a new instance
of that class. The ExampleClass Main() method creates
an instance of the OutputClass named outCl. You can create multiple
instances of OutputClass with different names. Each of these instances
are separate and stand alone. For example, if you create two OutputClass
instances as follows:
OutputClass oc1 = new OutputClass("OutputClass1");
OutputClass oc2 = new OutputClass("OutputClass2");
You create two separate instances of OutputClass with separate myString
fields and separate printString() methods. On the other hand, if a class
member is static, you can access it simply by using the syntax <classname>.<static
class member>. The instance names are oc1 and oc2.
Suppose OutputClass had the following static method:
public
static void staticPrinter()
{
Console.WriteLine("There is only one
of me.");
}
Then you could call that function from Main() like this:
OutputClass.staticPrinter();
You must call static class members through their class name and
not their instance name. This means that you don't need to instantiate a class to
use its static members. There is only ever one copy of a static
class member. A good use of static members is when there is a function
to be performed and no intermediate state is required, such as math calculations.
Matter of fact, the .NET Frameworks Base Class Library includes a Math
class that makes extensive use of static members.
Another type of constructor is the static constructor. Use static
constructor to initialize static fields in a class. You declare
a static constructor by using the keyword static just in front
of the constructor name. A static constructor is called before an instance
of a class is created, before a static member is called, and before
the static constructor of a derived class (covered in a later chapter).
They are called only once.
OutputClass also has a destructor. Destructors look just like constructors,
except they have a tilde, "~", in front of them. They don't take any parameters
and do not return a value. Destructors are places where you could put code to release
any resources your class was holding during its lifetime. They are normally called
when the C# garbage collector decides to clean your object from memory.