Activator.CreateInstance: Slow vs. Less-Slow

In the system I’m working on, there is a lot of runtime type resolution, e.g., lines like this:

var obj = Activator.CreateInstance(type, param1, param2, param3)

The params are arguments to the constructor of the type. The type itself is ultimately given through some configuration or otherwise-dynamic means.

Since we do a lot of this (many times per second), we’d like to ensure that instance creation is as fast as it can be. The method given above is not fast.

When this overload of CreateInstance is called, .Net has to do a lot of work to make sure it works: find the right constructor, verify that all the argument types match up, etc. This can be painfully slow, especially when, in a closed system, you can do a lot of offline validation to ensure that types are correctly specified.

Fortunately, Activator has another overload that is quite a bit faster, if you can use it.


This will call the default constructor of the type. However, we still have the problem of passing in those arguments. There are a few ways we could do this, but one of the simplest is to ensure that all the types you’re doing this for implement a common initialization interface, as in this sample program:

interface IPerson
    void Initialize(string name, DateTime dob, int weight);

class Employee : IPerson
    public Employee()

    public Employee(string name, DateTime dob, int weight)
        Initialize(name, dob, weight);

    public Employee(string name, DateTime dob)
        : this(name, dob, -1)

    public void Initialize(string name, DateTime dob, int weight)
    { = name;
        this.dob = dob;
        this.weight = weight;

    private string name;
    private DateTime dob;
    private int weight;

class Program
    static void Main(string[] args)
        const int iterations = 1000000;

        Console.WriteLine("Timing Activator.CreateInstance(type, params)...");
        var employees = new IPerson[iterations];

        var stopwatch = Stopwatch.StartNew();

        for (int i = 0; i < iterations; ++i)
            employees[i] = Activator.CreateInstance(typeof(Employee), 
                "Bob", DateTime.Now, 220) as IPerson;


        Console.WriteLine("Total time: {0} for {1:N0} employees", 
            stopwatch.Elapsed.ToString(), iterations);

        Console.WriteLine("Timing Activator.CreateInstance(type) + Initialization...");
        var employees2 = new IPerson[iterations];

        var stopwatch2 = Stopwatch.StartNew();            

        for (int i = 0; i < iterations; ++i)
            employees2[i] = Activator.CreateInstance(typeof(Employee)) as IPerson;
            employees2[i].Initialize("Bob", DateTime.Now, 220);


        Console.WriteLine("Total time: {0} for {1:N0} employees", 
            stopwatch2.Elapsed.ToString(), iterations);

What do you think the time difference in the two approaches is?

Timing Activator.CreateInstance(type, params)…

Total time: 00:00:05.4765664 for 1,000,000 employees

Timing Activator.CreateInstance(type) + Initialization…

Total time: 00:00:01.6007687 for 1,000,000 employees

About 3.5x faster. Pretty good. In practice, the improvement will vary. In some of our own timing experiments, we actually saw a much better speedup.

Like this tip? Check out my book, C # 4.0 How-To, where you’ll finds hundreds of great tips like this one.

3 thoughts on “Activator.CreateInstance: Slow vs. Less-Slow

  1. Ben Post author

    Yes, codegen is also one of the options we’ve measured and thought about — it’s MUCH faster than even this method…but of course, it’s a bit more complex (not much, though).

  2. Andrew

    On line 9, you have to know at compile time that you want a List OpenAngleBracket stnirg CloseAngleBracket.What can you do if you only know you want stnirg at runtime?How can you tell the C# .NET that “o” is a List OpenAngleBracket x CloseAngleBracket where x is not known until runtime? Is there a way to access the methods of List OpenAngleBracket CloseAngleBracket from “o”?

Comments are closed.