¿Cómo paso las variables a un método de evento de botones?

Question

Necesito poder pasar dos objetos al método que se dispara cuando hago clic en un botón. ¿Cómo hago esto?

Hasta ahora he estado buscando en la creación de una modificados eventArgs:

public class CompArgs : System.EventArgs 
    { 
    private object metode; 
    private Type typen; 

    public CompArgs(object m, Type t) 
    { 
     this.metode = m; 
     this.typen = t; 
    } 

    public object Metode() 
    { 
     return metode; 
    } 

    public Type Typen() 
    { 
     return typen; 
    } 
} 

Pero ¿cómo lo uso? ¿Es posible de alguna manera anular el evento click del botón para usar un eventhandler personalizado, que toma CompArgs como parámetro?

private void button1_Click(object sender, EventArgs e) 
     { 


      Assembly assembly = Assembly.LoadFile(@"c:\components.dll"); 

      int counter = 0; 

      foreach (Type type in assembly.GetTypes()) 
      { 
       if (type.IsClass == true) 
       { 

        Button btn = new Button(); 
        btn.Location = new Point(174 + (counter * 100),10); 
        btn.Size = new Size(95, 23); 
        btn.Name = type.Name; 
        btn.Text = type.Name; 
        btn.UseVisualStyleBackColor = true; 


        this.Controls.Add(btn); 

        object obj = Activator.CreateInstance(type); 

        //I need to pass on obj and type to the btn_Click 
        btn.Click += new eventHandler(btn_Click); 

        counter++; 
       } 
      } 
     } 

Y el evento de método en el que lo necesito:

private void btn_Click(object sender, CompArgs ca) 
     { 
       MessageBox.Show((string)ca.Typen().InvokeMember("getMyName", 
          BindingFlags.Default | BindingFlags.InvokeMethod, 
          null, 
          ca.Metode(), 
          null)); 

     } 

Answer 1

Cant que acaba de establecer una propiedad o variable de miembro en el formulario que aloja el botón y acceder a ellos desde el evento de clic de botón?

EDIT: a medida sugerencia clase de botón después de comentario de retroalimentación (no es lo mismo que el anterior sugerencia)

class MyButton : Button 
{ 
    private Type m_TYpe; 

    private object m_Object; 

    public object Object 
    { 
     get { return m_Object; } 
     set { m_Object = value; } 
    } 

    public Type TYpe 
    { 
     get { return m_TYpe; } 
     set { m_TYpe = value; } 
    } 
} 




Button1Click(object sender, EventArgs args) 
{ 
    MyButton mb = (sender as MyButton); 

    //then you can access Mb.Type 
    //and Mb.object 
} 

Answer 2

No puede utilizar su propia clase de argumento de evento personalizado para una firma de controlador de eventos predefinidos. Al menos, el tipo de argumento de evento personalizado nunca será utilizado por ninguna llamada predeterminada al controlador (que solo será del tipo EventArgs en el caso de un botón); podría, potencialmente, llamar al manejador usted mismo, pasando su tipo personalizado, sin embargo, necesitaría tener la lógica para devolverlo desde un EventArgs al que se lo había lanzado.

Como una posible solución (según su situación), considere un tipo compuesto para encapsular los elementos que necesita, como con su tipo de argumento de evento, pero mantenga la instancia requerida como una variable accesible que puede utilizarse desde el evento manejador, o, al menos, por el/los método/es que invoca el controlador par.

Por ejemplo, definir el tipo de ...

public class MyType 
{ 
    public object AccessibleItem { get; set; } 
} 

Y, en su clase de formulario ...

private MyType MyTypeInstance = new MyType(); 

private void Button_Click(object sender, EventArgs e) 
{ 
    //here we can set the item, if needs be... 
    MyTypeInstance.AccessibleItem = new Anything(); 
    //or access the item to use as required... 
    DoSomeMagicWithMyObject(MyTypeInstance.AccessibleItem); 
} 

EDIT:

