如何通过组合包含属性？

Question

在我第三次不得不重构当前项目中的继承链后，我在 Google 上搜索“继承很烂”，发现我遇到的问题并不少见，组合是推荐的替代解决方案。

我了解如何使用组合以函数的形式添加行为，但我在想出以相同方式添加属性的方法时遇到了问题。

假设我想为树节点建模。每个节点至少有两个属性：名称和描述。

class Node {
   public string Name { get; set; }
   public string Description { get; set; }
}

其他更具体的节点会继承这些属性，如下所示：

class StructuredNode : Node {
   public List<Node> Children { get; set; }
}

如何在不依赖继承和随之而来的问题的情况下实现属性代码的类似可重用性？
是否有这种设计模式，还是在这种情况下我必须使用继承？

提前致谢！

编辑： “组合优于继承”的例子：

• ScottLilly
• Wikipedia
• Codingdelight

Answer 1

然后取决于类，你应该依赖子抽象（这也是使用组合的一部分）所以对于你的情况你应该这样做

public interface INode {
   string Name { get; set; }
   string Description { get; set; }
}

class Node : INode {
   public string Name { get; set; }
   public string Description { get; set; }
}

class StructuredNode : INode {
   public string Name { get; set; }
   public string Description { get; set; }
   public List<INode> Children { get; set; }
}

或者你也可以这样做

//this is something similar to decorator pattern.
class StructuredNode  {
   private readonly INode _node;
   public StructureNode(INode node)
   {
      _node = node;//now you can reuse function of any class which implements INode
   }

   public List<INode> Children { get; set; }
}

你以后也应该这样做

   List<Node> nodes = List<Node>();
   StructuredNode sNode = new StructuredNode();
   sNode.Children  = nodes; 

这是可能的，因为一切都基于抽象。现在所有实现都使用INode

或

在评论中建议您的其他解决方案是使用Decorator pattern。如果你只想扩展你的类而不修改它。

Answer 2

如何在不依赖继承和随之而来的问题的情况下归档属性代码的类似可重用性？

使用继承的替代方法是接口或组合。但是，特别是对于属性，您有点卡住了。

• 接口不能像基类一样包含默认实现。因此，虽然您可以强制您的类使用正确的“组合属性结构”，但如果不在每个实现接口的类中实现可重用方法（或者你可以吗？休息后更多！ em>)
• Composition 在 C# 中根本不存在，您可以动态地将属性添加到类中（除非您对 Dictionary<string,string> 感到满意）。可能有一些人为的方法可以技术上让它发挥作用，但这不是一个好方法。

---

接口+扩展方法。

这里可以使用扩展方法来替换您在继承的基类中找到的可重用逻辑。

这样做有一个缺点：您希望在扩展方法中访问的属性必须是接口协定的一部分并且可以公开访问。
除了这个缺点之外，它还能满足您的所有其他要求。

---

首先，一个基于继承的例子：

public class Property
{
    public string Name { get; set; }
    public string Value { get; set; }
}

public class PropertyComposedObject
{
    public List<Property> Properties { get; set; }

    public Property GetProperty(string name)
    {
        return this.Properties.SingleOrDefault(x => x.Name == name);
    }
}

public class Person : PropertyComposedObject
{

}

---

如果我们改用接口，我们将无法获得诸如共享GetNode(string) 方法之类的好处。您可以将其添加为接口的一部分，但随后每个实现类都将负责实现该方法（导致您在各处复制/粘贴相同的方法）。

没有扩展方法的接口示例：

public class Property
{
    public string Name { get; set; }
    public string Value { get; set; }
}

public interface IPropertyComposedObject
{
    List<Property> Properties { get; set; }

    Property GetProperty(string name);
}

public class Person : IPropertyComposedObject
{
    public List<Property> Properties { get; set; }

    public Property GetProperty(string name)
    {
        return this.Properties.SingleOrDefault(x => x.Name == name);
    }
}

---

但是扩展方法允许我们定义可重用方法一次，但仍然可以从每个实现接口的类中访问它：

public class Property
{
    public string Name { get; set; }
    public string Value { get; set; }
}

public interface IPropertyComposedObject
{
    List<Property> Properties { get; set; }
}

public class Person : IPropertyComposedObject
{
    public List<Property> Properties { get; set; }
}

public static class IPropertyComposedObjectExtensions
{
    public Property GetProperty(this IPropertyComposedObject obj, string name)
    {
        return obj.Properties.SingleOrDefault(x => x.Name == name);
    }
}

Answer 3

我尽量减少代码重复的尝试：

interface INodeProperties
{
    string Name { get; set; }
    string Description { get; set; }
}

class NodeProperties : INodeProperties
{
    public string Name { get; set; }
    public string Description { get; set; }
}

interface INode
{
     INodeProperties NodeProps { get; set; }
}

class Node : INode
{
     public INodeProperties NodeProps { get; set; } = new NodeProperties();
}

interface IStructuredNode
{
      List<Node> Children { get; set; }
}

class StructuredNode: INode, IStructuredNode
{
     public INodeProperties NodeProps { get; set; } = new NodeProperties();
     public List<Node> Children { get; set; }
}

缺点：再“跳”一次即可到达实际的属性... :(

Answer 4

有一个INode接口，封装了常用属性。

这样你应该有自动属性，然后避免将逻辑放在属性的getter和setter中，因为你不能重用这个逻辑。

那么重复自动属性定义并不重要，也不影响可重用性。

如果需要属性变更通知，最好使用postsharp等拦截器库。