一种禁用事件处理的设计模式

Question

为了简单说明我的困境，让我说我有以下代码：

class A
{
    // May be set by a code or by an user.
    public string Property
    {
        set { PropertyChanged(this, EventArgs.Empty); }
    }

    public EventHandler PropertyChanged;
}

class B
{
    private A _a;

    public B(A a)
    {
        _a = a;
        _a.PropertyChanged += Handler;
    }

    void Handler(object s, EventArgs e)
    {
        // Who changed the Property?
    }

    public void MakeProblem()
    {
        _a.Property = "make a problem";
    }
}

为了履行其职责，B级必须对A的PropertyChanged事件作出反应，但在某些情况下也能够自行交替该属性。 不幸的是，其他对象也可以与Property进行交互。

我需要一个顺序流的解决方案。 也许我可以使用一个变量来禁用一个动作：

bool _dontDoThis;

void Handler(object s, EventArgs e)
{
    if (_dontDoThis)
        return;

    // Do this!
}

public void MakeProblem()
{
    _dontDoThis = true;
    _a.Property = "make a problem";
    _dontDoThis = false;
}

有更好的方法吗？

其他考虑因素

• 我们无法改变A.
• A是密封的。
• PropertyChanged事件还有其他各方联系，我不知道他们是谁。 但是当我从B更新属性时，不应该通知它们。 但我无法将他们与活动断开，因为我不了解他们。
• 如果还有更多线程可以同时与该属性进行交互，该怎么办？

解决的子弹越多越好。

原来的问题

我最初的问题是TextBox（WPF），我想根据其内容和焦点进行补充。 所以我需要对TextChanged事件做出反应，如果它的来源是从我的补充中派生的，我还需要省略该事件。 在某些情况下，不应通知TextChanged事件的其他侦听器。 某些状态和样式的某些字符串对其他人不可见。

Answer 1

如果不处理您发起的事件非常重要，也许您应该更改设置Property以包含更改的发起者的方式？

public class MyEventArgs : EventArgs
{
    public object Changer;
}

public void SetProperty(string p_newValue, object p_changer)
{
   MyEventArgs eventArgs = new MyEventArgs { Changer = p_changer };
   PropertyChanged(this, eventArgs); 
}

然后在你的处理程序中 - 只需检查你的不是发起者。

我发现注册和成员的所有这些变化在多线程和可扩展性方面都很成问题。

Answer 2

实际上，你正试图打破事件委托机制，任何“解决方案”都会变得脆弱，因为对BCL的更新可能会破坏你的代码。 您可以使用反射设置支持字段。 这当然要求您有权执行此操作并查看问题的通用框架，并不一定是您拥有所需的权限

public void MakeProblem()
{
  if (_backingField == null) {
    _backingField = = _a.GetType().GetField(fieldname)
  }
  _backingField.SetValue(_a,"make a problem");
}

但是当我开始时，你正试图打破事件委托机制。 这个想法是事件的接收者是独立的。 禁用可能导致很难找到错误，因为查看任何给定的代码片段它看起来是正确的但只有当你意识到一些狡猾的开发人员破解委托机制时你才意识到为什么屏幕上显示的信息似乎是缓存版本的实际值。 调试器显示属性的预期值，但由于事件被隐藏，负责更新显示的处理程序从未被触发，因此显示旧版本（或者日志显示不正确的信息，因此当您尝试重新创建用户的问题时已根据日志内容报告您将无法访问，因为日志中的信息不正确，因为它基于没有人黑客攻击事件委托机制

Answer 3

我认为你的解决方案是可行的，虽然我会在B中创建一个嵌套的IDisposable类，它使用'using'执行相同的操作，或者将'_dontDoThis = false'放在'finally'子句中。

class A
{
    // May be set by a code or by an user.
    public string Property
    {
        set { if (!_dontDoThis) PropertyChanged(this, EventArgs.Empty); }
    }

    public EventHandler PropertyChanged;
    bool _dontDoThis;
}

class B
{

    private class ACallWrapper : IDisposable
    {
        private B _parent;
        public ACallWrapper(B parent)
        {
            _parent = parent;
            _parent._a._dontDoThis = true;
        }

