O que C# 3.0 não tem que C# 4.0 tem ?

Examinais as Escrituras, porque vós cuidais ter nelas a vida eterna, e são elas que de mim testificam; João 5:39

O C# 3.0 introduziu recursos revolucionários como LINQ, lambdas e tipos anônimos. Já o C# 4.0, lançado em conjunto com o .NET Framework 4.0 (em 2010), focou em produtividade, interoperabilidade com COM e dynamic typing, abrindo portas para uma linguagem ainda mais poderosa e versátil.

Neste artigo, você vai entender o que foi adicionado no C# 4.0, que não existia no C# 3.0 – com exemplos claros e comparações lado a lado.

🆕 Funcionalidades adicionadas no C# 4.0 (que não existem no C# 3.0)

🧪 1. dynamic – Tipagem dinâmica em tempo de execução

C# 3.0:

object pessoa = GetPessoa();

Console.WriteLine(((Pessoa)pessoa).Nome);

C# 4.0:

dynamic pessoa = GetPessoa();

Console.WriteLine(pessoa.Nome); // Sem cast, sem IntelliSense

Útil para interoperar com JavaScript, JSON dinâmico, COM, ou bibliotecas que retornam objetos indefinidos.

🧾 2. Argumentos nomeados

Chamadas de métodos com maior clareza.

// Suporte no C# 4.0:

EnviarEmail(destinatario: "[email protected]", assunto: "Olá", corpo: "Tudo certo?");

Excelente para melhorar legibilidade e evitar ambiguidade quando há muitos parâmetros.

🔧 3. Argumentos opcionais

C# 4.0:

void EnviarEmail(string destinatario, string assunto = "Sem assunto", string corpo = "")

{

    // ...

}



// Chamada possível:

EnviarEmail("[email protected]");

Antes disso, era necessário criar múltiplas sobrecargas do método.

🔄 4. Covariância e contravariância em genéricos

Permite usar subtipos em interfaces genéricas sem casting manual.

Exemplo: Covariância (entrada de dados)

IEnumerable<string> nomes = new List<string>();

IEnumerable<object> objetos = nomes; // Só possível a partir do C# 4.0

Exemplo: Contravariância (parâmetros de entrada)

Action<object> acao = x => Console.WriteLine(x);

Action<string> acaoStr = acao; // possível com contravariância

Essencial para programação genérica mais flexível, especialmente com interfaces como IEnumerable<T> e IComparer<T>.

📤 5. Melhoria na Interoperabilidade com COM (ex: Office)

Antes do C# 4.0, era necessário lidar com muitos ref, out, objetos como object, etc.

Antes (C# 3.0):

Excel.Range range = worksheet.Cells[1, 1] as Excel.Range;

range.Value2 = "Olá";

Com C# 4.0 (dynamic + argumentos opcionais):

var excel = new Microsoft.Office.Interop.Excel.Application();

excel.Workbooks.Add();

excel.Cells[1, 1] = "Olá mundo!";

Tornou o uso do Office Interop muito mais limpo.

📌 Resumo das diferenças

🤔 Por que essas mudanças importam?

• 🌐 Abertura para integração com sistemas dinâmicos (ex: scripts, JSON, JS)


• 💻 Código mais legível e menos verboso


• 🔄 Compatibilidade mais fluida com APIs existentes (Office, COM)


• 🤝 Menor necessidade de sobrecargas ou casts manuais

⚠️ Cuidados com dynamic

Embora poderoso, o uso excessivo de dynamic:

• Remove a verificação de tipos em tempo de compilação


• Afeta performance (por usar DLR)


• Pode causar erros em runtime difíceis de rastrear
  

Use com moderação, especialmente apenas onde o tipo realmente não é conhecido em tempo de compilação.

🎓 Conclusão

A transição do C# 3.0 para o C# 4.0 representou um refinamento da linguagem, com foco em produtividade, interoperabilidade e flexibilidade. Embora tenha introduzido menos recursos que o salto do 2.0 para 3.0, ele preparou o terreno para o que viria no C# 5, 6 e além.

🤝 Conecte-se Comigo

Quer aprender mais sobre a evolução do C#, boas práticas modernas e arquitetura em .NET? Vamos conversar!

• 💼 LinkedIn
  


• ✍️ Medium
  


• 📬 [email protected]