相当于函数指针~~~
如果了解函数指针的话，就不用举例了

delegate double processdclegate(double param1,double param2);
        static double multiply(double param1, double param2)
        {
            return param1 * param2; 
        }
        static double divide(double param1, double param2)
        {
            return param1 / param2; 
        }
       static void Main(string[] args)
        {
           processdclegate process;
            Console.WriteLine("enter 2 numbers separated with a comma:");
            string input = Console.ReadLine();
            int commapos = input.IndexOf(',');
            double param1 = Convert.ToDouble(input.Substring(0,commapos));
            double param2 = Convert.ToDouble(input.Substring(commapos+1,input.Length-commapos-1));
            Console.WriteLine("enter M to multiply or D to divide:");
            input = Console.ReadLine();
            if (input == "M")
                process = new processdclegate(multiply);
            else
                process = new processdclegate(divide);
            Console.WriteLine("result: {0}",process(param1,param2));
      }
这个例子,如输M在 process = new processdclegate(multiply);它怎么把param1,param2传过去了呢?

我也没有理解，但我到有个方法可以解决。
将param1,param2 申明为public 即可。

才翻了一下书，才明白。
虽然 process = new processdclegate(multiply)这里的multiply没有带参数过去，但在最后，我们可以委托 process 将参数送过去： 
 Console.WriteLine("result: {0}",process(param1,param2));

form1 
pulbic delegate void Function1(int a) 声明委托
publbic Function1 myFunction 定义委托

form1 中某个方法或函数
void aaa()
{
   myFunction (11); 
}

Form2

void bbb()
{
   Form1 myForm = new Form1();
   myForm.myFunction = new Form2.Form1.Function1(my_NewFunction); //定义委托
   myForm.Show() 
}

void my_NewFunction(int b)
{
   MessageBox.Show(b.ToString());
}

这样当执行form1中的aaa方法时，form2就可以接受到参数1并弹出MessageBox

以上是.net 2003中的写法
.net 2005 应该是myForm.myFunction += new System.EventHandler(my_NewFunction); //New委托事件 
具体的记不清楚，写代码时按TAB键，new 后面的事件会自动生成
当关闭时要记得myForm.myFunction -= new System.EventHandler(my_NewFunction); //删除委托事件

委托是C＃中的一种引用类型，类似于C/C++中的函数指针。与函数指针不同的是，委托是面向对象、类型安全的，而且委托可以引用静态方法和实例方法，而函数指针只能引用静态函数。委托主要用于 .NET Framework 中的事件处理程序和回调函数。
    一个委托可以看作一个特殊的类，因而它的定义可以像常规类一样放在同样的位置。与其他类一样，委托必须先定义以后，再实例化。与类不同的是，实例化的委托没有与之相应的术语(类的实例化称作对象)，作为区分我们将实例化的委托称为委托实例。
    委托是事件的基础。
    通过将委托与命名方法或匿名方法关联，可以实例化委托。有关更多信息，请参见命名方法和匿名方法。 
    为了与命名方法一起使用，委托必须用具有可接受签名的方法进行实例化。有关方法签名中允许的方差度的更多信息，请参见委托中的协变和逆变。为了与匿名方法一起使用，委托和与之关联的代码必须一起声明。本节讨论这两种实例化委托的方法。
using System;
// Declare delegate -- defines required signature:
delegate void SampleDelegate(string message);

class MainClass
{
    // Regular method that matches signature:
    static void SampleDelegateMethod(string message)
    {
        Console.WriteLine(message);
    }

    static void Main()
    {
        // Instantiate delegate with named method:
        SampleDelegate d1 = SampleDelegateMethod;
        // Instantiate delegate with anonymous method:
        SampleDelegate d2 = delegate(string message)
        { 
            Console.WriteLine(message); 
        };

        // Invoke delegate d1:
        d1("Hello");
        // Invoke delegate d2:
        d2(" World");
    }
}

在2005下,委托可以分为带参委托和无参委托.
看看MSDN上的例子吧.
把委托当成事件处理好了

Object element) 方法，否则将抛出 UnsupportedOperationException。如果列表为可变大小，则程序员必须另外重写 add(int index, Object e