What are C# generics and why are they important?

C# generics allow developers to design classes, methods, interfaces, and delegates with a type of data that can be specified as a parameter. This enhances code reusability, type safety, and performance.

How do generic classes improve code flexibility in C#?

Generic classes, such as `Box `, provide a blueprint for creating instances with different data types, thereby increasing versatility and ensuring type safety without the need for casting.

Can you give an example of a generic method in C#?

Yes, a generic method like `Swap ` can operate on different types and is defined with type parameters at the method level, allowing for operations like swapping two elements in an array.

What role do generic interfaces and delegates play in C#?

Generic interfaces and delegates enable defining flexible contracts and type-safe callbacks, promoting code reuse and adaptability across different data types.

Why are generic collections preferred over non-generic ones?

Generic collections in the `System.Collections.Generic` namespace like `List ` and `Dictionary ` offer type-safe and efficient ways to store and manipulate data, minimizing runtime errors.

How can custom generic types be beneficial?

Custom generic types allow for encapsulating common operations across various data types, which is particularly useful in creating libraries and utilities for diverse applications.

How does IronPDF integrate with C# Generics?

IronPDF can be used with C# Generics to generate PDFs from HTML content, allowing customization through generic classes like `PdfOptions ` for flexible PDF generation.

What are the capabilities of the IronPDF library?

IronPDF is a versatile library for .NET developers to create, edit, and extract PDF documents, supporting tasks like converting HTML to PDF, editing PDFs, and converting PDFs to images.

What is an example of using IronPDF with generic code?

A generic method in IronPDF can create a PDF using the `PdfGenerator.GeneratePdf` method, which accepts a `PdfOptions ` to handle HTML to PDF conversions with customizable metadata.

How can developers try IronPDF's features?

Developers can explore IronPDF's capabilities by accessing a free trial of its PDF library tools, allowing them to integrate and test PDF functionalities within their applications.

The C# PDF Library

Explore IronPDF Start Free Trial

HTML to PDF

Online Demo See All Code Examples

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

.NET HELP

C# Generics (How It Works For Developers)

Jacob Mellor

Updated: July 19, 2026

C# generics introduce a way to design classes, methods, interfaces, and delegates where the type of data they manage can be specified as a parameter. This concept, known as a generic type parameter, allows for the creation of flexible and reusable code components. By using generics, you can maximize code reusability, type safety, and performance. For instance, a generic class can be defined once but instantiated with various data types, offering versatility and type integrity. In this article, we'll learn about the basics of C# Generics and IronPDF library features for PDF manipulation.

The Basics of Generic Classes

A generic class in C# is a blueprint for creating a class with a placeholder for the type it contains or operates on. This placeholder, often denoted by T, represents a type parameter that is specified when the class is instantiated. We can create generic classes with type parameter T to handle various data types. Generic classes are particularly useful for collection classes, like lists, queues, and hash tables, as they can hold any data type while ensuring type safety and reducing the need for casting.

Simple Example of a Generic Class

Consider a generic class named Box that is designed to store a value of any type:

public class Box<T>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

public class Box<T>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

Public Class Box(Of T)
'INSTANT VB NOTE: The field data was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private data_Conflict As T

	Public Sub New(ByVal data As T)
		Me.data_Conflict = data
	End Sub

	Public ReadOnly Property Data() As T
		Get
			Return data_Conflict
		End Get
	End Property
End Class

Public Class Box(Of T)
'INSTANT VB NOTE: The field data was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private data_Conflict As T

	Public Sub New(ByVal data As T)
		Me.data_Conflict = data
	End Sub

	Public ReadOnly Property Data() As T
		Get
			Return data_Conflict
		End Get
	End Property
End Class

To use this class, you create an instance specifying the actual type for T:

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

This code illustrates how a single class (Box<T>) can adapt to store different data types (int, string), showcasing the power of generics for code reuse and type safety.

Implementing Generic Methods

Generic methods are similar to generic classes but are defined with type parameters at the method level. This allows for creating methods that can operate on different types while being defined in a non-generic class or a generic one.