bien, mirando a su código de corriente I solo puedo ofrecerte esto por ahora (no agrega los elementos al contenedor de control de formularios y utiliza un iterador variable dentro de Linq (que creo que está mal visto o simplemente mal, pero ... bueno, pero bueno ... .):

private void BuildButtonToObjectDictionary() 
    { 
     int counter = 0; 
     var assembly = Assembly.LoadFile(@"c:\components.dll"); 

     var buttonToObjectDictionary = (
      from type in assembly.GetTypes() 
      where type.IsClass && !type.IsAbstract 
      select new 
      { 
       Button = new Button 
       { 
        Name = type.Name, 
        Text = type.Name, 
        Size = new Size(95, 25), 
        Location = new Point(175 + (counter * 100), 10), 
        UseVisualStyleBackColor = true 
       }, 
       Item = Activator.CreateInstance(type), 
       Index = counter++ 
      }); 
    } 

Answer 3

necesitaría para ver más código para dar una mejor respuesta, pero podría crear un evento que tiene sus CompArgs como parámetro y se activa cuando el buttonEvent es capturado

Answer 4

Si archivo que yourForm.Designer.cs abiertas verá todos los automóviles código generado por VS. Aquí puede modificar el método llamado al hacer clic en el botón (o agregar un segundo método).

this.yourButton.Location = new System.Drawing.Point(211, 51); 
this.yourButton.Name = "yourButton"; 
this.yourButton.Size = new System.Drawing.Size(75, 23); 
this.yourButton.TabIndex = 0; 
this.yourButton.Text = "yourButton"; 
this.yourButton.UseVisualStyleBackColor = true; 
this.yourButton.Click += new System.EventHandler(this.yourMethodHere(object1, object2); 

Espero que esto ayude.

Answer 5

No estoy seguro de si esto existe en Winforms pero lo hace en WPF: Hay un objeto "tag" en todos los controles al que puede adjuntar cualquier objeto.Puede guardar el objeto que desea pasar y luego en el controlador de eventos leerlo de nuevo desde el objeto emisor.

private void Button_Click(object sender, RoutedEventArgs e) 
{ 
    var note = (sender as FrameworkElement).Tag as Note; 
    //Do something with note here 
} 

Answer 6

Crearía un nuevo botón y anularía el método OnClick. En lugar de pasar los EventArgs, pase una nueva clase derivada con sus miembros adicionales.

En el delegado que recibe el evento, transfiera los EventArgs dados a la clase más derivada que espera obtener, configure alternativamente un nuevo evento que se active al mismo tiempo cuando se presiona el botón y conéctese a ese en cambio, para hacer las cosas más implícitas.

Código Ejemplo:

public partial class Form1 : Form 
{ 
    public Form1() 
    { 
     InitializeComponent(); 

     ButtonEx b1 = new ButtonEx(); 
     b1.OnCustomClickEvent += new ButtonEx.OnCustomClickEventHandler(b1_OnCustomClickEvent); 
    } 

    void b1_OnCustomClickEvent(object sender, ButtonEx.CustomEventArgs eventArgs) 
    { 
     string p1 = eventArgs.CustomProperty1; 
     string p2 = eventArgs.CustomProperty2; 
    } 
} 

public class ButtonEx : Button 
{ 
    public class CustomEventArgs : EventArgs 
    { 
     public String CustomProperty1; 
     public String CustomProperty2; 
    } 

    protected override void OnClick(EventArgs e) 
    { 
     base.OnClick(e); 
     if(OnCustomClickEvent != null) 
     { 
      OnCustomClickEvent(this, new CustomEventArgs()); 
     } 
    } 

    public event OnCustomClickEventHandler OnCustomClickEvent; 
    public delegate void OnCustomClickEventHandler(object sender , CustomEventArgs eventArgs); 
} 

Answer 7

Wow, ustedes están haciendo esto por completo a difícil. No hay necesidad de ninguna clase personalizada o anulación de método. En este ejemplo, solo necesito pasar un número de índice de pestaña. Puede especificar lo que desee, siempre que su método espere ese tipo de valor.

button.Click += (sender, EventArgs) => { buttonNext_Click(sender, EventArgs, item.NextTabIndex); }; 

void buttonNext_Click(object sender, EventArgs e, int index) 
    { 
     //your code 
    } 

Answer 8

Puede usar la propiedad Tag del botón. Se puede añadir un valor de cadena a esta propiedad desde la ventana de propiedades de diseño y luego recogerlo dentro del manejador como tan:

private void MyButton_Click(object sender, EventArgs e) 
    { 
     string tagValue = ((Button) sender).Tag; 

     if(tag == "blah") 
     { 
      // Do something 
     } 
    }