C# 包含项更改时激发的ObservableCollection

我发现这个话题对于这里的很多人来说是一场真正的斗争，因此它实际上涵盖的相当好！然而，所提供的解决方案似乎都不适合我

正如标题所说，问题在于当项目的值发生变化时，ObservableCollection不会触发，只有当项目本身以某种方式被删除、添加或更改时才会触发

我尝试了使用BindingList的解决方案——尽管很多人反对——但它不起作用，使用扩展的ObserviecCollections的解决方案，如解释的那样。所有这些似乎都不起作用……这就留下了一个问题：错误是在我认为的地方，还是完全在其他地方

好的，这是我的密码：

基类：

public class ModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propName = "")
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(propName));
        }
    }
}

class TestSensor : ModelBase
{


    private bool isOnline;
    public bool IsOnline
    {
        get
        {
            return isOnline;
        }
        set
        {
            if (isOnline != value)
            {
                isOnline = value;
                this.OnPropertyChanged();
            }
        }
    }


    private double sensorDatauStrain;
    public double SensorDatauStrain
    {
        get { return sensorDatauStrain; }
        set
        {
            if (sensorDatauStrain != value)
            {
                sensorDatauStrain = value;
                this.OnPropertyChanged();
            }
        }
    }


    private double sensorDatakNewton;
    public double SensorDatakNewton
    {
        get { return sensorDatakNewton; }
        set
        {
            if (sensorDatakNewton != value)
            {
                sensorDatakNewton = value;
                this.OnPropertyChanged();
            }
        }
    }


    private double sensorDataTon;
    public double SensorDataTon
    {
        get { return sensorDataTon; }
        set
        {
            if (sensorDataTon != value)
            {
                sensorDataTon = value;
                this.OnPropertyChanged();
            }
        }
    }


    private double sensorDatausTon;
    public double SensorDatausTon
    {
        get { return sensorDatausTon; }
        set
        {
            if (sensorDatausTon != value)
            {
                sensorDatausTon = value;
                this.OnPropertyChanged();
            }
        }
    }

    private string sensorName;
    public string SensorName
    {
        get { return sensorName; }
        set
        {
            if (sensorName != value)
            {
                sensorName = value;
                this.OnPropertyChanged();
            }
        }
    }

    public TestSensor(string name, double ustrain,double kNewton, double ton, double uston)
    {
        this.SensorName = name;
        this.SensorDatauStrain = ustrain;
        this.SensorDatakNewton = kNewton;
        this.SensorDataTon = ton;
        this.SensorDatausTon = uston;
        this.IsOnline = true;
    }
 }

然后我有一个包含这些传感器的类：

class Holm : ModelBase
{
    public Holm(String Name, TestSensor sensor1, TestSensor sensor2)
    {
        Sensor1 = sensor1;
        Sensor2 = sensor2;
        this.Name = Name;
    }


    private string name;
    public string Name
    {
        get
        {
            return name;
        }

        set
        {
            if (name != value)
            {
                name = value;
                this.OnPropertyChanged();
            }
        }
    }

    private TestSensor sensor1;
    public TestSensor Sensor1
    {
        get
        {
            return sensor1;
        }
        set
        {
            if (sensor1 != value)
            {
                sensor1 = value;
                this.OnPropertyChanged();
            }
        }
    }

    private TestSensor sensor2;
    public TestSensor Sensor2
    {
        get
        {
            return sensor2;
        }
        set
        {
            if (sensor2 != value)
            {
                sensor2 = value;
                this.OnPropertyChanged();
            }

        }
    }

    public bool IsOnline
    {
        get
        {
            if (!Sensor1.IsOnline || !Sensor2.IsOnline)
            {
                return false;
            }
            else
            {
                return true;
            }

        }

    }

 }

