What are the differences between delegates and events

Question

What are the differences between delegates and an events  Don t both hold references to functions that can be executed

User · Answer

For people live in 2020  and want a clean answer    Definitions   delegate  defines a function pointer  event  defines   1  protected interfaces  and  2  operations     -    and  3  advantage  you don t need to use new keyword anymore     Regarding the adjective protected     eventTest SomeoneSay   null                  Compile Error     eventTest SomeoneSay   new Say SayHello      Compile Error   Also notice this section from Microsoft  https   docs microsoft com en-us dotnet standard events  raising-multiple-events Code Example  with delegate  public class DelegateTest       public delegate void Say       Define a pointer type  quot void  lt -    quot  named  quot Say quot       private Say say       public DelegateTest             say    new Say SayHello          Setup the field  Say say  first          say    new Say SayGoodBye                    say Invoke                   public void SayHello        display  quot Hello World  quot  to your GUI           public void SayGoodBye        display  quot Good bye  quot  to your GUI           with event  public class EventTest       public delegate void Say        public event Say SomeoneSay      Use the type  quot Say quot  to define event  an                                       auto-setup-everything-good field for you      public EventTest              SomeoneSay    SayHello           SomeoneSay    SayGoodBye            SomeoneSay                   public void SayHello        display  quot Hello World  quot  to your GUI           public void SayGoodBye        display  quot Good bye  quot  to your GUI          Reference  Event vs  Delegate - Explaining the important differences between the Event and Delegate patterns in C  and why they re useful   https   dzone com articles event-vs-delegate

User · Answer

What a great misunderstanding between events and delegates    A delegate specifies a TYPE  such as a class  or an interface does   whereas an event is just a kind of MEMBER  such as fields  properties  etc   And  just like any other kind of member an event also has a type  Yet  in the case of an event  the type of the event must be specified by a delegate   For instance  you CANNOT declare an event of a type defined by an interface    Concluding  we can make the following Observation  the type of an event MUST be defined by a delegate  This is the main relation between an event and a delegate and is described in the section II 18  Defining events of ECMA-335  CLI  Partitions I to VI      In typical usage  the TypeSpec  if present  identifies a delegate whose signature matches the arguments passed to the event   s fire method    However  this fact does NOT imply that an event uses a backing delegate field  In truth  an event may use a backing field of any different data structure type of your choice  If you implement an event explicitly in C   you are free to choose the way you store the event handlers  note that event handlers are instances of the type of the event  which in turn is mandatorily a delegate type---from the previous Observation   But  you can store those event handlers  which are delegate instances  in a data structure such as a List or a Dictionary or any other else  or even in a backing delegate field  But don   t forget that it is NOT mandatory that you use a delegate field

User · Answer

Delegate is a type-safe function pointer  Event is an implementation of publisher-subscriber design pattern using delegate

User · Answer

You can also use events in interface declarations  not so for delegates

User · Answer

An Event declaration adds a layer of abstraction and protection on the delegate instance   This protection prevents clients of the delegate from resetting the delegate and its invocation list and only allows adding or removing targets from the invocation list

User · Answer