Example of a Generic Method

Here's a method that swaps two elements in an array of any type:

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

Public Class Utility
	' Swaps two elements by reference using generics
	Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
		Dim temp As T = lhs ' Store lhs in a temporary variable
		lhs = rhs ' Assign rhs to lhs
		rhs = temp ' Assign temp (original lhs) to rhs
	End Sub
End Class

Public Class Utility
	' Swaps two elements by reference using generics
	Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
		Dim temp As T = lhs ' Store lhs in a temporary variable
		lhs = rhs ' Assign rhs to lhs
		rhs = temp ' Assign temp (original lhs) to rhs
	End Sub
End Class

Usage of the above method can be as follows:

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Exploring Generic Interfaces and Delegates

Generic interfaces and delegates enable defining contracts and callback methods that can operate with any type. Implementing a generic interface or using a generic delegate in your class or method enhances flexibility and code reuse.

Generic Interface Example

A generic repository interface for data access operations might look like this:

public interface IRepository<T>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<T> GetAll();
}

public interface IRepository<T>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<T> GetAll();
}

Public Interface IRepository(Of T)
	Sub Add(ByVal item As T)
	Function GetById(ByVal id As Integer) As T
	Function GetAll() As IEnumerable(Of T)
End Interface

Public Interface IRepository(Of T)
	Sub Add(ByVal item As T)
	Function GetById(ByVal id As Integer) As T
	Function GetAll() As IEnumerable(Of T)
End Interface

This interface can be implemented by any class to handle specific data types, allowing for consistent data access patterns across different types.

Generic Delegate Example

A generic delegate could be used to define a type-safe callback:

public delegate void Action<T>(T item);

public delegate void Action<T>(T item);

Public Delegate Sub Action(Of T)(ByVal item As T)

Public Delegate Sub Action(Of T)(ByVal item As T)

Utilizing Generic Collections

Generic collection classes, such as List<T>, Dictionary<TKey, TValue>, and others in the System.Collections.Generic namespace, offer type-safe, efficient collections for storing and manipulating data of any specific type. These collections are superior to their non-generic counterparts because they eliminate the need for casting and reduce runtime errors.

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Creating Custom Generic Types

Beyond using built-in generic types, you can create your own to encapsulate operations that are common across different data types but need to be handled in a type-specific manner. This approach is particularly useful for building libraries, frameworks, or utilities that are to be used with various data types.

Custom Generic Type Example

Consider a generic Result class that encapsulates operation results along with a success flag and an optional message:

public class Result<T>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

public class Result<T>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

Public Class Result(Of T)
	Private privateSuccess As Boolean
	Public Property Success() As Boolean
		Get
			Return privateSuccess
		End Get
		Private Set(ByVal value As Boolean)
			privateSuccess = value
		End Set
	End Property
	Private privateData As T
	Public Property Data() As T
		Get
			Return privateData
		End Get
		Private Set(ByVal value As T)
			privateData = value
		End Set
	End Property
	Private privateMessage As String
	Public Property Message() As String
		Get
			Return privateMessage
		End Get
		Private Set(ByVal value As String)
			privateMessage = value
		End Set
	End Property

	Public Sub New(ByVal success As Boolean, ByVal data As T, Optional ByVal message As String = "")
		Me.Success = success
		Me.Data = data
		Me.Message = message
	End Sub
End Class

Public Class Result(Of T)
	Private privateSuccess As Boolean
	Public Property Success() As Boolean
		Get
			Return privateSuccess
		End Get
		Private Set(ByVal value As Boolean)
			privateSuccess = value
		End Set
	End Property
	Private privateData As T
	Public Property Data() As T
		Get
			Return privateData
		End Get
		Private Set(ByVal value As T)
			privateData = value
		End Set
	End Property
	Private privateMessage As String
	Public Property Message() As String
		Get
			Return privateMessage
		End Get
		Private Set(ByVal value As String)
			privateMessage = value
		End Set
	End Property

	Public Sub New(ByVal success As Boolean, ByVal data As T, Optional ByVal message As String = "")
		Me.Success = success
		Me.Data = data
		Me.Message = message
	End Sub
