using System;

​

    public class Node

    {

        public T GetParent<T>() where T : BaseClass

        {

            return ((Node<T>)this).Parent;

        }

        static public Node<T> Create<T>(T innerClass) where T : BaseClass

        {

            return new Node<T>(innerClass);

        }

        static public T GetParent<T>(T child) where T: BaseClass

        {

            return child.ContainerNode.GetParent<T>();

        }

    }

    public class Node<T> : Node where T : BaseClass

    {

        public T Parent { get; set; }

        public T This { get; set; }

        public Node(T innerClass) 

        {

            this.This = innerClass;

            innerClass.ContainerNode = this;

        }

​

        public Node(T innerClass, T parent) 

        {

            this.This = innerClass;

            innerClass.ContainerNode = this;

            this.Parent = parent;

        }

        static public implicit operator T (Node<T> input)

        {

            return input.This;

        }

​

    }

    public abstract class BaseClass 

    {

        public Node ContainerNode { get; set; }

​

    }

    public class DerivedClass1 : BaseClass

    {

        protected DerivedClass1 Parent

        {

            get

            {

                return Node.GetParent(this);

            }

        }

    }

    public class DerivedClass2 : BaseClass

    {

    }

​

​

public class Program

{

​

​

    public static void Main()

    {

        var child1 = Node.Create(new DerivedClass1());

        var parent1 = Node.Create(new DerivedClass1());

        child1.Parent = parent1;

        DerivedClass1 implicitlyCast = child1;

        var child2 = Node.Create(new DerivedClass2());

        var parent2 = Node.Create(new DerivedClass1()); //Oops!

        child2.Parent = parent2;  //Does not compile

    }

}