Instancier une classe avec son type

Question

Je cherche un moyen plus rapide que Activator.CreateInstance d'instancier une classe de son type.

Je le fais de cette façon pour l'instant: Activator.CreateInstance(typeof(LoginView)); mais c'est extrêmement lent: je vois des retards lors de l'instanciation des différentes vues.

Une suggestion pour moi? Je googler pendant des heures maintenant et je ne l'ai pas trouver un moyen plus rapide que cela pour faire ce que je veux ..:/

Merci beaucoup (:

Answer 1

Vous pouvez utiliser des génériques.

T MyActivator<T>() where T : new() { return new T(); } 

T MyActivator<T>(T variable) where T : new() { return new T(); } 

La première est utilisée si vous connaissez le type (utilisez explicitement le type).
Le second est utilisé pour déduire le type d'une variable:

MyType blah = MyActivator<MyType>(); 

SomeType someVar; 
object blah = MyActivator(someVar); 

Answer 2

EDIT Il semble que le type est . générique, et non pas seulement LoginView Vous pouvez essayer ceci:.

public void Foo<T>(T input) where T : new() 
{ 
    var myInstance = new T(); 
} 

Answer 3

Vous pouvez utiliser des expressions Linq comme expliqué dans ce blog post dans votre cas, il serait

ConstructorInfo ctor = typeof(LoginView).GetConstructors().First(); 
ObjectActivator<LoginView> createdActivator = GetActivator<LoginView>(ctor); 


LoginView instance = createdActivator(); 

Au cas où le lien va vers le bas, c'est ObjectActivator délégué

delegate T ObjectActivator<T>(params object[] args); 

et la méthode GetActivator

public static ObjectActivator<T> GetActivator<T> 
    (ConstructorInfo ctor) 
{ 
    Type type = ctor.DeclaringType; 
    ParameterInfo[] paramsInfo = ctor.GetParameters();     

    //create a single param of type object[] 
    ParameterExpression param = 
     Expression.Parameter(typeof(object[]), "args"); 

    Expression[] argsExp = 
     new Expression[paramsInfo.Length];    

    //pick each arg from the params array 
    //and create a typed expression of them 
    for (int i = 0; i < paramsInfo.Length; i++) 
    { 
     Expression index = Expression.Constant(i); 
     Type paramType = paramsInfo[i].ParameterType;    

     Expression paramAccessorExp = 
      Expression.ArrayIndex(param, index);    

     Expression paramCastExp = 
      Expression.Convert (paramAccessorExp, paramType);    

     argsExp[i] = paramCastExp; 
    }     

    //make a NewExpression that calls the 
    //ctor with the args we just created 
    NewExpression newExp = Expression.New(ctor,argsExp);     

    //create a lambda with the New 
    //Expression as body and our param object[] as arg 
    LambdaExpression lambda = 
     Expression.Lambda(typeof(ObjectActivator<T>), newExp, param);    

    //compile it 
    ObjectActivator<T> compiled = (ObjectActivator<T>)lambda.Compile(); 
    return compiled; 
} 

Un avantage à utiliser cette méthode sur la méthode générique est que vous pouvez facilement passer dans les paramètres à votre constructeur mais le désavantage étant le code plus verbeux.

Answer 4

Au lieu de prendre un Type qui renvoie le résultat de typeof, prendre un délégué qui vous obtient une instance de l'objet:

Func<object> myActivator =() => new LoginView(); 

Peut-être même avoir une méthode pour vous aider à le faire, si elle avait le rendre plus facile sur votre code:

public static Func<object> GetActivator<T>() where T : new() 
{ 
    return() => new T(); 
} 

Cela aura une très petite surcharge pour appeler le délégué Func. Devrait être beaucoup plus rapide que d'appeler Activator.CreateInstance sur un Type.