C# Event Handlers automatically created by WinForms Designer

Question

Just moved from VB.NET to C#.

In VB to connect and Event Handler to a Sub we use the Handles clause.

From what it seems, this do not exist in C#.

After creating a simple application with a button I realize that Window Forms Designer automatically created an EventHandler to my button1_Click function (after I double clicked it), in Form1.Designer.cs with this code:

this.button1.Click += new System.EventHandler(this.button1_Click);

But, in VB, the WinForms Designer create the Handles clause in my class, in the function header. So, C# create the default EventHandler in designer file, while VB creates in main class where control resides.

Is this correct? Am I missing something here?

Answer 1

Yes, this is correct, the designer creates it in the generated *.designer.cs file. You can of course create event handlers manually with the same syntax. This behaviour is achieved by the partial class feature, where you can define parts of a class in different files.

Answer 2

You're right in that there is no analog to the VB.NET handles clause (or the corresponding WithEvents variable decorator) in C#. These only exist in VB.NET as holdovers from classic VB, and they have overhead in their use (the generated IL actually has to monitor everywhere that the variable is set in order to detach and attach all of the functions that handles that event).

If you examine the IL for a VB.NET form or control, you'll actually find that there is a property created for every single WithEvents variable, and the setter takes care of removing all of the actual handlers from the old value (assuming it's non-null) and attaching them to the new value (assuming it's non-null).

The analog for C#'s event handling in VB.NET is the AddHandler statement.

Answer 3

Consider += as AddHandler with AddressOf

Answer 4

The VB Handles keyword is just syntactic sugar to basically do the same thing that you see in C#. You could write VB the same way, but why would you?

The C# method (which you could emulate in VB) does allow more flexibility (i.e. calling the same method for two different controls).

Answer 5

Everything that is modified into the Form1.cs[Design] will have a code part into Form1.Deisgner.cs This is the way C#.NET knows how to make stuff to appear.

It should have created also in your Form1.cs some code where you actually fill what will be in the event.

Answer 6

Hi,

This behavior is absolutely correct and you are not missing anything.

In VB, you can subscribe to an event using Handles keyword or AddHandler and AddressOf operators. Visual Studio uses Handles keyword for designer generated events. Since, the event handlers must be in the code behind file and not in the designer file, you can see them while editing the code behind file. If Visual Studio used AddHandler, it would have inserted that code into InitializeComponent method in the designer code file.

On the other hand, C# has one operator (+=) only to subscribe to events. So, that code goes into the designer file and not in the code behind file to avoid mixing designer generated code with the user code.

Hope this helps!