Как я могу ограничить дочерние узлы узлов в древовидной структуре

Может что-то вроде

public abstract class AbstractNode<T> //where T : AbstractNode
{

  public abstract NodeCollection<T> ChildNodes
  {
    get;
    set;
  }
}

возможно работа? Просто не уверен в закомментированной части

EDIT: Это очень плохо внутри, но компилируется...

  public abstract class BaseNode
  {
  }

  public abstract class AbstractNode<T> : BaseNode where T : BaseNode
  {
    public abstract NodeCollection<T> ChildNodes
    {
      get;
      set;
    }
  }

  public class ConcreteNodeA : AbstractNode<ConcreteNodeA>
  {
    public void Special() { }

    public override NodeCollection<ConcreteNodeA> ChildNodes
    {
      get;
      set;
    }
  }

  public class ConcreteNodeB : AbstractNode<ConcreteNodeA>
  {
    public void DoSomething()
    {
      ChildNodes[0].ChildNodes[0].ChildNodes[0].Special();
    }

    public override NodeCollection<ConcreteNodeA> ChildNodes
    {
      get;
      set;
    }
  }

  public class NodeCollection<T> : BindingList<T>
  {
    //add extra events here that notify what nodes were added, removed, or changed
  }

К сожалению нет. Вы должны выбрать; вы хотите, чтобы свойство Children ConcreteNode было NodeCollection<AbstractNode> или NodeCollection<ConcreteNode>?

Проблема возникает, когда вы думаете о добавлении узла в свою коллекцию; что, если у вас есть ConcreteNodeA, который вы превратили в AbstractNode. Затем вы пытаетесь позвонить

concreteA_As_Abstract.Add(concreteB);

NodeCollection должен разрешать добавление; NodeCollection не будет. Таким образом, вы должны сделать выбор.

Новые функции ковариантности/контравариантности C#4 могут вам помочь (дополнительную информацию см. в блоге Эрика Липперта), но их не будет до VS2010.

Это напоминает мне кое-что, с чем я играл, и я добавлю сюда код, предлагающий вам принять его с «зерном соли»: я еще не полностью протестировал его, и для меня есть некоторые очень странные кое-что об этом коде (ищите комментарии "// странно :"). Это было сделано в бета-версии 2 VS Studio 2010, скомпилированной для FrameWork 4.0.

using System;
using System.Collections.Generic;
using System.Linq;

// WARNING : EXPERIMENTAL CODE : DO NOT USE FOR ANYTHING BUT EDUCATIONAL PURPOSES

// comments about how crazy the code is : are welcome :)

namespace stronglyTypedTree
{
    // TreeNodes is a strongly typed List of strongly typed Nodes
    public class TreeNodes<T> : List<Node<T>>
    {
        // weird : sometimes the compiler informs me that new is
        // required, if i have not used new, and sometimes it informs
        // me, when I have added new, that new is not required
        public new void Add(Node<T> newNode)
        {
            Console.WriteLine("Add called in TreeNodes class : Type = " + typeof(T).ToString() + " : Node Key = " + newNode.Key.ToString());
            newNode.Parent = this;
            base.Add(newNode);
        }
    }

    // strongly typed Node
    public class Node<T>
    {
        // note : implement a key/value pair
        // instead of this ?
        internal T _key;

        // experimental : have not fully considered
        // the case of root nodes

        // better to make this a property ?
        public TreeNodes<T> Parent;

        // better to make this a property ?
        public TreeNodes<T> Nodes;

        public Node()
        {
            Nodes = new TreeNodes<T>();
        }

        // weird : calling base() here does NOT seem to call the
        // parameterless ctor above : the Nodes collection is, thus, 
        // not instantiated : will cause errors at run-time !
        public Node(T keyValue) : base()
        {
            _key = keyValue;
            // had to insert this : see note above
            Nodes = new TreeNodes<T>();
        }

        public T Key
        {
            get { return _key; }
            set { _key = value; }
        }
    }

    public class Tree<T>
    {
        public TreeNodes<T> Nodes;

        public string Name;

        public Tree()
        {
            Nodes = new TreeNodes<T>();
        }

        // weird : see note on ctor with one parameter
        // in the Node class above
        public Tree(string treeName) : base()
        {
            Name = treeName;
            // had to insert this : see note above
            Nodes = new TreeNodes<T>();
        }
    }

    // define some strongly typed Node classes

    // weird : i thought i could get away with not defining explicit ctors :
    // that ctor's of the Node class would be automatically invoked
    public class intNode : Node<int>
    {
        public intNode() : base() { }

        public intNode(int keyValue) : base(keyValue) { }
    }

    public class strNode : Node<string>
    {
        public strNode() : base() { }

        public strNode(string keyValue) : base(keyValue) { }
    }
}

Некоторые примеры тестовых вызовов:

    intNode myIntNode1 = new intNode();
    myIntNode1.Key = 100;
    intNode myIntNode2 = new intNode(777);

    strNode myStrNode1 = new strNode();
    myStrNode1.Key = "hello";
    strNode myStrNode2 = new strNode("string node 2");

    Tree<int> intTree = new Tree<int>();
    intTree.Name = "Tree of Integer";

    Tree<string> strTree = new Tree<string>("Tree of String");

    intTree.Nodes.Add(myIntNode1);
    intTree.Nodes.Add(myIntNode2);

    strTree.Nodes.Add(myStrNode1);
    strTree.Nodes.Add(myStrNode2);

    myIntNode1.Nodes.Add(new intNode(999));
    myStrNode2.Nodes.Add(new strNode("subNode of strNode2"));

    Console.WriteLine(intTree.Nodes.Count);

    Console.WriteLine(intTree.Nodes[0]);

    Console.WriteLine(strTree.Nodes.Count);

    Console.WriteLine(strTree.Nodes[1]);

лучший, Билл

Это то, что вы хотите:

namespace Foo 
{   
    public interface INode
    {
        string Speak();
    }

    public abstract class AbstractRoot<T> where T : INode
    {
        public abstract IList<T> Children { get; set; }
    }

    public class GammaChild : INode
    {
        public string Speak() { return "I am GammaNode."; }
    }

    public class BetaChild : AbstractRoot<BetaChild>, INode
    {
        public string Speak() { return "I am BetaNode."; }
        public string BetaSpeak() { return "I am talking Beta-specific things."; }

        private IList<BetaChild> children;
        public override IList<BetaChild> Children { get { return children; } set { children = value; } }
    }

    public class AlphaRoot<T> : AbstractRoot<T>, INode where T : BetaChild
    {
        public string Speak() { return "I am AlphaRoot."; }

        private IList<T> children;
        public override IList<T> Children { get { return children; } set { children = value; } }
    }

    public class Test
    {
        public void Run()
        {
            AlphaRoot<BetaChild> alphaBetaTree = new AlphaRoot<BetaChild>();
            alphaBetaTree.Children.Add(new BetaChild());

            alphaBetaTree.Children[0].BetaSpeak();

            AlphaRoot<GammaChild> alphaGammaTree = new AlphaRoot<GammaChild>();
            alphaGammaTree.Children.Add(new GammaChild());
        }
    }
}

И, как и ожидалось, ошибка компиляции при попытке использовать дерево для GammaChild:

The type 'Foo.GammaChild' must be convertible to 'Foo.BetaChild' in order to use it as parameter 'T' in the generic type or method 'Foo.AlphaRoot<T>'