FAQ --- Part 1

Event: An event is a message sent by an object to signal the occurance of an action. The action could be caused by the user interaction such as a mouse click or it could be triggered by some other program.

1. The object that raises the event is called the event sender.
2. The object that captures the event and responds to it is called the event receiver.

In event communication, the event sender class does not know which object or method will receive (handle) the events it raises. What is needed is an intermediary (or pointer-like mechanism) between the source and the receiver. The .NET Framework defines a special type (Delegate) that provides the functionality of a function pointer.

Delegates: A delegate is a class that can hold a reference to a method. Unlike other classes, a delegate class has a signature, and it can hold references only to methods that match its signature.

There are three steps in defining and using delegates:
Declaration
Instantiation
Invocation

A very basic example (SimpleDelegate1.cs):

using System;

namespace Akadia.BasicDelegate
{
// Declaration
public delegate void SimpleDelegate();

class TestDelegate
{
public static void MyFunc()
{
Console.WriteLine("I was called by delegate ...");
}

public static void Main()
{
// Instantiation
SimpleDelegate simpleDelegate = new SimpleDelegate(MyFunc);

// Invocation
simpleDelegate();
}
}
}

Compile an test:

# csc SimpleDelegate1.cs
# SimpleDelegate1.exe
I was called by delegate ...

Delegates in 1.1
///
/// Declaring a Class with Sum Method
///
public class clsDelegate
{
public int Sum(int a, int b)
{
return a + b;
}
}

// Delegate Declaration
public delegate int SumDelegate(int x,int y);

private void btnSubmit_Click(object sender, EventArgs e)
{
// Delegate Initialization
SumDelegate obj = new SumDelegate(new clsDelegate().Sum);

// Invoking Delegate
MessageBox.Show("Sum: " + obj(2 ,3).ToString());
}

Delegates in 2.0
public delegate int AddDelegate(int a, int y);
private void btnSubmit1_Click(object sender, EventArgs e)
{
AddDelegate obj= delegate(int x,int y) {return x + y;};
MessageBox.Show(obj(5,7).ToString());
}

Anonymous Method
Below is an exapmle of using an anonymous method.

public delegate int ChangeInt(int x);

ChangeInt myDelegate = new ChangeInt(
delegate(int x)
{
return x * 2;
}
);

Understainding Lambda Expression:
It is a simplest form for writing an anonymous method:
ChangeInt myDelegate = x => x * 2;

In case we have more than 1 parameter:
If you have a delegate that takes two arguments:

// Defines a delegate that takes two ints and returns an int
public delegate int MultiplyInts(int arg, int arg2);

You can declare and initialize a delegate:
MultiplyInts myDelegate = (a, b) => a * b;


In case delegate return type is void,but have a parameter then Lambda expression will be:
// Defines a delegate that takes a string and returns void
public delegate void OutputToConsole(string arg);

static void Main(string[] args)
{
OutputToConsole o = a => {
Console.WriteLine(a);
};
o("Hello, World");
}


In case delegate have returns void and takes no arguments, it results in interesting syntax:
// Defines a delegate that takes no arguments and returns void
public delegate void OutputHelloToConsole();

static void Main(string[] args)
{
OutputHelloToConsole o = () =>
{
Console.WriteLine("Hello, World");
};
o();
}

Extension Method
Another new concept that comes with .NET 3.5 is the Extension methods. Now we can include our own custom methods in already defined objects. We can create static classes and include custom methods to objects. Extension method behavior is similar to that of static methods. You can declare them only in static classes. To declare an extension method, you specify the keyword this as the first parameter of the method. Let us look at the following example:
public static class ExtensionMethods
{
public static int ToInt32Extension(this string s)
{
return Int32.Parse(s);
}
}

If we include the above class namespace to our application, any string variable will have ToInt32Extension method.

This function takes 0 arguments and passes the string to s. We can also pass parameters just like below:
public static class ExtensionMethods
{
public static int ToInt32ExtensionAddInteger(this string s,int value)
{
return Int32.Parse(s) + value;
}
}

Here integer value is also passed.
string s = "10";
s.ToInt32Extension(); it'll return int data as declared above in function.


