Pasar el tipo de objeto actual a la llamada del constructor base

Question

¿Cómo tomo el Type de la clase heredada y lo paso al constructor base de la clase también heredado? Vea el ejemplo de código siguiente:

// VeryBaseClass is in an external assembly 
public abstract class VeryBaseClass 
{ 
    public VeryBaseClass(string className, MyObject myObject) 
    { 

    } 
} 

// BaseClass and InheritedClass are in my assembly 
public abstract class BaseClass : VeryBaseClass 
{ 
    public BaseClass(MyObject myObject) : 
     base(this.GetType().Name, myObject) // can't reference "this" (Type expected) 
    { 

    } 
} 

public class InheritedClass : BaseClass 
{ 
    public InheritedClass(MyObject myObject) 
    { 

    } 
} 

La línea base(typeof(this).Name, myObject) no funciona porque no puedo hacer referencia a this sin embargo, ya que el objeto no ha terminado de construir y por lo tanto no existe.

¿Es posible tomar el Type del objeto que está construyendo actualmente?

EDIT:

Corregido la muestra como orsogufo suggested, pero aún así no funciona, como this no está definido.

EDIT 2:

Solo para aclarar, quiero terminar con "InheritedClass" que se pasa en el VeryBaseClass(string className, MyObject myObject) constructor.

Answer 1

Ah Hah! Encontré una solución. Puede hacerlo con genéricos:

public abstract class VeryBaseClass 
{ 
    public VeryBaseClass(string className, MyObject myObject) 
    { 
     this.ClassName = className; 
    } 

    public string ClassName{ get; set; } 
} 
public abstract class BaseClass<T> : VeryBaseClass 
{ 
    public BaseClass(MyObject myObject) 
     : base(typeof(T).Name, myObject) 
    { 
    } 
} 

public class InheritedClass : BaseClass<InheritedClass> 
{ 
    public InheritedClass(MyObject myObject) 
     : base(myObject) 
    { 

    } 
} 

Answer 2

¿GetType(). El nombre no funciona?

Answer 3

Una posible solución:

class VeryBase { 
    public VeryBase(string name) { 
     Console.WriteLine(name); 
    } 
} 

class Base<T> : VeryBase where T : Base<T> { 
    protected Base() 
     : base(typeof(T).Name) { 
    } 
} 

class Derived : Base<Derived> { 
    public Derived() { 
    } 
} 

class Program { 
    public static void Main(params string[] args) { 
     Derived d = new Derived(); 
    } 
} 

Answer 4

que he tenido exactamente el mismo dolor antes de ahora en el Google Wave Robot .NET API donde quería hacer pasar el constructor en algunos valores basados ​​en atributos. Puede echar un vistazo a mi solución en el código para derived type y base type. Básicamente pasé un delegado al constructor base, y luego llamé a ese delegado que pasaba "esto" al delegado. Por lo que en su caso se tendría:

public VeryBaseClass(Func<VeryBaseClass, string> classNameProvider) 
{ 
    this.name = classNameProvider(this); 
} 

y

public BaseClass() : base(FindClassName) 
{ 
} 

private static string FindClassName(VeryBaseClass @this) 
{ 
    return @this.GetType().Name; 
} 

Es muy feo, pero funciona.

EDITAR: Este enfoque solo funciona si puede cambiar el constructor de su clase base como se muestra; si no puedo, no estoy seguro de que es realmente factible en absoluto :(

Answer 5

Sin embargo, otra opción ...

// VeryBaseClass is in an external assembly 
public abstract class VeryBaseClass 
{ 
    public VeryBaseClass(string className) 
    { 
     Console.WriteLine(className); 
    } 
} 

// BaseClass and InheritedClass are in my assembly 
public abstract class BaseClass : VeryBaseClass 
{ 
    public BaseClass(string className) 
     : 
     base(className) 
    { 

    } 
} 

public class InheritedClass : BaseClass 
{ 
    public InheritedClass() 
     : base(typeof(InheritedClass).Name) 
    { 
    } 
} 

Answer 6

Si la capacidad de determinar el tipo de la clase heredada en tiempo de ejecución es más importante que rendimiento que puede echar un vistazo a la StackTrace para ver donde el constructor está siendo llamado desde es posible que tenga que codificar en más supuestos cuando se llama a GetInheritedClassName en este ejemplo:.

public abstract class BaseClass : VeryBaseClass 
{ 
    private static string GetInheritedClassName 
    { 
     get 
     { 
      // Get the current Stack 
      StackTrace currentStack = new StackTrace(); 
      MethodBase method = currentStack.GetFrame(1).GetMethod(); 

      // 1st frame should be the constructor calling 
      if (method.Name != ".ctor") 
       return null; 

      method = currentStack.GetFrame(2).GetMethod(); 

      // 2nd frame should be the constructor of the inherited class 
      if (method.Name != ".ctor") 
       return null; 

      // return the type of the inherited class 
      return method.ReflectedType.Name; 
     } 
    } 

    public BaseClass(MyObject myObject) : 
     base(GetInheritedClassName, myObject) 
    { 

    } 
} 

no puedo pensar en una gran manera de forma dinámica obtener el nombre de la clase heredada sin implicaciones de rendimiento. Me dan cuenta es lo que quería evitar, pero si necesitaba para llamar a una asamblea del partido tercero de estos requisitos que acaba de requerir cada clase para especificar su propio tipo:

public abstract class BaseClass : VeryBaseClass 
{ 
    public BaseClass(string className, MyObject myObject) : 
     base(className, myObject) 
    { 

    } 
} 

public class InheritedClass : BaseClass 
{ 
    public InheritedClass(MyObject myObject) : base("InheritedClass", myObject) 
    { 

    } 
}