How to Dynamically Call Generic Methods in C#

You can dynamically call a generic method in C# using either reflection with MakeGenericMethod() or the dynamic keyword to let the runtime handle the type binding. The reflection approach provides compile-time type safety while the dynamic keyword offers more concise syntax for runtime type resolution.

Contents

• Using Reflection to Invoke Generic Methods
• Using the dynamic Keyword
• Using the DLR and Dynamitey Framework
• Performance Considerations
• Complete Example Code
• Best Practices

Using Reflection to Invoke Generic Methods

The traditional approach uses reflection to dynamically create and invoke generic methods. You can use the MakeGenericMethod() method to create a specific generic method from a generic method definition.

public void Example(string typeName)
{
    Type myType = FindType(typeName);
    
    // Get the method info for the generic method
    MethodInfo genericMethod = typeof(Sample).GetMethod(nameof(GenericMethod));
    
    // Create the specific generic method with the runtime type
    MethodInfo specificMethod = genericMethod.MakeGenericMethod(myType);
    
    // Invoke the method
    specificMethod.Invoke(this, null);
}

For static methods, the approach is similar but you pass null as the first parameter to Invoke():

// For static methods
MethodInfo staticGenericMethod = typeof(Sample).GetMethod(nameof(StaticMethod));
MethodInfo staticSpecificMethod = staticGenericMethod.MakeGenericMethod(myType);
staticSpecificMethod.Invoke(null, null); // First parameter is null for static methods

This approach provides compile-time type safety and works consistently across all .NET versions. As Brian Lagunas explains, “When using a generic method, the generic argument (often referred to as T) must be provided as a known type at compile time,” but reflection allows us to work around this constraint at runtime.

Using the dynamic Keyword

A more concise approach is using the dynamic keyword, which lets the runtime handle the type binding automatically. This approach was introduced in C# 4.0 with the Dynamic Language Runtime (DLR).

public void Example(string typeName)
{
    Type myType = FindType(typeName);
    
    // Create an instance of the type to use as a carrier
    dynamic dummyInstance = Activator.CreateInstance(myType);
    
    // Use dynamic to invoke the method - runtime will resolve the overload
    GenericMethod(dummyInstance);
    
    // For static methods
    Sample.StaticMethod(dummyInstance);
}

As mentioned on Reddit, “You can use the dynamic type and let the runtime pick the right overload for you without having to use reflection.” This approach is more readable and requires less code than reflection.

However, as noted by The Reformed Programmer, there are performance considerations: “With dynamic there is a cost on first decode and call of the method in my libraries which use dynamic – about 0.2 seconds or more on my system.”

Using the DLR and Dynamitey Framework

The Dynamic Language Runtime (DLR) provides more advanced dynamic capabilities. For easier access to these features, you can use the open-source Dynamitey framework, which “gives you easy cached run-time access to the same calls the compiler would generate for you” StackOverflow.

First, install the Dynamitey package via NuGet:

Install-Package Dynamitey

Then use it like this:

using Dynamitey;

public void Example(string typeName)
{
    Type myType = FindType(typeName);
    
    // Using Dynamitey for dynamic invocation
    Invoke.InvokeMember(this, "GenericMethod", myType);
    
    // For static methods
    Invoke.InvokeMember(null, "StaticMethod", myType, typeof(Sample));
}

This approach provides cached access which can significantly improve performance in scenarios requiring repeated dynamic calls.

Performance Considerations

When choosing between approaches, consider the following performance implications:

As Damir’s Corner explains, “By using dynamic you postpone the type checking until runtime, when the actual type is already known.” This can be beneficial but comes with runtime type safety implications.

For the highest performance in performance-critical scenarios, you can use Reflection.Emit as mentioned in the Microsoft Learn documentation, though this approach is more complex to implement.

Complete Example Code

Here’s a complete example showing all approaches in action:

using System;
using System.Reflection;
using Dynamitey;

public class Sample
{
    public void Example(string typeName)
    {
        Type myType = FindType(typeName);
        
        Console.WriteLine($"Invoking methods with type: {myType.Name}");
        
        // Approach 1: Reflection
        InvokeWithReflection(myType);
        
        // Approach 2: dynamic keyword
        InvokeWithDynamic(myType);
        
        // Approach 3: Dynamitey
        InvokeWithDynamitey(myType);
    }
    
