In your question, you express the need for a "generic" wrapper type (note I use the term "generic" here independently of any language).

Well, I don't see any problem with that. And if you ask me how to do it with .NET, I would just design this, once for all types, going one step further from you:

interface IWrapper<T>
{
    T BaseObject { get; }
}

Then, a wrapper class would simply be:

class Bar<TFoo> : IWrapper<TFoo> where TFoo : Foo
{
    public TFoo BaseObject { get; private set; }
}

I could go further again and define the non generic one, because it's ofen desirable to have both, as it's sometimes hard to work with generic-only clases/interface with meta/reflection code (but this is really optional):

interface IWrapper
{
    object BaseObject { get; }
}

If you do this, it could be natural to have IWrapper<T> derive from IWrapper, like this:

interface IWrapper<T> : IWrapper
{
    new T BaseObject { get; }
}

And the class would be this:

class Bar<TFoo> : IWrapper<TFoo> where TFoo : Foo
{
    public TFoo BaseObject { get; private set; }

    object IWrapper.BaseObject => BaseObject;
}

PS: as a side note, you can have a look at WCF's ServiceModel ChannelFactory<T> class that has a combined generic/non generic hierarchy somewhat relevant with your question.