C# .NET - explain abstract class,interface,delegates,procedures

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

http://www.aspspider.com/qa/Question3421.aspx

msdn.microsoft.com/en-us/library/aa288436.aspx

Abstract Class

An abstract class is a special kind of class that cannot be instantiated. So the question is why we need a class that cannot be instantiated? An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated. The advantage is that it enforces certain hierarchies for all the subclasses. In simple words, it is a kind of contract that forces all the subclasses to carry on the same hierarchies or standards.
E.g.:

using System;
abstract class MyAbs
{
public abstract void AbMethod1();
public abstract void AbMethod2();
}
//not necessary to implement all abstract methods
//partial implementation is possible
abstract class MyClass1 : MyAbs
{
public override void AbMethod1()
{
Console.WriteLine("Abstarct method #1");
}
}
class MyClass : MyClass1
{
public override void AbMethod2()
{
Console.WriteLine("Abstarct method #2");
}
}
class MyClient
{
public static void Main()
{
MyClass mc = new MyClass();
mc.AbMethod1();
mc.AbMethod2();
}
}

Interface

An interface is not a class. It is an entity that is defined by the word Interface. An interface has no implementation; it only has the signature or in other words, just the definition of the methods without the body. As one of the similarities to Abstract class, it is a contract that is used to define hierarchies for all subclasses or it defines specific set of methods and their arguments. The main difference between them is that a class can implement more than one interface but can only inherit from one abstract class. Since C# doesn’t support multiple inheritance, interfaces are used to implement multiple inheritance.

See these links to know more abt abstract class n interface;

http://www.codeproject.com/KB/cs/abstractsvsinterfaces.aspx

http://geekswithblogs.net/mahesh/archive/2006/07/05/84120.aspx

http://www.c-sharpcorner.com/UploadFile/rajeshvs/AbstractClassesNMethods11122005014357AM/AbstractClassesNMethods.aspx

Delegates

A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked. Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and secure.

A delegate declaration defines a type that encapsulates a method with a particular set of arguments and return type. For static methods, a delegate object encapsulates the method to be called. For instance methods, a delegate object encapsulates both an instance and a method on the instance. If you have a delegate object and an appropriate set of arguments, you can invoke the delegate with the arguments.

An interesting and useful property of a delegate is that it does not know or care about the class of the object that it references. Any object will do; all that matters is that the method's argument types and return type match the delegate's. This makes delegates perfectly suited for "anonymous" invocation.

See this link to know abt delegates;

http://msdn.microsoft.com/en-us/library/aa288459(VS.71).aspx

See this link for procedures;

http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com.ibm.db2.udb.apdv.sql.doc/doc/t0011399.htm

Best Luck!!!!!!!!!!!!!!
Sujit.

Abstract Class

• Abstract class defines functionality that is implemented by one or more subclass.
• Abstract class states “what” to do, rather than “how” to do.
• Abstract class cannot be instantiated.
• Abstract method “must” be overridden in derived class.
• Abstract classes can provide all, some, or none of the actual implementation of a class. It provides a default code or stub for their child class.
• It is useful while creating Component.

Example:

abstract class shape

{

        void draw() { }

}

class circle : shape

{

        void draw()

        {

               Console.WriteLine(“Circle”);

        }

}

class rectangle : shape

{

        void draw()

        {

               Console.WriteLine(“rectangle”);

        }

}

class triangle : shape

{

        void draw()

        {

               Console.WriteLine(“triangle”);

        }

}

static void main()

{

        shape s;

        s = new circle();

        s.draw();

        s = new rectangle();

        s.draw();

        s = new triangle();

        s.draw();

}

Interface

Practical Example

public interface IDrivable

{

   void GoForward(int Speed);

}

public class Truck : IDrivable

{

   public void GoForward(int Speed)

   {

      // Implementation omitted

   }

}

public class Aircraft : IDrivable

{

   public void GoForward(int Speed)

   {

      // Implementation omitted

   }

}

public class Train : IDrivable

{

   public void GoForward(int Speed)

   {

      // Implementation omitted

   }

}

Extra 

Both classes and structures can implement interfaces, including multiple interfaces.

A delegate in C# is similar to a function pointer in C or C++ but they are managed and type safe. Using a delegate allows the programmer to encapsulate a reference of one or more methods that have identical signatures. 

The delegate object can then be passed to Event or Method which can call the referenced method, without having to know at compile time which method will be invoked.

There are four steps in defining and using delegates: 

Delegate has 4 steps:
1- Definition : public delegate void TestCallback();
2- Declaration: Testcallback tc;
3- Instantiation: tc= new Testcallback(Test.f);
4- Call: tc();

Procedures:

A procedure or function is an object stored in the database, and run as a unit to solve a specific problem or perform a set of related tasks. Procedures and functions permit the caller to provide parameters that can be input only, output only, or input and output values. Procedures and functions let you combine the ease and flexibility of SQL with the procedural functionality of a structured programming language.

Procedures and functions are identical except that functions always return a single value to the caller, while procedures do not but could return value