        public void Dispose()
        {
            _parent._a._dontDoThis = false;
        }
    }

    private A _a;

    public B(A a)
    {
        _a = a;
        _a.PropertyChanged += Handler;
    }

    void Handler(object s, EventArgs e)
    {
        // Who changed the Property?
    }

    public void MakeProblem()
    {
        using (new ACallWrapper(this))
            _a.Property = "make a problem";
    }
}

另一方面，如果这两个类在同一个程序集中，我会使用'internal'修饰符。

internal bool _dontDoThis;

这样，您就可以保持更好的OOP设计。

而且，如果两个类都在同一个程序集中，我会在A中编写以下代码：

    // May be set by a code or by an user.
    public string Property
    {
        set 
        { 
            internalSetProperty(value);
            PropertyChanged(this, EventArgs.Empty); 
        }
    }
    internal internalSetProperty(string value)
    {
        // Code of set.
    }

在这种情况下，B可以访问internalSetProperty而不会触发PropertyChanged事件。

线程同步：
注意：下一节适用于WinForms - 我不知道它是否也适用于WPF。
对于线程同步，因为我们指的是一个控件。 您可以使用GUI线程机制进行同步：

class A : Control
{
    public string Property
    {
        set 
        { 
            if (this.InvokeRequired) 
            {
                this.Invoke((Action<string>)setProperty, value);
                reutrn;
            }
            setProperty(value);
        }
    }


    private void setProperty string()
    {
        PropertyChanged(this, EventArgs.Empty); 
    }
}

Answer 4

好问题。

作为一般情况，您不能乱用密封类的事件处理程序。 通常你可以覆盖A的假设OnPropertyChanged并根据某些标志提升或不提高事件。 或者，你可以提供一个不会引发事件的setter方法，如@Vadim所建议的那样。 但是，如果A是密封的，那么最好的选择就是将标志添加到列表中，就像你一样。 这将使您能够识别由B引发的PropertyChanged事件，但您将无法为其他侦听器抑制该事件。

现在，既然你提供的上下文......恰好有这样的WPF的方式。 所有这一切需要做的是B的处理程序TextBox.TextChanged需要设置e.Handled = _dontDoThis 。 如果B的一个被添加为第一个听众，那将会为所有其他听众提供通知。 如何确保这种情况发生？ 反射！

UIElement只公开AddHandler和RemoveHandler方法，没有允许手动指定处理程序优先级的InsertHandler 。 但是，快速查看.NET源代码（下载整个内容或查询所需内容 ）可以发现AddHandler将参数转发给Interal方法EventHandlersStore.AddRoutedEventHandler ，它执行此操作：

// Create a new RoutedEventHandler 
RoutedEventHandlerInfo routedEventHandlerInfo =
    new RoutedEventHandlerInfo(handler, handledEventsToo); 

// Get the entry corresponding to the given RoutedEvent
FrugalObjectList<RoutedEventHandlerInfo> handlers = (FrugalObjectList<RoutedEventHandlerInfo>)this[routedEvent];
if (handlers == null) 
{
    _entries[routedEvent.GlobalIndex] = handlers = new FrugalObjectList<RoutedEventHandlerInfo>(1); 
} 

// Add the RoutedEventHandlerInfo to the list 
handlers.Add(routedEventHandlerInfo);

所有这些都是内部的，但可以使用反射重新创建：

public static class UIElementExtensions
{
    public static void InsertEventHandler(this UIElement element, int index, RoutedEvent routedEvent, Delegate handler)
    {
        // get EventHandlerStore
        var prop = typeof(UIElement).GetProperty("EventHandlersStore", BindingFlags.NonPublic | BindingFlags.Instance);
        var eventHandlerStoreType = prop.PropertyType;
        var eventHandlerStore = prop.GetValue(element, new object[0]);

        // get indexing operator
        PropertyInfo indexingProperty = eventHandlerStoreType.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance)
            .Single(x => x.Name == "Item" && x.GetIndexParameters().Length == 1 && x.GetIndexParameters()[0].ParameterType == typeof(RoutedEvent));

