C# Academy · Aula

O tipo dynamic

Adie a resolução do tipo para a execução usando dynamic.

O tipo dynamic é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. 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 4 aulas no total.

O que é dynamic?

O tipo dynamic ignora a verificação de tipos em tempo de compilação. O acesso a membros e as operações são resolvidos em tempo de execução.

using System;

class Program {
    static void Main() {
        dynamic value = 10;
        Console.WriteLine(value + 5);
    }
}

Reatribuindo tipos diferentes

Uma variável dynamic pode armazenar qualquer tipo e até mesmo mudar de tipo entre atribuições.

using System;

class Program {
    static void Main() {
        dynamic x = 1;
        Console.WriteLine(x);
        x = "now a string";
        Console.WriteLine(x);
    }
}

Associação em tempo de execução

Com dynamic, o compilador confia em você. As buscas por métodos e propriedades acontecem quando a linha é executada, não quando é compilada.

using System;

class Program {
    static void Main() {
        dynamic text = "hello";
        Console.WriteLine(text.ToUpper());
    }
}

Os erros aparecem em tempo de execução

Como a verificação é adiada, um membro incorreto lança uma RuntimeBinderException em tempo de execução, em vez de falhar na compilação.

using System;
using Microsoft.CSharp.RuntimeBinder;

class Program {
    static void Main() {
        dynamic n = 5;
        try {
            n.NoSuchMethod();
        } catch (RuntimeBinderException) {
            Console.WriteLine("No such member");
        }
    }
}

dynamic versus var

var é fixo em tempo de compilação; dynamic permanece flexível em tempo de execução. Eles parecem semelhantes, mas se comportam de maneiras muito diferentes.

using System;

class Program {
    static void Main() {
        var fixedType = 10;
        dynamic flexible = 10;
        flexible = "changed";
        Console.WriteLine(fixedType + " " + flexible);
    }
}

Aritmética com dynamic

Os operadores em dynamic são resolvidos em tempo de execução com base nos valores envolvidos.

using System;

class Program {
    static void Main() {
        dynamic a = 3;
        dynamic b = 4;
        Console.WriteLine(a * b);
    }
}

Valores retornados dynamic

Um método pode retornar dynamic quando o tipo realmente varia, mas quem o chama perde o suporte do compilador em tempo de compilação.

using System;

class Program {
    static dynamic GetValue(bool flag) {
        return flag ? (dynamic)42 : "text";
    }
    static void Main() {
        Console.WriteLine(GetValue(true));
        Console.WriteLine(GetValue(false));
    }
}

Casos de uso de dynamic

dynamic ajuda na interoperabilidade com COM, em dados semelhantes a JSON e ao chamar código cuja estrutura só é conhecida em tempo de execução.

using System;

class Program {
    static void Main() {
        dynamic data = 100;
        data += 1;
        Console.WriteLine(data);
    }
}

Custo de desempenho

A associação em tempo de execução tem um custo adicional. Para laços de repetição críticos ou código simples, prefira tipos estáticos por velocidade e segurança.

using System;

class Program {
    static void Main() {
        int fast = 0;
        for (int i = 0; i < 5; i++) fast += i;
        Console.WriteLine(fast);
    }
}

Sem IntelliSense

Os editores não podem sugerir membros para um dynamic, pois o tipo só é conhecido em tempo de execução. Isso torna o desenvolvimento mais lento.

using System;

class Program {
    static void Main() {
        dynamic s = "Code";
        Console.WriteLine(s.Length);
    }
}

Use com moderação

Recorra a dynamic somente quando a tipagem estática realmente não puder expressar o cenário; caso contrário, prefira tipos concretos.

using System;

class Program {
    static void Main() {
        dynamic flexible = 7;
        Console.WriteLine(flexible.GetType().Name);
    }
}

Verificação rápida

Teste sua compreensão de dynamic.

Recapitulação

dynamic desativa a verificação de tipos em tempo de compilação e resolve os membros em tempo de execução; assim, uma variável dynamic pode mudar de tipo e chamadas inválidas lançam RuntimeBinderException.

Ao contrário de var, que é fixo em tempo de compilação, dynamic é flexível, mas custa desempenho, perde o IntelliSense e deve ser usado com moderação.

Perguntas Frequentes

A aula “O tipo dynamic” é grátis?

Sim — o texto completo de “O tipo dynamic” é 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 4 aulas no total.

O que vou aprender em “O tipo dynamic”?

Adie a resolução do tipo para a execução usando dynamic. 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 3 de 4.

Quanto tempo leva a aula “O tipo dynamic”?

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

← Voltar para C# Academy