Question

我在层次结构中有一个对象，其值可以默认为父对象的值。两个对象属于同一类型。

作为示例：如果Score属性为double.NaN，则应从Score属性指向的对象检索Parent值，但仅如果设置了Parent（Parent != null）。

我的问题是，我如何可靠而通用地实施这样的模型？我有2个选项，但也许还有更多？

选项1：更改每个属性getter和setter以检查正在设置或获取的属性是否具有默认值，如果是，请尝试从父级读取

    private double score = double.NaN;
    public double Score
    {
        get { return (score == double.NaN && Parent != null) ? Parent.Score : score; }
        set { score = (Parent != null && Parent.Score == value) ? double.NaN : value; }
    }

优点：

分别对所有属性值进行实时原子更新
显式比较默认值

缺点：

每个属性getter和setter都需要手动实现，这可能容易出错
每次获取和设置都会影响性能

选项2：实施对象加载和保存的默认

    void AfterLoad()
    {
        if(Parent != null)
        {
            if(score == double.NaN)
            {
                score = Parent.Score;
            }
            // (...)
        }
    }

    void BeforeSave()
    {
        if(Parent != null)
        {
            if(score == Parent.Score)
            {
                score = double.NaN;
            }
            // (...)
        }
    }

    void AfterSave()
    {
        AfterLoad();
    }

优点：

父关系仅在加载（一次）和保存（两次）时使用，以提高性能

缺点：

在任何时候父对象更改都不会影响子属性
在更改父对象之前和之后，需要处理子项（在父项更改后回退到新的默认值）
原子性可能会受到影响 - 在保存对象期间，任何其他线程都无法访问

我确信很多人在实现对象“样式”模型时有类似的dillema。我正在寻找一个干净且有效的解决方案，它也可以将子对象和父对象的集合连接在一起（使用CompositeCollection？）。

Answer 1

您可以使用WPF样式的方法，其中属性值不存储在字段中，而是存储在基类的字典中。

这样所有属性看起来都像

double Prop {
 get{ return (double)GetValue("Prop"); }
 set{ SetValue("Prop",value); }
}

如果没有为当前类设置，GetValue将检查所有父项以查找默认值。

Answer 2

我正在处理类似的情况并用这两个类来解决它，我对它并不完全满意，但也许它有帮助......

public class RootProperty<T>
{
    private T _value;

    public virtual T Value
    {
        get { return _value; }
        set
        {
            if (Equals(value, _value)) return;
            _value = value;
        }
    }

    public static implicit operator T(RootProperty<T> p)
    {
        return p.Value;
    }

    public override string ToString()
    {
        return "[RootProperty<" + typeof(T).Name + ">] " + Value;
    }
}

public class InheritedProperty<T> : RootProperty<T>
{
    private bool _override;

    public bool Override
    {
        get { return _override; }
        set
        {
            if (value.Equals(_override)) return;
            _override = value;

            //If we now override and we had no value before, copy the value that was previously inherited for convinience
            if (_override && (Value == null || Value.Equals(default(T))))
                Value = Parent.Value;

        }
    }

    public RootProperty<T> Parent { get; private set; }

    public override T Value
    {
        get
        {
            if (Override)
            {
                return base.Value;
            }

            if (Parent == null)
                throw new Exception("Parent musn't be null");
            return Parent.Value;
        }
        set
        {
            Override = true;
            base.Value = value;
        }
    }

    public InheritedProperty(RootProperty<T> parent)
    {
        Parent = parent;
    }

    public override string ToString()
    {
        return "[InheritedProperty<" + typeof(T).Name + ">] " + Value;
    }
}

示例用法

class TestParent
{
    public RootProperty<int> MyInt { get; private set; }

    public TestParent()
    {
        MyInt = new RootProperty<int>();
    }

}

class TestChild
{
    public InheritedProperty<int> MyInt { get; private set; }

    public TestChild(TestParent parent)
    {
        MyInt = new InheritedProperty<int>(parent.MyInt);
    }
}

Answer 3

我建议使用Modified Preorder Tree Traversal来组织这些类，然后将它们存储在一个List<MyClass>中。然后，您可以使用LINQ对该属性进行排序和查找第一个非null值。我不能谈论它的表现，但它可能值得一试。

LINQ应该类似于：

var node = myList.Where(x => x.LeftNumber <= target.LeftNumber && x.RightNumber >= target.RightNumber)
                 .OrderByDescending(x => x.LeftNumber)
                 .FirstOrDefault(x => x.Prop != double.NaN);
return (node != null) ? node.Prop : double.NaN;

x.LeftNumber <= target.LeftNumber && x.RightNumber >= target.RightNumber将获得target节点，它的父节点和所有其他祖先。

OrderByDescending将对它们进行排序，以便树的底部是第一个。您可以选择使用Last()代替OrderBy().First()

FirstOrDefault()将获得第一个实际具有值的值，从target节点开始并处理树。

编辑：以下是我用来从父子关系重建树的方法。

protected static void RebuildTree()
{
    RebuildTree(allNodes[0], 0);
    SaveAllNodes();
}
private static int RebuildTree(Taxonomy node, int left)
{
    node.leftNumber = left;
    node.rightNumber = left + 1;
    foreach (Taxonomy child in node.Children)
    {
        node.rightNumber = RebuildTree(child, node.rightNumber);
    }
    return node.rightNumber + 1;
}

使用默认引用对象关系访问C＃中属性的默认值

3 个答案: