Можно ли "украсть" обработчик событий из одного элемента управления и передать его другому?

Ответ 1

Да, это технически возможно. Отражение требуется, потому что многие из членов являются частными и внутренними. Запустите новый проект Windows Forms и добавьте две кнопки. Тогда:

using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Reflection;

namespace WindowsFormsApplication1 {
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
      button1.Click += new EventHandler(button1_Click);
      // Get secret click event key
      FieldInfo eventClick = typeof(Control).GetField("EventClick", BindingFlags.NonPublic | BindingFlags.Static);
      object secret = eventClick.GetValue(null);
      // Retrieve the click event
      PropertyInfo eventsProp = typeof(Component).GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
      EventHandlerList events = (EventHandlerList)eventsProp.GetValue(button1, null);
      Delegate click = events[secret];
      // Remove it from button1, add it to button2
      events.RemoveHandler(secret, click);
      events = (EventHandlerList)eventsProp.GetValue(button2, null);
      events.AddHandler(secret, click);
    }

    void button1_Click(object sender, EventArgs e) {
      MessageBox.Show("Yada");
    }
  }
}

Если это убедит вас, что Microsoft очень старалась помешать вам сделать это, вы поняли код.

Ответ 2

Нет, вы не можете этого сделать. Причина заключается в инкапсуляции - события просто подписываются/отписываются, т.е. Не позволяют "заглянуть внутрь", чтобы узнать, какие подписчики уже подписаны.

Что вы можете сделать, это вывести из Button и создать общедоступный метод, который вызывает OnClick. Тогда вам просто нужно сделать btn1 экземпляр этого класса и подписаться на обработчик на btn2, который вызывает btn1.RaiseClickEvent() или то, что вы вызываете методом.

Я не уверен, что действительно рекомендую. Что вы на самом деле пытаетесь сделать? Какая большая картина?

EDIT: Я вижу, что вы приняли версию, которая извлекает текущий набор событий с отражением, но в случае, если вас интересует альтернатива, которая вызывает обработчик OnXXX в исходном элементе управления, у меня есть образец здесь, Сначала я скопировал все события, но это действительно приводит к некоторым очень странным эффектам. Обратите внимание, что эта версия означает, что если кто-либо присоединяется к событию в исходной кнопке после вызова CopyEvents, он все еще "подключен", то есть на самом деле не имеет значения, когда вы связываете эти два.

using System;
using System.Drawing;
using System.Reflection;
using System.Windows.Forms;

class Test
{
    static void Main()
    {

        TextBox output = new TextBox 
        { 
            Multiline = true,
            Height = 350,
            Width = 200,
            Location = new Point (5, 15)
        };
        Button original = new Button
        { 
            Text = "Original",
            Location = new Point (210, 15)
        };
        original.Click += Log(output, "Click!");
        original.MouseEnter += Log(output, "MouseEnter");
        original.MouseLeave += Log(output, "MouseLeave");

        Button copyCat = new Button
        {
            Text = "CopyCat",
            Location = new Point (210, 50)
        };

        CopyEvents(original, copyCat, "Click", "MouseEnter", "MouseLeave");

        Form form = new Form 
        { 
            Width = 400, 
            Height = 420,
            Controls = { output, original, copyCat }
        };

        Application.Run(form);
    }

    private static void CopyEvents(object source, object target, params string[] events)
    {
        Type sourceType = source.GetType();
        Type targetType = target.GetType();
        MethodInfo invoker = typeof(MethodAndSource).GetMethod("Invoke");
        foreach (String eventName in events)
        {
            EventInfo sourceEvent = sourceType.GetEvent(eventName);
            if (sourceEvent == null)
            {
                Console.WriteLine("Can't find {0}.{1}", sourceType.Name, eventName);
                continue;
            }

            // Note: we currently assume that all events are compatible with
            // EventHandler. This method could do with more error checks...

            MethodInfo raiseMethod = sourceType.GetMethod("On"+sourceEvent.Name, 
                                                          BindingFlags.Instance | 
                                                          BindingFlags.Public | 
                                                          BindingFlags.NonPublic);
            if (raiseMethod == null)
            {
                Console.WriteLine("Can't find {0}.On{1}", sourceType.Name, sourceEvent.Name);
                continue;
            }
            EventInfo targetEvent = targetType.GetEvent(sourceEvent.Name);
            if (targetEvent == null)
            {
                Console.WriteLine("Can't find {0}.{1}", targetType.Name, sourceEvent.Name);
                continue;
            }
            MethodAndSource methodAndSource = new MethodAndSource(raiseMethod, source);
            Delegate handler = Delegate.CreateDelegate(sourceEvent.EventHandlerType,
                                                       methodAndSource,
                                                       invoker);

            targetEvent.AddEventHandler(target, handler);
        }
    }

    private static EventHandler Log(TextBox output, string text)
    {
        return (sender, args) => output.Text += text + "\r\n";
    }

    private class MethodAndSource
    {
        private readonly MethodInfo method;
        private readonly object source;

        internal MethodAndSource(MethodInfo method, object source)
        {
            this.method = method;
            this.source = source;
        }

        public void Invoke(object sender, EventArgs args)
        {
            method.Invoke(source, new object[] { args });
        }
    }
}

Ответ 3

Я немного поработал с решением @nobugz и придумал эту общую версию, которая может быть использована для большинства объектов общего назначения.

То, что я узнал, это то, что события, поскольку, как я понимаю, автоматические события на самом деле скомпилированы с помощью поля поддержки делегата с тем же именем:

Итак, здесь для кражи обработчиков событий для более простых объектов:

class Program
{
    static void Main(string[] args)
    {
        var d = new Dummy();
        var d2 = new Dummy();

        // Use anonymous methods without saving any references
        d.MyEvents += (sender, e) => { Console.WriteLine("One!"); };
        d.MyEvents += (sender, e) => { Console.WriteLine("Two!"); };

        // Find the backing field and get its value
        var theType = d.GetType();
        var bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance;

        var backingField = theType.GetField("MyEvents", bindingFlags);
        var backingDelegate = backingField.GetValue(d) as Delegate;

        var handlers = backingDelegate.GetInvocationList();

        // Bind the handlers to the second instance
        foreach (var handler in handlers)
            d2.MyEvents += handler as EventHandler;

        // See if the handlers are fired
        d2.DoRaiseEvent();

        Console.ReadKey();
    }
}

class Dummy
{
    public event EventHandler MyEvents;

    public void DoRaiseEvent() { MyEvents(this, new EventArgs()); }
}

Думал, что это может быть полезно для некоторых.

Но обратите внимание, что события, связанные с проводкой в ​​компонентах Windows Forms, отличаются друг от друга. Они оптимизированы таким образом, что несколько событий не занимают много памяти, просто сохраняя нули. Так что вам нужно немного больше копаться, но @nobugz уже сделал это: -)

Статья Делегаты и события об объединенных делегатах может помочь прояснить много вопросов в ответах.

Ответ 4

Вы можете использовать общий обработчик событий для ваших кнопок и ваших полей изображений (как в комментариях к более раннему ответу), а затем использовать объект 'sender', чтобы определить, как обрабатывать событие во время выполнения.