Csharp/C Sharp/Language Basics/delegate Event

Материал из .Net Framework эксперт
Перейти к: навигация, поиск

A class receives the notification when a static method is used as an event handler

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

/* A class receives the notification when

  a static method is used as an event handler. */ 
 

using System;

// Declare a delegate for an event. delegate void MyEventHandler();

// Declare an event class. class MyEvent {

 public event MyEventHandler SomeEvent; 

 // This is called to fire the event. 
 public void OnSomeEvent() { 
   if(SomeEvent != null) 
     SomeEvent(); 
 } 

}

class X {

 /* This is a static method that will be used as 
    an event handler. */ 
 public static void Xhandler() { 
   Console.WriteLine("Event received by class."); 
 } 

}

public class EventDemo3 {

 public static void Main() {  
   MyEvent evt = new MyEvent(); 

   evt.SomeEvent += new MyEventHandler(X.Xhandler); 

   // Fire the event. 
   evt.OnSomeEvent(); 
 } 

}


      </source>


An event multicast demonstration

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

// An event multicast demonstration.

using System;

// Declare a delegate for an event. delegate void MyEventHandler();

// Declare an event class. class MyEvent {

 public event MyEventHandler SomeEvent; 

 // This is called to fire the event. 
 public void OnSomeEvent() { 
   if(SomeEvent != null) 
     SomeEvent(); 
 } 

}

class X {

 public void Xhandler() { 
   Console.WriteLine("Event received by X object"); 
 } 

}

class Y {

 public void Yhandler() { 
   Console.WriteLine("Event received by Y object"); 
 } 

}

public class EventDemo1 {

 static void handler() { 
   Console.WriteLine("Event received by EventDemo"); 
 } 

 public static void Main() {  
   MyEvent evt = new MyEvent(); 
   X xOb = new X(); 
   Y yOb = new Y(); 

   // Add handlers to the event list. 
   evt.SomeEvent += new MyEventHandler(handler); 
   evt.SomeEvent += new MyEventHandler(xOb.Xhandler); 
   evt.SomeEvent += new MyEventHandler(yOb.Yhandler); 

   // Fire the event. 
   evt.OnSomeEvent(); 
   Console.WriteLine(); 

   // Remove a handler. 
   evt.SomeEvent -= new MyEventHandler(xOb.Xhandler); 
   evt.OnSomeEvent(); 
 } 

}


      </source>


A very simple event demonstration

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

// A very simple event demonstration.

using System;

// Declare a delegate for an event. delegate void MyEventHandler();

// Declare an event class. class MyEvent {

 public event MyEventHandler SomeEvent; 

 // This is called to fire the event. 
 public void OnSomeEvent() { 
   if(SomeEvent != null) 
     SomeEvent(); 
 } 

}

public class EventDemo {

 // An event handler. 
 static void handler() { 
   Console.WriteLine("Event occurred"); 
 } 

 public static void Main() {  
   MyEvent evt = new MyEvent(); 

   // Add handler() to the event list. 
   evt.SomeEvent += new MyEventHandler(handler); 

   // Fire the event. 
   evt.OnSomeEvent(); 
 } 

}


      </source>


Chaining events.

<source lang="csharp">

using System; public class EventTestClass {

   private int nValue;
   public delegate void ValueChangedEventHandler();
   public event ValueChangedEventHandler Changed;
   protected virtual void OnChanged() {
       if (Changed != null)
           Changed();
       else
           Console.WriteLine("Event fired. No handler!");
   }
   public EventTestClass(int nValue) {
       SetValue(nValue);
   }
   public void SetValue(int nV) {
       if (nValue != nV) {
           nValue = nV;
           OnChanged();
       }
   }

} public class Mainclass {

   public void HandleChange1() {
       Console.WriteLine("Handler 1 Called");
   }
   public void HandleChange2() {
       Console.WriteLine("Handler 2 Called");
   }
   public Mainclass() {
   }
   public static void Main() {
       EventTestClass etc = new EventTestClass(3);
       Mainclass app = new Mainclass();
       etc.Changed += new EventTestClass.ValueChangedEventHandler(app.HandleChange1);
       etc.Changed += new EventTestClass.ValueChangedEventHandler(app.HandleChange2);
       etc.SetValue(5);
       etc.SetValue(5);
       etc.SetValue(3);
   }

}

