C# generic method with or without method parameter

In C#, a generic method is a method that is declared with a type parameter (usually denoted as <T>). However, when the method is called then type argument for type parameter is optional or not, is explained in this post.

Here is a breakdown of generic methods with and without method parameters, followed by the core differences.

Generic Method WITH Method Parameters

In this scenario, the type parameter <T> is used as the data type for one or more of the arguments passed into the method.

Example

public class Utility
{
    // The type parameter T is used in
    // the method parameter (T input)
    public void PrintDetails<T>(T input)
    {
        Console.WriteLine($"Type: " +
            $"{typeof(T)}, Value: {input}");
    }
}

How you call it:

Because the compiler can see what you are passing into the method, it can automatically figure out what T is. This is called Type Inference.

class Program
{
    static void Main(string[] args)
    {
        Utility util = new Utility();

        // 1. Calling WITHOUT explicitly
        // specifying the type (Type Inference)
        util.PrintDetails("Hello World"); // Compiler infers T is string
        util.PrintDetails(123); // Compiler infers T is int

        // 2. Calling WITH explicitly specifying the type
        util.PrintDetails<double>(45.67);
    }
}

Generic Method WITHOUT Method Parameters

In this scenario, the type parameter <T> is used inside the method body or as the return type, but it does not appear in the method's input parameters.

Example

public class Factory
{
    // T is the return type, but 
    // the method takes no arguments
    public T CreateInstance<T>() where T : new()
    {
        return new T();
    }
}

How you call it:

Because there are no arguments being passed, the compiler has zero clues to figure out what T should be. Therefore, you must explicitly provide the type parameter.

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

class Program
{
    static void Main(string[] args)
    {
        Factory factory = new Factory();

        // You MUST explicitly state <Person> or <List<int>>
        Person p = factory.CreateInstance<Person>();
        var list = factory.CreateInstance<List<int>>();

        // THIS WILL FAIL TO COMPILE:
        // Error: Type arguments cannot be inferred
        // var item = factory.CreateInstance(); 

    }
}

Key Differences

Feature	With Method Parameter (Method<T>(T arg))	Without Method Parameter (Method<T>())
Type Inference	Supported. The compiler looks at the argument passed to determine T.	Not Supported. The compiler has no input data to analyze.
Calling Syntax	Clean and implicit: Method(argument)	Explicit: Method<Type>()
Primary Use Case	Processing, comparing, or operating on data of a flexible type (e.g., swapping two values, logging an object).	Creating instances, fetching configuration, or casting data (e.g., Dependency Injection containers, ORMs like Entity Framework).

Summary

• Use with method parameters when the method needs to ingest and act upon generic data. You get the benefit of cleaner code via type inference.
• Use without method parameters when the method needs to generate, fetch, or convert something into a specific type from scratch. You must explicitly tell the compiler what type you want.