How do I raise an event via reflection in .NET/C#?

Question

I have a third-party editor that basically comprises a textbox and a button (the DevExpress ButtonEdit control). I want to make a particular keystroke (Alt + Down) emulate clicking the button. In order to avoid writing this over and over, I want to make a generic KeyUp event handler that will raise the ButtonClick event. Unfortunately, there doesn't seem to be a method in the control that raises the ButtonClick event, so...

How do I raise the event from an external function via reflection?

Frisky

Answer 1

Here's a demo using generics (error checks omitted):

using System;
using System.Reflection;
static class Program {
  private class Sub {
    public event EventHandler<EventArgs> SomethingHappening;
  }
  internal static void Raise<TEventArgs>(this object source, string eventName, TEventArgs eventArgs) where TEventArgs : EventArgs
  {
    var eventDelegate = (MulticastDelegate)source.GetType().GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(source);
    if (eventDelegate != null)
    {
      foreach (var handler in eventDelegate.GetInvocationList())
      {
        handler.Method.Invoke(handler.Target, new object[] { source, eventArgs });
      }
    }
  }
  public static void Main()
  {
    var p = new Sub();
    p.Raise("SomethingHappening", EventArgs.Empty);
    p.SomethingHappening += (o, e) => Console.WriteLine("Foo!");
    p.Raise("SomethingHappening", EventArgs.Empty);
    p.SomethingHappening += (o, e) => Console.WriteLine("Bar!");
    p.Raise("SomethingHappening", EventArgs.Empty);
    Console.ReadLine();
  }
}

Nosegay

I noticed you made an eventInfo local variable, but you never do anything with it. Is it just me or could the first line be removed? – Understood

you don't need to get the eventInfo. it is useless. otherwise, good sample! – Brasier

I don't think it's necessary to call GetInvocationList(). Just invoking eventDelegateis enough. – Claw

eventDelegate.DynamicInvoke(args) works just fine as @Claw stated. – Marchand

you don't use eventInfo – Brisk

Answer 2

In general, you can't. Think of events as basically pairs of AddHandler/RemoveHandler methods (as that's basically what what they are). How they're implemented is up to the class. Most WinForms controls use EventHandlerList as their implementation, but your code will be very brittle if it starts fetching private fields and keys.

Does the ButtonEdit control expose an OnClick method which you could call?

Footnote: Actually, events can have "raise" members, hence EventInfo.GetRaiseMethod. However, this is never populated by C# and I don't believe it's in the framework in general, either.

Husky

Answer 3

You can't normally raise another classes events. Events are really stored as a private delegate field, plus two accessors (add_event and remove_event).

To do it via reflection, you simply need to find the private delegate field, get it, then invoke it.

Skywriting

Answer 4

I wrote an extension to classes, which implements INotifyPropertyChanged to inject the RaisePropertyChange<T> method, so I can use it like this:

this.RaisePropertyChanged(() => MyProperty);

without implementing the method in any base class. For my usage it was to slow, but maybe the source code can help someone.

So here it is:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using System.Globalization;

namespace Infrastructure
{
    /// <summary>
    /// Adds a RaisePropertyChanged method to objects implementing INotifyPropertyChanged.
    /// </summary>
    public static class NotifyPropertyChangeExtension
    {
        #region private fields

        private static readonly Dictionary<string, PropertyChangedEventArgs> eventArgCache = new Dictionary<string, PropertyChangedEventArgs>();
        private static readonly object syncLock = new object();

        #endregion

        #region the Extension's

