How to Create an Object Instance from a Type in C#

By the end of this page, you will understand how to create objects dynamically in C# when you only have a Type at runtime. You will learn the most common approach using Activator.CreateInstance, how constructors affect object creation, when reflection is useful, and what mistakes to avoid when instantiating types dynamically.

In normal C# code, object creation usually happens with the new keyword:

var user = new User();

That works when the type is known at compile time. But sometimes a program discovers the type later, while it is running. This happens in scenarios like:

• plugin systems
• dependency injection containers
• serializers
• configuration-driven object creation
• test frameworks

When all you have is a Type object, you cannot write:

new type(); // invalid

because new requires a compile-time type name, not a runtime Type value.

This is where Activator.CreateInstance becomes useful. It lets you ask the runtime to create an object from a Type.

object instance = Activator.CreateInstance(type);

This creates a new instance of the specified type, usually by calling its parameterless constructor.

Why this matters:

• It allows flexible, extensible programs.
• It supports runtime discovery of classes.

Think of Type as a blueprint label, not the actual building.

• new User() means: "Build me a house from the User blueprint I already know."
• Type type = ... means: "Here is a label that tells you which blueprint to use, but you only find out at runtime."
• Activator.CreateInstance(type) means: "Use this blueprint label and build one instance now."

So Type tells you what something is, and Activator.CreateInstance is the worker that actually builds it.

Basic syntax

object instance = Activator.CreateInstance(type);

This returns an object, because the compiler may not know the exact type.

Example with a parameterless constructor

using System;

class Person
{
    public string Name { get; set; }
}

class Program
{
    static void Main()
    {
        Type type = typeof(Person);
        object instance = Activator.CreateInstance(type);

        Person person = (Person)instance;
        person.Name = "Ava";

        Console.WriteLine(person.Name);
    }
}

What this does

• typeof(Person) gets the runtime Type.
• Activator.CreateInstance(type) creates a new Person.
• The result is returned as object.
• You cast it back to Person if needed.

Consider this example:

using System;

class Message
{
    public string Text { get; set; } = "Hello";
}

class Program
{
    static void Main()
    {
        Type type = typeof(Message);
        object instance = Activator.CreateInstance(type);
        Message message = (Message)instance;

        Console.WriteLine(message.Text);
    }
}

Step by step

1. Type type = typeof(Message);

   • The program gets metadata describing the Message class.
   • No object is created yet.

2. object instance = Activator.CreateInstance(type);

   • The runtime checks the Message type.
   • It finds a usable parameterless constructor.
   • It creates a new Message object.
   • The result is stored as object.

Plugin systems

An app may load class names from assemblies and create plugin objects dynamically.

Type pluginType = loadedAssembly.GetType("MyApp.Plugins.CsvExporter");
object plugin = Activator.CreateInstance(pluginType);

Configuration-based services

A configuration file may specify which implementation to use.

• EmailSender
• SmsSender
• PushNotificationSender

The application resolves the type at runtime and creates it.

Testing frameworks

Test runners often discover test classes through reflection and instantiate them automatically.

Serialization and mapping tools

Libraries may create objects before populating their properties from JSON, XML, or database records.

Command or job processors

A background worker may discover a job type from a queue message and instantiate the appropriate handler.

In real projects, developers usually combine runtime object creation with safer design patterns.

Common patterns

Create via interface or base class

Instead of using the created object as plain object, cast to a known abstraction:

IPlugin plugin = (IPlugin)Activator.CreateInstance(type);
plugin.Run();

This makes the rest of the code cleaner and safer.

Guard clauses before creation

Real code often validates the type first:

if (type == null)
    throw new ArgumentNullException(nameof(type));

if (type.IsAbstract || type.IsInterface)
    throw new InvalidOperationException("Type cannot be instantiated.");

Constructor matching

If arguments are needed, code ensures the right constructor exists.

object service = Activator.CreateInstance(type, connectionString);

Error handling

Because dynamic creation can fail at runtime, developers often wrap it:

try
{
     Activator.CreateInstance(type);
}
 (Exception ex)
{
      InvalidOperationException(, ex);
}

1. Trying to use new with a Type

Broken code:

Type type = typeof(string);
// var x = new type(); // invalid

Why it fails:

• new needs a real type name at compile time.
• type is just a variable holding metadata.

Use this instead:

object x = Activator.CreateInstance(type);

2. Assuming every type has a parameterless constructor

Broken code:

class Person
{
    public Person(string name) { }
}

Type type = typeof(Person);
object instance = Activator.CreateInstance(type); // fails

Fix:

object instance = Activator.CreateInstance(type, "Mia");

Quick reference

Create an instance from a Type

object instance = Activator.CreateInstance(type);

Create with constructor arguments

object instance = Activator.CreateInstance(type, arg1, arg2);

Generic version

T instance = Activator.CreateInstance<T>();

Rules to remember

• new SomeType() works only when the type is known at compile time.
• Activator.CreateInstance works when the type is known only at runtime.
• The return type is usually object.
• Cast the result to a known interface, base class, or concrete type.
• The target type must be instantiable.

Common checks

if (type == null)
    throw new ArgumentNullException(nameof(type));

if (type.IsInterface || type.IsAbstract)
    throw new InvalidOperationException();

How do I create an instance from a Type in C#?

Use Activator.CreateInstance(type). It asks the runtime to create an object for that Type.

Can I use new with a Type variable?

No. The new keyword requires a compile-time type name, not a runtime Type value.

What happens if the type has no default constructor?

You must pass matching constructor arguments, for example:

Activator.CreateInstance(type, "value")

Why does Activator.CreateInstance return object?

Because the compiler may not know the specific type in advance. You usually cast it to a known type, interface, or base class.

Can I create interfaces or abstract classes this way?

No. Interfaces and abstract classes cannot be instantiated directly.

Is Activator.CreateInstance slower than new?

Yes, generally it is slower because it uses runtime mechanisms. For most normal code, prefer when possible.

• Reflection - Type and Activator are part of reflection-based programming.
• Constructors - Object creation depends on which constructors a type provides.
• Casting - The created instance is often returned as object and must be cast.
• Interfaces - Casting to an interface makes dynamic code safer and cleaner.
• Generics - Generic type parameters offer another way to create instances in some cases.
• Factory Pattern - A common alternative to reflection-based object creation.
• Dependency Injection - Many DI containers create objects dynamically at runtime.
• Abstract Classes - Important because abstract types cannot be instantiated directly.