C# 大量依赖于其他属性的属性

我们有一个大约有50~60个属性的类，这些属性依赖于同一类的属性+其他一些类的属性。目前，在一个属性的更改上，我们提高了20个其他属性的属性更改，这使得代码混乱且容易出错。处理这种情况的最佳方法是什么？有没有解决这个问题的设计模式

public class ClassA 
{
    public ClassB classB;

    public int Prop1
    {
        get { return CalculateValueForProp1(); }
    }

    private int prop2;
    public int Prop2
    {
        get { return prop2; }
        set
        {
            prop2 = value;
            OnPropertyChange(nameof(Prop2));
            OnPropertyChange(nameof(Prop1));
        }
    }


    private int prop3;
    public int Prop3
    {
        get { return prop3; }
        set
        {
            prop3 = value;
            OnPropertyChange(nameof(Prop3));
            OnPropertyChange(nameof(Prop1));
        }
    }

    public int CalculateValueForProp1()
    {
        return (this.prop2 * 10 + this.Prop1 * 20 + classB.AnotherProperty*10);
    }
}

---

尝试将属性的依赖项映射到对象结构。因此，您必须找到属性之间的依赖关系

如果您设法拥有一个定义“基本”属性的基类，则可以派生具有依赖（例如计算）属性的类。因此，如果基属性发生更改，派生类也应该使用此事件，更新其属性并触发自己的事件

未经测试，但我希望你明白这一点：

public class ClassA 
{
    private int prop2;
    public int Prop2
    {
        get { return prop2; }
        set
        {
            prop2 = value;
            OnPropertyChange(nameof(Prop2));
        }
    }

    private int prop3;
    public int Prop3
    {
        get { return prop3; }
        set
        {
            prop3 = value;
            OnPropertyChange(nameof(Prop3));
        }
    }
}

public ClassB classB
{
    public ClassB(ClassA classAinstance)
    {
        classAinstance.PropertyChanged += (s,e) => OnPropertyChange(nameof(Prop1));
    }

    public int Prop1
    {
        get { return (this.prop2 * 10 + this.Prop1 * 20 + classB.AnotherProperty*10); }
    }
}

---

尝试将属性的依赖项映射到对象结构。因此，您必须找到属性之间的依赖关系

如果您设法拥有一个定义“基本”属性的基类，则可以派生具有依赖（例如计算）属性的类。因此，如果基属性发生更改，派生类也应该使用此事件，更新其属性并触发自己的事件

未经测试，但我希望你明白这一点：

public class ClassA 
{
    private int prop2;
    public int Prop2
    {
        get { return prop2; }
        set
        {
            prop2 = value;
            OnPropertyChange(nameof(Prop2));
        }
    }

    private int prop3;
    public int Prop3
    {
        get { return prop3; }
        set
        {
            prop3 = value;
            OnPropertyChange(nameof(Prop3));
        }
    }
}

public ClassB classB
{
    public ClassB(ClassA classAinstance)
    {
        classAinstance.PropertyChanged += (s,e) => OnPropertyChange(nameof(Prop1));
    }

    public int Prop1
    {
        get { return (this.prop2 * 10 + this.Prop1 * 20 + classB.AnotherProperty*10); }
    }
}

---

将其分解为许多较小的类，而这些类的职责较低。任何类中的50~60个属性在一个类中都太多了。这是一个基本原理，比如关注点的分离，你不需要像那样膨胀一个类。因此，该解决方案与属性无关，并且将使用基本属性。您可以使用

“

作为属性名来引发事件，这将仅使用一个事件使所有属性无效。最好的方法是实际执行您所做的操作。将其拆分为许多较小的类，而这些类的职责较低。任何类中的50~60个属性在一个类中都是太多的代码。这是一个基本原理，比如关注点的分离，你不需要像那样膨胀一个类。因此，该解决方案与属性无关，并且将使用基本属性。您可以使用

“

作为属性名来引发事件，这将仅使用一个事件使所有属性无效。最好的方法是实际执行您所做的操作。我添加了示例代码，可能会有所帮助。我添加了示例代码，可能会有所帮助。