¡¼ Usage Sample: 
-------------------------------------
event: 		OnMessageReceived
delegate: 	dMessageReceived

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// add
using ZLib.WinForm.NotifyMessaging;

namespace ZLib.WinForm
{
    public sealed class ZNotifyString: IDisposable 
    {
        private bool mbDisposed = false;

        public delegate void dMessageReceived(object sender, string e);
        public event dMessageReceived OnMessageReceived;
        
        private XDListener listener;
        private string msChannelName;

        public string Name
        {
            get { return msChannelName; }
        }
        public ZNotifyString(string sName)
        {
            listener = new XDListener();

            listener.MessageReceived += new XDListener.XDMessageHandler(listener_MessageReceived);

            listener.RegisterChannel(sName);

            msChannelName = sName;
 
        }

        void listener_MessageReceived(object sender, XDMessageEventArgs e)
        {
            if (e.DataGram.Channel == msChannelName)
                OnMessageReceived(this, e.DataGram.Message);
        }

        ~ZNotifyString()
        {
            myDispose(true);
            GC.SuppressFinalize(this);
        }

        public static void SendStringMessage(string sName, string sMessage)
        {
            XDBroadcast.SendToChannel(sName, sMessage);
        }
        public static void SendStringMessage(string sName, string sFormat, params object[] poa)
        {
            XDBroadcast.SendToChannel(sName, string.Format(sFormat, poa));
        }

        #region IDisposable Members

        public void Dispose()
        {
            myDispose(true);
            GC.SuppressFinalize(this);
        }
        private void myDispose(bool bDisposing)
        {
            if (!this.mbDisposed)
            {
                if (bDisposing)
                {
                    // Dispose managed resources
                    // mRD.Dispose()
                }

//                this.CloseConnection();
                listener.UnRegisterChannel(msChannelName);

                mbDisposed = true;
            }
        }

        #endregion


    }
}

----------------------------------------------------
Receiver:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
// add
using ZLib.WinForm;

namespace ZWinMsg
{
    public partial class Form1 : Form
    {
        private const string mcsChannelName = "__ZWinMsg";
        ZNotifyString mNotify = new ZNotifyString(mcsChannelName);
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            mNotify.OnMessageReceived += new ZNotifyString.dMessageReceived(mNotify_OnMessageReceived);
        }

        void mNotify_OnMessageReceived(object sender, string e)
        {
            this.txtMsg.Text = sender.ToString() + ":" + e;
        }
    }
}


------------------------------------------
caller:
        private const string mcsChannelName = "__ZWinMsg";
	
        private void btnSendConsole_Click(object sender, EventArgs e)
        {
            //ZNotifyString.SendStringMessage("TASK36CK", DateTime.Now.ToString());
            ZNotifyString.SendStringMessage(mcsChannelName, DateTime.Now.ToString());
        }



¡¼ A delegate is a type that references a method.
 
Once a delegate is assigned a method, it behaves exactly like that method. 
The delegate method can be used like any other method, with parameters and a return value, as in this example:

public delegate int PerformCalculation(int x, int y);


Any method that matches the delegate's signature, which consists of the return type and parameters, can be assigned to the delegate. 
This makes is possible to programmatically change method calls, and also plug new code into existing classes. 
As long as you know the delegate's signature, you can assign your own delegated method.

This ability to refer to a method as a parameter makes delegates ideal for defining callback methods. 
For example, a sort algorithm could be passed a reference to the method that compares two objects. 
Separating the comparison code allows the algorithm to be written in a more general way.

¡¼ Delegates Overview

Delegates have the following properties:
Delegates are similar to C++ function pointers, but are type safe.
Delegates allow methods to be passed as parameters.
Delegates can be used to define callback methods.
Delegates can be chained together; for example, multiple methods can be called on a single event.

Methods don't need to match the delegate signature exactly. For more information, see Covariance and Contravariance

C# version 2.0 introduces the concept of Anonymous Methods, which permit code blocks to be passed as parameters in place of a separately defined method.


// A set of classes for handling a bookstore:
namespace Bookstore
{
    using System.Collections;

    // Describes a book in the book list:
    public struct Book
    {
        public string Title;        // Title of the book.
        public string Author;       // Author of the book.
        public decimal Price;       // Price of the book.
        public bool Paperback;      // Is it paperback?

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

    // Declare a delegate type for processing a book:
    public delegate void ProcessBookDelegate(Book book);

    // Maintains a book database.
    public class BookDB
    {
        // List of all books in the database:
        ArrayList list = new ArrayList();

        // Add a book to the database:
        public void AddBook(string title, string author, decimal price, bool paperBack)
        {
            list.Add(new Book(title, author, price, paperBack));
        }

        // Call a passed-in delegate on each paperback book to process it: 
        public void ProcessPaperbackBooks(ProcessBookDelegate processBook)
        {
            foreach (Book b in list)
            {
                if (b.Paperback)
                    // Calling the delegate:
                    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 TestBookDB
    {
        // Print the title of the book.
        static void PrintTitle(Book b)
        {
            System.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:
            System.Console.WriteLine("Paperback Book Titles:");

            // Create a new delegate object associated with the static 
            // method Test.PrintTitle:
            bookDB.ProcessPaperbackBooks(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(totaller.AddBookToTotal);

            System.Console.WriteLine("Average Paperback Book Price: ${0:#.##}",
                    totaller.AveragePrice());
        }

        // 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);
        }
    }
}

output:
Paperback Book Titles:
   The C Programming Language
   The Unicode Standard 2.0
   Dogbert's Clues for the Clueless
Average Paperback Book Price: $23.97

¡¼¡³¡µ¡º¡·¡ó¤jºõ²Å¸¹