我有一个第三方编辑器，它基本上包含一个文本框和一个按钮（DevExpress ButtonEdit 控件）。我想让特定的击键（Alt+ Down）模拟单击按钮。为了避免一遍又一遍地写这个，我想制作一个通用的 KeyUp 事件处理程序，它将引发 ButtonClick 事件。不幸的是，控件中似乎没有引发 ButtonClick 事件的方法，所以......
如何通过反射从外部函数引发事件？
Josh Kodroff
问问题
24222 次
8 回答
40
这是一个使用泛型的演示（省略了错误检查）：
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();
}
}
于 2009-02-25T14:19:41.900 回答
14
一般来说，你不能。将事件视为基本上成对的AddHandler/RemoveHandler方法（因为它们基本上就是这样）。它们的实现方式取决于班级。大多数 WinForms 控件都EventHandlerList用作它们的实现，但是如果它开始获取私有字段和密钥，您的代码将非常脆弱。
控件是否ButtonEdit公开了OnClick您可以调用的方法？
脚注：实际上，事件可以有“raise”成员，因此EventInfo.GetRaiseMethod. 但是，C# 从未填充过它，而且我也不相信它在一般框架中。
于 2008-10-13T18:44:21.707 回答
11
您通常不能引发其他类事件。事件实际上存储为私有委托字段，外加两个访问器（add_event 和 remove_event）。
要通过反射来完成，您只需要找到私有委托字段，获取它，然后调用它。
于 2008-10-13T18:43:31.287 回答
10
我写了一个类的扩展，它实现了 INotifyPropertyChanged 来注入 RaisePropertyChange<T> 方法，所以我可以像这样使用它：
this.RaisePropertyChanged(() => MyProperty);
无需在任何基类中实现该方法。对于我的使用来说它很慢，但也许源代码可以帮助某人。
所以这里是：
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;
}
}
}
我删除了原始代码的某些部分，因此扩展应该按原样工作，而无需引用我的库的其他部分。但它并没有真正经过测试。
PS 部分代码是从别人那里借来的。真可惜，我忘记了我是从哪里得到它的。:(
于 2010-07-22T19:25:56.340 回答
7
从Raising an event via reflection开始，虽然我认为VB.NET中的答案，也就是说，这篇文章之前的两篇文章将为您提供通用方法（例如，我会从 VB.NET 中寻找灵感引用不在同一类中的类型）：
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");
于 2008-10-13T18:42:51.943 回答
6
事实证明，我可以做到这一点，但没有意识到：
buttonEdit1.Properties.Buttons[0].Shortcut = new DevExpress.Utils.KeyShortcut(Keys.Alt | Keys.Down);
但如果我不能，我将不得不深入研究源代码并找到引发事件的方法。
谢谢大家的帮助。
于 2008-10-14T14:40:45.583 回答
6
似乎Wiebe Cnossen接受的答案中的代码可以简化为：
private void RaiseEventViaReflection(object source, string eventName)
{
((Delegate)source
.GetType()
.GetField(eventName, BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(source))
.DynamicInvoke(source, EventArgs.Empty);
}
于 2016-05-28T11:00:48.550 回答
5
如果你知道控件是一个按钮，你可以调用它的PerformClick()方法。对于其他事件，我也有类似的问题，例如OnEnter, OnExit。如果我不想为每个控件类型派生一个新类型，我就无法引发这些事件。
于 2009-02-25T12:44:18.370 回答