Anonymous Type
Annonymous types introduced with .NET can create object without even declaring the classes. The members of the
anonymous types are implicitely defined during compilation

var x = new { Name ="AA", Age =30, ... };
This would create a new object of annonymous type.
when we check it like x. then it'll list proerties listed above in x.


Meaning of VAR
Var is a new keyword added in .NET 3.5. This is called Implicit Type Variable. During runtime it automatically
assigns its type of the variable based on the object if finds.

var x = 10 // implies the variable is of integer type
var x = new list(); // Means x holds list of employees

var is very useful when working with annonymous typed just introduced. It assigns the type of the variable based on
the type of the object passed in, so there is no difference of doing List() x = new List() and doing var x = new List() as in both the case the type of the variable x is always get to List.

Only restriction is we cannot define members of var type.

Remoting & Webservice

Process:

1. It is an instance of the computer program that is being excuted.

2. It is used as a secuirty boundaries.

3. One process has its own virtual memory and does not overlap the other process virtual memory. due to this one process cannot crash the other process.

4. Any Problem or error in one process does not affect the other process.

Application Domain:

1. It is used as a security boundary in which .Net application executes.

2. In application domain multiple applications can run in same process without influencing each other.

3. Any problem or error in one application domain does not affect the other applicaiton domains.

4. One Process can have multiple applicaiton domains.

Note: To invoke method in a object running in different applicaiton domain .Net remoting is used.

What are two different types of remote object creation mode in .Net?

There are two different ways in which object can be created using Remoting.

1. SAO (Server activated objects) also called as Well-Known call mode.

2. CAO (Client activated objects)

1. SAO: It has two modes "Single Call" & "Singleton".

a. Single call: In it object is created with every method call thus making the object stateless.

b. Singleton: In it object is created only once and the object is shared with all clients.

2. CAO: These are stateful as compared to SAO. In it the creation request is sent from client side. Client holds a proxy to the server object created on server.

Constructors in C#

A constructor is a special method or function used to initialize & create the object of a class.

Types Of Constructory:

Constructor can be of two types

1. Class Constructor (Static Constructors)

2. Instance Constructor (Non Static Constructors)

1. Class Constructor (Static Constructor): A static constructor is used to initialize any static data, or to perform a particular action that needs performed once only. It is called automatically before the first instance is created or any static members are

referenced.

Static constructors have the following properties:

1. A static constructor does not take access modifiers or have parameters.

2. A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.

3. A static constructor cannot be called directly.

4.The user has no control on when the static constructor is executed in the program.

5. A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.

6. Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.

2. Instance Constructor (Non-static constructor): These constructors are normally used to initialize the mermbers and to create the constructor of class.

1. Public

A class constructor is by default public.

2. Private

When we create a private constructor, we cannot create object of the class directly from a client. Also we cannot inherit this class to another class.So by this way we can add security to class that it cannot be instantiated. Also a common use for a private constructor is to implement the singleton pattern.

3. Protected

When we declare a constructor protected then only drive class can create instance of that class.

Copy Constructor:

A copy constructor is a special constructor used to create a new object as a copy of an existing object. This constructor takes a single argument: a reference to the object to be copied. Unlike some languages, C# does not provide a copy constructor. If you create a new object and want to copy the values from an existing object, you have to write the appropriate method yourself.

class Person

{

private string name;

private int age;

// Copy constructor.

public Person(Person previousPerson)

{

name = previousPerson.name;

age = previousPerson.age;

}

// Instance constructor.

public Person(string name, int age)

{

this.name = name;

this.age = age;

}

// Get accessor.

public string Details

{

get

{

return name + " is " + age.ToString();

}

}

}

class TestPerson

{

static void Main()

{

// Create a new person object.

Person person1 = new Person("George", 40);

// Create another new object, copying person1.

Person person2 = new Person(person1);

System.Console.WriteLine(person2.Details);

}

}

Shallow Copy Vs Deep Copy:

Shallow copy copies the structure of the object, deep copy copies structure as well as data.

Dataset.Clone()- Shallow Copy

Dataset.Copy() -- Deep Copy