        object handlers = indexingProperty.GetValue(eventHandlerStore, new object[] { routedEvent });
        if (handlers == null)
        {
            // just add the handler as there are none at the moment so it is going to be the first one
            if (index != 0)
            {
                throw new ArgumentOutOfRangeException("index");
            }
            element.AddHandler(routedEvent, handler);
        }
        else
        {
            // create routed event handler info
            var constructor = typeof(RoutedEventHandlerInfo).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).Single();
            var handlerInfo = constructor.Invoke(new object[] { handler, false });

            var insertMethod = handlers.GetType().GetMethod("Insert");
            insertMethod.Invoke(handlers, new object[] { index, handlerInfo });
        }
    }
}

现在调用InsertEventHandler(0, textBox, TextBox.TextChangedEvent, new TextChangedEventHandler(textBox_TextChanged))将确保您的处理程序将成为列表中的第一个处理程序，使您能够禁止其他侦听器的通知！

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        var textBox = new TextBox();
        textBox.TextChanged += (o, e) => Console.WriteLine("External handler");
        var b = new B(textBox);
        textBox.Text = "foo";
        b.MakeProblem();
    }
}

class B
{
    private TextBox _a;
    bool _dontDoThis;

    public B(TextBox a)
    {
        _a = a;
        a.InsertEventHandler(0, TextBox.TextChangedEvent, new TextChangedEventHandler(Handler));
    }

    void Handler(object sender, TextChangedEventArgs e)
    {
        Console.WriteLine("B.Handler");
        e.Handled = _dontDoThis;
        if (_dontDoThis)
        {
            e.Handled = true;
            return;
        }
        // do this!
    }

    public void MakeProblem()
    {
        try
        {
            _dontDoThis = true;
            _a.Text = "make a problem";
        }
        finally
        {
            _dontDoThis = false;
        }

    }
}

输出：

B.Handler
External handler
B.Handler

Answer 5

我找到了一个与第三方有关的解决方案，这些解决方案与该属性相关联，我们不希望在该属性发生变化时对它们进行nofify。

虽然有要求：

• 我们有能力覆盖A.
• A具有在属性更改时调用的虚方法，并允许挂起要引发的事件。
• 在更改财产时立即引发事件。

解决方案是用MyA替换A，如下所示：

class A
{
    // May be set by a code or by an user.
    public string Property
    {
        set { OnPropertyChanged(EventArgs.Empty); }
    }

    // This is required
    protected virtual void OnPropertyChanged(EventArgs e)
    {
        PropertyChanged(this, e);
    }

    public EventHandler PropertyChanged;
}

// Inject MyA instead of A
class MyA : A
{
    private bool _dontDoThis;

    public string MyProperty
    {
        set
        {
            try
            {
                _dontDoThis = true;
                Property = value;
            }
            finally
            {
                _dontDoThis = false;
            }
        }
    }

    protected override void OnPropertyChanged(EventArgs e)
    {
        // Also third parties will be not notified
        if (_dontDoThis)
            return;

        base.OnPropertyChanged(e);
    }
}

class B
{
    private MyA _a;

    public B(MyA a)
    {
        _a = a;
        _a.PropertyChanged += Handler;
    }

    void Handler(object s, EventArgs e)
    {
        // Now we know, that the event is not raised by us.
    }

    public void MakeProblem()
    {
        _a.MyProperty = "no problem";
    }
}

不幸的是我们仍然使用back bool字段，我们假设一个线程。 为了摆脱第一个，我们可以使用EZSlaver建议的重构解决方案（ 这里 ）。 首先，创建一次性包装：

class Scope
{
    public bool IsLocked { get; set; }

    public static implicit operator bool(Scope scope)
    {
        return scope.IsLocked;
    }
}

class ScopeGuard : IDisposable
{
    private Scope _scope;

    public ScopeGuard(Scope scope)
    {
        _scope = scope;
        _scope.IsLocked = true;
    }

    public void Dispose()
    {
        _scope.IsLocked = false;
    }
}

然后MyProperty可能会被重构为：

private readonly Scope _dontDoThisScope = new Scope();

public string MyProperty
{
    set
    {
        using (new ScopeGuard (_dontDoThisScope))
            Property = value;
    }
}