在事件触发器中使用显式接口

Question

我有explcitly实现一个接口，一个基本用户控制IWindow包含事件Closing ：

public interface IWindow
{
    event EventHandler<CancelEventArgs> Closing;
}

public class MyUserControl : UserControl, IWindow
{
    ...
    event EventHandler<CancelEventArgs> IWindow.Closing
    { add remove } // Code removed for brevity
    ...
}

在我的XAML中，我试图在事件发生时触发某种动作。

<i:EventTrigger EventName="Closing" SourceObject="{Binding Path=., RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=controls:IWindow}}">

这样可以成功找到实现IWindow的用户控件，但是在绑定它时会失败，因为该用户控件本身不包含Closing事件。 相反，它是在IWindow明确实现的。

如果我以非明确的方式实现事件，那么它将起作用 。 我已经意识到了这一点，并且如果真的没有其他方法可以使用它。

但是，我想知道是否可以通过显式实现使用该接口。

我尝试了几种不同的方法：

1. 将以上代码与显式实现一起使用。
2. 使用转换器将类型转换为IWindow 。
3. 在EventName属性中指定显式事件的绑定路径。

在前两种情况下， EventTriggerBase.RegisterEvent使用派生类而不是我的接口，并且操作失败并显示：

ArgumentException：在类型“ OptionsView”上找不到名为“ Closing”的事件。 （OptionsView是我的UserControl名称）

堆栈跟踪的顶部是：

at System.Windows.Interactivity.EventTriggerBase.RegisterEvent(Object obj, String eventName)
at System.Windows.Interactivity.EventTriggerBase.OnSourceChangedImpl(Object oldSource, Object newSource)

在RegisterEvent ，前两行是：

Type type = obj.GetType();
EventInfo @event = type.GetEvent(eventName);

这显然会失败，因为obj.GetType()返回派生类型而不是接口，即使我将类型作为接口传递也是如此。

略微但又相关，当将控件和命令绑定到接口实现时，我能够使用绑定语法，例如：

{Binding Path=(models:IDataViewModelBase.SaveCommand)}

Answer 1

通过设法从EventTriggerBase获取功能并使用界面自己实现，我设法解决了这一问题。

我已经为EventTrigger写了一些扩展方法，可以用来实现相同的目的。 请注意，我仅在自己的实现中对此进行了测试，并且不能保证它会在所有情况下都有效。

要在代码中使用此代码，请在Window ， View ， UserControl等的Loaded事件中：

foreach (TriggerBase trigger in Interaction.GetTriggers(this))
{
    if (trigger is EventTrigger eventTrigger)
        if (!eventTrigger.WillEventBeHandled())
            eventTrigger.RegisterInterfaceEvent();
}

或者，您可以扩展DependencyObject并在Loaded事件中调用扩展：

this.RegisterMissingInterfaceEventTriggers();

EventTrigger的扩展方法如下：

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Windows.Interactivity;

/// <summary>
/// A class that defines extensions to an event trigger.
/// </summary>
public static class EventTriggerExtensions
{
    #region Methods
    #region _Private_
    private static bool TryFindInterface(Type objectType, Type interfaceType, out Type foundType)
    {
        bool returnValue = false;

        foundType = objectType.GetInterface(interfaceType.Name);
        if (foundType == null)
        {
            if (objectType.BaseType != null && objectType.BaseType != objectType)
                returnValue = TryFindInterface(objectType.BaseType, interfaceType, out foundType);
        }
        else
            returnValue = true;

        return returnValue;
    }

    private static bool TryGetInterfaces(EventTrigger eventTrigger, out Type[] interfaces, bool excludeSystemInterfaces = true)
    {
        List<Type> interfaceList;
        bool returnValue = false;

        // Defaults
        interfaces = null;
        interfaceList = new List<Type>();

        // Get source object interfaces
        if (eventTrigger.SourceObject != null)
        {
            if (TryGetInterfaces(eventTrigger.SourceObject.GetType(), out Type[] newInterfaces, excludeSystemInterfaces))
                interfaceList.AddRange(newInterfaces);
        }

        // Get source interfaces
        if (eventTrigger.Source != null && eventTrigger.Source != eventTrigger.SourceObject)
        {
            if (TryGetInterfaces(eventTrigger.Source.GetType(), out Type[] newInterfaces, excludeSystemInterfaces))
            {
                foreach (Type item in newInterfaces)
                    if (!interfaceList.Contains(item))
                        interfaceList.Add(item);
            }
        }

        if (interfaceList.Count > 0)
        {
            interfaces = interfaceList.ToArray();
            returnValue = true;
        }

        return returnValue;
    }
    private static bool TryGetInterfaces(Type sourceType, out Type[] interfaces, bool excludeSystemInterfaces = true)
    {
        List<Type> interfaceList;
        bool returnValue = false;

        // Defaults
        interfaces = null;
        interfaceList = new List<Type>();

        foreach (Type item in sourceType.GetInterfaces())
        {
            if (!excludeSystemInterfaces ||
                (excludeSystemInterfaces && !(item.FullName.StartsWith("System.") || item.FullName.StartsWith("Microsoft."))))
            {
                interfaceList.Add(item);
            }
        }

        if (interfaceList.Count > 0)
        {
            returnValue = true;
            interfaces = interfaceList.ToArray();
        }

        return returnValue;
    }

