一点委托的例子和自已做的一点笔记,给自已标志一下,嘿嘿

看书时做的一点笔记

在作为普通函数的指针,回调,事件,线程的时候,委托是很有用的.作为一个普通的函数的指针,一个委托可以是一个方法的参数,函数的返回值,类成员或是局部成员变量.
使用委托的一般过程:定义,创建,调用
用DELEDAGE定义
public delegate int DelegateClass(string s)
用NEW关健字创建委托的一个实例,在其构造函数中用一个函数指针来初始化该委托,也可以不用NEW隐式地创建并初始化一个委托
DelegateClass obj=new DelegateClass(methodA);
DelegateClass obj=methodA;
用调用运算符"()"来调用该委托.也可使用Invoke方法来调用
obj("1")
obj.Invoke("1")
不使用时,将这委托置为NULL
当一个委托作为多个函数指针的宿主时,函数是以先入先出,排队的顺序进行调用的
对于一个实例方法的调用,采用Object.method如果是静态方法,则采用class.method,如果在同一个类里面,则无需对象名和实例名了
多播委托维护着一个调用列表,多播委托中的每一个委托在该列表中都有一个条目击者,条目添加到调用列表中的顺序与委托被添加的顺序相同(队列).GetInvocationList以一个委托数组的方式返回该调用列表
Delegate.Method属性返回一个MethodInfo类型,该类型对用委托抽象的函数进行了包装


这下面的例子是从MSDN上载下来的,可值得好好回味一下,也特别是其面向对象的关系吧,嘿嘿,
分为这三个类三种对象去查看,感觉还好

using System;

namespace Bookstore
{
    using System.Collections;
    //每本书的信息,其实这也可以是一个类

    public struct Book
    {
        public string Title; public string Author;
        public decimal Price; public bool Paperback;
        public Book(string title, string author, decimal price, bool paperBack)
        {
            Title = title;
            Author = author;
            Price = price;
            Paperback = paperBack;
        }
    }

    public delegate void ProcessBookDelegate(Book book);

    // Maintains a book database.
    //这是一个书的数据库类,记录着每次客户的购物篮
    public class BookDB
    {
        //可看成购物篮
        ArrayList list = new ArrayList();

        //把用户选择的书添加进来
        public void AddBook(string title, string author, decimal price, bool paperBack)
        {
            list.Add(new Book(title, author, price, paperBack));
        }

        //委托发挥作用，委托作为参数传入方法ProcessPaperbackBooks内，该方法并不知道委托指        向的是什么方法
        //反正是罗列这么些书,管他是打印书名还是别的等等
        //把书的信息提供出去,也即是接口吧
        public void ProcessPaperbackBooks(ProcessBookDelegate processBook)
        {
            foreach (Book b in list)
            {
                if (b.Paperback)
                {
                    processBook(b);
                }
                //其实这里是把书的信息反馈出去吧
                // 调用委托所指向的方法               
            }
        }
    }
}

// Using the Bookstore classes:
namespace BookTestClient
{
    using Bookstore;

    // Class to total and average prices of books:
    class PriceTotaller
    {
        //可看成售书员对象
        int countBooks = 0;
        decimal priceBooks = 0.0m;

        internal void AddBookToTotal(Book book)
        {
            countBooks += 1;
            priceBooks += book.Price;
        }

        internal decimal AveragePrice()
        {
            return priceBooks / countBooks;
        }
    }

    // Class to test the book database:
    class Test
    {
        //购物的人
        // Print the title of the book.
        static void PrintTitle(Book b)
        {
            Console.WriteLine("   {0}", b.Title);
        }