To define about event in simple way   Event is a REFERENCE to a delegate with two restrictions   Cannot be invoked directly Cannot be assigned values directly  e g eventObj   delegateMethod    Above two are the weak points for delegates and it is addressed in event   Complete code sample to show the difference in fiddler is here https   dotnetfiddle net 5iR3fB    Toggle the comment between Event and Delegate and client code that invokes assign values to delegate to understand the difference  Here is the inline code       This is working program in Visual Studio   It is not running in fiddler because of infinite loop in code  This code demonstrates the difference between event and delegate         Event is an delegate reference with two restrictions for increased protection              1  Cannot be invoked directly             2  Cannot assign value to delegate reference directly  Toggle between Event vs Delegate in the code by commenting un commenting the relevant lines     public class RoomTemperatureController       private int  roomTemperature   25   Default Starting room Temperature     private bool  isAirConditionTurnedOn   false   Default AC is Off     private bool  isHeatTurnedOn   false   Default Heat is Off     private bool  tempSimulator   false      public  delegate void OnRoomTemperatureChange int roomTemperature     OnRoomTemperatureChange is a type of Delegate  Check next line for proof         public  OnRoomTemperatureChange WhenRoomTemperatureChange      get  set     Exposing the delegate to outside world  cannot directly expose the delegate  line above        public  event OnRoomTemperatureChange WhenRoomTemperatureChange      get  set     Exposing the delegate to outside world  cannot directly expose the delegate  line above         public RoomTemperatureController                 WhenRoomTemperatureChange    InternalRoomTemperatuerHandler            private void InternalRoomTemperatuerHandler int roomTemp                System Console WriteLine  Internal Room Temperature Handler - Mandatory to handle  Should not be removed by external consumer of ths class  Note  if it is delegate this can be removed  if event cannot be removed                 User cannot directly asign values to delegate  e g  roomTempControllerObj OnRoomTemperatureChange   delegateMethod  System will throw error      public bool TurnRoomTeperatureSimulator               set                        tempSimulator   value              if  value                                SimulateRoomTemperature      Turn on Simulator                                               get   return  tempSimulator              public void TurnAirCondition bool val                 isAirConditionTurnedOn   val           isHeatTurnedOn    val   Binary switch If Heat is ON - AC will turned off automatically  binary          System Console WriteLine  Aircondition       isAirConditionTurnedOn           System Console WriteLine  Heat       isHeatTurnedOn              public void TurnHeat bool val                 isHeatTurnedOn   val           isAirConditionTurnedOn    val   Binary switch If Heat is ON - AC will turned off automatically  binary          System Console WriteLine  Aircondition       isAirConditionTurnedOn           System Console WriteLine  Heat       isHeatTurnedOn               public async void SimulateRoomTemperature                 while   tempSimulator                        if   isAirConditionTurnedOn                   roomTemperature--   Decrease Room Temperature if AC is turned On             if   isHeatTurnedOn                   roomTemperature     Decrease Room Temperature if AC is turned On             System Console WriteLine  Temperature       roomTemperature               if  WhenRoomTemperatureChange    null                  WhenRoomTemperatureChange  roomTemperature               System Threading Thread Sleep 500    Every second Temperature changes based on AC Heat Status                     public class MySweetHome       RoomTemperatureController roomController   null      public MySweetHome                 roomController   new RoomTemperatureController            roomController WhenRoomTemperatureChange    TurnHeatOrACBasedOnTemp            roomController WhenRoomTemperatureChange   null    Setting NULL to delegate reference is possible where as for Event it is not possible            roomController WhenRoomTemperatureChange DynamicInvoke     Dynamic Invoke is possible for Delgate and not possible with Event         roomController SimulateRoomTemperature            System Threading Thread Sleep 5000           roomController TurnAirCondition  true           roomController TurnRoomTeperatureSimulator   true             public void TurnHeatOrACBasedOnTemp int temp                if  temp  gt   30              roomController TurnAirCondition true           if  temp  lt   15              roomController TurnHeat true              public static void Main string   args                MySweetHome home   new MySweetHome

User · Answer

To understand the differences you can look at this 2 examples  Example with Delegates  in this case  an Action - that is a kind of delegate that doesn t return a value   public class Animal       public Action Run  get  set        public void RaiseEvent                 if  Run    null                        Run                        To use the delegate  you should do something like this   Animal animal  new Animal    animal Run         gt  Console WriteLine  I m running    animal Run         gt  Console WriteLine  I m still running     animal RaiseEvent      This code works well but you could have some weak spots   For example  if I write this    animal Run         gt  Console WriteLine  I m running    animal Run         gt  Console WriteLine  I m still running    animal Run        gt  Console WriteLine  I m sleeping       with the last line of code  I have overridden the previous behaviors just with one missing    I have used   instead of      Another weak spot is that every class which uses your Animal class can raise RaiseEvent just calling it animal RaiseEvent     To avoid these weak spots you can use events in c    Your Animal class will change in this way   public class ArgsSpecial   EventArgs       public ArgsSpecial  string val                Operation val             public string Operation  get  set       public class Animal          Empty delegate  In this way you are sure that value is always    null         because no one outside of the class can change it      public event EventHandler lt ArgsSpecial gt  Run   delegate         public void RaiseEvent                    Run this  new ArgsSpecial  Run faster               to call events   Animal animal  new Animal     animal Run     sender  e    gt  Console WriteLine  I m running  My value is  0    e Operation    animal RaiseEvent      Differences    You aren t using a public property but a public field  using events  the compiler protects your fields from unwanted access  Events can t be assigned directly  In this case  it won t give rise to the previous error that I have showed with overriding the behavior  No one outside of your class can raise the event  Events can be included in an interface declaration  whereas a field cannot   Notes   EventHandler is declared as the following delegate   public delegate void EventHandler  object sender  EventArgs e    it takes a sender  of Object type  and event arguments  The sender is null if it comes from static methods   This example  which uses EventHandler lt ArgsSpecial gt   can also be written using EventHandler instead   Refer here for documentation about EventHandler

