events and delegate

Prashant Jadhav

hi guys my question is is about event and delegates
as defination of event events are type of delegates it means event also behave as function pointer.
so why do we need event to point to event handler function we can create just a delegate and make it regester with the
event handler fuction.
even i tried this and i have not received any error heres the coding which i tried
plz go through it and reply me whether i made any mistake.
using System;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Counter c = new Counter(new Random().Next(10));
c.ThresholdReached +=c_ThresholdReached;

Console.WriteLine("press 'a' key to increase total");
while (Console.ReadKey(true).KeyChar == 'a')
{
Console.WriteLine("adding one");
c.Add(1);
}
}

static void c_ThresholdReached(object sender, ThresholdReachedEventArgs e)
{
Console.WriteLine("The threshold of {0} was reached at {1}.", e.Threshold, e.TimeReached);
Console.ReadLine();
}
}

class Counter
{
private int threshold;
private int total;

public Counter(int passedThreshold)
{
threshold = passedThreshold;
}

public void Add(int x)
{
total += x;
if (total >= threshold)
{
ThresholdReachedEventArgs args = new ThresholdReachedEventArgs();
args.Threshold = threshold;
args.TimeReached = DateTime.Now;
OnThresholdReached(args);
}
}

protected virtual void OnThresholdReached(ThresholdReachedEventArgs e)
{

if (ThresholdReached != null)
{
ThresholdReached(this, e);
}
}
public eventhand ThresholdReached;
public delegate void eventhand(object a,ThresholdReachedEventArgs e);
}

public class ThresholdReachedEventArgs : EventArgs
{
public int Threshold { get; set; }
public DateTime TimeReached { get; set; }
}
}

and theres another code we can get on msdn which use even to make subscriber class to register event handler function.

using System;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Counter c = new Counter(new Random().Next(10));
c.ThresholdReached += c_ThresholdReached;

Console.WriteLine("press 'a' key to increase total");
while (Console.ReadKey(true).KeyChar == 'a')
{
Console.WriteLine("adding one");
c.Add(1);
}
}

static void c_ThresholdReached(object sender, ThresholdReachedEventArgs e)
{
Console.WriteLine("The threshold of {0} was reached at {1}.", e.Threshold, e.TimeReached);
Environment.Exit(0);
}
}

class Counter
{
private int threshold;
private int total;

public Counter(int passedThreshold)
{
threshold = passedThreshold;
}

public void Add(int x)
{
total += x;
if (total >= threshold)
{
ThresholdReachedEventArgs args = new ThresholdReachedEventArgs();
args.Threshold = threshold;
args.TimeReached = DateTime.Now;
OnThresholdReached(args);
}
}

protected virtual void OnThresholdReached(ThresholdReachedEventArgs e)
{
EventHandler handler = ThresholdReached;
if (handler != null)
{
handler(this, e);
}
}

public event EventHandler ThresholdReached;
}

public class ThresholdReachedEventArgs : EventArgs
{
public int Threshold { get; set; }
public DateTime TimeReached { get; set; }
}
}

8 Replies

Know the answer? Post it — somebody with the same question will find it here.

Prashant Jadhav12y ago
thank vulpes for your reply
you are the only person who really intrested in others problem
and tend to solve it
i really appreciate
thank you very much
0
Vulpes12y ago
I'm Sorry, Prashant, but I can't see the point of spending time trying to produce a real world example of what can happen if you use an ordinary delegate instead of an event when it's already clear that, whatever the example, it's possible to do some potentially undesirable things if you use the former.

C# has a lot of features which try to avoid common programming pitfalls and the purpose of events is to prevent subscribers from interfering with each other which could lead to unpredictable behavior

You can use ordinary delegates instead if you are confident that you (or another programmer in your group) will never use anything other than += or -= but, if you use events instead, the compiler will ensure that you can't do otherwise which, to my mind, is a good thing.

0
Prashant Jadhav12y ago
hi vulpes can you please give me any real life example where such problems which you have mentioned occurs when someone use delegate to point to event handler in subscriber.
and events are use to overcome this problem.
0
Vulpes12y ago
In 'real world' programming no one would write an application in that fashion.

