<p>What's the best way to call a generic method when the type parameter isn't known at compile time, but instead is obtained dynamically at runtime?</p>

<p>Consider the following sample code - inside the <code>Example()</code> method, what's the most concise way to invoke <code>GenericMethod&lt;T&gt;()</code> using the <code>Type</code> stored in the <code>myType</code> variable?</p>

<pre><code>public class Sample
{
    public void Example(string typeName)
    {
        Type myType = FindType(typeName);

        // What goes here to call GenericMethod&lt;T&gt;()?
        GenericMethod&lt;myType&gt;(); // This doesn't work

        // What changes to call StaticMethod&lt;T&gt;()?
        Sample.StaticMethod&lt;myType&gt;(); // This also doesn't work
    }

    public void GenericMethod&lt;T&gt;()
    {
        // ...
    }

    public static void StaticMethod&lt;T&gt;()
    {
        //...
    }
}
</code></pre>

You need to use reflection to get the method to start with, then "construct" it by supplying type arguments with
MakeGenericMethod
:
```
```
MethodInfo method = typeof(Sample).GetMethod(nameof(Sample.GenericMethod));
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);
```
```
For a static method, pass
```
null
```
as the first argument to
```
Invoke
```
. That's nothing to do with generic methods - it's just normal reflection.
As noted, a lot of this is simpler as of C# 4 using
```
dynamic
```
- if you can use type inference, of course. It doesn't help in cases where type inference isn't available, such as the exact example in the question.