User · Answer

Here is another good link to refer to  http   csharpindepth com Articles Chapter2 Events aspx  Briefly  the take away from the article - Events are encapsulation over delegates   Quote from article      Suppose events didn t exist as a concept in C   NET  How would another class subscribe to an event  Three options          A public delegate variable   A delegate variable backed by a property   A delegate variable with AddXXXHandler and RemoveXXXHandler methods         Option 1 is clearly horrible  for all the normal reasons we abhor public variables       Option 2 is slightly better  but allows subscribers to effectively override each other - it would be all too easy to write someInstance MyEvent   eventHandler  which would replace any existing event handlers rather than adding a new one  In addition  you still need to write the properties       Option 3 is basically what events give you  but with a guaranteed convention  generated by the compiler and backed by extra flags in the IL  and a  free  implementation if you re happy with the semantics that field-like events give you  Subscribing to and unsubscribing from events is encapsulated without allowing arbitrary access to the list of event handlers  and languages can make things simpler by providing syntax for both declaration and subscription

User · Answer

NOTE  If you have access to C  5 0 Unleashed  read the  Limitations on Plain Use of Delegates  in Chapter 18 titled  Events  to understand better the differences between the two     It always helps me to have a simple  concrete example  So here s one for the community  First I show how you can use delegates alone to do what Events do for us  Then I show how the same solution would work with an instance of EventHandler  And then I explain why we DON T want to do what I explain in the first example  This post was inspired by an article by John Skeet   Example 1  Using public delegate  Suppose I have a WinForms app with a single drop-down box  The drop-down is bound to an List lt Person gt   Where Person has properties of Id  Name  NickName  HairColor  On the main form is a custom user control that shows the properties of that person  When someone selects a person in the drop-down the labels in the user control update to show the properties of the person selected     Here is how that works  We have three files that help us put this together    Mediator cs -- static class holds the delegates Form1 cs -- main form  DetailView cs -- user control shows all details   Here is the relevant code for each of the classes   class Mediator       public delegate void PersonChangedDelegate Person p     delegate type definition     public static PersonChangedDelegate PersonChangedDel    delegate instance  Detail view will  subscribe  to this      public static void OnPersonChanged Person p    Form1 will call this when the drop-down changes                if  PersonChangedDel    null                        PersonChangedDel p                       Here is our user control   public partial class DetailView   UserControl       public DetailView                 InitializeComponent            Mediator PersonChangedDel    DetailView PersonChanged             void DetailView PersonChanged Person p                BindData p              public void BindData Person p                lblPersonHairColor Text   p HairColor          lblPersonId Text   p IdPerson ToString            lblPersonName Text   p Name          lblPersonNickName Text   p NickName             Finally we have the following code in our Form1 cs  Here we are Calling OnPersonChanged  which calls any code subscribed to the delegate   private void comboBox1 SelectedIndexChanged object sender  EventArgs e        Mediator OnPersonChanged  Person comboBox1 SelectedItem     Call the mediator s OnPersonChanged method  This will in turn call all the methods assigned  i e  subscribed to  to the delegate -- in this case  DetailView PersonChanged       Ok  So that s how you would get this working without using events and just using delegates  We just put a public delegate into a class -- you can make it static or a singleton  or whatever  Great    BUT  BUT  BUT  we do not want to do what I just described above  Because public fields are bad for many  many reason  So what are our options  As John Skeet describes  here are our options    A public delegate variable  this is what we just did above  don t do this  i just told you above why it s bad  Put the delegate into a property with a get set  problem here is that subscribers could override each other -- so we could subscribe a bunch of methods to the delegate and then we could accidentally say PersonChangedDel   null  wiping out all of the other subscriptions  The other problem that remains here is that since the users have access to the delegate  they can invoke the targets in the invocation list -- we don t want external users having access to when to raise our events  A delegate variable with AddXXXHandler and RemoveXXXHandler methods   This third option is essentially what an event gives us  When we declare an EventHandler  it gives us access to a delegate -- not publicly  not as a property  but as this thing we call an event that has just add remove accessors   Let s see what the same program looks like  but now using an Event instead of the public delegate  I ve also changed our Mediator to a singleton    Example 2  With EventHandler instead of a public delegate  Mediator   class Mediator        private static readonly Mediator  Instance   new Mediator         private Mediator            public static Mediator GetInstance                 return  Instance             public event EventHandler lt PersonChangedEventArgs gt  PersonChanged    this is just a property we expose to add items to the delegate       public void OnPersonChanged object sender  Person p                var personChangedDelegate   PersonChanged as EventHandler lt PersonChangedEventArgs gt           if  personChangedDelegate    null                        personChangedDelegate sender  new PersonChangedEventArgs     Person   p                         Notice that if you F12 on the EventHandler  it will show you the definition is just a generic-ified delegate with the extra  sender  object   public delegate void EventHandler lt TEventArgs gt  object sender  TEventArgs e     The User Control   public partial class DetailView   UserControl       public DetailView                 InitializeComponent            Mediator GetInstance   PersonChanged    DetailView PersonChanged             void DetailView PersonChanged object sender  PersonChangedEventArgs e                BindData e Person              public void BindData Person p                lblPersonHairColor Text   p HairColor          lblPersonId Text   p IdPerson ToString            lblPersonName Text   p Name          lblPersonNickName Text   p NickName             Finally  here s the Form1 cs code   private void comboBox1 SelectedIndexChanged object sender  EventArgs e            Mediator GetInstance   OnPersonChanged this   Person comboBox1 SelectedItem       Because the EventHandler wants and EventArgs as a parameter  I created this class with just a single property in it   class PersonChangedEventArgs       public Person Person   get  set        Hopefully that shows you a bit about why we have events and how they are different -- but functionally the same -- as delegates