It's just a simple example to illustrate that you can do things using an ordinary delegate which would be regarded as undesirable in the publish/subscribe pattern. Those things simply aren't possible if you use an event instead because the code won't compile.
0
Prashant Jadhav12y ago
hi vulpes thank you for rplying me
i hope you will answer my question
as coding that you have given you have passed even publisher class to an method outside of main method as following

class Program
{
static void Main()
{
Program p = new Program();
// subscribe to MyEvent
EventProvider ep = new EventProvider();
ep.MyEvent += p.Handler1;
// fire event
ep.OnMyEvent(p, null);
// create Rogue object
Rogue r = new Rogue();
r.SomeMethod(ep);
Console.ReadKey();
}

since we all create our application logic in main method and our application gets end when main method gets end my point is why would any programmer send event publisher object that has created to another method outside of main method which is the original application.why would someone create such bug in his own application.

0
Vulpes12y ago
The advantage of using an event rather than ordinary delegate is that subscribers can't do things such as the following:

1. Get details of other subscribers.

2. Replace other subscribers by reassigning the delegate.

3. Clear all subscribers by setting the event to null.

Here's a simple example which illustrates these points:

using System;

class EventProvider
{
// using an ordinary delegate
public EventHandler MyEvent;

public void OnMyEvent(object sender, EventArgs e)
{
if(MyEvent != null) MyEvent(sender, e);
}
}

class Program
{
static void Main()
{
Program p = new Program();
// subscribe to MyEvent
EventProvider ep = new EventProvider();
ep.MyEvent += p.Handler1;
// fire event
ep.OnMyEvent(p, null);
// create Rogue object
Rogue r = new Rogue();
r.SomeMethod(ep);
Console.ReadKey();
}

private void Handler1(object sender, EventArgs e)
{
Console.WriteLine("Handler 1 called");
}
}

class Rogue
{
public void SomeMethod(EventProvider ep)
{
// list out details of existing handlers
Console.WriteLine("\nThe existing handler is:\n");

foreach(Delegate d in ep.MyEvent.GetInvocationList())
{
Console.WriteLine(" Method : {0}, Target : {1}\n", d.Method, d.Target);
}

// substitute a new handler for the previous one by reassignment
ep.MyEvent = this.Handler2;

// fire event again
ep.OnMyEvent(this, null);

// remove existing handler but without using -=
ep.MyEvent = null;

// add a new handler using +=
ep.MyEvent += this.Handler3;

// fire event again
ep.OnMyEvent(this, null);
}

private void Handler2(object sender, EventArgs e)
{
Console.WriteLine("Handler 2 called in place of Handler 1");
}

private void Handler3(object sender, EventArgs e)
{
Console.WriteLine("\nHandler 3 called in place of Handler 2");
}

}

The output is:

Handler 1 called

The existing handler is:

Method : Void Handler1(System.Object, System.EventArgs), Target : Program

Handler 2 called in place of Handler 1

Handler 3 called in place of Handler 2

If in the EventProvider class, you now change this line:

public EventHandler MyEvent;

to this:

public event EventHandler MyEvent;

then it simply won't compile and you'll be informed on 3 occasions that:

The event 'EventProvider.MyEvent' can only
appear on the left hand side of += or -= (except when used from within
the type 'EventProvider'

0
Prashant Jadhav12y ago
hi vulpes
thank you for replying
i didnt get you following statement

This restriction ensures that a subscriber to the event cannot find out anything about or interfere with other subscribers to the event which is the main reason for having them in the first place.

if you mean that we only register methods with event is advantage of event the what about delegate even with delegate we can only register method thats it what else can someone do
0
Vulpes12y ago
The difference between events and other delegates is that, outside the class in which the event is defined, the only operations permitted on the event are += and -=. These, of course, add an eventhandler to, or remove an eventhandler from, the event's invocation list.

This restriction ensures that a subscriber to the event cannot find out anything about or interfere with other subscribers to the event which is the main reason for having them in the first place.

So, whatever you can do with an event you'll also be able to do with an 'ordinary' delegate but the former is safer.
0