最后是包含我失败的ObservaleCollection的ViewModel—不包括一些不相关的内容：

    class MainViewViewModel : ModelBase
    {

           public ItemsChangeObservableCollection<Holm> HolmList { get;set;}

              public MainViewViewModel()
            {  

            Sensor11 = new TestSensor("Sensor 1.1", 0, 0, 0, 0);
            Sensor12 = new TestSensor("Sensor 1.2", 0, 0, 0, 0);
            Sensor21 = new TestSensor("Sensor 2.1", 0, 0, 0, 0);
            Sensor22 = new TestSensor("Sensor 2.2", 0, 0, 0, 0);
            Sensor31 = new TestSensor("Sensor 3.1", 0, 0, 0, 0);
            Sensor32 = new TestSensor("Sensor 3.2", 0, 0, 0, 0);
            Sensor41 = new TestSensor("Sensor 4.1", 0, 0, 0, 0);
            Sensor42 = new TestSensor("Sensor 4.2", 0, 0, 0, 0);


            Holm1 = new Holm("Holm 1", Sensor11, Sensor12);
            Holm2 = new Holm("Holm 2", Sensor21, Sensor22);
            Holm3 = new Holm("Holm 3", Sensor31, Sensor32);
            Holm4 = new Holm("Holm 4", Sensor41, Sensor42);

            HolmList = new ItemsChangeObservableCollection<Holm>();
            HolmList.Add(Holm1);
            HolmList.Add(Holm2);
            HolmList.Add(Holm3);
            HolmList.Add(Holm4);

             }


    private TestSensor sensor11;
    public TestSensor Sensor11
    {
        get { return sensor11; }
        set
        {
            if (sensor11 != value)
            {
                sensor11 = value;
                this.OnPropertyChanged();
                this.OnPropertyChanged("Holm1");
                this.OnPropertyChanged("HolmList");
            }
        }
    }
    private TestSensor sensor12;
    public TestSensor Sensor12
    {
        get { return sensor12; }
        set
        {
            if (sensor12 != value)
            {
                sensor12 = value;
                this.OnPropertyChanged();
                this.OnPropertyChanged("Holm1");
                this.OnPropertyChanged("HolmList");
            }
        }
    }



    private TestSensor sensor21;
    public TestSensor Sensor21
    {
        get { return sensor21; }
        set
        {
            if (sensor21 != value)
            {
                sensor21 = value;
                this.OnPropertyChanged();
            }
        }
    }
    private TestSensor sensor22;
    public TestSensor Sensor22
    {
        get { return sensor22; }
        set
        {
            if (sensor22 != value)
            {
                sensor22 = value;
                this.OnPropertyChanged();

            }
        }
    }


    private TestSensor sensor31;
    public TestSensor Sensor31
    {
        get { return sensor31; }
        set
        {
            if (sensor31 != value)
            {
                sensor31 = value;
                this.OnPropertyChanged();

            }
        }
    }
    private TestSensor sensor32;
    public TestSensor Sensor32
    {
        get { return sensor32; }
        set
        {
            if (sensor32 != value)
            {
                sensor32 = value;
                this.OnPropertyChanged();

            }
        }
    }


    private TestSensor sensor41;
    public TestSensor Sensor41
    {
        get { return sensor41; }
        set
        {
            if (sensor41 != value)
            {
                sensor41 = value;
                this.OnPropertyChanged();
                                }
        }
    }
    private TestSensor sensor42;
    public TestSensor Sensor42
    {
        get { return sensor42; }
        set
        {
            if (sensor42 != value)
            {
                sensor42 = value;
                this.OnPropertyChanged();
                                }
        }
    }



    private Holm holm1;
    public Holm Holm1
    {
        get
        {
            return holm1;
        }
        set
        {
            if (holm1 != value)
            {
                holm1 = value;
                this.OnPropertyChanged();
                this.OnPropertyChanged("HolmList");
            }
        }
    }

    private Holm holm2;
    public Holm Holm2
    {
        get
        {
            return holm2;
        }
        set
        {
            if (holm2 != value)
            {
                holm2 = value;
                this.OnPropertyChanged();
            }
        }
    }
    private Holm holm3;
    public Holm Holm3
    {
        get
        {
            return holm3;
        }
        set
        {
            if (holm3 != value)
            {
                holm3 = value;
                this.OnPropertyChanged();
            }
        }
    }
    private Holm holm4;
    public Holm Holm4
    {
        get
        {
            return holm4;
        }
        set
        {
            if (holm4 != value)
            {
                holm4 = value;
                this.OnPropertyChanged();
            }
        }
    }
  }

