Generics: Is this improper use?

Question

I have a class library in which I'm using generics as below. I'm not sure if it's an improper use or not. So aside from the fact that it works and everything "depends", id like some specific critique on how this usage might fall apart. In particular In wondering about the shadowing of non generic properties with generic counterparts. Is this an accepted practice?

 public interface IPickOrder
    {
        IPickOrderHeader Header { get; }

        ERPListBase<IPickOrderLine> Lines { get; }
    }



 public interface IPickOrder<TPickOrderHeader, TPickOrderLine> : IPickOrder
        where TPickOrderHeader : class, IPickOrderHeader
        where TPickOrderLine : class, IPickOrderLine
    {
        new TPickOrderHeader Header { get; }

       new ERPListBase<TPickOrderLine> Lines { get; }
    }




 public class PickOrder : IPickOrder
    {
        public IPickOrderHeader Header { get; protected set; }

        public ERPListBase<IPickOrderLine> Lines { get; protected set; }

        public PickOrder() { }
    }



   public class PickOrder<TPickOrderHeader, TPickOrderLine> : PickOrder, IPickOrder<TPickOrderHeader, TPickOrderLine>
        where TPickOrderHeader : class, IPickOrderHeader, new()
        where TPickOrderLine : class, IPickOrderLine, new()
    {
        public new TPickOrderHeader Header
        {
            get { return base.Header as TPickOrderHeader; }
            protected set { base.Header = value; }
        }

        public new ERPListBase<TPickOrderLine> Lines { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        public PickOrder() : base() { }
    } 

Answer 1

I feel you on the "My reasons are more due to preference than need." comment but the inheritance from PickOrder and public new ERPListBase<TPickOrderLine> Lines { get; protected set; } will confuse somebody best case and really mess things up worst case. While it may still give you that feeling of impending doom here are some suggestions to make this safer while keeping the look and feel you prefer.

Consider implementing the property like so (also for Header)

public new ERPListBase<TPickOrderLine> Lines {
    get {
        // note that you can't control base.Lines so some values may not be of TPickOrderLine
        return new ERPListBase<TPickOrderLine>(base.Lines.OfType<TPickOrderLine>());
    }
    protected set { base.Lines = new new ERPListBase<IPickOrderLine>(value.Cast<IPickOrderLine>()); }
}

Consider not reusing the base class and using explicit interface implementation:

public class PickOrder<TPickOrderHeader, TPickOrderLine> :
    IPickOrder<TPickOrderHeader, TPickOrderLine>
    where TPickOrderHeader : class, IPickOrderHeader, new()
    where TPickOrderLine : class, IPickOrderLine, new()
{
    public TPickOrderHeader Header { get; protected set; }

    IPickOrderHeader IPickOrder.Header { get { return Header; } }

    public ERPListBase<TPickOrderLine> Lines { get; protected set; }

    ERPListBase<IPickOrderLine> IPickOrder.Lines { get { return new ERPListBase<IPickOrderLine>(Lines.Cast<IPickOrderLine>()); } }
}

Whatever you do, avoid storing the same data twice as you may be doing (depending on use) in your current code.