如何从一种类型的多个实例禁用对事件的订阅，而只允许一种类型的实例订阅

你试图解决问题的方法从根本上就是错误的。您的服务类定义了在某些情况下将被触发的事件。一些客户机订阅该事件，通过这种方式请求在事件发生时得到通知。这仅仅是实现观察者模式的。net方式，因此您的服务(作为主题或可观察对象)不应该在订阅和通知部分应用任何逻辑，从而违背了模式的整个目的。Hans Passant已经指出了您的设计中的一些缺陷，但即使他的解决方案也不完美，因为查看事件签名，完全不清楚只有表单实例方法应该被注册-可以尝试使用静态方法，匿名lambda/方法，一些类方法等。

在我看来，以下是一些可行的选择。

(A)保留您的NotificationService事件，但从订阅和通知部分删除任何"魔法"(简而言之，使用定义和触发事件的常规方式)，并将所需的逻辑放在订阅者中:

public static class NotifierService
{
    public delegate void NotifierServiceEventHandler(object sender, NotifierServiceEventArgs e);
    public static event NotifierServiceEventHandler OnOk;
    public static void NotifyOk(string fullMessage = "Ok.", string shortMessage = null)
    {
        var handler = OnOk;
        if (handler != null)
            handler(typeof(NotifierService), new NotifierServiceEventArgs(StatusType.Ok, fullMessage, shortMessage ?? fullMessage));
    }
}

假设只有活动表单应该处理通知，MainForm和ManagedForm中的现有处理程序将在其方法体中使用类似的东西

if (this != ActiveForm) return;
// do the processing

你甚至可以创建一个像这样的基本表单

class NotifiedForm : Form
{
    protected override void OnActivated(EventArgs e)
    {
        base.OnActivated(e);
        NotifierService.OnOk += OnNotifyOK;
        // similar for other events
    }
    protected override void OnDeactivate(EventArgs e)
    {
        base.OnDeactivate(e);
        NotifierService.OnOk -= OnNotifyOK;
        // similar for other events
    }
    protected virtual void OnNotifyOK(object sender, NotifierServiceEventArgs e) { }
    // similar for other events
}

，让你的MainForm, ManagedForm(和任何其他需要的)继承，只是覆盖OnNotifyXXX方法和应用他们的逻辑。

(B)如果服务的唯一目的是充当窗体的通知协调器，那么您可以删除事件以及订阅/退订部分(因为Application.OpenForms和Form.ActiveForm已经提供了所需的足够信息)并处理服务中的逻辑。为了做到这一点，您需要某种基本接口或表单，最简单的方法是使用与选项(a)中可选的方法类似的方法，通过创建一个基本表单类，如下所示

class NotifiedForm : Form
{
    public virtual void OnNotifyOK(object sender, NotifierServiceEventArgs e) { }
    // similar for other notifications
}

，让您的MainForm, ManagedForm和其他需要从它继承。请注意，这里没有逻辑(检查ActiveForm等)，因为现在这是调用者的责任。那么服务可以是这样的:

public static class NotifierService
{
    public static void NotifyOk(string fullMessage = "Ok.", string shortMessage = null)
    {
        var target = Form.ActiveForm as NotifiedForm;
        if (target != null)
            target.OnNotifyOK(typeof(NotifierService), new NotifierServiceEventArgs(StatusType.Ok, fullMessage, shortMessage ?? fullMessage));
    }
    // similar for other notifications
}

，如果逻辑是只通知活动表单。

或

public static class NotifierService
{
    public static void NotifyOk(string fullMessage = "Ok.", string shortMessage = null)
    {
        // Could also be a forward for, forach etc.
        for (int i = Application.OpenForms.Count - 1; i >= 0; i--)
        {
            var target = Application.OpenForms[i] as NotifiedForm;
            if (target != null /* && someOtherCritaria(target) */)
            {
                target.OnNotifyOK(typeof(NotifierService), new NotifierServiceEventArgs(StatusType.Ok, fullMessage, shortMessage ?? fullMessage));
                // Could also continue
                break;
            }
        }
    }
    // similar for other notifications
}

如果需要一些其他的逻辑(我怀疑)。

希望有帮助。在任何情况下，选项(A)都更灵活，允许更多的使用场景，但是如果使用场景是设计固定的，那么选项(B)更好，因为它对客户机的要求更少(因此更不容易出错)，并在一个地方提供集中的应用程序逻辑。

我希望你这样做:

1. 从事件访问器方法中删除魔法，让所有订阅者订阅事件。现在你的主表单和所有其他表单都订阅了这个事件。

2. 现在将魔术放入事件调用方法中。例如，在NotifyOK方法中，首先获取委托的调用列表，然后使用调用列表中每个委托的DynamicInvoke或invoke方法逐一调用每个委托，只有在尚未为特定的DeclaringType调用时才使用。参见下面的算法:

    public static void NotifyOk(string fullMessage = "Ok.", string shortMessage = null)
    {
       NotifierServiceEventHandler handler;
       lock (Locker)
       {
           handler = _notifierServiceEventHandler;
       }
       if (handler == null) return;
       // Get invocation list of handler as you have done in event accessor
       //initialise a new List<T> to hold the declaring types
       // loop through each member (delegate) of invocation list
         // if the current member declaration type is not in List<t>
          // Invoke or DynamicInvoke current delegate
          // add the declaration type of current delegate to List<t> 
    }
   

Try this:?)

