C#

There are different types in C# such as class,interfaces and enums.One of the reference type is delegate.Delegate allows to define objects which can point to a function.This makes it convenient to define decoupled application and pass function as a parameter value to other functions.

For example if you define a delegate called ProcessDelegate then you can create an object of this delegate.This delegate object can point to a method called printMessage which can be passed to a function:

You declare a delegate by using the keyword delegate followed by the signature of the method the delegate will point to:

delegate [return type] Method(parameter list);

by this understanding we can define a delegate called SimpleDelegate:

public delegate int SimpleDelegate(string message);

Now we can declare an object of this delegate as:

 

SimpleDelegate delObj=simpleMethod;

Now we can call this method as:

delObj("hello world");

If you notice above we are calling the simpleMethod by using the delegate object.This allows to create loosely coupled application and to pass the function reference to other functions as parameters.

If we require we can define the logic to call appropriate function using delegate at runtime as:

if(true)
{
delObj("hello world");
}
else
{
delAnotherObject("Another Message");
}

 

Follow on:

Switch statement is one of the conditional statements in c# such as if else.Switch statement in C# is a concise way of writing conditions specially when your code is cluttered with lots of else if conditions,which is making code difficult to read.

It is used for selecting one of the blocks from a list of code blocks.The code block to execute is determined based on the value of the match expression.The keywords used in switch statement are:

• switch It accesses the matchExpression in the beginning.
• case It defines various constant values which are matched with the matchExpression

its syntax is

switch(matchExpression)
{
case Value1:
code block1;
break;

case Value2:
case Value3:
code block2;
break;

default:
code block default;
break;

}

Following is a simple switch case statement:

switch(num)
{
case 1:
Console.WriteLine("Case 1");
break;

case 2:
Console.WriteLine("Case 2");
break;
case 3:
case 4:
Console.WriteLine("Case 3");
break;

default:
Console.WriteLine("not found"); ;
break;

}

It will check the value of the num variable in the beginning and based on that value it will execute the appropriate case statement.If none of the case statement matches then default case will be executed and “not found” will be displayed.

You can notice above that we used same code block for both Case 3 and Case 4.This is allowed in C# and you could write common logic for multiple cases this way.

Follow on:

Many times you need to initialize class objects while creating them.One obvious approach is that you can use constructors for this.Suppose if you have declared a class as below:

public class Products
{
public int Category { get; set; }
public int Name { get; set; }

}

As you can see it has no constructor,so if you want to create an object of this class and initialize properties at the same time then you can not do so.
But you can initialize object while creating it using the Object initializer syntax.To initialize an objects properties while creating an object you assign values to the properties in curly braces:

var classObject=new Class{Property1=value1,Property2=value2}

Now you can assign values to the properties of the Products class at initialization as:

var product=new Products{Category=1,Name="Desktop"};

we can also initialize collection objects this way >link to another post

Object initializers for creating Anonymous types

Suppose you want to create a class just for using it single time.You can create anonymous class for this.To create anonymous class you use object initializers.For example,if you want to create an object of anonymous class called product:

var product=new {Category=1,Name="Desktop"};

This is specially useful when you are using LINQ and need to project values not defined in a type.In the following example we are projecting values which are not defined in a type:

var items =
from item in items
select new { item.Name,DateTime.Now };

 

Follow on: