//定義有返回值的委托 
  public delegate string GenricDelegate<T, S>(T title, S author);

  //定義事件委托。
  public delegate void GenricDelegateEnent<E,P>(E Name,P Address);

  public class GenericDelegateClass<V,F>
  {
    //聲明委托
    public GenricDelegate<V, F> GdeleValue;
    //聲明事件委托
    public event GenricDelegateEnent<V, F> GdEvent = null;

    public string GetValues(V title, F author)
    {
      //調(diào)用委托
      return GdeleValue(title, author);
    }

    public GenericDelegateClass()
    {
    }

    public void InvokeEvent(V name, F address)
    {
      if (GdEvent != null)
      {
        //調(diào)用委托
        GdEvent(name, address);
      }
    }
  }

    private void btnDelegate_Click(object sender, EventArgs e)
    {

      GenericDelegateClass<string, string> gd = new GenericDelegateClass<string, string>();
      //將DelegateReturn事件梆定給GdeleValue
      gd.GdeleValue = new GenricDelegate<string, string>(DelegateReturn);
      //將GenericEvent事件梆定給GdEvent
      gd.GdEvent += new GenricDelegateEnent<string, string>(GenericEvent<string,string>);
    }

    public string DelegateReturn<T,S>(T title,S author)
    {
      return title.ToString() + author;
    }

    private void GenericEvent<V, F>(V name, F address)
    {
      //
    }

public delegate void Del<T>(T item);
public static void Notify(int i) { }

Del<int> m1 = new Del<int>(Notify);

class Stack<T>
{
  T[] items;
  int index;

  public delegate void StackDelegate(T[] items);
}

private static void DoWork(float[] items) { }

public static void TestStack()
{
  Stack<float> s = new Stack<float>();
  Stack<float>.StackDelegate d = DoWork;
}

delegate void StackEventHandler<T, U>(T sender, U eventArgs);

class Stack<T>
{
  public class StackEventArgs : System.EventArgs { }
  public event StackEventHandler<Stack<T>, StackEventArgs> stackEvent;

  protected virtual void OnStackChanged(StackEventArgs a)
  {
    stackEvent(this, a);
  }
}

class SampleClass
{
  public void HandleStackChange<T>(Stack<T> stack, Stack<T>.StackEventArgs args) { }
}

public static void Test()
{
  Stack<double> s = new Stack<double>();
  SampleClass o = new SampleClass();
  s.stackEvent += o.HandleStackChange;
}