</source>


Create a custom means of managing the event invocation list

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

// Create a custom means of managing the event invocation list.

using System;

// Declare a delegate for an event. delegate void MyEventHandler();

// Declare an event class that holds up to 3 events. class MyEvent {

 MyEventHandler[] evnt = new MyEventHandler[3]; 

 public event MyEventHandler SomeEvent { 
   // Add an event to the list. 
   add { 
     int i; 

     for(i=0; i < 3; i++) 
       if(evnt[i] == null) { 
         evnt[i] = value;  
         break; 
       } 
     if (i == 3) Console.WriteLine("Event list full."); 
   } 

   // Remove an event from the list. 
   remove { 
     int i; 

     for(i=0; i < 3; i++) 
       if(evnt[i] == value) { 
         evnt[i] = null; 
         break; 
       } 
     if (i == 3) Console.WriteLine("Event handler not found."); 
   } 
 }  
 
 // This is called to fire the events.  
 public void OnSomeEvent() {  
     for(int i=0; i < 3; i++) 
       if(evnt[i] != null) evnt[i]();  
 }  

}

// Create some classes that use MyEventHandler. class W {

 public void Whandler() {  
   Console.WriteLine("Event received by W object");  
 }  

}

class X {

 public void Xhandler() {  
   Console.WriteLine("Event received by X object");  
 }  

}

class Y {

 public void Yhandler() {  
   Console.WriteLine("Event received by Y object");  
 }  

}

class Z {

 public void Zhandler() {  
   Console.WriteLine("Event received by Z object");  
 }  

}

public class EventDemo4 {

 public static void Main() {   
   MyEvent evt = new MyEvent();  
   W wOb = new W();  
   X xOb = new X();  
   Y yOb = new Y();  
   Z zOb = new Z(); 

   // Add handlers to the event list. 
   Console.WriteLine("Adding events."); 
   evt.SomeEvent += new MyEventHandler(wOb.Whandler);  
   evt.SomeEvent += new MyEventHandler(xOb.Xhandler);  
   evt.SomeEvent += new MyEventHandler(yOb.Yhandler);  

   // Can"t store this one -- full. 
   evt.SomeEvent += new MyEventHandler(zOb.Zhandler);  
   Console.WriteLine(); 
 
   // Fire the events.  
   evt.OnSomeEvent();  
   Console.WriteLine();  
 
   // Remove a handler. 
   Console.WriteLine("Remove xOb.Xhandler."); 
   evt.SomeEvent -= new MyEventHandler(xOb.Xhandler);  
   evt.OnSomeEvent();  

   Console.WriteLine(); 

   // Try to remove it again. 
   Console.WriteLine("Try to remove xOb.Xhandler again."); 
   evt.SomeEvent -= new MyEventHandler(xOb.Xhandler);  
   evt.OnSomeEvent();  

   Console.WriteLine(); 

   // Now, add Zhandler. 
   Console.WriteLine("Add zOb.Zhandler."); 
   evt.SomeEvent += new MyEventHandler(zOb.Zhandler); 
   evt.OnSomeEvent();  

 }  

}


      </source>


Delegate and event hierarchy

<source lang="csharp"> /*

* C# Programmers Pocket Consultant
* Author: Gregory S. MacBeth
* Email: gmacbeth@comporium.net
* Create Date: June 27, 2003
* Last Modified Date:
*/

using System; namespace Client.Chapter_8___Delegates_and_Events {

 public delegate int MyDelegateEventHandler(MyEventArgs e);
 
 public class MyEventSubscriber
 {
   static void Main(string[] args)
   {
     MyEventPublisher EventPublisher = new MyEventPublisher();
     MyEventArgs MyArgs = new MyEventArgs();
     MyArgs.MyString = "Hello World";
     EventPublisher.MyEvent += new MyDelegateEventHandler(MyHandler);
     EventPublisher.DoSomething(MyArgs);
   }
   static int MyHandler(MyEventArgs e)
   {
     Console.WriteLine(e.MyString);
     return 0;
   }
 }
 public class MyEventArgs: EventArgs
 {
   public int MyInt;
   public long MyLong;
   public string MyString;
 }
 public class MyEventPublisher
 {
   public event MyDelegateEventHandler MyEvent;
   public int DoSomething(MyEventArgs e)
   {
     MyEvent(e);
     return 0;
   }
 }

}

      </source>


