Question

In C#, is it possible to write something like this:

public class MyClass<T> : T 
    where T : class, new() 
{
}

I know that the above implementation does not compile, but what I am actually trying to achive is implementing some kind of generic wrapper to an unknown type, so that an client can call the wrapper just as he would call the type, provided by the parameter T, instead of calling it using something like wrapper.Instance.SomeMember().

Thanks in advance!

Answer 1

This isn’t possible.

In my opinion, I don’t think that a wrapper should be implemented using inheritance.

For example, let’s say we’ve an Engine class and you need to implement a FerrariEngine. And you have a Car class.

You’re saying that Car should inherit FerrariEngine. It looks terrible for me!

At the end of the day, you’re looking to do something like dependency injection using inheritance and, again, this isn’t the right path.

My suggestion is don’t try to make your life easier: decide an architecture based on rational points.

UPDATE

The OP said in some comment:

I want to make this class to manage instances of objects of type T, so
that the client does not need to take care of when the instances need
to be created.

You don’t need to make strange things to get what you want:

public interface IEngine 
{
     void Start();
}

public sealed class FerrariEngine : IEngine
{
     public FerrariEngine()
     {
          Start();
     }

     public void Start()
     {
     }
}

public abstract class Car<TEngine> where TEngine: IEngine, new()
{
    public Car()
    {
        _engine = new Lazy<TEngine>(() => new TEngine());
    }

    private readonly Lazy<TEngine> _engine;

    public TEngine Engine
    {
        get { return _engine.Value; }
    }
}

public class FerrariCar : Car<FerrariEngine>
{
}

Finally, if we create an instance of FerrariCar:

Car<FerrariEngine> myFerrari = new FerrariCar();

The engine will be instantiated and started, without developer intervention!

Check how Lazy<T> and basic generic constraints make the job 😉

In summary:

• Using Lazy<T> the engine will be instantiated only when some access the Engine property.
• Once the lazy-loaded engine is instantiated, since FerrariEngine implements a parameterless constructor calling Start() itself, it will start the engine.

I believe that this sample illustrates you how you can get what you’re looking for and using C# “as is”!