Clase abstracta que hereda el tipo más derivado

Question

Lamentablemente, no puedo encontrar el proyecto original que me llevó a esta pregunta. Eso quizás le hubiera dado a esta pregunta un poco más de contexto.

EDIT: me encontré con el proyecto original que he visto esto en: http://mews.codeplex.com/SourceControl/changeset/view/63120#1054567 con una aplicación concreta en: http://mews.codeplex.com/SourceControl/changeset/view/63120#1054606

Digamos que tengo una clase abstracta con una aplicación concreta que hace algo útil como:

abstract class AbstractClass 
{ 
    public virtual int ConvertNumber(string number) 
    { 
     string preparedNumber = Prepare(number); 
     int result = StringToInt32(number); 
     return result; 
    } 

    protected abstract string Prepare(string number); 

    protected virtual int StringToInt32(string number) 
    { 
     return Convert.ToInt32(number); 
    } 
} 

sealed class ConcreteClass : AbstractClass 
{ 
    protected override string Prepare(string number) 
    { 
     return number.Trim(); 
    } 

    public override int ConvertNumber(string number) 
    { 
     return base.ConvertNumber(number); 
    } 
} 

Esto es tan básico como se puede. Ahora en el código que he visto en la web del autor implementado inheritence heredando la clase abstracta de la forma más derivada, por ejemplo:

abstract class AbstractGenericClass<TGenericClass> 
    where TGenericClass : AbstractGenericClass<TGenericClass> 
{ 
    public virtual int ConvertNumber(string number) 
    { 
     string preparedNumber = Prepare(number); 
     int result = StringToInt32(number); 
     return result; 
    } 

    protected abstract string Prepare(string number); 

    protected int StringToInt32(string number) 
    { 
     return Convert.ToInt32(number); 
    } 
} 

sealed class ConcreteGenericClass : AbstractGenericClass<ConcreteGenericClass> 
{ 
    protected override string Prepare(string number) 
    { 
     return number.Trim(); 
    } 

    public override int ConvertNumber(string number) 
    { 
     return base.ConvertNumber(number); 
    } 
} 

Ahora ¿por qué uno hacer tal cosa? Recuerdo muy vagamente que esta era una técnica muy usada en ATL por razones de rendimiento (¿alguna forma de llamar implementaciones concretas de miembros sin trabajar con un vtable?). No estoy muy seguro de esta parte.

He comprobado el IL generado para ambos casos y son exactamente iguales.

¿Quién me puede explicar esto?

Answer 1

Esa es una versión C# de lo que se llama el Patrón de Plantilla Curiosamente Recurrente en C++. Es un poco extraño, y personalmente, trato de evitarlo. Es útil, pero me resulta más confuso que útil.

Véase mi artículo para más detalles:

http://blogs.msdn.com/b/ericlippert/archive/2011/02/03/curiouser-and-curiouser.aspx