Delegates And Events

<source lang="csharp"> /* Learning C# by Jesse Liberty Publisher: O"Reilly ISBN: 0596003765

  • /
using System;
namespace DelegatesAndEvents
{
    public enum comparison
    {
        theFirstComesFirst = 1,
        theSecondComesFirst = 2
    }
    // A simple collection to hold two items
    class Pair
    {
        // Private array to hold the two objects
        private object[] thePair = new object[2];
        // The delegate declaration
        public delegate comparison
            WhichIsFirst(object obj1, object obj2);
        // Passed in constructor takes two objects,
        // added in order received
        public Pair(
            object firstObject,
            object secondObject)
        {
            thePair[0] = firstObject;
            thePair[1] = secondObject;
        }
        // Public method that orders the
        // two objects by whatever criteria the objects like!
        public void Sort(
            WhichIsFirst theDelegatedFunc)
        {
            if (theDelegatedFunc(thePair[0],thePair[1])
                == comparison.theSecondComesFirst)
            {
                object temp = thePair[0];
                thePair[0] = thePair[1];
                thePair[1] = temp;
            }
        }
        // Public method that orders the
        // two objects by the reverse of whatever criteria the
        // objects likes!
        public void ReverseSort(
            WhichIsFirst theDelegatedFunc)
        {
            if (theDelegatedFunc(thePair[0],thePair[1]) ==
                comparison.theFirstComesFirst)
            {
                object temp = thePair[0];
                thePair[0] = thePair[1];
                thePair[1] = temp;
            }
        }
        // Ask the two objects to give their string value
        public override string ToString()
        {
            return thePair[0].ToString() + ", "
                + thePair[1].ToString();
        }
    }
    class Dog
    {
        private int weight;
        public Dog(int weight)
        {
            this.weight=weight;
        }
        // dogs are sorted by weight
        public static comparison WhichDogComesFirst(
            Object o1, Object o2)
        {
            Dog d1 = (Dog) o1;
            Dog d2 = (Dog) o2;
            return d1.weight > d2.weight ?
                comparison.theSecondComesFirst :
                comparison.theFirstComesFirst;
        }
        public override string ToString()
        {
            return weight.ToString();
        }
    }
    class Student
    {
        private string name;
        public Student(string name)
        {
            this.name = name;
        }
        // Students are sorted alphabetically
        public static comparison
            WhichStudentComesFirst(Object o1, Object o2)
        {
            Student s1 = (Student) o1;
            Student s2 = (Student) o2;
            return (String.rupare(s1.name, s2.name) < 0 ?
                comparison.theFirstComesFirst :
                comparison.theSecondComesFirst);
        }
        public override string ToString()
        {
            return name;
        }
    }
   public class TesterDelegatesAndEvents11
   {
      public void Run()
      {
          // Create two students and two dogs
          // and add them to Pair objects
          Student Jesse = new Student("Jesse");
          Student Stacey = new Student ("Stacey");
          Dog Milo = new Dog(65);
          Dog Fred = new Dog(12);
          Pair studentPair = new Pair(Jesse,Stacey);
          Pair dogPair = new Pair(Milo, Fred);
          Console.WriteLine("studentPair\t\t\t: {0}",
              studentPair.ToString());
          Console.WriteLine("dogPair\t\t\t\t: {0}",
              dogPair.ToString());
          // Instantiate the delegates
          Pair.WhichIsFirst  theStudentDelegate =
              new Pair.WhichIsFirst(
              Student.WhichStudentComesFirst);
          Pair.WhichIsFirst theDogDelegate =
              new Pair.WhichIsFirst(
              Dog.WhichDogComesFirst);
          // Sort using the delegates
          studentPair.Sort(theStudentDelegate);
          Console.WriteLine("After Sort studentPair\t\t: {0}",
              studentPair.ToString());
          studentPair.ReverseSort(theStudentDelegate);
          Console.WriteLine("After ReverseSort studentPair\t: {0}",
              studentPair.ToString());
          dogPair.Sort(theDogDelegate);
          Console.WriteLine("After Sort dogPair\t\t: {0}",
              dogPair.ToString());
          dogPair.ReverseSort(theDogDelegate);
          Console.WriteLine("After ReverseSort dogPair\t: {0}",
              dogPair.ToString());
      }
      static void Main()
      {
         TesterDelegatesAndEvents11 t = new TesterDelegatesAndEvents11();
         t.Run();
      }
   }
}
          
      </source>


Delegates And Events 2

<source lang="csharp"> /* Learning C# by Jesse Liberty Publisher: O"Reilly ISBN: 0596003765

  • /
using System;
namespace DelegatesAndEvents
{
    public enum comparison
    {
        theFirstComesFirst = 1,
        theSecondComesFirst = 2
    }
    // A simple collection to hold two items.
    class Pair
    {
        // Private array to hold the two objects.
        private object[] thePair = new object[2];
        // The delegate declaration.
        public delegate comparison
            WhichIsFirst(object obj1, object obj2);
        // Passed in constructor takes two objects,
        // added in order received.
        public Pair(
            object firstObject,
            object secondObject)
        {
            thePair[0] = firstObject;
            thePair[1] = secondObject;
        }
        // Public method that orders
        // the two objects by whatever criteria the objects like!
        public void Sort(
            WhichIsFirst theDelegatedFunc)
        {
            if (theDelegatedFunc(thePair[0],thePair[1])
                == comparison.theSecondComesFirst)
            {
                object temp = thePair[0];
                thePair[0] = thePair[1];
                thePair[1] = temp;
            }
        }
        // Public method that orders
        // the two objects by the reverse of whatever criteria
        // the objects like!
        public void ReverseSort(
            WhichIsFirst theDelegatedFunc)
        {
            if (theDelegatedFunc(thePair[0],thePair[1]) ==
                comparison.theFirstComesFirst)
            {
                object temp = thePair[0];
                thePair[0] = thePair[1];
                thePair[1] = temp;
            }
        }
        // Ask the two objects to give their string value.
        public override string ToString()
        {
            return thePair[0].ToString() + ", "
                + thePair[1].ToString();
        }
    }
    class Dog
    {
        private int weight;
        // A static delegate.
        public static readonly Pair.WhichIsFirst OrderDogs =
            new Pair.WhichIsFirst(Dog. WhichDogComesFirst);
        public Dog(int weight)
        {
            this.weight=weight;
        }
        // Dogs are sorted by weight.
        public static comparison WhichDogComesFirst(
            Object o1, Object o2)
        {
            Dog d1 = (Dog) o1;
            Dog d2 = (Dog) o2;
            return d1.weight > d2.weight ?
                comparison.theSecondComesFirst :
                comparison.theFirstComesFirst;
        }
        public override string ToString()
        {
            return weight.ToString();
        }
    }
    class Student
    {
        private string name;
        // A static delegate.
        public static readonly Pair.WhichIsFirst OrderStudents =
            new Pair.WhichIsFirst(Student.WhichStudentComesFirst);
        public Student(string name)
        {
            this.name = name;
        }
        // Students are sorted alphabetically.
        public static comparison
            WhichStudentComesFirst(Object o1, Object o2)
        {
            Student s1 = (Student) o1;
            Student s2 = (Student) o2;
            return (String.rupare(s1.name, s2.name) < 0 ?
                comparison.theFirstComesFirst :
                comparison.theSecondComesFirst);
        }
        public override string ToString()
        {
            return name;
        }
    }
   public class TesterDelegatesAndEvents1
   {
      public void Run()
      {
          // Create two students and two dogs
          // and add them to Pair objects.
          Student Jesse = new Student("Jesse");
          Student Stacey = new Student ("Stacey");
          Dog Milo = new Dog(65);
          Dog Fred = new Dog(12);
          // Create the Pair object.
          Pair studentPair = new Pair(Jesse,Stacey);
          Pair dogPair = new Pair(Milo, Fred);
          Console.WriteLine("studentPair\t\t\t: {0}",
              studentPair.ToString());
          Console.WriteLine("dogPair\t\t\t\t: {0}",
              dogPair.ToString());
          // Tell the student Pair to sort itself,
          // passing in the Student delegate.
          studentPair.Sort(Student.OrderStudents);
          Console.WriteLine("After Sort studentPair\t\t: {0}",
              studentPair.ToString());
          studentPair.ReverseSort(Student.OrderStudents);
          Console.WriteLine("After ReverseSort studentPair\t: {0}",
              studentPair.ToString());
          // Tell the Dog pair to sort itself,
          // passing in the Dog delegate.
          dogPair.Sort(Dog.OrderDogs);
          Console.WriteLine("After Sort dogPair\t\t: {0}",
              dogPair.ToString());
          dogPair.ReverseSort(Dog.OrderDogs);
          Console.WriteLine("After ReverseSort dogPair\t: {0}",
              dogPair.ToString());
      }
      [STAThread]
      static void Main()
      {
         TesterDelegatesAndEvents1 t = new TesterDelegatesAndEvents1();
         t.Run();
      }
   }
}
          
      </source>


Events:Add and Remove Functions

<source lang="csharp"> using System; public class AddandRemoveFunctions {

   static public void ButtonHandler(object sender, EventArgs e)
   {
       Console.WriteLine("Button clicked");
   }
   
   public static void Main()
   {
       Button button = new Button();
       
       button.AddClick(new Button.ClickHandler(ButtonHandler));
       
       button.SimulateClick();
       
       button.RemoveClick(new Button.ClickHandler(ButtonHandler));
   }

} public class Button {

   public delegate void ClickHandler(object sender, EventArgs e);
   private ClickHandler click;
   
   public void AddClick(ClickHandler clickHandler)
   {
       click += clickHandler;
   }
   
   public void RemoveClick(ClickHandler clickHandler)
   {
       click -= clickHandler;
   }
   
   protected void OnClick()
   {
       if (click != null)
       click(this, null);
       
   }
   
   public void SimulateClick()
   {
       OnClick();
   }

}

      </source>


Events:Add and Remove Functions 2

<source lang="csharp"> using System; public class AddandRemoveFunctions2 {

   static public void ButtonHandler(object sender, EventArgs e)
   {
       Console.WriteLine("Button clicked");
   }
   
   public static void Main()
   {
       Button button = new Button();
       
       button.Click += new Button.ClickHandler(ButtonHandler);
       
       button.SimulateClick();
       
       button.Click -= new Button.ClickHandler(ButtonHandler);
   }

} public class Button {

   public delegate void ClickHandler(object sender, EventArgs e);
   
   public event ClickHandler Click;
   
   protected void OnClick()
   {
       if (Click != null)
       Click(this, null);
   }
   
   public void SimulateClick()
   {
       OnClick();
   }

}


      </source>


Events: Custom Add and Remove

<source lang="csharp"> /* A Programmer"s Introduction to C# (Second Edition) by Eric Gunnerson Publisher: Apress L.P. ISBN: 1-893115-62-3

  • /

// 23 - Events\Custom Add and Remove // copyright 2000 Eric Gunnerson using System; using System.Collections; using System.Runtime.rupilerServices;

public class EventsCustomAddandRemove {

   static public void ButtonHandler(object sender, EventArgs e)
   {
       Console.WriteLine("Button clicked");
   }
   
   public static void Main()
   {
       Button button = new Button();
       
       button.Click += new Button.ClickHandler(ButtonHandler);
       
       button.SimulateClick();
       
       button.Click -= new Button.ClickHandler(ButtonHandler);
       
       button.TearDown();
   }

} // // Global delegate cache. Uses a two-level hashtable. The delegateStore hashtable // stores a hashtable keyed on the object instance, and the instance hashtable is // keyed on the unique key. This allows fast tear-down of the object when it"s destroyed. // public class DelegateCache {

   private DelegateCache() {}    // nobody can create one of these
   
   Hashtable delegateStore = new Hashtable();    // top level hash table
   
   static DelegateCache dc = new DelegateCache();    // our single instance
   
   Hashtable GetInstanceHash(object instance)
   {
       Hashtable instanceHash = (Hashtable) delegateStore[instance];
       
       if (instanceHash == null)
       {
           instanceHash = new Hashtable();
           delegateStore[instance] = instanceHash;
           
       }
       return(instanceHash);
   }
   
   public static void Combine(Delegate myDelegate, object instance, object key)
   {
       lock(instance)
       {
           Hashtable instanceHash = dc.GetInstanceHash(instance);        
           
           instanceHash[key] = Delegate.rubine((Delegate) instanceHash[key],
           myDelegate);
       }
   }
   
   public static void Remove(Delegate myDelegate, object instance, object key)
   {
       lock(instance)
       {
           Hashtable instanceHash = dc.GetInstanceHash(instance);        
           
           instanceHash[key] = Delegate.Remove((Delegate) instanceHash[key],
           myDelegate);
       }
   }
   
   public static Delegate Fetch(object instance, object key)
   {
       Hashtable instanceHash = dc.GetInstanceHash(instance);        
       
       return((Delegate) instanceHash[key]);
   }
   
   public static void ClearDelegates(object instance)
   {
       dc.delegateStore.Remove(instance);
   }

} public class Button {

   public void TearDown()
   {
       DelegateCache.ClearDelegates(this);
   }
   
   
   public delegate void ClickHandler(object sender, EventArgs e);
   
   static object clickEventKey = new object();
   
   public event ClickHandler Click
   {
       add
       {
           DelegateCache.rubine(value, this, clickEventKey);
       }
       
       remove
       {
           DelegateCache.Remove(value, this, clickEventKey);
       }
   }
   
   protected void OnClick()
   {
       ClickHandler ch = (ClickHandler) DelegateCache.Fetch(this, clickEventKey);
       
       if (ch != null)
       ch(this, null);
   }
   
   public void SimulateClick()
   {
       OnClick();
   }

}

      </source>


Individual objects receive notifications when instance event handlers are used

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

/* Individual objects receive notifications when instance

  event handlers are used. */ 
 

