委托--delegate

委托，跟类很相似，能够定义对象，但是区别是

1，委托必须有关键字delegate。

2，委托有类型修饰符，比如void,string,int。修饰符取决于他的方法返回类型。

3，委托没有方法实现。

 delegate void printFunction();

委托的作用是给委托对象添加几个方法，在使用委托的时候同时调用使用几个方法。

每次委托调用，他的委托的方法都会实现。

调用委托的方式：

委托名（）；

给委托添加方法的方法有：

1，通过实例调用方法添加。例如：

test t = new test();
printFunction p = new printFunction(t.print1);

2,通过静态方法调用方法添加。例如：

test t = new test();
 printFunction p = new  printFunction(test.print1);

但是print1必须是静态方法。

3，赋值委托：不用new 委托了。

 test t = new test();
printFunction p =t.print1;

或者
 test t = new test();
printFunction p =test.print1;

3，组合委托：相当于把第一个委托的方法和第二个委托的方法一起加给第三个委托。

test t = new test();
printFunction p = new  printFunction(t.print1);
printFunction p2 = new printFunction(t.print2);
printFunction p3 = p + p2;
p3();

4，利用+=，和—=来添加和减少方法。

test t = new test();
printFunction p = new  printFunction(t.print1);
p += t.print2;

这种方法的实质其实就是创建了一个新委托，相当于左边的委托加上右边方法的组合委托。

实例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    delegate void printFunction();
    class test
    {
        public void print1()
        {
            Console.WriteLine("第一个打印");
        }
        public void print2()
        {
            Console.WriteLine("第二个打印");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            test t = new test();
            printFunction p = new  printFunction(t.print1);
            p += t.print2;
            p += t.print1;
            p += t.print2;
            p();
            Console.WriteLine(".....................");
            printFunction p2 = new printFunction(t.print2);
            printFunction p3 = p + p2;
            p3();
            Console.ReadLine();
        }
    }
}

结果：

带有返回值的委托

：如果委托有返回值 ，并且调用列表中有一个以上的方法会发生以下情况：

1，调用列表最后一个方法的返回值就是委托调用返回的值。

2，调用列表中除了最后一个方法，其他方法的返回值都会被忽略。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    delegate int printFunction();
    class test
    {
        int val = ;
        public int print1()
        {
            val += ;
            return val;
        }
        public int print2()
        {
            val += ;
            return val;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            test t = new test();
            printFunction p =t.print1;
            p += t.print2;
            p += t.print1;
            Console.WriteLine("value is {0}",p());

            Console.ReadLine();
        }
    }
}

结果:

调用带引用参数的委托。

如果委托带有引用参数。参数值会跟着调用列表中的一个或多个方法的返回值 而改变。

在调用委托列表的下一个方法时，参数的新值会传递给下一个方法。

注意

1,委托和调用的方法的参数是一样的。

2，传值是在调用委托的时候才通过委托传递给方法过去的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    delegate void printFunction(ref int x);
    class Program
    {
        public void add1(ref int x)
        { x += ; }
        public void add2(ref int x)
        { x += ; }
        static void Main(string[] args)
        {
            Program pm = new Program();
            printFunction p = pm.add1;
            p += pm.add2;
            p += pm.add1;

            int x = ;

            p(ref x); //这里才真正传值，把x传递过去，前面只是给定义，并且通过调用方法改变x的值。

            Console.WriteLine("{0}",x);
            Console.ReadLine();
        }
    }
}

运行结果：

12.