O que são genéricos em C#?

Os genéricos em C# introduzem uma maneira de projetar classes, métodos, interfaces e delegates com um parâmetro de tipo. Isso permite a criação de componentes de código flexíveis e reutilizáveis que oferecem segurança de tipos e melhorias de desempenho.

Como funcionam as classes genéricas em C#?

Uma classe genérica em C# usa um parâmetro de tipo, geralmente denotado por T , que atua como um marcador para o tipo que ela contém ou sobre o qual opera. Isso permite que a classe seja instanciada com vários tipos de dados, mantendo a segurança de tipos.

Você pode dar um exemplo de uma classe genérica em C#?

Sim, um exemplo simples é uma classe Box que armazena um valor de qualquer tipo. Você pode criar instâncias como Box ou Box para armazenar diferentes tipos de dados usando a mesma classe.

O que é um método genérico em C#?

Um método genérico é definido com parâmetros de tipo no nível do método, permitindo que ele opere em diferentes tipos. Ele pode fazer parte de uma classe não genérica ou genérica, proporcionando flexibilidade no projeto do método.

Quais são os benefícios de usar coleções genéricas em C#?

Coleções genéricas como List e Dictionary oferecem armazenamento seguro e eficiente para qualquer tipo específico, eliminando a necessidade de conversão e reduzindo erros em tempo de execução.

Como posso criar tipos genéricos personalizados em C#?

Você pode criar tipos genéricos personalizados para encapsular operações comuns a diferentes tipos de dados, mas tratadas de maneira específica para cada tipo, o que é útil para criar bibliotecas ou utilitários.

Como os genéricos em C# podem melhorar a geração de PDFs no .NET?

Os genéricos em C# podem ser utilizados com uma biblioteca PDF para criar componentes flexíveis e reutilizáveis. Por exemplo, uma classe PdfOptions pode ser usada para armazenar opções de geração de PDF, demonstrando a adaptabilidade dos genéricos nas tarefas de PDF.

Como posso utilizar uma biblioteca PDF com genéricos em C#?

Uma biblioteca de PDF, como o IronPDF, pode usar genéricos em C# para aprimorar sua funcionalidade. Por exemplo, um método genérico poderia ser usado para converter HTML em PDF, proporcionando uma abordagem flexível para a geração de documentos.

Quais são as vantagens de usar genéricos em C#?

Os genéricos em C# permitem a reutilização de código em diferentes tipos de dados, garantem a verificação de tipos em tempo de compilação, reduzem erros em tempo de execução e melhoram a qualidade geral do código. Eles possibilitam a escrita de código adaptável e de fácil manutenção.

A biblioteca C# PDF

Q: Como interfaces genéricas e delegates podem ser usados em C#?

Interfaces genéricas e delegados permitem a definição de contratos e métodos de retorno de chamada que podem operar com qualquer tipo, aumentando a flexibilidade e a reutilização de código.

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

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

ATUALIZAÇÕES DO DESENVOLVEDOR

Genéricos em C# (Como funciona para desenvolvedores)

Curtis Chau

Updated: 19 de julho de 2026

Os genéricos em C# introduzem uma maneira de projetar classes, métodos, interfaces e delegados onde o tipo de dados que eles gerenciam pode ser especificado como um parâmetro. Esse conceito, conhecido como parâmetro de tipo genérico, permite a criação de componentes de código flexíveis e reutilizáveis. Ao usar genéricos , você pode maximizar a reutilização de código, a segurança de tipos e o desempenho. Por exemplo, uma classe genérica pode ser definida uma única vez, mas instanciada com vários tipos de dados, oferecendo versatilidade e integridade de tipos. Neste artigo, aprenderemos sobre os conceitos básicos de genéricos em C# e os recursos da biblioteca IronPDF para manipulação de PDFs .

Noções básicas de classes genéricas

Uma classe genérica em C# é um modelo para criar uma classe com um espaço reservado para o tipo que ela contém ou sobre o qual opera. Este marcador, geralmente denotado por T , representa um parâmetro de tipo que é especificado quando a classe é instanciada. Podemos criar classes genéricas com parâmetro de tipo T para lidar com diversos tipos de dados. Classes genéricas são particularmente úteis para classes de coleção, como listas, filas e tabelas hash, pois podem armazenar qualquer tipo de dado, garantindo a segurança de tipos e reduzindo a necessidade de conversão de tipos.

Exemplo simples de uma classe genérica

Considere uma classe genérica chamada Box , projetada para armazenar um valor de qualquer tipo:

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)
    Private data As T

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

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Public Class Box(Of T)
    Private data As T

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

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Para usar essa classe, você cria uma instância especificando o tipo real para 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")

Este código ilustra como uma única classe (Box) pode se adaptar para armazenar diferentes tipos de dados (int, string), demonstrando o poder dos genéricos para reutilização de código e segurança de tipos.

Implementando métodos genéricos