    private void InvokeWithReflection(Type type)
    {
        Console.WriteLine("\n--- Reflection Approach ---");
        
        // Instance method
        MethodInfo genericMethod = typeof(Sample).GetMethod(nameof(GenericMethod));
        MethodInfo specificMethod = genericMethod.MakeGenericMethod(type);
        specificMethod.Invoke(this, null);
        
        // Static method
        MethodInfo staticGenericMethod = typeof(Sample).GetMethod(nameof(StaticMethod));
        MethodInfo staticSpecificMethod = staticGenericMethod.MakeGenericMethod(type);
        staticSpecificMethod.Invoke(null, null);
    }
    
    private void InvokeWithDynamic(Type type)
    {
        Console.WriteLine("\n--- Dynamic Keyword Approach ---");
        
        try
        {
            dynamic dummyInstance = Activator.CreateInstance(type);
            
            // Instance method
            GenericMethod(dummyInstance);
            
            // Static method
            Sample.StaticMethod(dummyInstance);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Dynamic approach failed: {ex.Message}");
        }
    }
    
    private void InvokeWithDynamitey(Type type)
    {
        Console.WriteLine("\n--- Dynamitey Approach ---");
        
        try
        {
            // Instance method
            Invoke.InvokeMember(this, "GenericMethod", type);
            
            // Static method
            Invoke.InvokeMember(null, "StaticMethod", type, typeof(Sample));
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Dynamitey approach failed: {ex.Message}");
        }
    }
    
    public void GenericMethod<T>()
    {
        Console.WriteLine($"GenericMethod called with type: {typeof(T)}");
    }
    
    public static void StaticMethod<T>()
    {
        Console.WriteLine($"StaticMethod called with type: {typeof(T)}");
    }
    
    private Type FindType(string typeName)
    {
        Type type = Type.GetType(typeName);
        if (type == null)
        {
            // Try to find in current assembly
            type = typeof(Sample).Assembly.GetTypes()
                .FirstOrDefault(t => t.Name == typeName);
        }
        return type ?? throw new TypeLoadException($"Type {typeName} not found");
    }
}

Best Practices

When implementing dynamic generic method invocation in C#, consider these best practices:

1. Choose the right approach based on your specific needs:

   • Use reflection for compile-time type safety and precise control
   • Use dynamic for more concise code when type safety is less critical
   • Use Dynamitey for better performance in scenarios requiring repeated dynamic calls

2. Cache method infos when possible to improve performance:

   csharp

   private static readonly MethodInfo _genericMethod = typeof(Sample).GetMethod(nameof(GenericMethod));
   
   public void CachedInvocation(Type type)
   {
       MethodInfo specificMethod = _genericMethod.MakeGenericMethod(type);
       specificMethod.Invoke(this, null);
   }
   

3. Handle exceptions appropriately since dynamic operations can fail at runtime:

   csharp

   try
   {
       dynamic invocation = PerformDynamicCall();
   }
   catch (RuntimeBinderException ex)
   {
       // Handle dynamic binding errors
   }
   catch (TargetInvocationException ex)
   {
       // Handle method invocation errors
   }
   

4. Consider performance implications in performance-critical code paths, especially when using the dynamic keyword which has initial compilation overhead.

5. Use meaningful parameter names when working with dynamic code to improve maintainability and debugging.

As Rick van den Bosch demonstrates in his example, the key challenge is that “the type of the properties was dynamic and only known at runtime,” which is exactly the scenario these approaches solve.

Sources

1. r/csharp on Reddit: How to dynamically call a generic method of T with a Func argument?
2. Brian Lagunas: Dynamically invoking a generic method with Reflection in .NET C#
3. Stack Overflow: How do I call a generic method using a Type variable?
4. The Reformed Programmer: Using .NET Generics with a type derived at runtime
5. Rick van den Bosch .NET: How To: Call a generic method with a runtime type
6. Microsoft Learn: How to: Define a Generic Method with Reflection Emit
7. Damir’s Corner: Minimizing Reflection Usage with Generics and Dynamic
8. CodeProject: Dynamically Invoke Generic Methods

Conclusion

Dynamically calling generic methods in C# can be accomplished through several approaches, each with its own trade-offs. The reflection approach provides the most control and compile-time safety, while the dynamic keyword offers the most concise syntax. For better performance in repeated scenarios, consider using the Dynamitey framework which provides cached access to dynamic operations.

Your choice should depend on your specific requirements for type safety, performance, and code maintainability. Remember that while these techniques solve the runtime type resolution problem, they come with different performance characteristics and type safety guarantees that you should consider for your particular use case.