Common and Non-Common Interface - List T

I have the following interface representing a hierarchical data structure, so the name is IHierachicalItem

public interface IHierachicalItem
{
    IHierachicalItem Parent { get; set; }
    IList<IHierachicalItem> Children { get; set; }
}

      

        
        
        
      

    

Now I have several classes that inherit from this interface:

public class HierachicalItemA : IHierachicalItem
{
    public IHierachicalItem Parent { get; set; }
    public IList<IHierachicalItem> Children { get; set; }
}

public class HierachicalItemB : IHierachicalItem
{
    public IHierachicalItem Parent { get; set; }
    public IList<IHierachicalItem> Children { get; set; }
}

public class HierachicalItemC : IHierachicalItem
{
    public IHierachicalItem Parent { get; set; }
    public IList<IHierachicalItem> Children { get; set; }
}

      

        
        
        
      

    

I wanted to extend the interface so that classes will return when accessing the parent and children property of the same class instead of the interface. So I thought about using a generic interface:

public interface IHierachicalItem<T> : IHierachicalItem
{
    new T Parent { get; set; }
    new IList<T> Children { get; set; }
}

      

        
        
        
      

    

Now I am facing the problem that I only want one instance of Children and not call something like .OfType.ToList (). How can I achieve this?

public class HierachicalItemB : IHierachicalItem<HierachicalItemB>
{
    IHierachicalItem IHierachicalItem.Parent { get { return this.Parent as IHierachicalItem; } set { this.Parent = (HierachicalItemB)value; } }
    IList<IHierachicalItem> IHierachicalItem.Children { get { return this.Children.OfType<IHierachicalItem>().ToList(); } set { this.Children = value.OfType<HierachicalItemB>().ToList(); } }

    public HierachicalItemB Parent { get; set; }
    public IList<HierachicalItemB> Children { get; set; }
}

      

        
        
        
      

    

I could also use .Cast <> instead of .OfType <> but that doesn't change the fact that I would have to call .ToList (), or if the interface says the ObersavbleCollection will initialize a new ObservableCollection over and over again, any ideas?