Création d'une instance de type sans constructeur par défaut en C # à l'aide de la réflexion

Prenons l'exemple du cours suivant:

class Sometype
{
    int someValue;

    public Sometype(int someValue)
    {
        this.someValue = someValue;
    }
}

Je souhaite ensuite créer une instance de ce type en utilisant la réflexion:

Type t = typeof(Sometype);
object o = Activator.CreateInstance(t);

Normalement, cela fonctionnera, mais comme SomeTypen'a pas défini de constructeur sans paramètre, l'appel à Activator.CreateInstancelèvera une exception de type MissingMethodExceptionavec le message " Aucun constructeur sans paramètre défini pour cet objet. " Existe-t-il un autre moyen de créer une instance de ce type? Ce serait un peu nul d'ajouter des constructeurs sans paramètre à toutes mes classes.

J'ai initialement publié cette réponse ici , mais voici une réimpression car ce n'est pas exactement la même question mais a la même réponse:

FormatterServices.GetUninitializedObject()créera une instance sans appeler de constructeur. J'ai trouvé cette classe en utilisant Reflector et en explorant certaines des classes de sérialisation .Net.

Je l'ai testé à l'aide de l'exemple de code ci-dessous et il semble que cela fonctionne très bien:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Runtime.Serialization;

namespace NoConstructorThingy
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass myClass = (MyClass)FormatterServices.GetUninitializedObject(typeof(MyClass)); //does not call ctor
            myClass.One = 1;
            Console.WriteLine(myClass.One); //write "1"
            Console.ReadKey();
        }
    }

    public class MyClass
    {
        public MyClass()
        {
            Console.WriteLine("MyClass ctor called.");
        }

        public int One
        {
            get;
            set;
        }
    }
}

Utilisez cette surcharge de la méthode CreateInstance:

public static Object CreateInstance(
    Type type,
    params Object[] args
)

Crée une instance du type spécifié à l'aide du constructeur qui correspond le mieux aux paramètres spécifiés.

Voir: http://msdn.microsoft.com/en-us/library/wcxyzt4d.aspx

Lorsque j'en ai évalué les performances, (T)FormatterServices.GetUninitializedObject(typeof(T))c'était plus lent. En même temps, les expressions compilées vous apporteraient de grandes améliorations de vitesse bien qu'elles ne fonctionnent que pour les types avec le constructeur par défaut. J'ai adopté une approche hybride:

public static class New<T>
{
    public static readonly Func<T> Instance = Creator();

    static Func<T> Creator()
    {
        Type t = typeof(T);
        if (t == typeof(string))
            return Expression.Lambda<Func<T>>(Expression.Constant(string.Empty)).Compile();

        if (t.HasDefaultConstructor())
            return Expression.Lambda<Func<T>>(Expression.New(t)).Compile();

        return () => (T)FormatterServices.GetUninitializedObject(t);
    }
}

public static bool HasDefaultConstructor(this Type t)
{
    return t.IsValueType || t.GetConstructor(Type.EmptyTypes) != null;
}

Cela signifie que l'expression de création est effectivement mise en cache et n'encourt des pénalités que la première fois que le type est chargé. Traitera également les types de valeur de manière efficace.

Appeler:

MyType me = New<MyType>.Instance();

Notez que (T)FormatterServices.GetUninitializedObject(t)cela échouera pour la chaîne. Par conséquent, une gestion spéciale de la chaîne est en place pour renvoyer une chaîne vide.

Bonnes réponses mais inutilisables sur le framework compact dot net. Voici une solution qui fonctionnera sur CF.Net ...

class Test
{
    int _myInt;

    public Test(int myInt)
    {
        _myInt = myInt;
    }

    public override string ToString()
    {
        return "My int = " + _myInt.ToString();
    }
}

class Program
{
    static void Main(string[] args)
    {
        var ctor = typeof(Test).GetConstructor(new Type[] { typeof(int) });
        var obj = ctor.Invoke(new object[] { 10 });
        Console.WriteLine(obj);
    }
}