在扩展方法中如何根据实现类创建对象

Question

在扩展方法中如何基于实现类创建对象。因此，在下面的代码中我想添加一个“AddRelationship”扩展方法，但是我不确定如何在扩展方法中创建一个关系对象？即不想将扩展方法与关系的这个特定实现联系起来，

   public static class TopologyExtns
    {

        public static void AddNode<T>(this ITopology<T> topIf, INode<T> node)
        {
            topIf.Nodes.Add(node.Key, node);
        }

        public static INode<T> FindNode<T>(this ITopology<T> topIf, T searchKey)
        {
            return topIf.Nodes[searchKey];
        }

        public static bool AddRelationship<T>(this ITopology<T> topIf, INode<T> parentNode, INode<T> childNode)
        {
            var rel = new RelationshipImp();  // ** How do I create an object from teh implementation 
            // Add nodes to Relationship
            // Add relationships to Nodes
        }
    }


    public interface ITopology<T>
    {
        //List<INode> Nodes { get; set; }
        Dictionary<T, INode<T> > Nodes { get; set; }
    }

    public interface INode<T> 
    {
        // Properties
        List<IRelationship<T>> Relationships { get; set; }
        T Key { get; }
    }

    public interface IRelationship<T>
    {
        // Parameters
        INode<T> Parent { get; set; }
        INode<T> Child { get; set; }
    }


namespace TopologyLibrary_Client
{

    class RelationshipsImp : IRelationship<string>
    {
        public INode<string> Parent { get; set; }
        public INode<string> Child { get; set; }
    }
}

    public class TopologyImp<T> : ITopology<T>
    {
        public Dictionary<T, INode<T>> Nodes { get; set; }
        public TopologyImp()
        {
            Nodes = new Dictionary<T, INode<T>>();
        }

    }

谢谢

Answer 1

您可以添加一个表示关系实现类的额外类型参数，指定它必须是 IRelationship 并具有无参数构造函数的约束：

public static bool AddRelationship<T,R>(this ITopology<T> topIf, INode<T> parentNode, INode<T> childNode) 
    where R : IRelationship, new() {
    var rel = new R();
    // ...
}

然后您应该像这样调用它来指定 IRelationship 具体类型（ 'R'类型参数）：

topology.AddRelationship<string, RelationshipImp>(parentNode, childNode);

编辑：替代方法，没有扩展方法：您定义（并稍后实例化）一个RelationshipFactory类：

class RelationshipFactory<R> 
    where R : IRelationship, new(){
    // no longer an extension method:
    public static bool AddRelationship<T>(ITopology<T> topIf, INode<T> parentNode, INode<T> childNode) {
        var rel = new R();
        // ...
    }
}

Answer 2

一种方法是通过修改其接口来支持 IRelationship 或 INode 类，将责任推给它们。 code> 工厂方法，例如 ITopology 可以这样修改：

public interface ITopology<T>
{
    IRleationship<T> CreateRelationship(INode<T> parent, INode<T> child);
    Dictionary<T, INode<T> > Nodes { get; set; }
}

然后 AddRelationship 看起来像这样：

public static bool AddRelationship<T>(this ITopology<T> topIf, INode<T> parentNode, INode<T> childNode)
{
    var relationship = topIf->CreateRelationship(parentNode, childNode);
    // ...
}

由于您正在使用扩展方法，因此修改这些接口可能是不可能或不需要的，但它是一种选择。

Answer 3

解决有关您的设计的另一个（可能的）问题。当您可以简单地将 AddRelationship 方法放入拓扑实现中时，为什么还要使用扩展方法呢？在这种情况下是否有特定需要使用扩展方法？另外，是否会出现单个节点可以有多个父节点的情况？

我认为这样的事情是有序的：

public interface INode<T> 
{
    // Properties
    INode<T> Parent { get; }
    IEnumerable<INode<T>> Children { get; }
    String Key { get; }

    void AddChild(INode<T> child);
}

public class Node<T> : INode<T>
{
    public Node(String key) : this(key, null) {}
    public Node(String key, INode<T> parent)
    {
        this.Parent = parent;
        this.Children = new List<T>();
        this.Key = key; 
    }

    public virtual INode<T> Parent { get; protected set; }
    public virtual String Key { get; protected set; }
    public virtual List<T> Children { get; protected set; }

    public void AddChild(INode<T> node) 
    {
        this.Children.Add(node);
    }
}

不需要扩展方法，也不需要中间 IRelationship 类。这一切都取决于修改接口的能力，并且 INode 只能有一个父节点。

编辑（基于OP的评论）：

考虑到您专门在使扩展方法的API看起来更干净之后，您也许可以这样做：

public static bool AddRelationship(this INode<T> node, IRelationship<T> relationship) 
{
    if (node.Relationships == null)
        node.Relationships = new List<T>;

    if (relationship == null) throw new ArgumentNullException("relationship");

    node.Relationships.Add(relationship);
    return true; // I'd make this method void
}

然后调用它是：

INode node = new Node<String>("some key");
INode someParent = new Node<String>("some parent key");
INode someChild = new Node<String>("some child key");

node.AddRelationship(new RelationshipImp(someParent, someChild));

我还没有测试过这个，所以我可能会与指定泛型的位置无关。我不知道推理引擎是否可以推断出它需要的东西。

作为一个兴趣点，您为什么决定选择“节点有许多父母和许多孩子”而不是“节点有邻居”？我最近构建了一个图形结构，并且发现字典或节点列表足以对方向进行建模。只需再次阅读原始问题 - 关系是否应该存储在拓扑中？这会更有意义，而且这似乎就是您试图用原始扩展方法做的事情。

如果关系驻留在拓扑中，那么我会采用发布的其他答案：

public static bool AddRelationship<T,R>(this ITopology<T> top, INode<T> parent, INode<T> child ) where R : IRelationship, new
{
    IRelationship<T> rel = new R();
    rel.Parent = parent;
    rel.Child = child;
    top.Relationships.Add(rel);
}

并调用此：

ITopology<String> top = new TopologyImp<String>;
top.AddRelationship<RelationshipImp>(new NodeImp("parent"), new NodeImp("Child"));