How do I tell which control the mouse has been cli

I have been looking around for a while for some code that tells what control the mouse has clicked. I have a Form with over 50 controls and I don't want to click each one to make a mouse clicked on. How would I do this?

回答1:

You can use the Tag property of each control. So set it to something meaningful and on Click event do something like this:

(sender As Control).Tag

EDIT: Also you may do this:

foreach (Control item in this.Controls)     //this IS YOUR CURRENT FORM
{
    if ((sender as Control).Equals(item))
    {
        //Do what you want
    }
}

回答2:

Approach One: Individualized Handling

The mouse click event will actually be received by the control on which the mouse is clicked, so the only thing you need to do is handle the MouseClick event for that control. That makes sense if you want mouse clicks to do something different for each of your controls.

This is just the basic event-handling strategy that you should already be familiar with. The event handler method can be wired up either using the designer or manually via code, and looks like this:

private void myControl_MouseClick(object sender, MouseEventArgs e)
{
   // do something when the myControl control is clicked
}

Approach Two: Consolidated Handling

If you want the same behavior on multiple controls, you would wire up a single event handler method to handle the MouseClick event for multiple controls. Then, from inside of the event handler method, you would use the sender parameter to identify the control that was clicked. For example, you could cast sender to a Control object and test the value of the Name property.

If you wanted all controls of a certain type to behave a certain way, and all controls of another type to behave a different way, you could have two event handler methods and wire the controls up accordingly by type.

The easiest way to do this is to wire up the event handler methods through code. The designer would work, but it would be overly tedious to use it for each of many controls. For example, in your form's constructor, you could loop over all of the controls and hook up your event handlers:

public MyForm()
{
   this.InitializeComponent();

   // Wire up your event handlers.
   foreach (Control ctrl in this.Controls)
   {
      if (ctrl is Label)
      {
         // Wire all Label controls up to do one thing.
         ctrl.MouseClick += new MouseEventHandler(LabelControls_MouseClick);
      }
      else if (ctrl is Button)
      {
         // Wire up all Button controls to do another thing.
         ctrl.MouseClick += new MouseEventHandler(ButtonControls_MouseClick);
      }
      else
      {
         // And wire up the rest of the controls to do a third thing.
         ctrl.MouseClick += new MouseEventHandler(OtherControls_MouseClick);
      }
   }
}

private void LabelControls_MouseClick(object sender, MouseEventArgs e)
{
   // do something when a Label control is clicked
}

private void ButtonControls_MouseClick(object sender, MouseEventArgs e)
{
   // do something when a Button control is clicked
}

private void OtherControls_MouseClick(object sender, MouseEventArgs e)
{
   // do something when a control other than a Label or Button is clicked
}

Approach Three: Global Handling

If you've made all of these controls transparent (that is, transparent to mouse events, not visually transparent) so that mouse click events are handled at a higher level (i.e., by your form), you can use the Control.GetChildAtPoint method to determine the control that was clicked on. You just specify the coordinates of the location at which the mouse was clicked, and the method will return the child control (if any) that is located at that point.

private void myForm_MouseClick(object sender, MouseEventArgs e)
{
   Control ctrl = Control.GetChildAtPoint(e.Location);
   if (ctrl != null)
   {
      // do something with the clicked control
   }
   else
   {
      // if ctrl is null, then the parent form itself was clicked,
      // rather than one of its child controls
  }
}

I don't really recommend this approach, though, because it violates good object-oriented design. You have to write code to determine which control is which based on its unique properties, instead of just letting the runtime determine and handle that automatically.