> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# Generic Method A generic method in C# is a method declared with one or more type parameters, allowing the method's signature and implementation to operate on unspecified data types while enforcing strict compile-time type safety. By deferring the specification of the data type until the method is invoked, generic methods eliminate the performance overhead of boxing/unboxing operations and the runtime risks of downcasting associated with `System.Object`. ## Syntax and Anatomy A generic method is defined by appending a type parameter list, enclosed in angle brackets (`< >`), immediately after the method name and before the method parameter list. ```csharp theme={"dark"} public class ExampleClass { public void MethodName(T1 parameter1, T2 parameter2) { // Method implementation } } ``` * **Type Parameter (`T1`, `T2`)**: The placeholder for the type that will be provided by the caller. By convention, single type parameters are named `T`, while multiple parameters use descriptive names prefixed with 'T' (e.g., `TKey`, `TValue`). * **Type Argument**: The actual, concrete data type (e.g., `int`, `string`, `Customer`) supplied when the method is invoked. ## Invocation and Type Inference When invoking a generic method, you can explicitly provide the type arguments. However, the C# compiler features a robust type inference engine that can automatically deduce the type arguments based on the types of the arguments passed into the method parameters. ```csharp theme={"dark"} using System; public class GenericDemo { public void DisplayType(T value) { Console.WriteLine(typeof(T).Name); } public void Execute() { // Explicit invocation DisplayType(42); // Implicit invocation via type inference DisplayType(42); } } ``` *Note: Type inference relies strictly on method arguments. The compiler cannot infer type parameters based solely on the method's return type or local variable assignments.* ## Generic Type Constraints Without constraints, an unconstrained type parameter `T` can resolve to either a reference type or a value type. Consequently, the compiler only allows you to access members defined on `System.Object`. To access specific members or enforce type rules, you apply constraints using the `where` contextual keyword. Constraints restrict the kinds of types that can be substituted for a type parameter. ```csharp theme={"dark"} using System; public class Factory { public T CreateAndFormat(T input) where T : class, IFormattable, new() { T instance = new T(); // Implementation return instance; } } ``` Common constraints include: * `where T : struct`: Must be a non-nullable value type. * `where T : class`: Must be a reference type. * `where T : notnull`: Must be a non-nullable type (value or reference). * `where T : new()`: Must have a public parameterless constructor. * `where T : `: Must be or derive from the specified base class. * `where T : `: Must implement the specified interface. * `where T : unmanaged`: Must be an unmanaged type (contains no reference types at any level of nesting). ## Overload Resolution Generic methods participate in method overloading. You can overload methods based on the number of type parameters, as well as the standard method parameter signatures. ```csharp theme={"dark"} public class Processor { public void Process(int value) { } // Non-generic public void Process(T value) { } // Generic with one type parameter public void Process(T value, U id) { } // Generic with two type parameters } ``` During compilation, if a caller invokes `Process(42)`, the compiler's overload resolution rules will prefer the non-generic `Process(int)` over the generic `Process(T)` because exact, non-generic matches are given higher precedence than generic substitutions. ## Compilation and Runtime Behavior Unlike Java's type erasure, C# implements reified generics. The type parameters are preserved in the compiled Intermediate Language (IL) and resolved by the Just-In-Time (JIT) compiler at runtime. * **For Reference Types**: The JIT compiler generates a single native code implementation that is shared across all reference type arguments (e.g., `string`, `object`, custom classes), because all object references are the same size in memory. * **For Value Types**: The JIT compiler generates a distinct, specialized native code implementation for each unique value type argument (e.g., `int`, `double`, custom structs) to accommodate their differing memory footprints and alignment requirements.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More