typisieren mit Typ/string Name der Klasse

Question

ich eine Variable objDataModel vom Typ haben UDataModel die sich von AbstractDataModel

public class AbstractDataModel 
{ 
    internal string SomeName { get; set; } 
} 
public class UDataModel: AbstractDataModel 
{ 

} 

public class FDataModel: AbstractDataModel 
{ 

} 


public class UCommandProcessor : AbstractCommandProcessor<UDataModel> 
{ 

} 
public class FCommandProcessor : AbstractCommandProcessor<FDataModel> 
{ 

} 
public abstract class AbstractCommandProcessor<TDataModel> :SomeInterface<TDataModel> 
    where TDataModel: AbstractDataModel 
{ 

} 

erbt Ich habe Variable vom Typ von UDataModelType heißt var tDataModelType= typeOf(UDataModel) verwendet, die ich in der Lage bin sein Objekt zu erstellen.

var tDataModel = (AbstractDataModel)Activator.CreateInstance(tDataModelType); 

Ich habe Variable vom Typ UCommandProcessor dh var processorType= typeOf(UCommandProcessor) ich in der Lage bin Aufgabe

var processor = Activator.CreateInstance(processorType); 

zu schaffen, aber ich bin nicht in der Lage es in UCommandProcessor typisieren Als ich versuchte,

var processor = (AbstractCommandProcessor<AbstractDataModel>)Activator.CreateInstance(processorType); 

Ich bekomme eine Ausnahme von

Das Objekt des Typs 'ABC.Domain.UCommandProcessor' konnte nicht in den Typ 'ABC.Common.Contract.AbstractCommandProcessor`1 [ABC.Common.Contract.AbstractDataModel]' umgewandelt werden.

Gibt es eine Methode wie

var processor = (AbstractCommandProcessor<typeOf(tDataModel)>)Activator.CreateInstance(processorType); 

Auch ich wie

var processor = (AbstractCommandProcessor<typeOf(tDataModel)>)Activator.CreateInstance(processorType); 

Answer 1

Die Besetzung kann nicht funktionieren, tun kann nicht, wenn Sie AbstractCommandProcessor<AbstractDataModel> werfen Sie im Grunde Kovarianz benötigt werden, was nur für Schnittstellen und Delegaten unterstützt. In dieser Zeile:

(AbstractCommandProcessor<AbstractDataModel>)Activator.CreateInstance(processorType); 

Die Besetzung könnte genauso gut ein AbstractCommandProcessor<FDataModel> sein, die eindeutig nicht gültig ist. Ich würde vorschlagen, eine abstrakte Klasse machen AbstractCommandProcessor, aus denen die generische Version stammt, dann können Sie nur auf die nicht-generische Version werfen:

public abstract class AbstractCommandProcessor {} 

public class AbstractCommandProcessor<T> : AbstractCommandProcessor, SomeInterface<T> 
              where T: AbstractDataModel 

... 
var processor = (AbstractCommandProcessor)Activator.CreateInstance(processorType); 

Edit: Wenn Sie nicht wirklich Klassen benötigen, könnten Sie machen es arbeitet mit Schnittstellen und Kovarianz:

public interface AbstractDataModel { } 
public class UDataModel : AbstractDataModel { } 
public class FDataModel : AbstractDataModel { } 


public class UCommandProcessor : AbstractCommandProcessor<UDataModel> { } 
public class FCommandProcessor : AbstractCommandProcessor<UDataModel> { } 
public interface AbstractCommandProcessor<out TDataModel> : SomeInterface<TDataModel> 
where TDataModel : AbstractDataModel 
{ } 

public interface SomeInterface<out TDataModel> where TDataModel : AbstractDataModel { } 

... 

var processor = 
    (AbstractCommandProcessor<AbstractDataModel>)Activator.CreateInstance(processorType); 

Dies wegen Kovarianz arbeiten (das out Schlüsselwort, das bedeutet, dass Sie etwas mehr abgeleitet sein als durch die generische Einschränkung verwenden können).