7

为了简单地说明我的困境,假设我有以下代码:

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 事件做出反应,但也能够在某些情况下自行更改该属性。不幸的是,其他对象也可以与该属性交互。

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

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 更新属性时,他们也不应该被通知。但我无法将他们与活动断开连接,因为我不认识他们。
  • 如果同时还有更多线程可以与属性交互怎么办?

解决的子弹越多越好。

原来的问题

我最初的问题是一个文本框(WPF),我想根据它的内容和焦点来补充它。所以我需要对 TextChanged 事件做出反应,如果它的起源来自我的补充,我还需要省略该事件。在某些情况下,不应通知 TextChanged 事件的其他侦听器。某些状态和样式的某些字符串对其他人是不可见的。

4

5 回答 5

2

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

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); 
}

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

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

于 2013-08-05T11:38:10.013 回答
2

好吧,本质上您正在尝试破坏事件委托机制,并且任何“解决方案”都会变得脆弱,因为对 BCL 的更新可能会破坏您的代码。您可以使用反射设置支持字段。这当然需要您确实有权执行此操作,并且看到问题的一般框架可能并不总是您拥有所需的权限

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

但是当我开始时,您正试图打破事件委托机制。这个想法是事件的接收者是独立的。禁用可能会导致很难找到错误,因为查看任何给定的代码看起来都是正确的,但是只有当您意识到某些狡猾的开发人员已经破解了委托机制时,您才会意识到为什么屏幕上显示的信息似乎是实际值的缓存版本。

于 2013-08-06T08:34:28.033 回答
1

在我看来,您的解决方案是可能的,尽管我会在 B 中创建一个嵌套的 IDisposable 类,它与“使用”做同样的事情,或者将“_dontDoThis = false”放在“最终”子句中。

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 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 可以在不触发PropertyChanged事件的情况下访问internalSetProperty 。

线程同步:
注意:下一部分适用于 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); 
    }
}
于 2013-08-05T11:53:33.363 回答
1

好问题。

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

现在,既然您提供了上下文......在 WPF 中有一种方法可以做到这一点。所有需要做的是需要设置B的处理程序。这将抑制所有其他侦听器的通知,前提是 's 已添加为第一个侦听器。如何确保发生这种情况?反射!TextBox.TextChangede.Handled = _dontDoThisB

UIElement只公开AddHandlerRemoveHandler方法,InsertHandler不允许手动指定处理程序的优先级。但是,快速浏览 .NET 源代码(下载整个源代码或查询您需要的内容)会发现AddHandler将参数转发到内部方法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
于 2013-08-06T08:53:58.567 回答
0

我找到了一种与第三方相关的解决方案,该解决方案与房产相关,我们不想在房产发生变化时通知他们。

虽然有以下要求:

  • 我们有能力覆盖 A。
  • A 有一个在属性更改时调用的虚拟方法,并允许暂停要引发的事件。
  • 更改属性时立即引发该事件。

解决办法是把A换成MyA,如下:

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建议的重构解决方案(here)。首先,创建一个一次性包装:

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;
    }
}
于 2013-08-06T07:47:25.610 回答