Events

[Techno]

How do you create a custom event? is it possible?

I have a form
it creates an instance of another class
this class file has a public property which is of type bool

everytime that bool value changes, i want the form to pick it up (the change) and notify me. is it possible?

If it is possible, then the "notification" event can be done on the form? or must it be done in the class the variable/eventhandler is created?

[MrPolite]

ok I wrote an extended sample for you
make a new project, add 2 buttons to it. Copy this inside the Form1 class:

        private MySampleClass test  = new MySampleClass();
        private void Form1_Load(object sender, System.EventArgs e)
        {
            // Add event handlers
            test.CoolChanged   += new MySampleClass.IsCoolChangedEventHandler(test_CoolChanged);
            test.FooWasCalled  += new EventHandler(test_FooWasCalled);
        }

        // has to have the signature of a System.EventHandler delegate
        private void test_FooWasCalled (object sender, EventArgs e)
        {
            MessageBox.Show    ("function Foo of the test class was called!!!");
        }

        // has to have the signature of a MySampleClass.IsCoolChangedEventHandler delegate
        private void test_CoolChanged (MySampleClass sender, bool newCoolValue, object dummy)
        {
            MessageBox.Show    ("Field IsCool of the test class was called and the new value is: " +
                newCoolValue.ToString() );
        }

        private void button1_Click(object sender, System.EventArgs e)
        {
            this.test.IsCool = true;
        }

        private void button2_Click(object sender, System.EventArgs e)
        {
            this.test.Foo();
        } 

this is a test class with events. paste this to a new file or outside the form1 class:

public class MySampleClass
    {
        // An event that uses a generic event handler (therefore we use System.EventHandler

        /// <summary>
        /// Raised when the Foo() function of this class is called
        /// </summary>
        public event EventHandler FooWasCalled;


        // We need a custom delegate to handle out special event
        // This events parameters are customized! yay :D
        public delegate void IsCoolChangedEventHandler (MySampleClass sender, bool newCoolValue, object dummy);

        /// <summary>
        /// Raised when the IsCool field of the class is changed.
        /// </summary>
        public event IsCoolChangedEventHandler CoolChanged;




        private bool isCool  = false;
        public bool IsCool
        {
            get
            {
                return isCool;
            }
            set
            {
                isCool = value;
                // value changed, raise the event

                if (CoolChanged!=null)
                    CoolChanged (this, value, null);
            }
        }

        /// <summary>
        /// Does some stuff then raises the FooWasCalled event
        /// </summary>
        public void Foo()
        {
            /*
             * do stuff
             */
              

            // If there are any event handlers attached to this event, then
            // the value will NOT be null, that's why we have to check for
            // a null reference first
            if (this.FooWasCalled != null)
            {
                // the sytax for a System.EventHandler delegate is this: 
                //     (object sender, EventArgs e)
                // So I'm passing the class as the sender, and I'm not
                // passing anything as the eventargs
                FooWasCalled (this, null);
            }
        }        
    } 

also note that if you wanna get really fancy in C#, you can use events as properties (most people dont know this). For example

private event EventHandler myEvent;
        public event EventHandler MyEvent
        {
            // add event handler
            add
            {
                myEvent += value;

                //do other stuff you want
            }
            // remove event handler
            remove
            {
                myEvent -= value;

                //do other stuff you want
            }
        } 

let me know if you need explanations and rate if it helps

[Techno]

sounds awesome!
i will give this a try and then get back to you with questions but also will give you a rating

[Hack]

Hopefully, you will find this interesting.

[Techno]

Thanks hack!

[usedggues]

Good site Respect for admin...

[Bombdrop]

If you are using .Net 2.0 or above you can use the generic EventHandler<T> thus removing the need to use a delegate. please find an example attached.

Hope this helps!!

[jmcilhinney]

Just note, Bombdrop, that using the EventHandler<TEventArgs> doesn't mean you don't have to USE a delegate. It means you don't have to DECLARE a delegate. EventHandler<TEventArgs> is itself a delegate.