我试图在 UserControl 引发事件，并在主程序中捕获它，但事件总是返回 null

Question

我试图在 userControl 类之一中引发事件，并在 Main 类中触发它。我尝试了两种不同的方式来触发这个事件，其中一种有效，但我仍然想知道为什么其他方式不能工作，以及如何解决它。

我的 userContol 类：

public partial class UserControl1 : UserControl
{

    public UserControl1()
    {
        InitializeComponent();
        if (System.ComponentModel.DesignerProperties.GetIsInDesignMode(this))
        {
            return;
        }
        Class1 c = new Class1();

        Thread accept = new Thread(
                     () =>
                     {
                         c.connection();

                     }

                     );
        accept.Start();

    }

}

还有 Class1：

   public class Class1
{
   public delegate void myhandler(object sender, EventArgs e);
   public event myhandler test;

   public Class1()
   {

   }
   public void connection()
   {
       test(this, new EventArgs());
   }


}

在 Main 中，我只是简单地添加到所指对象中，然后添加

 xmlns:my="clr-namespace:WpfControlLibrary1;assembly=WpfControlLibrary1"

然后我尝试在 main 中订阅此事件

public partial class SurfaceWindow1 : SurfaceWindow
{
    /// <summary>
    /// Default constructor.
    /// </summary>
    public SurfaceWindow1()
    {
        InitializeComponent();
        Class1 c = new Class1();
        c.test+=new Class1.myhandler(c_test);
        // Add handlers for window availability events
        AddWindowAvailabilityHandlers();
    }
    public void c_test(object sender, EventArgs e)
    {
        MessageBox.Show("fire");
        }
}

如果我只在线程中引发这个事件，它工作正常，但如果我尝试让它在这个线程中引发，这个测试事件只返回 null，并显示：

Object reference not set to an instance of an object.

看起来我从来没有订阅过。那么如果我必须在线程中使用它，如何修复它。

Answer 1

这是您真正不应该做的事情的一个很好的例子。您正在尝试订阅由另一个类“拥有”的类的事件。您基本上是在挖掘类型层次结构以找到您想要的事件。这违背了良好的设计。

特别是在 UI 应用程序中，有一个设计概念叫做事件冒泡。拥有引发事件的原始对象的类型处理该事件。在处理该事件时，它会引发自己的重复事件。这是一个展示这个概念的简短程序：

public class RootEventClass
{
    public event EventHandler SomeKindOfEvent;

    protected virtual void OnSomeKindOfEvent(object sender, EventArgs e)
    {
        EventHandler handler = SomeKindOfEvent;
        if (handler != null)
            handler(this, e);
    }

    public void RaiseEvent()
    {
        Console.WriteLine("Root Event Firing");
        OnSomeKindOfEvent(this, EventArgs.Empty);
    }
}

public class FirstOwnerClass
{
    private RootEventClass _rootClass;
    public event EventHandler SomeKindOfEvent;

    public FirstOwnerClass()
    {
        _rootClass = new RootEventClass();
        _rootClass.SomeKindOfEvent += _rootClass_SomeKindOfEvent;
    }

    void _rootClass_SomeKindOfEvent(object sender, EventArgs e)
    {
        Console.WriteLine("First Owner Class Handling Root Owner Event");
        OnSomeKindOfEvent(this, e);
    }

    protected virtual void OnSomeKindOfEvent(object sender, EventArgs e)
    {
        EventHandler handler = SomeKindOfEvent;
        if (handler != null)
            handler(this, e);
    }

    public void RaiseEvent()
    {
        _rootClass.RaiseEvent();
    }
}

public class SecondOwnerClass
{
    private FirstOwnerClass _firstClass;
    public event EventHandler SomeKindOfEvent;

    public SecondOwnerClass()
    {
        _firstClass = new FirstOwnerClass();
        _firstClass.SomeKindOfEvent +=_firstClass_SomeKindOfEvent;
    }

    void _firstClass_SomeKindOfEvent(object sender, EventArgs e)
    {
        Console.WriteLine("Second Owner Class Handling First Owner Event");
        OnSomeKindOfEvent(this, e);
    }

    protected virtual void OnSomeKindOfEvent(object sender, EventArgs e)
    {
        EventHandler handler = SomeKindOfEvent;
        if (handler != null)
            handler(this, e);
    }

    public void RaiseEvent()
    {
        _firstClass.RaiseEvent();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        SecondOwnerClass secondOwner = new SecondOwnerClass();
        secondOwner.SomeKindOfEvent += secondOwner_SomeKindOfEvent;

        secondOwner.RaiseEvent();

        Console.ReadKey(true);
    }

    static void secondOwner_SomeKindOfEvent(object sender, EventArgs e)
    {
        Console.WriteLine("Got an event from the second owner defined in main");
    }
}

如果你运行这个程序，你会得到如下输出：

根事件触发 第一个所有者类处理根所有者事件 第二个所有者类处理第一个所有者事件 从 main 中定义的第二个所有者那里获得了一个事件

那么这里发生了什么。 Main 方法定义了一个 SecondOwner 对象，然后告诉它引发一个事件，这只是将所有权链传递给根对象。神奇的是事件冒泡。该事件被每个拥有的类拦截并传递。这样它就可以决定是否传递它。

另外，Main 方法只需要知道在SecondOwner 类中创建的事件，它不必挖掘SecondOwner、FirstOwner 和最后的RootEventClass。

这是一个很容易掌握的概念，不要强迫您的用户（或您自己）挖掘类型和所有权来获取事件，如果该类的用户需要该事件，请复制该事件并将其冒泡。