Call a Generic Method with a Runtime Type in C#

By the end of this page, you will understand why GenericMethod<myType>() does not compile in C#, and how to call a generic method when the type is only known at runtime. You will learn how to use reflection with GetMethod(), MakeGenericMethod(), and Invoke() for both instance and static generic methods, along with common mistakes and practical patterns used in real codebases.

In C#, generic type arguments such as T are normally chosen at compile time. That means code like this works:

GenericMethod<int>();

because int is a known type when the code is compiled.

But this does not work:

Type myType = typeof(int);
GenericMethod<myType>();

The reason is that myType is a variable, not a type name in source code. C# generic syntax requires an actual type at compile time, not a Type object stored in memory.

When the type is only available at runtime, the usual solution is reflection.

The key reflection steps are:

1. Find the generic method definition.
2. Create a closed generic version of that method using MakeGenericMethod(runtimeType).
3. Invoke the method.

Example idea:

MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod));
MethodInfo closedMethod = method.MakeGenericMethod(myType);
closedMethod.Invoke(this, null);

This matters in real programs because runtime-selected types appear often:

Think of a generic method like a template machine.

• GenericMethod<int>() means: “build the machine configured for int.”
• GenericMethod<string>() means: “build the machine configured for string.”

At compile time, C# wants you to say exactly which machine you want.

A Type variable is more like a note in your hand that says which machine to build later. The compiler cannot use that note directly in generic syntax. Instead, reflection acts like a factory worker who reads the note at runtime and builds the correct version of the machine for you.

So:

• generic syntax (<int>) = compile-time choice
• Type object (typeof(int) or runtime result) = runtime choice
• reflection = bridge between the two

Core syntax

To call a generic method using a runtime Type in C#, use reflection:

MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod));
MethodInfo closedMethod = method.MakeGenericMethod(myType);
closedMethod.Invoke(this, null);

For a static generic method:

MethodInfo method = typeof(Sample).GetMethod(nameof(StaticMethod));
MethodInfo closedMethod = method.MakeGenericMethod(myType);
closedMethod.Invoke(null, null);

Complete example

using System;
using System.Reflection;

public class Sample
{
    public void Example(string typeName)
    {
        Type myType = FindType(typeName);

        MethodInfo instanceMethod = typeof(Sample).GetMethod(nameof(GenericMethod));
        MethodInfo closedInstanceMethod = instanceMethod.MakeGenericMethod(myType);
        closedInstanceMethod.Invoke(this, null);

        MethodInfo staticMethod = typeof(Sample).GetMethod((StaticMethod));
        MethodInfo closedStaticMethod = staticMethod.MakeGenericMethod(myType);
        closedStaticMethod.Invoke(, );
    }

    
    {
        Console.WriteLine();
    }

    
    {
        Console.WriteLine();
    }

    
    {
         typeName 
        {
             => (),
             => (),
            _ => ()
        };
    }
}

Traceable example

using System;
using System.Reflection;

public class Sample
{
    public void Example()
    {
        Type myType = typeof(string);

        MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod));
        MethodInfo closedMethod = method.MakeGenericMethod(myType);
        closedMethod.Invoke(this, null);
    }

    public void GenericMethod<T>()
    {
        Console.WriteLine(typeof(T).FullName);
    }
}

Step by step

1. myType is assigned

Type myType = typeof(string);

Now myType stores the runtime type System.String.

2. The generic method definition is found

MethodInfo method = (Sample).GetMethod((GenericMethod));

Where this is used

Serializers

A serializer may discover the target type at runtime and need to call a generic method like:

Deserialize<T>()

Dependency injection containers

A DI framework may resolve services from a Type object and internally build calls to generic methods such as:

Resolve<T>()

Mapping libraries

Object mappers often receive source and destination types dynamically and may call generic conversion methods behind the scenes.

Plugin systems

A plugin loader might inspect assemblies, find types, and invoke generic registration methods based on discovered classes.

