{

}

else

{

Console.WriteLine("a contains an odd number");

}

// output: "a contains an odd number that is a multiple of 3"

Important to note that if a condition is met in the above example , the control skips other tests and jumps to the end of that particular if else construct.So, the order of tests is important if you are using if .. else if construct

C# Boolean expressions use short-circuit evaluation. This is important in cases where evaluating conditions may have side e ects:

if (someBooleanMethodWithSideEffects() && someOtherBooleanMethodWithSideEffects()) {

//...

}

There's no guarantee that someOtherBooleanMethodWithSideEffects will actually run.

It's also important in cases where earlier conditions ensure that it's "safe" to evaluate later ones. For example:

if (someCollection != null && someCollection.Count > 0) {

// ..

}

The order is very important in this case because, if we reverse the order:

if (someCollection.Count > 0 && someCollection != null) {

it will throw a NullReferenceException if someCollection is null.

Section 52.42: static

The static modifier is used to declare a static member, which does not need to be instantiated in order to be accessed, but instead is accessed simply through its name, i.e. DateTime.Now.

static can be used with classes, fields, methods, properties, operators, events, and constructors.

While an instance of a class contains a separate copy of all instance fields of the class, there is only one copy of each static field.

class A

{

static public int count = 0;

public A()

{

count++;

}

}

class Program

{

static void Main(string[] args)

{

A a = new A(); A b = new A(); A c = new A();

Console.WriteLine(A.count); // 3

}

}

count equals to the total number of instances of A class.

The static modifier can also be used to declare a static constructor for a class, to initialize static data or run code that only needs to be called once. Static constructors are called before the class is referenced for the first time.

class A

{

static public DateTime InitializationTime;

// Static constructor static A()

{

InitializationTime = DateTime.Now;

// Guaranteed to only run once

Console.WriteLine(InitializationTime.ToString());

}

}

A static class is marked with the static keyword, and can be used as a beneficial container for a set of methods that work on parameters, but don't necessarily require being tied to an instance. Because of the static nature of the class, it cannot be instantiated, but it can contain a static constructor. Some features of a static class include:

Can't be inherited

Can't inherit from anything other than Object

Can contain a static constructor but not an instance constructor

Can only contain static members

Is sealed

The compiler is also friendly and will let the developer know if any instance members exist within the class. An example would be a static class that converts between US and Canadian metrics:

static class ConversionHelper {

private static double oneGallonPerLitreRate = 0.264172;

public static double litreToGallonConversion(int litres) { return litres * oneGallonPerLitreRate;

}

}

When classes are declared static:

public static class Functions

{

public static int Double(int value)

{

return value + value;

}

In a generic class, let's consider

public class Cup<T>

{

// ...

}

T is called a type parameter. The class definition can impose constraints on the actual types that can be supplied for T.

The following kinds of constraints can be applied:

value type

reference type

default constructor

inheritance and implementation

value type

In this case only structs (this includes 'primitive' data types such as int, boolean etc) can be supplied

public class Cup<T> where T : struct

{

// ...

}

reference type

In this case only class types can be supplied

public class Cup<T> where T : class

{

// ...

}

hybrid value/reference type

Occasionally it is desired to restrict type arguments to those available in a database, and these will usually map to value types and strings. As all type restrictions must be met, it is not possible to specify where T : struct or string (this is not valid syntax). A workaround is to restrict type arguments to IConvertible which has built in types of "... Boolean, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char, and String." It is possible other objects will implement IConvertible, though this is rare in practice.

public class Cup<T> where T : IConvertible

{

// ...

}

default constructor

Only types that contain a default constructor will be allowed. This includes value types and classes that contain a default (parameterless) constructor

public class Cup<T> where T : new

{

// ...