public interface IWorkContext {
    T Node<T>() where T : class, IHierachy<T>;
    IHierachyItem Node();
}

public interface IHierachyItem {
    int Id { get; set; }
    string Title { get; set; }
}

public interface IHierachy<T> : IHierachyItem where T : IHierachy<T> {
    T Parent { get; set; }
    IList<T> Children { get; set; }
}

public class WorkContext {
    public static IWorkContext Current {
        get { return DependencyResolver.Current.GetService<IWorkContext>(); }
    }
}

public class DefaultWorkContext : IWorkContext {
    // Nhibernate session
    private readonly ISession _session;

    public DefaultWorkContext(ISession session) {
        _session = session;
    }

    public T Node<T>() where T : class, IHierachy<T> {
        return _session.Get<T>(2);
    }

    public IHierachyItem Node() {
        return Node<SiteMapNode>();
    }
}

public class SiteMapNode : IHierachy<SiteMapNode> {
    public virtual int Id { get; set; }
    public virtual SiteMapNode Parent { get; set; }
    public virtual string Title { get; set; }
    public virtual IList<SiteMapNode> Children { get; set; }

    public SiteMapNode() {
        Children = new List<SiteMapNode>();
    }
}

var node = WorkContext.Current.Node();
var parentNode = ((IHierachy<SiteMapNode>)node).Parent;

var node2 = WorkContext.Current.Node<SiteMapNode>();
var parentNode2 = node2.Parent;

public inetrface IHierarchy : IHierarchyItem
{
    IHierarchy Parent { get; set; }
    IList<IHierarchy> Children { get; set; }
}

public interface IHierarchy<T> : IHierarchy // Implies IHierarchyItem
    where T : IHierarchy<T>
{ ... } // As you had it.

public SiteMapNode : IHierarchy<SiteMapNode> // Implies IHierarchy
{
    private SiteMapNode _Parent;
    private IList<SiteMapNode> _Children;

    // Implicit implement of IHierarchyItem and members of SiteMapNode itself.
    int Id { get; set; }
    string Title { get; set; }

    // Implicit implementation of IHierarchy<SiteMapNode> members
    // These are also members of SiteMapNode itself.

    SiteMapNode Parent
    {
        get { return _Parent; }
        set { _Parent = value; }
    }

    IList<SiteMapNode> Children
    {
        get return _Children;
        set _Children = value;
    }

    // Explicit implementation of IHierarchy members
    // The interface prefix is required to distinguish these from the
    // type-specific members above to declare different return types.

    IHierarchy IHierarchy.Parent
    {
        get { return _Parent; } // Might need (IHierarchy) cast
        set { Parent = (SiteMapNode)value; }
    }

    IList<IHierarchy> IHierarchy.Children
    {
        get { return _Children; } // Might need (IList<IHierarchy>) cast
        set { _Children = (IList<SiteMapNode>)value; }
    }
}