End Class

IronPDF: C# PDF Library

IronPDF is a comprehensive library designed for .NET developers to create, edit, and extract PDF documents within their applications. IronPDF helps in generating PDFs from HTML, editing existing PDFs, converting PDFs to images, and many more. While IronPDF itself is not based on generics, understanding how to interact with this library in a C# environment can greatly enhance your application's document management capabilities.

Code Example: Using virtual Keyword with IronPDF

The idea behind using generics here is to create a reusable method that can generate a PDF from any given HTML string. This method will be generic, allowing us to specify different types of metadata or configurations as needed.

First, let's define a simple generic class that will hold our PDF generation options. For demonstration purposes, this class will be basic, but you can expand it with more properties to suit your needs.

public class PdfOptions<T>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

public class PdfOptions<T>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

Public Class PdfOptions(Of T)
	Public Property Metadata() As T
	Public Property HtmlContent() As String
End Class

Public Class PdfOptions(Of T)
	Public Property Metadata() As T
	Public Property HtmlContent() As String
End Class

Now, let's create a static method that generates a PDF using IronPDF, leveraging our PdfOptions<T> class. This method will take an instance of PdfOptions<T> as its parameter, showcasing the use of generics in action.

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<T>(PdfOptions<T> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<T>(PdfOptions<T> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
	' Generates a PDF from provided HTML content and options
	Public Sub GeneratePdf(Of T)(ByVal options As PdfOptions(Of T))
		' Initialize the IronPDF HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()

		' Optional: Apply any renderer options here, for example, setting the paper size
		renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

		' Generate the PDF from HTML content
		Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

		' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
		' For simplicity, we're just printing the metadata to console if it's of type string
		Dim tempVar As Boolean = TypeOf options.Metadata Is String
		Dim metadataString As String = If(tempVar, CStr(options.Metadata), Nothing)
		If tempVar Then
			Console.WriteLine($"Metadata: {metadataString}")
		End If

		' Save the PDF to a file
		Dim fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
		pdfDocument.SaveAs(fileName)
		Console.WriteLine($"PDF generated and saved as {fileName}")
	End Sub
End Module

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
	' Generates a PDF from provided HTML content and options
	Public Sub GeneratePdf(Of T)(ByVal options As PdfOptions(Of T))
		' Initialize the IronPDF HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()

		' Optional: Apply any renderer options here, for example, setting the paper size
		renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

		' Generate the PDF from HTML content
		Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

		' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
		' For simplicity, we're just printing the metadata to console if it's of type string
		Dim tempVar As Boolean = TypeOf options.Metadata Is String
		Dim metadataString As String = If(tempVar, CStr(options.Metadata), Nothing)
		If tempVar Then
			Console.WriteLine($"Metadata: {metadataString}")
		End If

		' Save the PDF to a file
		Dim fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
		pdfDocument.SaveAs(fileName)
		Console.WriteLine($"PDF generated and saved as {fileName}")
	End Sub
End Module

Finally, let's use our PdfGenerator class to generate a PDF document. In this example, the Metadata property could be a string containing a title or any other information you find relevant.

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

This example illustrates the basics of integrating IronPDF with C# Generics, providing a flexible way to generate PDFs from HTML content while allowing for customizable metadata or configurations through the generic PdfOptions<T> class. You can expand upon this by adding more sophisticated options and renderer configurations as needed for your application.

C# Generics (How It Works For Developers): Figure 1 - Example code output utilizing generics to create a PDF document from an HTML string using IronPDF

Conclusion

C# generics is a powerful tool for developing high-quality, reusable, and type-safe code. By understanding and applying generic classes, methods, interfaces, and delegates, you can write code that is more adaptable and easier to maintain. Generics not only enable code reuse across different data types but also ensure compile-time type checking, which reduces runtime errors and improves overall code quality. IronPDF offers a free trial of its PDF library tools, with costs from $999 onwards.

Jacob Mellor

Chat with engineering team now

Chief Technology Officer

Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.

...