    private static bool TryGetSourceObject(EventTrigger eventTrigger, out object sourceObject)
    {
        bool returnValue = false;

        sourceObject = eventTrigger.SourceObject;
        if (sourceObject == null)
            sourceObject = eventTrigger.Source;
        if (sourceObject != null)
            returnValue = true;

        return returnValue;
    }

    #endregion
    #region _Public_
    /// <summary>
    /// Registers the event for an explicitly implemented interface if the event is not currently handled.
    /// </summary>
    /// <param name="eventTrigger">An EventTrigger that is the event trigger.</param>
    /// <param name="excludeSystemInterfaces">Gets an indication whether to automatically exclude interfaces defined in system assemblies.</param>
    public static void RegisterInterfaceEvent(this EventTrigger eventTrigger, bool excludeSystemInterfaces = true)
    {
        // See whether the event trigger can find the type
        if (!WillEventBeHandled(eventTrigger))
        {
            if (TryGetInterfaces(eventTrigger, out Type[] interfaces, excludeSystemInterfaces))
            {
                Type theInterface = null;
                EventInfo theEvent = null;

                foreach (Type item in interfaces)
                {
                    if (item.GetEvent(eventTrigger.EventName) != null)
                    {
                        theInterface = item;
                        theEvent = item.GetEvent(eventTrigger.EventName);
                        break;
                    }
                }

                if (theInterface != null && theEvent != null)
                {
                    if (TryGetSourceObject(eventTrigger, out object sourceObject))
                    {
                        MethodInfo eventHandlerMethodInfo;

                        eventHandlerMethodInfo = typeof(EventTriggerBase).GetMethod("OnEventImpl", BindingFlags.Instance | BindingFlags.NonPublic);
                        theEvent.AddEventHandler(sourceObject, Delegate.CreateDelegate(theEvent.EventHandlerType, eventTrigger, eventHandlerMethodInfo));
                    }
                }
            }
        }
    }

    /// <summary>
    /// Gets an indication of whether the event trigger will handle the event.
    /// </summary>
    /// <param name="eventTrigger">An EventTrigger that is the event trigger.</param>
    /// <returns>A bool that indicates the result.</returns>
    public static bool WillEventBeHandled(this EventTrigger eventTrigger)
    {
        bool returnValue = false;

        if (eventTrigger.SourceObject != null)
            returnValue = WillEventBeHandled(eventTrigger, eventTrigger.SourceObject.GetType());
        if (!returnValue && eventTrigger.Source != null)
            returnValue = WillEventBeHandled(eventTrigger, eventTrigger.Source.GetType());

        return returnValue;
    }
    /// <summary>
    /// Gets an indication of whether the event trigger will handle the event on the specified object.
    /// </summary>
    /// <param name="eventTrigger">An EventTrigger that is the event trigger.</param>
    /// <param name="targetObject">An object that is the object to handle the event on.</param>
    /// <returns>A bool that indicates the result.</returns>
    public static bool WillEventBeHandled(this EventTrigger eventTrigger, object targetObject)
    {
        return WillEventBeHandled(eventTrigger, targetObject.GetType());
    }
    /// <summary>
    /// Gets an indication of whether the event trigger will handle the event on the specified type.
    /// </summary>
    /// <param name="eventTrigger">An EventTrigger that is the event trigger.</param>
    /// <param name="targetType">A Type that is the target type.</param>
    /// <returns>A bool that indicates the result.</returns>
    public static bool WillEventBeHandled(this EventTrigger eventTrigger, Type targetType)
    {
        bool returnValue = false;

        if (targetType.GetEvent(eventTrigger.EventName) != null)
            returnValue = true;

        return returnValue;
    }

    #endregion
    #endregion
}

DependencyObject的扩展方法如下：

using System;
using System.Windows.Interactivity;

/// <summary>
/// A class that defines extensions to a trigger collection.
/// </summary>
public static class DependencyObjectExtensions
{
    #region Methods
    #region _Public_
    /// <summary>
    /// Registers missing event triggers for explicitly implemented interfaces if the event are not currently handled.
    /// </summary>
    /// <param name="obj">A DependencyObject that is the object to implementing interface events for.</param>
    /// <param name="excludeSystemInterfaces">Gets an indication whether to automatically exclude interfaces defined in system assemblies.</param>
    public static void RegisterMissingInterfaceEventTriggers(this System.Windows.DependencyObject obj, bool excludeSystemInterfaces = true)
    {
        TriggerCollection triggers;

        triggers = Interaction.GetTriggers(obj);
        foreach (TriggerBase trigger in triggers)
        {
            if (trigger is EventTrigger eventTrigger)
                if (!eventTrigger.WillEventBeHandled())
                    eventTrigger.RegisterInterfaceEvent();
        }
    }

    #endregion
    #endregion
}