Data access helpers

A repository may need to call methods like:

GetEntity<T>()

when T comes from configuration, metadata, or reflection.

Testing tools and frameworks

Unit testing frameworks often discover test classes and invoke generic helper methods using runtime type information.

Common patterns in real projects

Guard clauses before reflection

Reflection can fail if the method is not found or the type is invalid. Real code often validates early:

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

MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod))
    ?? throw new InvalidOperationException("Method not found.");

Caching MethodInfo

Reflection is slower than direct calls. In production code, developers often cache method metadata:

private static readonly MethodInfo GenericMethodDefinition =
    typeof(Sample).GetMethod(nameof(GenericMethod));

Then reuse it instead of calling GetMethod() repeatedly.

Wrapping reflection in helper methods

Teams usually avoid scattering reflection code everywhere. Instead, they create a helper:

public void ()
{
    MethodInfo method = (Sample).GetMethod((GenericMethod));
    MethodInfo closed = method.MakeGenericMethod(type);
    closed.Invoke(, );
}

1. Trying to use a Type variable in generic syntax

This does not compile:

Type myType = typeof(int);
GenericMethod<myType>();

Why

Generic angle-bracket syntax expects a compile-time type, not a variable.

Fix

Use reflection:

MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod));
MethodInfo closed = method.MakeGenericMethod(myType);
closed.Invoke(this, null);

2. Passing the wrong target to Invoke()

Broken code for an instance method:

closedMethod.Invoke(null, null);

Why

Instance methods need an object instance.

Fix

Use this or another object instance:

closedMethod.Invoke(this, null);

For static methods, is correct.

Generic call at compile time vs runtime

Instance vs static generic method invocation

Quick reference

Direct generic call

GenericMethod<int>();

Use this when the type is known at compile time.

Runtime generic call

MethodInfo method = typeof(Sample).GetMethod(nameof(GenericMethod));
MethodInfo closed = method.MakeGenericMethod(myType);
closed.Invoke(this, null);

Static runtime generic call

MethodInfo method = typeof(Sample).GetMethod(nameof(StaticMethod));
MethodInfo closed = method.MakeGenericMethod(myType);
closed.Invoke(null, null);

Rules

• GenericMethod<myType>() is invalid because myType is a variable, not a compile-time type.
• Use MakeGenericMethod() for generic methods.
• Use MakeGenericType() for generic classes/types.
• Pass an object instance to Invoke() for instance methods.
• Pass null to Invoke() for static methods.

How do I call a generic method when I only have a Type object in C#?

Use reflection: find the method with GetMethod(), create a closed generic method with MakeGenericMethod(type), then call Invoke().

Why does GenericMethod<myType>() not compile?

Because C# generic syntax requires a type known at compile time. myType is a variable holding a Type value at runtime.

How do I invoke a static generic method with reflection?

Use the same reflection steps, but pass null as the target in Invoke().

What is the difference between MakeGenericMethod and MakeGenericType?

MakeGenericMethod is for generic methods. MakeGenericType is for generic classes or other generic types.

Is reflection the only way to do this?

If the type is truly unknown until runtime, reflection is the standard approach. If the possible types are known ahead of time, a switch, delegate map, or polymorphic design may be better.

• Reflection — used to inspect types and invoke members dynamically at runtime.
• Generic methods — the core feature being invoked dynamically in this scenario.
• Generic type constraints — important when the runtime type must satisfy where rules.
• MethodInfo — represents method metadata and is required for reflective invocation.
• Static methods — relevant because static generic methods are invoked slightly differently.
• Instance methods — relevant because they require a target object when using Invoke().
• MakeGenericType — closely related API for constructing generic types instead of generic methods.
• Delegates — sometimes used as a faster alternative when the set of types is known.
• Polymorphism — often a cleaner design alternative when behavior can be attached to objects rather than chosen by type metadata.