How to set the defaul event for a user control?

Just a note of warning:

This is so good that System.ComponentModel is not a part standard .NET library (by "standard" I mean standardization under ECMA and ISO). Some .NET libraries are wonderful, some are not so good; and System.ComponentModel is the worse one from what I know.

Take this class System.ComponentModel.DefaultEventAttribute. It requires either immediate or explicit string constant as its argument. This is the worst case from the maintainability standpoint. If the string passes as a parameter is misspelled, a compiler cannot checkup anything and issue a single warning, but the behavior of the component under Designer will be modified. Some constructor of attribute classes require statically known type (hence, passed through typeof); it does not allow to provide any type constraint, but at least the compiler can check up if this is a really existing type. This is bad, too, but not as bad as a string constant.

With System.ComponentModel, such rotten technique is used all the time. I mean it: this is not a problem of Reflection, where the meta-data can be extracted from a type without using any string constants like member names (which is also possible), this is a problem of System.ComponentModel. There are fundamental problems related to limitations of attributes and System.Type (not quite a fully-fledged meta-class), but nevertheless most .NET libraries are free from System.ComponentModel.

I also explain some of related problems in my article Human-readable Enumeration Meta-data[^].

I would recommend anyone not to do much effort struggling with System.ComponentModel and Forms Design-time behavior. Microsoft already provided two new UI models; and who knows? may be life time expectancy of Forms and System.ComponentModel does not deserve wasting our lives on working to much in this direction? Our investment in our working time may never pay off…

—SA

OriginalGriff's answer, and SAK's eloquent critique of System.ComponentModel, are a feast for the intellect, and may well give you all the tools you need to achieve your solution.

But, I'm going to go, recklessly, 'out on a limb' here, and suggest a very different approach to this.

And, you'll forgive me, I hope, if I do this via Socratic method ... an 'experiment' for me, as well as you, perhaps ... since it would be interesting to me to know if what (I hope) I am implying by experimentation "resonates" with you.

Let me just ask to you do a simple experiment:

1. create a WinForms project, add a UserControl template to the project, insert one TextBox into the UserControl template, 'textBox1.' Leave the Text of textBox1 'blank.'

2. in the Load event of that UserControl put this one line of code:

textBox1.Text = "uc loaded";

3. Build the project.

4. at design-time drag-drop an instance of the compiled UserControl onto the surface of the Form.

5. observe what appears in textBox1 of the UserControl.

6. delete the design-time placed UserControl from the Form.

7. put a button on the Form and set its click handler to:

private void button1_Click(object sender, EventArgs e)
{
    UserControl1 uc1 = new UserControl1();
    this.Controls.Add(uc1);
}

8. once again observe what appears in the textBox1 of the UserControl.

9. Now: alter the code in the UserControl's Load event:

textBox1.Text = "uc loaded : " + this.Parent.Name;

10. Now once again build the Project and drag-drop an instance of the UserControl onto the Form surface: observe what's in textBox1.

11. Now delete the drag-dropped UserControl from the Form and run the project, and click on button1 in the Form that creates a new UserControl in code:

12. Observe the contents of textBox1 in the UserControl

Discussion:

0. note that the experiment described above does NOT require a reference to System.ComponentModel for either Form or UserControl.

1. why use a cannon to shoot a horse-fly ? i.e., why get involved with Attributes and System.ComponentModel ... if there's a simpler way ?

2. You now know (I hope) that whether a UserControl is drag-dropped on a Form at design-time, or created at run-time, its Load event is fired, and ... in that Load event ... access is available to the object (in this case a Form) that is creating it.

3. I'll assume that the technique required to publish/expose some method or whatever on a Form ... so it's available from an instance of the Form from outside the scope of the Form definition ... is obvious to you.

I'd be very interested to know if what is suggested here seems like a basis for a solution to the question you ask. And, I'm ready to drink the hemlock if the verdict requires it :)

experimentally yours, Bill

< This is really an extended comment, but, since it includes code, I think it more appropriate posted as 'solution.' >

Please vote for OriginalGriff's answer above, since this reply here simply extends OG's prescient suggestion to meet the precise requirements of the OP.

WinForms Project: one Form, 'Form1,' one UserControl, 'UserControl1,' one TextBox inside UserControl1, 'textBox1'

1. make sure you have a reference (or skip to step #2a) in the UserControl library-reference header to:

using System.ComponentModel;

2. adorn the UserControl definition with this attribute: like so:

[DefaultEvent("OperateEvent")]
public partial class UserControl1 : UserControl
{

2.a. okay: if you just hate typing the word 'using:' use this for the Attribute, as OG's example shows:

[System.ComponentModel.DefaultEvent("OperateEvent")]

3. Define an Event in the UserControl's code:

public delegate void OperateEventHandler(Object sender, EventArgs e);

public event OperateEventHandler OperateEvent;

public void Operate(object sender, EventArgs e)
{
    textBox1.Text = "Operate: called from " + sender.ToString();
}

4. Define the Load event of UserControl1:

private void UserControl1_Load(object sender, EventArgs e)
{
    textBox1.Text = "uc loaded : " + this.Parent.Name;
    this.OperateEvent += new OperateEventHandler(Operate);
}

5. And now ... the moment of truth ... build the Project: at design-time drag and drop a UserControl1 from the ToolBox onto Form1's surface, and then double-click on it. Observe the code generated in Form1. Repeat until satiated.

~

There are other interesting methods for such "indirect auto-event-hooking" you can use when creating custom-controls at run-time, as I hope was implied (even if unsatisfactorily 'rendered') by my first answer on this thread.