C# Academy · Aula

Entendendo a reflexão em C#

Use a reflexão para inspecionar e manipular objetos durante a execução

Entendendo a reflexão em C# é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 5 de 5. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 5 aulas no total.

Introdução à reflexão

Entendendo a reflexão em C#

Boas-vindas à próxima lição! Nesta lição, você aprenderá sobre reflexão em C#, um recurso avançado que permite inspecionar e interagir com tipos e objetos em tempo de execução. Vamos começar!

O que é reflexão?

Reflexão é a capacidade de um programa inspecionar e manipular sua própria estrutura em tempo de execução. Ela é comumente usada para:

Acessar metadados sobre tipos, métodos e propriedades.
Invocar métodos dinamicamente e acessar campos.
Criar estruturas e ferramentas, como serializadores e mapeadores objeto-relacionais.

Ponto principal: a reflexão faz parte do namespace System.Reflection.

Acessando informações de tipos

Use a classe Type para acessar metadados sobre um tipo. Exemplo:

Dica: use GetProperties, GetMethods e GetFields para inspecionar os membros de um tipo.

using System;

class SampleClass {
    public int Id { get; set; }
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);

        Console.WriteLine("Type Name: " + type.Name);
        Console.WriteLine("Properties:");
        foreach (var prop in type.GetProperties()) {
            Console.WriteLine("- " + prop.Name);
        }
    }
}

Criando objetos dinamicamente

Você pode usar reflexão para criar instâncias de uma classe dinamicamente. Exemplo:

Ponto principal: use Activator.CreateInstance para criar objetos em tempo de execução.

using System;

class SampleClass {
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var property = type.GetProperty("Name");
        property.SetValue(instance, "Reflection Example");

        Console.WriteLine("Name: " + property.GetValue(instance));
    }
}

Invocando métodos dinamicamente

A reflexão permite chamar métodos em tempo de execução sem conhecê-los no momento da compilação. Exemplo:

Dica: use GetMethod e Invoke para chamadas dinâmicas de métodos.

using System;

class SampleClass {
    public void Greet(string name) {
        Console.WriteLine("Hello, " + name);
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var method = type.GetMethod("Greet");
        method.Invoke(instance, new object[] { "World" });
    }
}

Trabalhando com attributes

A reflexão pode ser usada para inspecionar attributes personalizados aplicados a tipos, métodos ou propriedades. Exemplo:

Ponto principal: use GetCustomAttributes para recuperar informações sobre attributes.

using System;

[AttributeUsage(AttributeTargets.Class)]
class SampleAttribute : Attribute {
    public string Description { get; }
    public SampleAttribute(string description) {
        Description = description;
    }
}

[Sample("This is a sample class.")]
class SampleClass {}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        var attributes = type.GetCustomAttributes(typeof(SampleAttribute), false);

        foreach (SampleAttribute attr in attributes) {
            Console.WriteLine("Description: " + attr.Description);
        }
    }
}

Desafio prático

Crie um programa que use reflexão para inspecionar uma classe, listar seus métodos e propriedades e invocar um de seus métodos dinamicamente. Exemplo:

using System;

class SampleClass {
    public int Add(int a, int b) {
        return a + b;
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        Console.WriteLine("Methods:");
        foreach (var method in type.GetMethods()) {
            Console.WriteLine("- " + method.Name);
        }

        object instance = Activator.CreateInstance(type);
        var addMethod = type.GetMethod("Add");
        int result = (int)addMethod.Invoke(instance, new object[] { 5, 3 });

        Console.WriteLine("Result of Add: " + result);
    }
}

Práticas recomendadas para usar reflexão

Veja algumas práticas recomendadas:

Use reflexão com moderação, pois ela pode afetar o desempenho.
Armazene em cache os resultados da reflexão para melhorar a eficiência em chamadas repetidas.
Prefira soluções em tempo de compilação à reflexão quando possível.
Use reflexão em cenários dinâmicos, como extensões e estruturas de software.

Dica: combine reflexão com attributes personalizados para criar aplicativos flexíveis e dinâmicos.

Ótimo trabalho!

Parabéns! Você aprendeu a usar reflexão para inspecionar e manipular tipos em tempo de execução em C#. Isso conclui a categoria "Recursos avançados de C#". Vamos avançar para mais aventuras de programação!

Entendendo a reflexão em C# — ilustração 10

Perguntas Frequentes

A aula “Entendendo a reflexão em C#” é grátis?

Sim — o texto completo de “Entendendo a reflexão em C#” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 5 aulas no total.

O que vou aprender em “Entendendo a reflexão em C#”?

Use a reflexão para inspecionar e manipular objetos durante a execução Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 5 de 5.

Quanto tempo leva a aula “Entendendo a reflexão em C#”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Genéricos em C#
Async e Await: trabalhando com código assíncrono
Entendendo encadeamentos e tarefas
Explorando delegados e lambdas
Entendendo a reflexão em C#

← Voltar para C# Academy