User · Answer

An event in  net is a designated combination of an Add method and a Remove method  both of which expect some particular type of delegate   Both C  and vb net can auto-generate code for the add and remove methods which will define a delegate to hold the event subscriptions  and add remove the passed in delegagte to from that subscription delegate   VB net will also auto-generate code  with the RaiseEvent statement  to invoke the subscription list if and only if it is non-empty  for some reason  C  doesn t generate the latter   Note that while it is common to manage event subscriptions using a multicast delegate  that is not the only means of doing so   From a public perspective  a would-be event subscriber needs to know how to let an object know it wants to receive events  but it does not need to know what mechanism the publisher will use to raise the events   Note also that while whoever defined the event data structure in  net apparently thought there should be a public means of raising them  neither C  nor vb net makes use of that feature

User · Answer

In addition to the syntactic and operational properties  there s also a semantical difference    Delegates are  conceptually  function templates  that is  they express a contract a function must adhere to in order to be considered of the  type  of the delegate   Events represent     well  events  They are intended to alert someone when something happens and yes  they adhere to a delegate definition but they re not the same thing   Even if they were exactly the same thing  syntactically and in the IL code  there will still remain the semantical difference  In general I prefer to have two different names for two different concepts  even if they are implemented in the same way  which doesn t mean I like to have the same code twice

[c#] What are the differences between delegates and events?

Definitions:

Code Example:

with `delegate`:

with `event`:

Reference:

Examples related to c#

Examples related to events

Examples related to delegates

Examples related to glossary