Erstellen einer Instanz eines Typs ohne Standardkonstruktor in C # mithilfe von Reflection

Nehmen Sie die folgende Klasse als Beispiel:

class Sometype
{
    int someValue;

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

Ich möchte dann eine Instanz dieses Typs mithilfe von Reflection erstellen:

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

Normalerweise funktioniert dies. Da SomeTypejedoch kein parameterloser Konstruktor definiert wurde, löst der Aufruf von Activator.CreateInstanceeine Ausnahme vom Typ MissingMethodExceptionmit der Meldung " Kein parameterloser Konstruktor für dieses Objekt definiert " aus. Gibt es eine alternative Möglichkeit, eine Instanz dieses Typs weiterhin zu erstellen? Es wäre ein bisschen blöd, allen meinen Klassen parameterlose Konstruktoren hinzuzufügen.

Ich stellte ursprünglich diese Antwort hier , aber hier ist ein Nachdruck , da dies nicht genau die gleiche Frage ist , hat aber die gleiche Antwort:

FormatterServices.GetUninitializedObject()erstellt eine Instanz, ohne einen Konstruktor aufzurufen. Ich habe diese Klasse mit Reflector gefunden und einige der wichtigsten .Net-Serialisierungsklassen durchsucht.

Ich habe es mit dem folgenden Beispielcode getestet und es sieht so aus, als ob es großartig funktioniert:

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;
        }
    }
}

Verwenden Sie diese Überladung der CreateInstance-Methode:

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

Erstellt eine Instanz des angegebenen Typs mit dem Konstruktor, der den angegebenen Parametern am besten entspricht.

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

Beim Benchmarking war die Leistung (T)FormatterServices.GetUninitializedObject(typeof(T))langsamer. Gleichzeitig würden kompilierte Ausdrücke zu erheblichen Geschwindigkeitsverbesserungen führen, obwohl sie nur für Typen mit Standardkonstruktor funktionieren. Ich habe einen hybriden Ansatz gewählt:

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;
}

Dies bedeutet, dass der Erstellungsausdruck effektiv zwischengespeichert wird und nur beim ersten Laden des Typs eine Strafe verursacht. Behandelt auch Werttypen auf effiziente Weise.

Nennen:

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

Beachten Sie, dass dies (T)FormatterServices.GetUninitializedObject(t)für die Zeichenfolge fehlschlägt. Daher ist eine spezielle Behandlung für Zeichenfolgen vorhanden, um leere Zeichenfolgen zurückzugeben.

Gute Antworten, aber auf dem Dot Net Compact Framework unbrauchbar. Hier ist eine Lösung, die auf CF.Net funktioniert ...

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);
    }
}