如何在C#中继承WPF控件并同时使用泛型类？

它从一个泛型类开始，然后我从那个类继承。现在我有了一个节点，它将在稍后的阶段直观地表示出来。我当时的计划是从Thumb控件继承，以允许我的节点支持拖动，但现在的问题是C#中不支持多重继承。因此，在这一点上，我唯一的选择似乎是放弃我的代码并从Thumb继承基类（我不喜欢这样做，因为我的计划是让某些节点类不支持Thumb类中的功能）。我没有办法使用我的泛型类，同时从Thumb类（WPF）继承功能吗？如果能够继承节点以创建更专门的类，这些类还可以支持来自WPF控件（如Thumb）的功能，那将是非常好的

public class BaseNode<T> where T : BaseNode<T>
{
    private T _item;
    private T _parent;
    private List<BaseNode<T>> _children;

    public T Item
    {
        get { return _item; }
        set { _item = value; }
    }

    public BaseNode(T item)
    {
        _item = item;
    }
    public void SetParent(T parent)
    {
        _parent.Item = parent;
    }
    public void AddChild(T child)
    {
        _children.Add(new BaseNode<T>(child));
    }
    public void RemoveChild(T child)
    {
        var node = _children.FirstOrDefault(e => e.Item.Equals(child));
        if (node != null)
            _children.Remove(node);
    }
}

public class Node : BaseNode<Node>
{
    private Node _item;
    private List<NodeElement> NodeElements;

    Node (Node item) : base(item)
    {
        _item = item;
    }

    public void ResetElements()
    {
        NodeElements.ForEach(e => e.ResetState());
    }

    public void AddElement(NodeElement element)
    {
        NodeElements.Add(element);
    }

    public void RemoveElement(NodeElement element)
    {
        var elem = NodeElements.FirstOrDefault(e => e.Equals(element));
        if (elem != null)
            NodeElements.Remove(elem);
    }
}

公共类BaseNode，其中T:BaseNode
{
私人信托基金项目；
私人T_父母；
私人名单——儿童；
公共交通项目
{
获取{return\u item；}
设置{u item=value；}
}
公共基本节点（T项）
{
_项目=项目；
}
公共void SetParent（T parent）
{
_父项。项=父项；
}
公共无效添加子对象（T子对象）
{
_添加（新的BaseNode（child））；
}
公共无效删除child（T child）
{
var节点=_children.FirstOrDefault（e=>e.Item.Equals（child））；
如果（节点！=null）
_移除（节点）；
}
}
公共类节点：BaseNode
{
专用节点_项；
私有列表节点元素；
节点（节点项）：基础（项）
{
_项目=项目；
}
公共元素（）
{
ForEach（e=>e.ResetState（））；
}
公共无效添加元素（NodeElement元素）
{
添加（元素）；
}
公共void RemoveElement（NodeElement元素）
{
var elem=NodeElements.FirstOrDefault（e=>e.Equals（element））；
if（elem！=null）
删除节点元素（elem）；
}
}

如果要创建自定义

Thumb

类，则应从

Thumb

继承。然后可以使用组合使用泛型类。大概是这样的：

public interface INode<T>
{
    T Item { get; set; }
    void SetParent(T parent);
    void AddChild(T child);
    void RemoveChild(T child);
}

public class BaseNode<T> where T : INode<T>
{
    private T _item;
    private T _parent;
    private List<BaseNode<T>> _children;

    public T Item
    {
        get { return _item; }
        set { _item = value; }
    }

    public BaseNode(T item)
    {
        _item = item;
    }
    public void SetParent(T parent)
    {
        _parent.Item = parent;
    }
    public void AddChild(T child)
    {
        _children.Add(new BaseNode<T>(child));
    }
    public void RemoveChild(T child)
    {
        var node = _children.FirstOrDefault(e => e.Item.Equals(child));
        if (node != null)
            _children.Remove(node);
    }
}

public class Node : Thumb, INode<Node>
{
    private Node _item;
    private List<NodeElement> NodeElements;
    private readonly BaseNode<Node> _base;

    public Node()
    {
        _base = new BaseNode<Node>(this);
    }

    public void ResetElements()
    {
        NodeElements.ForEach(e => e.ResetState());
    }

    public void AddElement(NodeElement element)
    {
        NodeElements.Add(element);
    }

    public void RemoveElement(NodeElement element)
    {
        var elem = NodeElements.FirstOrDefault(e => e.Equals(element));
        if (elem != null)
            NodeElements.Remove(elem);
    }

    public Node Item
    {
        get { return _base.Item; }
        set { _base.Item = value; }
    }

    public void SetParent(Node parent)
    {
        _base.SetParent(parent);
    }
    public void AddChild(Node child)
    {
        _base.AddChild(child);
    }
    public void RemoveChild(Node child)
    {
        _base.RemoveChild(child);
    }
}

公共接口INode
{
T项{get；set；}
void SetParent（T parent）；
void-AddChild（T-child）；
无效删除child（T child）；
}
公共类基类节点，其中T:INode
{
私人信托基金项目；
私人T_父母；
私人名单——儿童；
公共交通项目
{
获取{return\u item；}
设置{u item=value；}
}
公共基本节点（T项）
{
_项目=项目；
}
公共void SetParent（T parent）
{
_父项。项=父项；
}
公共无效添加子对象（T子对象）
{
_添加（新的BaseNode（child））；
}
公共无效删除child（T child）
{
var节点=_children.FirstOrDefault（e=>e.Item.Equals（child））；
如果（节点！=null）
_移除（节点）；
}
}
公共类节点：Thumb，INode
{
专用节点_项；
私有列表节点元素；
专用只读BaseNode_base；
公共节点（）
{
_base=新的BaseNode（此节点）；
}
公共元素（）
{
ForEach（e=>e.ResetState（））；
}
公共无效添加元素（NodeElement元素）
{
添加（元素）；
}
公共void RemoveElement（NodeElement元素）
{
var elem=NodeElements.FirstOrDefault（e=>e.Equals（element））；
if（elem！=null）
删除节点元素（elem）；
}
公共节点项
{
获取{return\u base.Item；}
设置{u base.Item=value；}
}
公共void SetParent（节点父节点）
{
_base.SetParent（parent）；
}
公共void AddChild（节点子节点）
{
_base.AddChild（child）；
}
public void RemoveChild（节点子节点）
{
_基部。RemoveChild（儿童）；
}
}

---

包括自定义控件在内的所有节点都实现

INode

接口。

谢谢。这是一个非常好的答案。我以前从未被介绍过构图的概念。