using System;

// Declare a delegate for an event. delegate void MyEventHandler();

// Declare an event class. class MyEvent {

 public event MyEventHandler SomeEvent; 

 // This is called to fire the event. 
 public void OnSomeEvent() { 
   if(SomeEvent != null) 
     SomeEvent(); 
 } 

}

class X {

 int id; 

 public X(int x) { id = x; } 

 // This is an instance method that will be used as an event handler. 
 public void Xhandler() { 
   Console.WriteLine("Event received by object " + id); 
 } 

}

public class EventDemo2 {

 public static void Main() {  
   MyEvent evt = new MyEvent(); 
   X o1 = new X(1); 
   X o2 = new X(2); 
   X o3 = new X(3); 

   evt.SomeEvent += new MyEventHandler(o1.Xhandler); 
   evt.SomeEvent += new MyEventHandler(o2.Xhandler); 
   evt.SomeEvent += new MyEventHandler(o3.Xhandler); 

   // Fire the event. 
   evt.OnSomeEvent(); 
 } 

}


      </source>


Use delegate: event

<source lang="csharp"> /*

* C# Programmers Pocket Consultant
* Author: Gregory S. MacBeth
* Email: gmacbeth@comporium.net
* Create Date: June 27, 2003
* Last Modified Date:
*/

