Les gestionnaires d'événements peuvent-ils être volés et réaffectés lors de l'exécution en C# ?

Voler des gestionnaires d'événements : une odyssée du runtime

Introduction :

Dans le développement de logiciels, il peut parfois être nécessaire d'attribuer un gestionnaire d'événements à partir d'un contrôle à un autre au moment de l'exécution. Cet article examine la faisabilité d'une telle opération, en explorant à la fois les mises en garde potentielles et les solutions de contournement disponibles.

Question originale :

La question initiale cherchait à trouver un moyen de transférer un gestionnaire d'événements affecté à un bouton (btn1) à un autre bouton (btn2) au moment de l'exécution. Cependant, le compilateur a jugé cette affectation invalide, déclarant que les gestionnaires d'événements ne peuvent être affectés qu'au côté gauche des affectations.

Solution :

Alors que l'approche simple a rencontré une erreur du compilateur , il s'avère que voler des gestionnaires d'événements au moment de l'exécution est effectivement possible, mais avec une mise en garde : une réflexion est nécessaire. Reflection accorde l'accès aux membres privés et internes des objets, qui sont généralement inaccessibles.

Détails de mise en œuvre :

La solution comporte plusieurs étapes :

1. Récupération la clé d'événement secrète : Les gestionnaires d'événements sont stockés en interne à l'aide d'un champ privé nommé « EventClick ». La réflexion est utilisée pour accéder à ce champ de manière statique.
2. Obtention de la EventHandlerList : La propriété "Events" de la classe Component stocke une EventHandlerList contenant tous les gestionnaires d'événements enregistrés. Cette propriété est accessible par réflexion.
3. Suppression du gestionnaire de la source : À l'aide de EventHandlerList, le gestionnaire d'événements peut être supprimé du contrôle de source (btn1).
4. Ajout du gestionnaire à la destination : La même EventHandlerList est ensuite utilisée pour ajouter le gestionnaire d'événements au contrôle de destination (btn2).

Exemple de code :

Le code suivant démontre la technique de vol d'événements :

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");
    }
  }
}

Mise en garde :

Comme Comme l'illustre le code, le processus de vol des gestionnaires d'événements est plutôt compliqué et nécessite une connaissance complexe des structures d'objets internes. Force est de constater que Microsoft a déployé des efforts importants pour empêcher l’accès direct à ces structures, suggérant que cette technique devrait être utilisée judicieusement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!