C Sharp Programming/Classes

As in other object-oriented programming languages, the functionality of a C# program is implemented in one or more classes. The methods and properties of a class contain the code that defines how the class behaves.

C# classes support information hiding by encapsulating functionality in properties and methods and by enabling several types of polymorphism, including subtyping polymorphism via inheritance and parametric polymorphism via generics.

Several types of C# classes can be defined, including instance classes (standard classes that can be instantiated), static classes, and structures. Classes are defined using the keyword followed by an identifier to name the class. Instances of the class can then be created with the keyword followed by the name of the class.

The code below defines a class called with properties  and  and with empty methods  and. It also defines a class that instantiates and uses the  class:

Methods
C# methods are class members containing code. They may have a return value and a list of parameters, as well as a generic type declaration. Like fields, methods can be static (associated with and accessed through the class) or instance (associated with and accessed through an object instance of the class methods as well as a generic type declaration.

From C# 4.0 onwards, it is possible for a method to have optional parameters with default values, as users of C++ already know. For example, the method

can be called with one parameter only, as the second parameter, dx, is initialised to a default value.

Constructors of classes
A class's constructors control its initialization. A constructor's code executes to initialize an instance of the class when a program requests a new object of the class's type. Constructors often set properties of their classes, but they are not restricted to doing so.

Like other methods, a constructor can have parameters. To create an object using a constructor with parameters, the command accepts parameters. The code below defines and then instantiates multiple objects of the class, once using the constructor without parameters and once using the version with a parameter:

Output: Start Constructed without parameters Parameter for construction End

Constructors can call each other:

Finalizers (Destructors)
The opposite of constructors, finalizers define the final behavior of an object and execute when the object is no longer in use. Although they are often used in C++ to free resources reserved by an object, they are less frequently used in C# due to the .NET Framework Garbage Collector. An object's finalizer, which takes no parameters, is called sometime after an object is no longer referenced, but the complexities of garbage collection make the specific timing of finalizers uncertain.

Output: Constructed! Finalized!

Properties
C# properties are class members that expose functionality of methods using the syntax of fields. They simplify the syntax of calling traditional get and set methods (a.k.a. accessor methods). Like methods, they can be static or instance.

Properties are defined in the following way:

An even shorter way for getter/setter methods are accessors that do both in one line:

The code is equivalent to a GetLanguage and SetLanguage method definition, but without having to define these methods. The user can directly access the member, if it is not private, of course.

The C# keyword contains the value assigned to the property. After a property is defined it can be used like a variable. If you were to write some additional code in the get and set portions of the property it would work like a method and allow you to manipulate the data before it is read or written to the variable.

Using properties in this way provides a clean, easy to use mechanism for protecting data.

Indexers
C# indexers are class members that define the behavior of the array access operation (e.g. to access the first element of  even when  is not an array).

To create an indexer, use the this keyword as in the following example:

This code will create a string indexer that returns a string value. For example, if the class was, you could write code similar to the following:

Events
C# events are class members that expose notifications to clients of the class. Events are only fired and never assigned.

See also here for details.

Operator overloading
C# definitions are class members that define or redefine the behavior of basic C# operators (called implicitly or explicitly) on instances of the class:

Structures
Structures, or structs, are defined with the keyword followed by an identifier to name the structure. They are similar to classes, but have subtle differences. Structs are used as lightweight versions of classes that can help reduce memory management efforts when working with small data structures. In most situations, however, using a standard class is a better choice.

The principal difference between structs and classes is that instances of structs are values whereas instances of classes are references. Thus when you pass a struct to a function by value you get a copy of the object so changes to it are not reflected in the original because there are now two distinct objects but if you pass an instance of a class by reference then there is only one instance.

The structure below declares a  and a  field. Access to the field is granted through the  property :

Since C# 2.0, is possible to have arrays inside structures, but only in unsafe contexts:

The array is accessed using pointer arithmetic. Values are treat arrayed values as if they were C-style arrays using indexing, etc.

Structure constructors
Structures need constructors - or better to say initialisers, as they do not construct but just initialise the memory - so that their contents are not left uninitialised. Therefore, constructors without parametres are not allowed.

Structure variables can be assigned one to another if and only if the structure variable on the right side of the assignment are all initialised.

Static classes
Static classes are commonly used to implement a Singleton Pattern. All of the methods, properties, and fields of a class are also  (like the  method of the  class) and can thus be used without instantiating the  class: