Passare il tipo di oggetto corrente nella chiamata del costruttore di base

Question

Come posso prendere il Type della classe ereditata e passarlo nel costruttore di base della classe anche ereditato? Vedere il codice di esempio:

// 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 linea base(typeof(this).Name, myObject) non funziona perché non posso ancora riferimento this, come l'oggetto non è terminata la costruzione e pertanto non esiste.

È possibile afferrare lo Type dell'oggetto attualmente in costruzione?

EDIT:

Corretto il campione come orsogufo suggested, ma ancora non funziona, come this è indefinito.

EDIT 2:

tanto per chiarire, voglio finire con "InheritedClass" essere passato al costruttore VeryBaseClass(string className, MyObject myObject).

Answer 1

Ah Ah! Ho trovato una soluzione. Puoi farlo con i generici:

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

Does GetType(). Nome non funziona?

Answer 3

Una possibile soluzione:

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

Ho avuto esattamente lo stesso dolore prima ora nella Google Wave Robot .NET API dove volevo far passare il costruttore in alcuni valori in base agli attributi. Puoi dare un'occhiata alla mia soluzione nel codice per lo derived type e lo base type. Fondamentalmente passo un delegato al costruttore di base e poi chiama quel delegato che passa "questo" al delegato. Quindi nel tuo caso si avrebbe:

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

e

public BaseClass() : base(FindClassName) 
{ 
} 

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

E 'davvero brutto, ma funziona.

MODIFICA: questo approccio funziona solo se è possibile modificare il costruttore della classe base come mostrato; Se non è possibile, io non sono sicuro che sia effettivamente realizzabile a tutti :(

Answer 5

Ancora un'altra opzione ...

// 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

Se la possibilità di determinare il tipo di classe ereditata in fase di esecuzione è più importante le prestazioni si può dare un'occhiata al StackTrace per vedere dove il costruttore viene chiamato da potrebbe essere necessario codificare in più ipotesi al momento della chiamata GetInheritedClassName in questo esempio:.

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) 
    { 

    } 
} 

non riesco a pensare ad un ottimo modo per dinamicamente ottenere il nome della classe ereditata senza implicazioni sulla performance. Mi rendo conto è quello che si voleva evitare, ma se avevo bisogno di chiamare un assembly 3rd party con questi requisiti vorrei solo richiedere ogni classe di specificare il proprio 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) 
    { 

    } 
}