Question

我有一个实现INotifyPropertyChanged的类。我在一些viewModel中创建了一个类的实例。是否可以从类中删除此功能并在创建实例后注入它？我听说ICustomTypeDescriptor会让这种情况发生，但我不知道如何使用它。

public class C : ICustomNotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public int _id;
    public string _name;

    public int Id
    {
        get { return _id; }
        set
        {
            if (_id == value)
            {
                return;
            }

            _id = value;
            OnPropertyChanged("Id");
        }
    }

    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value)
            {
                return;
            }

            _name = value;
            OnPropertyChanged("Name");
        }
    }

    public void OnPropertyChanged(string name)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(name));
        }
    }

Answer 1

这不起作用。您可以继承并注入它，但您必须更改字节代码以确保正确的方法是CALLED - 这是更难的方法。

Answer 2

如果您只是试图阻止在首次创建对象并设置属性时触发通知，则可以添加/是false的布尔标志，直到属性设置一次为止。只有在标志为真时才执行通知。

编辑：

在删除所有INotifyPropertyChanged代码之后，我认为没有一种干净的方法来获取该功能，但是有很多方法可以从实例外部控制功能。

请注意，我在文本编辑器中编写了所有这些代码，而不是在VisualStudio中;它没有经过任何方式的测试。

添加启用通知的方法：

public class OptionalNotification : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    void OnPropertyChanged(string name) ...

    bool _shouldNotify;

    public void EnableNotifications()
    {
        _shouldNotify = true;
    }

    string _someProperty;
    public string SomeProperty
    {
        get { return _someProperty; }
        set 
        {
            if(_someProperty == value) return

            _someProperty = value;

            if(_shouldNotify) OnPropertyChanged("SomeProperty");
        }
    }
}

如果你在实例化时知道实例是否应该生成通知，你可以在没有方法的情况下做同样的事情，在这种情况下你只需要在构造函数中使用布尔参数。

另一种变体是使用Factory模式，其中Factory可以内部访问布尔标志并在构造时设置它。

将条件封装在代理中：

public interface IEntity : INotifyPropertyChanged
{
    string SomeProperty { get; set; }
}

public class Entity : IEntity
{
    public event PropertyChangedEventHandler PropertyChanged;

    public void OnPropertyChanged(string name) ...

    string _someProperty;
    public string SomeProperty
    {
        get { return _someProperty; }
        set 
        {
            if(_someProperty == value) return

            _someProperty = value;
            OnPropertyChanged("SomeProperty");
        }
    }
}

public class EntityNotificationProxy : IEntity
{
    IEntity _inner;

    public EntityNotificationProxy(IEntity entity)
    {
        _inner = entity;
        _inner.PropertyChanged += (o,e) => { if(ShouldNotify) OnPropertyChanged(o,e); }
    }

    public bool ShouldNotify { get; set; }

    public event PropertyChangedEventHandler PropertyChanged;

    void OnPropertyChanged(object sender, PropertChangedEventArgs e)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if(handler != null) handler(sender, e);
    }

    public string SomeProperty
    {
        get { return _inner.SomeProperty; }
        set 
        {
            if(_inner.SomeProperty == value) return

            _inner.SomeProperty = value;
        }
    }
}

在这里，您的消费类获取实体代理而不是实体本身（但不是更明智的，因为它在编程接口/抽象时仅引用IEntity。代理的包装可以在工厂或通过IoC容器/ DI框架进行。

这种方法的主要优点是您的实体维护纯INotifyPropertyChanged实现，条件方面是从无处理。另一个优点是它有助于对抽象和控制反转实施编程。

主要的缺点是，您需要为每个INotifyPropertyChanged实现创建代理，以便具有此条件行为。

创建一个注册表来跟踪哪些实例应该或不应该引发通知：

public static class PropertyNotificationRegistry
{
    static IDictionary<INotifyPropertyChanged, bool> _registeredClasses
        = new Dictionary<INotifyPropertyChanged, bool>;

    static void Register(INotifyPropertyChanged o, bool shouldNotify)
    {
        if(!(_registeredClasses.ContainsKey(o)) _registeredClasses.Add(o, shouldNotify);
        // could also implement logic to update an existing class in the dictionary
    }

    public static void ShouldNotifyWhenPropertiesChange(this INotifyPropertyChanged o)
    {
        Register(o, true);
    }

    public static void ShouldNotNotifyWhenPropertiesChange(this INotifyPropertyChanged o)
    {
        Register(o, false);
    }

    public static void NotifyPropertyChanged(this INotifyPropertyChanged o, Action notificationAction)
    {
        if(_registeredClasses.ContainsKey(o))
        {
            bool shouldNotify = _registeredClasses.Where(x => x.Key == o).Single().Value;

            if(shouldNotify) notificationAction();
        }
    }
}

public class EntityUsingNotificationRegistry : INotifyPropertyChanged
{
    ... // all the standard INotifyPropertyChanged stuff

    string _someProperty;
    public string SomeProperty
    {
        get { return _someProperty; }
        set 
        {
            if(_someProperty == value) return;

            _someProperty = value;
            this.NotifyPropertyChanged(() => OnPropertyChanged("SomeProperty"));
        }
    }
}

public class SomethingInstantiatingOurEntity
{
    public void DoSomething()
    {
        var entity1 = new EntityUsingNotificationRegistry();
        entity1.ShouldNotifyWhenPropertiesChange();

        var entity2 = new EntityUsingNotificationRegistry();
        entity2.ShouldNotNotifyWhenPropertiesChange();

        entity1.SomeProperty = "arbitrary string"; // raises event
        entity2.SomeProperty = "arbitrary string"; // does not raise event

        var entity3 = new EntityUsingNotificationRegistry();
        entity3.SomeProperty = "arbitrary string"; // does not raise event
        entity3.ShouldNotifyWhenPropertiesChange();
        entity3.SomeProperty = "another arbitrary string"; // now raises event
    }
}

现在，注册表有一个明显的缺点，即它保存对每个实例的引用，并将阻止垃圾收集器拾取这些实例。通过使用WeakReference实现注册表可能会有一个解决方案，但我不会对它们的使用情况有所建议。

将（INotifyPropertyChanged功能）注入到类的实例中

2 个答案:

编辑：

添加启用通知的方法：

将条件封装在代理中：

创建一个注册表来跟踪哪些实例应该或不应该引发通知：