        /// <summary>
        /// Verifies the name of the property for the specified instance.
        /// </summary>
        /// <param name="bindableObject">The bindable object.</param>
        /// <param name="propertyName">Name of the property.</param>
        [Conditional("DEBUG")]
        public static void VerifyPropertyName(this INotifyPropertyChanged bindableObject, string propertyName)
        {
            bool propertyExists = TypeDescriptor.GetProperties(bindableObject).Find(propertyName, false) != null;
            if (!propertyExists)
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
                    "{0} is not a public property of {1}", propertyName, bindableObject.GetType().FullName));
        }

        /// <summary>
        /// Gets the property name from expression.
        /// </summary>
        /// <param name="notifyObject">The notify object.</param>
        /// <param name="propertyExpression">The property expression.</param>
        /// <returns>a string containing the name of the property.</returns>
        public static string GetPropertyNameFromExpression<T>(this INotifyPropertyChanged notifyObject, Expression<Func<T>> propertyExpression)
        {
            return GetPropertyNameFromExpression(propertyExpression);
        }

        /// <summary>
        /// Raises a property changed event.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="bindableObject">The bindable object.</param>
        /// <param name="propertyExpression">The property expression.</param>
        public static void RaisePropertyChanged<T>(this INotifyPropertyChanged bindableObject, Expression<Func<T>> propertyExpression)
        {
            RaisePropertyChanged(bindableObject, GetPropertyNameFromExpression(propertyExpression));
        }

        #endregion

        /// <summary>
        /// Raises the property changed on the specified bindable Object.
        /// </summary>
        /// <param name="bindableObject">The bindable object.</param>
        /// <param name="propertyName">Name of the property.</param>
        private static void RaisePropertyChanged(INotifyPropertyChanged bindableObject, string propertyName)
        {
            bindableObject.VerifyPropertyName(propertyName);
            RaiseInternalPropertyChangedEvent(bindableObject, GetPropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Raises the internal property changed event.
        /// </summary>
        /// <param name="bindableObject">The bindable object.</param>
        /// <param name="eventArgs">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>
        private static void RaiseInternalPropertyChangedEvent(INotifyPropertyChanged bindableObject, PropertyChangedEventArgs eventArgs)
        {
            // get the internal eventDelegate
            var bindableObjectType = bindableObject.GetType();

            // search the base type, which contains the PropertyChanged event field.
            FieldInfo propChangedFieldInfo = null;
            while (bindableObjectType != null)
            {
                propChangedFieldInfo = bindableObjectType.GetField("PropertyChanged", BindingFlags.Instance | BindingFlags.NonPublic);
                if (propChangedFieldInfo != null)
                    break;

                bindableObjectType = bindableObjectType.BaseType;
            }
            if (propChangedFieldInfo == null)
                return;

            // get prop changed event field value
            var fieldValue = propChangedFieldInfo.GetValue(bindableObject);
            if (fieldValue == null)
                return;

            MulticastDelegate eventDelegate = fieldValue as MulticastDelegate;
            if (eventDelegate == null)
                return;

            // get invocation list
            Delegate[] delegates = eventDelegate.GetInvocationList();

            // invoke each delegate
            foreach (Delegate propertyChangedDelegate in delegates)
                propertyChangedDelegate.Method.Invoke(propertyChangedDelegate.Target, new object[] { bindableObject, eventArgs });
        }

        /// <summary>
        /// Gets the property name from an expression.
        /// </summary>
        /// <param name="propertyExpression">The property expression.</param>
        /// <returns>The property name as string.</returns>
        private static string GetPropertyNameFromExpression<T>(Expression<Func<T>> propertyExpression)
        {
            var lambda = (LambdaExpression)propertyExpression;

            MemberExpression memberExpression;

            if (lambda.Body is UnaryExpression)
            {
                var unaryExpression = (UnaryExpression)lambda.Body;
                memberExpression = (MemberExpression)unaryExpression.Operand;
            }
            else memberExpression = (MemberExpression)lambda.Body;

            return memberExpression.Member.Name;
        }

        /// <summary>
        /// Returns an instance of PropertyChangedEventArgs for the specified property name.
        /// </summary>
        /// <param name="propertyName">
        /// The name of the property to create event args for.
        /// </param>
        private static PropertyChangedEventArgs GetPropertyChangedEventArgs(string propertyName)
        {
            PropertyChangedEventArgs args;

            lock (NotifyPropertyChangeExtension.syncLock)
            {
                if (!eventArgCache.TryGetValue(propertyName, out args))
                    eventArgCache.Add(propertyName, args = new PropertyChangedEventArgs(propertyName));
            }

            return args;
        }
    }
}

