Creating instance of type without default constructor in C# using reflection

Question

Take the following class as an example:

class Sometype
{
    int someValue;

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

I then want to create an instance of this type using reflection:

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

Normally this will work, however because SomeType has not defined a parameterless constructor, the call to Activator.CreateInstance will throw an exception of type MissingMethodException with the message "No parameterless constructor defined for this object." Is there an alternative way to still create an instance of this type? It'd be kinda sucky to add parameterless constructors to all my classes.

FormatterServices.GetUninitializedObject not allow to create uninitialized string. You may get exception: System.ArgumentException: Uninitialized Strings cannot be created. Please keep this in mind. — Bartosz Pierzchlewicz
– Bartosz Pierzchlewicz, Commented Jan 15, 2010 at 8:14
Thanks for the heads up, but I'm already handling strings and basic types separately. — Aistina
– Aistina, Commented Jan 15, 2010 at 15:14

Twenty · Accepted Answer · 2023-09-12 11:59:38Z

161

I originally posted this answer here, but here is a reprint since this isn't the exact same question but has the same answer:

FormatterServices.GetUninitializedObject() will create an instance without calling a constructor. I found this class by using Reflector and digging through some of the core .Net serialization classes.

I tested it using the sample code below and it looks like it works great:

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

With .NET 8 right around the corner and the obsoletion of the FormatterService

You can use RuntimeHelpers.GetUninitializedObject, which is the same method that FormatterService.GetUninitializedObject was calling under the hood in the first place.

edited Sep 12, 2023 at 11:59

Twenty

6,2217 gold badges41 silver badges78 bronze badges

answered Dec 24, 2008 at 1:44

Jason Jackson

17.3k8 gold badges53 silver badges76 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

Aistina Over a year ago

Awesome, looks like that's exactly what I need. I assume uninitialized means all its memory will be set to zeros? (Similar to how structs are instantiated)

Jason Jackson Over a year ago

Whatever the default value is for each type will be the default. So objects will be null, ints 0, etc. I do think that any class-level initialization occurs, but no constructor is run.

Jason Jackson Over a year ago

@JSBangs, That sucks you are dinging a perfectly legitimate answer. Your comment and the other answer doesn't actually address the question asked. If you feel like you have a better answer then provide one. But the answer I provided highlight how to use a documented class in the same way other serialization classes use this code.

Sandeep Datta Over a year ago

@JSBangs FormatterServices (msdn.microsoft.com/en-us/library/…) is not undocumented.

Cel Over a year ago

using GetUninitializedObject seems to depend on your specific purpose: Because the new instance of the object is initialized to zero and no constructors are run, the object might not represent a state that is regarded as valid by that object. The current method should only be used for deserialization when the user intends to immediately populate all fields. It does not create an uninitialized string, since creating an empty instance of an immutable type serves no purpose.

|

Nick · Accepted Answer · 2008-12-24 01:44:50Z

73

Use this overload of the CreateInstance method:

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

Creates an instance of the specified type using the constructor that best matches the specified parameters.

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

answered Dec 24, 2008 at 1:44

Nick

2,5851 gold badge20 silver badges18 bronze badges

2 Comments

kamii Over a year ago

This solution oversimplifies the problem. What if I don't know my type and I'm saying "just create an object of the Type in this Type variable"?

Mitulát báti Over a year ago

@kamii if neither the type nor the parameters it expects are known then what can you do with that class?

Community · Accepted Answer · 2017-05-23 12:18:18Z

26

When I benchmarked performance of (T)FormatterServices.GetUninitializedObject(typeof(T)) it was slower. At the same time compiled expressions would give you great speed improvements though they work only for types with default constructor. I took a hybrid approach:

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

This means the create expression is effectively cached and incurs penalty only the first time the type is loaded. Will handle value types too in an efficient manner.

Call it:

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

Note that (T)FormatterServices.GetUninitializedObject(t) will fail for string. Hence special handling for string is in place to return empty string.

edited May 23, 2017 at 12:18

CommunityBot

11 silver badge

answered Apr 23, 2013 at 6:29

nawfal

73.8k59 gold badges342 silver badges379 bronze badges

3 Comments

jmodrak Over a year ago

It is strange how a look at one line of someone's code can save a day. Thank you, sir! Performance reasons took me to your post and the trick is done :) FormatterServices and Activator classes are underperforming compared to compiled expressions, what a pity one finds Activators all around the place.

Sнаđошƒаӽ Over a year ago

@nawfal Regarding your special handling for string, I know it would fail for string without this special handling, but I just want to know: will it work for all other types?

nawfal Over a year ago

@Sнаđошƒаӽ unfortunately no. The given example is barebones and .NET has many different types of types. For e.g. consider, if you pass a delegate type how will you give you it an instance? Or else if constructor throws what can you do about it? Many different ways to handle it. I had since answering this updated to handle lot more scenarios in my library. It isnt published anywhere for now.

Sandeep Datta · Accepted Answer · 2009-01-23 08:37:46Z

4

Good answers but unusable on the dot net compact framework. Here is a solution that will work on 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);
    }
}

edited Jan 23, 2009 at 8:37

answered Jan 22, 2009 at 11:48

Sandeep Datta

29.6k18 gold badges74 silver badges92 bronze badges

4 Comments

Rory MacLeod Over a year ago

This is the way I'd call a non-default constructor. I'm not sure I'd ever want to create an object without calling any constructor at all.

Sandeep Datta Over a year ago

You may want to create an object without calling constructors if you are writing custom serializers.

Aistina Over a year ago

Yup, that's the exact use case scenario this question was for :)

julealgon Over a year ago

@Aistina Perhaps you could add this information to the question? Most people would be against creating objects without calling their ctors and would take the time to argue with you about that, but your use case actually justifies it, so I think it is very relevant to the question itself.

Collectives™ on Stack Overflow

Creating instance of type without default constructor in C# using reflection

4 Answers 4

With .NET 8 right around the corner and the obsoletion of the FormatterService

8 Comments

2 Comments

3 Comments

4 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

With .NET 8 right around the corner and the obsoletion of the FormatterService

8 Comments

2 Comments

3 Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related