private bool _eventHasSubscribers = false;
private EventHandler<MyDelegateType> _myEvent;
public event EventHandler<MyDelegateType> MyEvent
{
   add 
   {
      if (_myEvent == null)
      {
         _myEvent += value;
      }
   }
   remove
   {
      _myEvent -= value;
   }
}

我将NotifierService简化为:

public static class NotifierService
{
    public static event EventHandler<NotifierServiceEventArgs> OnOk = delegate { };
    public static void NotifyOk(string fullMessage = "Ok.", string shortMessage = null)
    {
        OnOk(typeof(NotifierService), 
             new NotifierServiceEventArgs(StatusType.Ok, fullMessage, shortMessage ?? fullMessage));
    }
}

，然后在ManagedForm中使用这个处理程序

NotifierService.OnOk += Notify;
private void Notify(object sender, NotifierServiceEventArgs e)
{
    // handle event in first open ManagedForm
    if (Application.OpenForms.OfType<ManagedForm>().FirstOrDefault() == this)
    {
       // notification logic
    }
}

如果窗体以Modal模式打开(使用ShowDialog())，则可以使用另一种变体(根据这个问题):

private void Notify(object sender, NotifierServiceEventArgs e)
{
    // handle event in active (last shown) ManagedForm
    if (this.CanFocus)
    {
       // notification logic
    }
}

所以这个想法是所有的ManagedForm接收事件数据，然后决定他们是否应该做某事

注::取消订阅Dispose

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        NotifierService.OnOk -= Notify;
    }
    // default
    if (disposing && (components != null))
    {
        components.Dispose();
    }
    base.Dispose(disposing);
}

我做了一个类似于你的设置&我明白问题所在了。

我将给出2个工作建议来解决这个问题(你可以根据需要的变化选择)-

1. 最快修复与最小的改变你的原始代码-

所以这就是我从问题情况中理解的-您将事件NotifierService.OnOk钩到类ManagedForm &还编写了代码，以便在窗体关闭时从事件NotifierService.OnOk中解挂事件处理程序。

我假设你写的代码，从事件NotifierService.OnOk解开事件处理程序时，窗体关闭但我不确定的是，当你钩事件NotifierService.OnOk到它的事件处理程序在管理的形式。这很关键& &;我猜这是唯一的问题在你的设置。

我假设你已经把它设置在一个地方，只发生一次在生命周期的form - like构造函数或Load事件处理程序。这就是我重现这个问题的方法。

作为修复，只需将事件NotifierService.OnOk挂钩到它的事件处理程序在每次窗体激活时调用的地方就像像这样-

public partial class ManagedFrom : Form
{
    // this is the fix. Everytime the form comes up. It tries to register itself.
    //The existing magic will consider its request to register only when the other form is closed or if its the 1st of its type.
    protected override void OnActivated(EventArgs e)
    {
        base.OnActivated(e);
        NotifierService.OnOk += NotifierService_OnOk;
    }

不再需要更改，您在事件中的现有逻辑将照顾休息。我把原因写在上面的代码注释中。

 public static event NotifierServiceEventHandler OnOk
    {
        add
        {
            lock (Locker)  // I'm not removing the locks.  May be the publisher works in a multithreaded business layer.
            {
                _notifierServiceEventHandler += value;                  
            }
        }
        remove
        {
            lock (Locker)
            {
                _notifierServiceEventHandler -= value;
            }
        }
    }

 public partial class ManagedFrom : Form
{
    //start the subscription
    protected override void OnActivated(EventArgs e)
    {
        base.OnActivated(e);
        NotifierService.OnOk += NotifierService_OnOk;
    }
    //stop the subscription
    protected override void OnDeactivate(EventArgs e)
    {
        base.OnDeactivate(e);
        NotifierService.OnOk -= NotifierService_OnOk;
    }

public enum MessageType { StatusText, MessageBox }
public NotifyEventArgs: EventArgs
{
    public MessageType Type { get; }
    public string Message { get; }
    public NotifyEventArgs(MessageType type, string message)
    {
        Type = type;
        Message = message;
    }
}
public static NotifyManager
{
    public event EventHandler<NotifyMessageArgs> Notify;
    public static OnEventHandler(MessageType type, string message) =>
        Notify?.Invoke(null, new NotifyEventArgs(type, message));
}

void NotifyManager_Event(object sender, NotifyEventArgs e)
{
    if(e.Type == MessageType.MessageBox && this == Form.ActiveForm)
        MessageBox.Show(this, e.Message);
    else
        statusBar.Text = e.Message;
}

class ManagedForm
{
    public bool ShowNotifications {get; set;}
    public void OnEventNotification(object sender, ...)
    {
        if (this.ShowNotifications)
        {
            // show the notification
        }
    }

public OnFormActiveChanged(object sender, ...)
{
    this.ShowNotifications = this.Form.IsActive;
}

public OnFormBackColorChanged(object sender, ...)
{
    this.ShowNotifications = this.Form.BackColor == Color.Red;
}

public class MainAppForm : Form
{
    static MainAppForm mainAppForm;
    public MainAppForm()
    {
        mainAppForm = this;
    }
    public static void NotifyOk(Form sender, string fullMessage = "Ok.", string shortMessage = null)
    {
        mainAppForm.NotifyOk(sender, fullMessage, shortMessage);
    }
    public void NotifyOk(Form sender, string fullMessage, string shortMessage)
    {
        this.statusStrip.Invoke(delegate {
            this.statusStrip.Text = shortMessage;
        });
    }
}