        // Execution starts here.
        static void Main()
        {
            //实例化一个购物篮
            BookDB bookDB = new BookDB();

            // Initialize the database with some books:
            //往篮里加书
            AddBooks(bookDB);

            // Print all the titles of paperbacks:
            Console.WriteLine("Paperback Book Titles:");         // Create a new delegate object associated with the static
            //反馈书的信息,即是购物篮登记要的
            bookDB.ProcessPaperbackBooks(new ProcessBookDelegate(PrintTitle));
            //等于是把函数作为了参数,而这时的委托指向的函数即是书的数据库所要使用的函数,在这里是打印出书名
            //此时完成此任务的是书数据库,
            //即委托是去调用函数返回书的信息的

            // Get the average price of a paperback by using
            // a PriceTotaller object:
            PriceTotaller totaller = new PriceTotaller();
            // Create a new delegate object associated with the nonstatic
            // method AddBookToTotal on the object totaller:
            //而此时计算书的价格的,平均价格的,是另外一个类完成的,也即是收货员对象完成的
            bookDB.ProcessPaperbackBooks(new ProcessBookDelegate(totaller.AddBookToTotal));
            Console.WriteLine("Average Paperback Book Price: ${0:#.##}",
               totaller.AveragePrice());

            Console.ReadLine();
        }

        // Initialize the book database with some test books:
        static void AddBooks(BookDB bookDB)
        {
            //购物的人选择的书
            bookDB.AddBook("The C Programming Language",
               "Brian W. Kernighan and Dennis M. Ritchie", 19.95m, true);
            bookDB.AddBook("The Unicode Standard 2.0",
               "The Unicode Consortium", 39.95m, true);
            bookDB.AddBook("The MS-DOS Encyclopedia",
               "Ray Duncan", 129.95m, false);
            bookDB.AddBook("Dogbert's Clues for the Clueless",
               "Scott Adams", 12.00m, true);
        }
    }
}

以下是从另一博友那里抄来的:http://www.cnblogs.com/temptation/archive/2006/04/07/369106.html
感觉还好,
其实委托就是一个函数调用,上面也写了主要用的四个方面,而第一种却是比较少见的("普通函数的指针")所以特意贴上来上面这个例子

1.委托是什么？可以理解为对象的一种新的类型，类似于 C 或 C++ 中的函数指针。
2.什么时候使用委托？把方法传送给其他方法的时候使用它。
    我们知道方法的参数主要用于传递数据，比如: int I = int.Parse("99"),其中调用了System.Int32类的静态方法Parse（）。那么把一个方法在作为参数传给另一个方法，怎么传呢？
    最简单的途径就是把方法名作为参数传递给其他的方法。C#规定，如果要传递方法，必须把方法的细节封装在一种新的类型对象中，即委托。使用委托可以将方法 引用封装在委托对象内，然后可以将该委托对象传递给可调用所引用方法的代码,而不必在编译时知道将调用哪个方法。
    委托对象的一个有用属性是,它们可以：
    “+”运算符用来组合。组合的委托可调用组成它的那两个委托。只有相同类型的委托才可以组合。
    “-”运算符用来从组合的委托移除组件委托。
例：
using System;

delegate void MyDelegate( string s );

class MyClass
{
    public static void Hello( string s )
    {
        Console.WriteLine( "  Hello, {0}!", s );
    }

    public static void Goodbye( string s )
    {
        Console.WriteLine( "  Goodbye, {0}!", s );
    }

    public static void Main( )
    {
        MyDelegate a, b, c, d;
       
        // Create the delegate object a that references
        // the method Hello:
        a = new MyDelegate( Hello );
        // Create the delegate object b that references
        // the method Goodbye:
        b = new MyDelegate( Goodbye );
        // The two delegates, a and b, are composed to form c:
        c = a + b;
        // Remove a from the composed delegate, leaving d,
        // which calls only the method Goodbye:
        d = c - a;
       
        Console.WriteLine( "Invoking delegate a:" );
        a( "A" );
        Console.WriteLine( "Invoking delegate b:" );
        b( "B" );
        Console.WriteLine( "Invoking delegate c:" );
        c( "C" );
        Console.WriteLine( "Invoking delegate d:" );
        d( "D" );
    }
}


还有下面这位博友也给出了自已的见解,觉得也挺不错的,说到偶心里去了
http://www.cnblogs.com/yanchengrui/archive/2007/12/04/982436.html