Os métodos genéricos são semelhantes às classes genéricas, mas são definidos com parâmetros de tipo no nível do método. Isso permite a criação de métodos que podem operar em diferentes tipos, mesmo estando definidos em uma classe não genérica ou em uma genérica.

Exemplo de um método genérico

Aqui está um método que troca dois elementos em uma matriz de qualquer tipo:

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

A utilização do método acima pode ser feita da seguinte forma:

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)

Explorando interfaces genéricas e delegados

Interfaces genéricas e delegados permitem definir contratos e métodos de retorno de chamada que podem operar com qualquer tipo. Implementar uma interface genérica ou usar um delegado genérico em sua classe ou método aumenta a flexibilidade e a reutilização de código.

Exemplo de interface genérica

Uma interface genérica de repositório para operações de acesso a dados poderia ser semelhante a esta:

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(item As T)
    Function GetById(id As Integer) As T
    Function GetAll() As IEnumerable(Of T)
End Interface

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

Essa interface pode ser implementada por qualquer classe para lidar com tipos de dados específicos, permitindo padrões de acesso a dados consistentes em diferentes tipos.

Exemplo genérico de delegado

Um delegado genérico pode ser usado para definir um retorno de chamada com segurança de tipo:

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

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

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

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

Utilizando Coleções Genéricas

Classes de coleções genéricas, como List, Dictionary<TKey, TValue>, e outras no namespace System.Collections.Generic, oferecem coleções eficientes e seguras para armazenar e manipular dados de qualquer tipo específico. Essas coleções são superiores às suas contrapartes não genéricas porque eliminam a necessidade de conversão de tipos e reduzem os erros de tempo de execução.

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")

Criando tipos genéricos personalizados

Além de usar tipos genéricos predefinidos, você pode criar os seus próprios para encapsular operações que são comuns a diferentes tipos de dados, mas que precisam ser tratadas de maneira específica para cada tipo. Essa abordagem é particularmente útil para a construção de bibliotecas, estruturas ou utilitários que serão usados com diversos tipos de dados.

Exemplo de tipo genérico personalizado

Considere uma classe Result genérica que encapsula os resultados da operação juntamente com um indicador de sucesso e uma mensagem opcional:

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)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

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

Public Class Result(Of T)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

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

IronPDF: Biblioteca PDF em C#

IronPDF é uma biblioteca abrangente projetada para desenvolvedores .NET criarem, editarem e extrairem documentos PDF em seus aplicativos. O IronPDF ajuda a gerar PDFs a partir de HTML , editar PDFs existentes, converter PDFs em imagens e muito mais. Embora o IronPDF em si não seja baseado em genéricos, entender como interagir com essa biblioteca em um ambiente C# pode aprimorar significativamente os recursos de gerenciamento de documentos do seu aplicativo.

Exemplo de código: Usando palavra-chave virtual com IronPDF

A ideia por trás do uso de genéricos aqui é criar um método reutilizável que possa gerar um PDF a partir de qualquer string HTML fornecida. Este método será genérico, permitindo-nos especificar diferentes tipos de metadados ou configurações conforme necessário.

Primeiro, vamos definir uma classe genérica simples que irá armazenar nossas opções de geração de PDF. Para fins de demonstração, esta classe será básica, mas você pode expandi-la com mais propriedades para atender às suas necessidades.

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

Agora, vamos criar um método estático que gera um PDF usando IronPDF, aproveitando nossa classe PdfOptions. Este método aceitará uma instância de PdfOptions como seu parâmetro, demonstrando o uso de genéricos em ação.

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)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As 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
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

        ' Save the PDF to a file
        Dim fileName As String = $"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)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As 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
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

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

Finalmente, vamos usar nossa classe PdfGenerator para gerar um documento PDF. Neste exemplo, a propriedade Metadata poderia ser uma string contendo um título ou qualquer outra informação que você considere relevante.

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

Este exemplo ilustra o básico de integrar o IronPDF com C# Generics, proporcionando uma maneira flexível de gerar PDFs a partir de conteúdo HTML, permitindo ao mesmo tempo a personalização de metadados ou configurações através da classe genérica PdfOptions. Você pode expandir isso adicionando opções mais sofisticadas e configurações de renderização conforme necessário para sua aplicação.

C# Genéricos (Como Funciona para Desenvolvedores): Figura 1 - Saída de código exemplo utilizando genéricos para criar um documento PDF a partir de uma string HTML usando IronPDF

Conclusão

Os genéricos em C# são uma ferramenta poderosa para desenvolver código de alta qualidade, reutilizável e com segurança de tipos. Ao compreender e aplicar classes, métodos, interfaces e delegates genéricos, você pode escrever um código mais adaptável e fácil de manter. Os genéricos não apenas permitem a reutilização de código em diferentes tipos de dados, mas também garantem a verificação de tipos em tempo de compilação, o que reduz erros em tempo de execução e melhora a qualidade geral do código. IronPDF oferece uma avaliação gratuita de suas ferramentas de biblioteca PDF, com custos a partir de $999 em diante.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...