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.