I removed some parts of the original code, so the extension should work as is, without references to other parts of my library. But it's not really tested.

P.S. Some parts of the code was borrowed from someone else. Shame on me, that I forgot from where I got it. :(

Custumal

Thank you a lot. In fact, your answer is the only one here which does inheritance tree investigation and proper null-checking. – Hypocrite

Why do you cache the event args? The baggage required, the Dictionary and lock, outweighs any potential performance gain, imho. Am I missing something (shared state, etc)? – Schleicher

You should check out Solution 1 here: https://mcmap.net/q/450814/-how-to-raise-property-changed-in-derived-classes – Ardyce

Answer 5

It seems that the code from the accepted answer by Wiebe Cnossen could be simplified to this:

private void RaiseEventViaReflection(object source, string eventName)
{
    ((Delegate)source
        .GetType()
        .GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic)
        .GetValue(source))
        .DynamicInvoke(source, EventArgs.Empty);
}

Pappy

Answer 6

From Raising an event via reflection, although I think the answer in VB.NET, that is, two posts ahead of this one will provide you with the generic approach (for example, I'd look to the VB.NET one for inspiration on referencing a type not in the same class):

 public event EventHandler<EventArgs> MyEventToBeFired;

    public void FireEvent(Guid instanceId, string handler)
    {

        // Note: this is being fired from a method with in the same
        //       class that defined the event (that is, "this").

        EventArgs e = new EventArgs(instanceId);

        MulticastDelegate eventDelagate =
              (MulticastDelegate)this.GetType().GetField(handler,
               System.Reflection.BindingFlags.Instance |
               System.Reflection.BindingFlags.NonPublic).GetValue(this);

        Delegate[] delegates = eventDelagate.GetInvocationList();

        foreach (Delegate dlg in delegates)
        {
            dlg.Method.Invoke(dlg.Target, new object[] { this, e });
        }
    }

    FireEvent(new Guid(),  "MyEventToBeFired");

Candlefish

This example helped me out. I needed to raise a CLR event in a Windows application object in a WPF application of mine, and needed to reference it via reflection. So instead of this in the FireEvent method, I used Application.Current. Great tip, alter the bindingflags of FireEvent method as needed. – Atmosphere

Answer 7

As it turns out, I could do this and didn't realize it:

buttonEdit1.Properties.Buttons[0].Shortcut = new DevExpress.Utils.KeyShortcut(Keys.Alt | Keys.Down);

But if I couldn't I would've have to delve into the source code and find the method that raises the event.

Thanks for the help, all.

Frisky

Answer 8

If you know that the control is a button you can call its PerformClick() method. I have similar problem for other events like OnEnter, OnExit. I can't raise those events if I don't want to derive a new type for each control type.

Epithalamium

'Perform click'? You've gotta be kidding me, it's fantastic! – Pollinosis

Answer 9

A further refinement on some of the existing answers and comments.

This also takes into account that the delegate field may be defined on an inherited class.

public static void RaiseEvent<TEventArgs>(this object source, string eventName, TEventArgs eventArgs)
    where TEventArgs : EventArgs
{
    // Find the delegate and invoke it.
    var delegateField = FindField(source.GetType(), eventName);
    var eventDelegate = delegateField?.GetValue(source) as Delegate;
    eventDelegate?.DynamicInvoke(source, eventArgs);

    // This local function searches the class hierarchy for the delegate field.
    FieldInfo FindField(Type type, string name)
    {
        while (true)
        {
            var field = type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
            if (field != null)
            {
                return field;
            }

            var baseType = type.BaseType;
            if (baseType == null)
            {
                return null;
            }

            type = baseType;
        }
    }
}

Scoggins