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!
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.
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:
Lazy<T> the engine will be instantiated only when some access the Engine property.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"!
Car and Engine is not like a Car is an Eingine, it is more like a Car contains an Engine and you do need to know which eninge. That's why I am asking for 'something like'. I am not looking for a solution that is based on inheritance, I was just asking if it is possible at all, and if so, how. ;)
Stream to a StreamReader but have it remain useful after the StreamReader is done with it. At present, doing that requires either using boilerplate code to forward almost all members of the wrapper to corresponding members of the wrapped object, or else perhaps using something like Castle Dynamic Proxy; language support would seem more elegant (but doesn't as yet exist).
You could have a look at DynamicObject and do something like this:
class Foo<T> : DynamicObject
{
private T _instance;
public Foo(T instance)
{
_instance = instance;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
var member = typeof(T).GetProperty(binder.Name);
if (_instance != null &&
member.CanWrite &&
value.GetType() == member.PropertyType)
{
member.SetValue(_instance, value, null);
return true;
}
return false;
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
var member = typeof(T).GetProperty(binder.Name);
if (_instance != null &&
member.CanRead)
{
result = member.GetValue(_instance, null);
return true;
}
result = null;
return false;
}
}
class Bar
{
public int SomeProperty { get; set; }
}
class Program
{
static void Main(string[] args)
{
var bar = new Bar();
dynamic thing = new Foo<Bar>(bar);
thing.SomeProperty = 42;
Console.WriteLine(thing.SomeProperty);
Console.ReadLine();
}
}
class Foo { public string A; }you want to be able to do something likeMyClass<Foo>.A?MyClass<Foo>.Instance.Aout of curiosity?T, so that the client does not need to take care of when the instances need to be created. In an unmanaged world you would talk of something like an intelligent pointer. I think in C++ the behaviour I need can be achived by overloading thethis->operator, returning the contained instance.