using System; namespace Client.Chapter_8___Delegates_and_Events {

 public delegate void MyDelegateEventHandler(int i);
 
 public class MyEventSubscriberChapter_8___Delegates_and_Events
 {
   static void Main(string[] args)
   {
     MyEventPublisher EventPublisher = new MyEventPublisher();
     
     MyDelegateEventHandler MyAnonymousDelegate = delegate(int x)
     {
       Console.WriteLine("Anonymous Event FIRED!");
     };
     EventPublisher.MyEvent += MyAnonymousDelegate;
     
     EventPublisher.DoSomething();
   }
   
 }
 
 public class MyEventPublisher
 {
   public event MyDelegateEventHandler MyEvent;
   public int DoSomething()
   {
     MyEvent(5);
     return 0;
   }
 }

}

      </source>


Use the bult-in EventHandler delegate

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

  • /

// Use the bult-in EventHandler delegate.

using System;

// Declare an event class. class MyEvent {

 public event EventHandler SomeEvent; // uses EventHandler delegate 

 // This is called to fire SomeEvent. 
 public void OnSomeEvent() { 
   if(SomeEvent != null) 
     SomeEvent(this, EventArgs.Empty); 
 } 

}

public class EventDemo6 {

 static void handler(object source, EventArgs arg) { 
   Console.WriteLine("Event occurred"); 
   Console.WriteLine("Source is " + source); 
 } 

 public static void Main() {  
   MyEvent evt = new MyEvent(); 

   // Add handler() to the event list. 
   evt.SomeEvent += new EventHandler(handler); 

   // Fire the event. 
   evt.OnSomeEvent(); 
 } 

}


      </source>