Exposing inherited events

Question

I am writing several UserControls for other programmers here.

Some Exposed EventHandlers with same name as the base are accepted

(UserControl CodesCombo -> SelectedValueChanged)

some aren't

(UserControl TextBox -> TextChanged)

I'm writing a UserControl which contains a TextBox. I need to expose the TextChanged event to the potential consumers of this control.

I have a similar control based on a ComboBox, and in that I used

public event EventHandler SelectedValueChanged 
    {
    add { cbMain.SelectedValueChanged += value; }
    remove { cbMain.SelectedValueChanged -= value; }
    }

to expose the "Change" event "SelectedValueChanged", and it works without without any problems.

However, when I try to use this technique in my TextBox based control in a similar way

public event EventHandler TextChanged
    {
    add { tbMain.TextChanged += value; }
    remove { tbMain.TextChanged -= value; }
    }

I get a warning message:

'MyTextBox.TextChanged' hides inherited member 'UserControl.TextChanged'. Use new keyword if hiding was intentional.

I'm not entirely certain what the message means, other than the obvious, but what I do know is that I don't -think- I want to hide anything. I have internal SelectedValueChanged and TextChanged functions (cbMain_SelectedValueChanged, tbMain_TextChanged) which do a few things I need, but I want to allow the consumer to get an Event call on text change as well, just like they do in the ComboBox based one.

Also, I get no "change" event at all in the available list of event in the test program.

I've gotten around this for now by exposing the event as "TextChange"

new public event EventHandler TextChange
    {
    add { tbMain.TextChanged += value; }
    remove { tbMain.TextChanged -= value; }
    }

which gives me an event in the list and seems to work well enough, but I'd prefer to have a general solution to this as we're making several more controls along these lines for our package and I don't think I can get away with having names that are just "off".

Any idea what this message is really telling me, and how I can get my event internally, and also still get the user theirs?

Thanks!

Update: Asked for more specific code:

namespace NCFLSToolbox
    {
    public partial class NCFLSCodesCombo : UserControl
        {
        //Listed in the Events for System.Windows.Forms.ComboBox
        private void cbMain_SelectedValueChanged(object sender, EventArgs e)
            {
            ControlRequiredColoring();
            }

        //Exposed Event for user
        public event EventHandler SelectedValueChanged 
            {
            add { cbMain.SelectedValueChanged += value; }
            remove { cbMain.SelectedValueChanged -= value; }
            }
        }


    public partial class NCFLSTextbox : UserControl
        {
        //Listed in the Events for System.Windows.Forms.TextBox
        private void tbMain_TextChanged(object sender, EventArgs e)
            {
            ControlRequiredColoring();
            }


        //Couldn't expose "TextChanged" by name...
        ////public event EventHandler TextChanged
        ////    {
        ////    add { tbMain.TextChanged += value; }
        ////    remove { tbMain.TextChanged -= value; }
        ////    }

        //...so I exposed "TextChange" instead.
        public event EventHandler TextChange
            {
            add { tbMain.TextChanged += value; }
            remove { tbMain.TextChanged -= value; }
            }
        }
    }

Brian · Accepted Answer

The problem is that TextBox events do not propagate to the parent user control. If you wish them to do so, there are two ways to accomplish this:

1) Have the event on the user control ferry all additionals/removals to the event handler to the UserControl's event handler. This is roughly what your question is trying to do. However, I don't recommend it.

2) Have the event on the TextBox trigger events on the parent user control.

So, just run this code in your constructor, below InitializeComponent():
tbMain.TextChanged += (sender,e)=>OnTextChanged(e);

With this approach, a TextChanged event in the TextBox will call OnTextChanged, which raises a TextChanged event. You cannot invoke base class events directly (hence why the OnTextChanged method is provided).

Edit: tbMain.TextChanged += (sender,e)=>OnTextChanged(e); is semantically equivalent to the below code:

tbMain.TextChanged += OnTbMainTextChanged;
...
} //End of Constructor

private void OnTbMainTextChanged(object sender, EventArgs e)
{
    OnTextChanged(e);
}

The benefit of using a lambda function is that it is more self-contained. Among other benefits, using a self-contained lambda function makes it obvious to future code maintainers that the sender is not being propagated, without requiring the maintainer to navigate to the named method. This is what you want: from the perspective of subscribers to the user control, your use of a TextBox to implement your control is an implementation detail.

Exposing inherited events

Answers (2)

Related Questions