herencia genérica en C#?

Question

Duplicar posible:
Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates?

que puedo hacer

public class MyGenericClass : DL 
//but i cannot do 
public class MyGenericClass <T> : T 

¿Cómo haría el segundo? si no puedo hacer eso, ¿cómo puedo hacer algo como

public class MyGenericClass <T> 
{ 
    T obj; 
    //have all MyGenericClass.XYZ call obj.XYZ 
} 

Answer 1

Esto no es posible, ya que dependiendo de qué tipo es T, la interfaz pública de MyGenericClass cambiaría.

Si usted tiene un montón de diferentes clases que todos exponen la misma interfaz, se puede declarar MyGenericClass para exponer esa interfaz, y en la ejecución de todas las funciones delegar las llamadas a obj

Answer 2

usted podría hacer algo como

public interface IXyzable { void xyz(); } 

public class MyGenericClass<T> : IXyzable where T : IXyzable { 
    T obj; 
    public void xyz() { 
     obj.xyz(); 
    } 
} 

Editar: Ahora entiendo la pregunta

Answer 3

que necesitará todo de poner en práctica alguna de las interfaces para que sepa que obj.XYZ() tiene sentido su posible T, entonces usted puede hacer

public interface Ixyz 
{ 
    void XYZ(); 
} 

public class MyGenericClass<T> : Ixyz where T:Ixyz, new() 
{ 
    T obj; 

    public MyGenericClass() 
    { 
     obj = new T(); 
    } 

    public void XYZ() 
    { 
     obj.XYZ(); 
    } 
} 

he hecho MyGenericClass implementan IXYZ demasiado ya que, obviamente, sí expone el método correcto, pero tal vez eso es mejor dejar a cabo, ya que permite

var x = new MyGenericClass<MyGenericClass<SomeClass>>(); 

que es poco probable que sea siempre una buena idea.

Answer 4

Esto es más o menos pato-tipado, pero podrías usar el reflejo. Cuando crea la clase genérica con una referencia al obj, use la reflexión para intentar encontrar un método con la firma correcta. Mientras almacene una referencia al método, el rendimiento no será tan malo.

class BaseGeneric<T> 
{ 
    private T obj; 
    private MethodInfo mi; 
    private const string MethodNameOfInterest = "Xyz"; 

    public BaseGeneric(T theObject) 
    { 
     this.obj = theObject; 
     Type t = obj.GetType(); 
     mi = t.GetMethod(MethodNameOfInterest); 
    } 

    public void Xyz() 
    { 
     mi.Invoke(obj, null); 
    } 
} 

Por supuesto, sería necesario añadir mucho más por la comprobación de errores y tal, pero esa es la esencia de lo que se podía hacer. Además, no olvide agregar el espacio de nombres System.Reflection a su cláusula de uso.

Answer 5

El sistema de tipo .NET no permitirá declaraciones de tipo del formulario que está intentando. Una razón por la cual esto no se permite debe ser intuitiva: ¿cómo actuaría MyGenericClass<T> cuando T es una clase sellada (por ejemplo, System.String)?

Si realmente necesita esta funcionalidad (y sabe que el tipo T que va a utilizar no está sellado), puede generar proxies en tiempo de ejecución utilizando las clases en el espacio de nombres Reflection.Emit. También puede ser posible lograr este efecto utilizando herramientas de AOP como PostSharp.

Answer 6

La pregunta específica, por qué no se puede hacer esto:

public class MyGenericClass<T> : T 

Y usted puede hacer esto:

public class MyGenericClass<T> 
{ 
    T obj; 
} 

La razón es que el CLR le gusta ser capaz de compilar una sola versión del código para MyGenericClass que funcionará para cualquier tipo de referencia especificado para T.

Puede hacer esto para el segundo caso, porque puede reemplazar silenciosamente T con object e inserte los moldes apropiados, más o menos equivalente a:

public class MyGenericClass 
{ 
    object obj; 
} 

Pero para la versión de la herencia, ese truco no funciona.

Además, muchas instalaciones útiles serían imposibles de describir a través de las limitaciones de la interfaz. Cuando hereda de un tipo, puede hacer mucho más que solo llamar a métodos; también puede anularlos. Considere este ejemplo hipotético:

class MyBase 
{ 
    public virtual void MyVirtual() { } 
} 

class MyGenericDerived<T> : T 
{ 
    public override void MyVirtual() 
    { 
     Console.WriteLine("Overridden!"); 
    } 
} 

MyBase obj = new MyGenericDerived<MyBase>(); 
obj.MyVirtual(); 

Lo que yo quiero hacer hay algo así como una "mezcla en-", donde MyGenericDerived suministra las definiciones de las funciones virtuales en cualquier base de que se aplica a. Pero, ¿cómo sabe el compilador que T tendrá un método llamado MyVirtual que se puede anular? Tendría que poner una restricción en T. ¿Cómo podría expresar eso a través de las interfaces? Es imposible. El uso de interfaces para describir restricciones no es una solución adecuada una vez que permite la herencia de los parámetros de tipo. Esa es otra razón por la cual no existe en el lenguaje de hoy.

Answer 7

Qué tal esto:

class BaseClass<T> 
{ 
    public T property { get; set; } 
} 

class GenericClass<T> : BaseClass<T> 
{ 

} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     GenericClass<int> l = new GenericClass<int>(); 
     l.property = 10; 
    } 
} 

Con ello se consigue lo que quiere hacer?