Crear instancia de tipo sin constructor predeterminado en C # usando reflexión

Tome la siguiente clase como ejemplo:

class Sometype
{
    int someValue;

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

Luego quiero crear una instancia de este tipo usando la reflexión:

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

Normalmente esto funcionará, sin embargo, debido a que SomeTypeno se ha definido un constructor sin parámetros, la llamada a Activator.CreateInstancearrojará una excepción de tipo MissingMethodExceptioncon el mensaje " No se ha definido ningún constructor sin parámetros para este objeto " . ¿Existe alguna forma alternativa de crear una instancia de este tipo? Sería un poco asqueroso agregar constructores sin parámetros a todas mis clases.

Originalmente publiqué esta respuesta aquí , pero aquí hay una reimpresión ya que esta no es exactamente la misma pregunta pero tiene la misma respuesta:

FormatterServices.GetUninitializedObject()creará una instancia sin llamar a un constructor. Encontré esta clase usando Reflector y explorando algunas de las clases principales de serialización de .Net.

Lo probé usando el código de muestra a continuación y parece que funciona muy 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;
        }
    }
}

Utilice esta sobrecarga del método CreateInstance:

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

Crea una instancia del tipo especificado utilizando el constructor que mejor coincide con los parámetros especificados.

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

Cuando comparé el rendimiento (T)FormatterServices.GetUninitializedObject(typeof(T)), fue más lento. Al mismo tiempo, las expresiones compiladas le brindarían grandes mejoras de velocidad, aunque solo funcionan para tipos con constructor predeterminado. Adopté un enfoque híbrido:

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

Esto significa que la expresión de creación se almacena en caché de manera efectiva y solo se penaliza la primera vez que se carga el tipo. Manejará los tipos de valor también de manera eficiente.

Llámalo:

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

Tenga en cuenta que (T)FormatterServices.GetUninitializedObject(t)fallará para la cadena. Por lo tanto, existe un manejo especial para la cadena para devolver una cadena vacía.

Buenas respuestas pero inutilizables en el marco compacto de dot net. Aquí hay una solución que funcionará en 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);
    }
}