class MainViewModel:ModelBase
{
public ItemsChangeObservableCollection HolmList{get；set；}
public mainViewModel（）
{  
传感器11=新的测试传感器（“传感器1.1”，0,0,0,0）；
传感器12=新的测试传感器（“传感器1.2”，0,0,0,0）；
Sensor21=新的测试传感器（“传感器2.1”，0,0,0,0）；
Sensor22=新的测试传感器（“传感器2.2”，0,0,0,0）；
Sensor31=新的测试传感器（“传感器3.1”，0,0,0,0）；
Sensor32=新的测试传感器（“传感器3.2”，0,0,0,0）；
Sensor41=新的测试传感器（“传感器4.1”，0,0,0,0）；
Sensor42=新的测试传感器（“传感器4.2”，0,0,0,0）；
Holm1=新的Holm（“Holm1”，传感器11，传感器12）；
Holm2=新的Holm（“Holm 2”，传感器21，传感器22）；
Holm3=新的Holm（“Holm 3”，传感器31，传感器32）；
Holm4=新的Holm（“Holm4”，传感器41，传感器42）；
HolmList=new ItemsChangeObservableCollection（）；
添加（Holm1）；
添加（Holm2）；
添加（Holm3）；
添加（Holm4）；
}
专用测试传感器11；
公共测试传感器11
{
获取{return sensor11；}
设置
{
如果（传感器11！=值）
{
传感器11=数值；
this.OnPropertyChanged（）；
本条关于不动产变更（“Holm1”）；
本.OnPropertyChanged（“HolmList”）；
}
}
}
专用测试传感器12；
公共测试传感器12
{
获取{return sensor12；}
设置
{
如果（传感器12！=值）
{
传感器12=数值；
this.OnPropertyChanged（）；
本条关于不动产变更（“Holm1”）；
本.OnPropertyChanged（“HolmList”）；
}
}
}
专用测试传感器21；
公共测试传感器21
{
获取{return sensor21；}
设置
{
如果（传感器21！=值）
{
传感器21=数值；
this.OnPropertyChanged（）；
}
}
}
专用测试传感器22；
公共测试传感器22
{
获取{return sensor22；}
设置
{
如果（传感器22！=值）
{
传感器22=数值；
this.OnPropertyChanged（）；
}
}
}
专用测试传感器31；
公共测试传感器31
{
获取{return sensor31；}
设置
{
如果（传感器31！=值）
{
sensor31=数值；
this.OnPropertyChanged（）；
}
}
}
专用测试传感器32；
公共测试传感器32
{
获取{return sensor32；}
设置
{
如果（传感器32！=值）
{
sensor32=数值；
this.OnPropertyChanged（）；
}
}
}
专用测试传感器41；
公共测试传感器41
{
获取{return sensor41；}
设置
{
如果（传感器41！=值）
{
传感器41=数值；
this.OnPropertyChanged（）；
}
}
}
专用测试传感器42；
公共测试传感器42
{
获取{return sensor42；}
设置
{
如果（传感器42！=值）
{
传感器42=数值；
this.OnPropertyChanged（）；
}
}
}
二等兵霍尔姆·霍尔姆1；
公共霍尔姆霍尔姆1
{
得到
{
返回1；
}
设置
{
if（holm1！=值）
{
holm1=值；
this.OnPropertyChanged（）；
本.OnPropertyChanged（“HolmList”）；
}
}
}
二等兵霍尔姆·霍尔姆2；
公共霍尔姆霍尔姆2
{
得到
{
返回2；
}
设置
{
if（holm2！=值）
{
holm2=数值；
this.OnPropertyChanged（）；
}
}
}
二等兵霍尔姆·霍尔姆3；
公共霍尔姆霍尔姆3
{
得到
{
返回3；
}
设置
{
if（holm3！=值）
{
holm3=数值；
this.OnPropertyChanged（）；
}
}
}
二等兵霍姆霍姆4；
公共霍尔姆霍尔姆4
{
得到
{
返回4；
}
设置
{
if（holm4！=值）
{
holm4=值；
this.OnPropertyChanged（）；
}
}
}
}

Xaml并不重要，而且还没有完成。到目前为止，我已经用以下代码解决了这个问题：

<CheckBox Content="Sensor1.1" IsChecked="{Binding HolmList[0].Sensor1.IsOnline}"/>
<TextBlock Text="{Binding HolmList[0].Sensor1.IsOnline, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"/>
<CheckBox Content="Sensor1.2" IsChecked="{Binding HolmList[0].Sensor2.IsOnline}"/>
<TextBlock Text="{Binding HolmList[0].Sensor2.IsOnline, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}"/>
<TextBlock Text="{Binding HolmList[0].IsOnline, UpdateSourceTrigger=PropertyChanged}" />

我只希望Holms IsOnline属性在

public class EnhancedObservableCollection<T> : ObservableCollection<T>
    where T : INotifyPropertyChanged
{
    public EnhancedObservableCollection(bool isCollectionChangedOnChildChange)
    {
        IsCollectionChangedOnChildChange = isCollectionChangedOnChildChange;
    }

    public EnhancedObservableCollection(List<T> list, bool isCollectionChangedOnChildChange) : base(list)
    {
        IsCollectionChangedOnChildChange = isCollectionChangedOnChildChange;
    }

    public EnhancedObservableCollection(IEnumerable<T> collection, bool isCollectionChangedOnChildChange) : base(collection)
    {
        IsCollectionChangedOnChildChange = isCollectionChangedOnChildChange;
    }

    public bool IsCollectionChangedOnChildChange { get; set; }

    public event EventHandler<string> ChildChanged;

    protected override void RemoveItem(int index)
    {
        var item = Items[index];
        item.PropertyChanged -= ItemOnPropertyChanged;
        base.RemoveItem(index);
    }

    private void ItemOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
    {
        var handler = ChildChanged;
        if (handler != null)
        {
            handler(this, propertyChangedEventArgs.PropertyName);
        }
        if (IsCollectionChangedOnChildChange)
        {
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace));
        }
    }

    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        item.PropertyChanged += ItemOnPropertyChanged;
    }
}

class Holm : ModelBase
{
    public Holm(String Name, TestSensor sensor1, TestSensor sensor2)
    {
        Sensor1 = sensor1;
        Sensor2 = sensor2;
        this.Name = Name;

        Sensor1.PropertyChanged += OnSensorOnlineChanged;
        Sensor2.PropertyChanged += OnSensorOnlineChanged;
    }

    private void OnSensorOnlineChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "IsOnline")
        {
            OnPropertyChanged(nameof(IsOnline));
        }
    }
}