Da Rivalidade com o Java ao Código Aberto: a História do C#

Uma linguagem nascida de um processo judicial, desenhada pelo criador do Turbo Pascal, que passou quase quinze anos presa ao Windows e depois se libertou.

Nenhuma linguagem de programação nasce no vácuo. O C nasceu para escrever o Unix. O Rust, da frustração com falhas de memória num navegador. O C# nasceu de uma briga entre duas das maiores empresas de tecnologia do mundo, e das mãos de um projetista que já tinha criado duas das ferramentas de programação mais amadas dos anos 80 e 90. Entender essa origem explica muita coisa que você vai ver na linguagem: por que ela se parece tanto com Java à primeira vista, por que ela divergiu tanto depois, e por que durante mais de uma década ela foi sinônimo de Windows.

O homem por trás da linguagem

Anders Hejlsberg é dinamarquês. No começo dos anos 80, escreveu um compilador Pascal tão rápido e compacto que a Borland o licenciou e o lançou em 1983 como Turbo Pascal. Para toda uma geração, aquele era o primeiro contato com um ambiente em que se editava, compilava e rodava o programa na mesma tela, em segundos. Anos depois, Hejlsberg foi o arquiteto-chefe do Delphi (1995), que levou a mesma produtividade ao desenvolvimento de aplicações gráficas para Windows.

Em 1996 a Microsoft o contratou. Ele trouxe consigo uma convicção que atravessa toda a sua carreira: uma linguagem precisa ser produtiva no uso diário, e as ferramentas ao redor dela (editor, compilador, depurador) fazem parte da linguagem tanto quanto a sintaxe. Guarde essa ideia. Ela explica por que o C# foi desenhado desde o início pensando em autocompletar, em refatoração e em mensagens de erro úteis.

A briga que criou uma linguagem

Em meados dos anos 90, o Java da Sun Microsystems era a novidade que prometia mudar tudo: "escreva uma vez, rode em qualquer lugar". A Microsoft licenciou o Java e criou sua própria implementação, o Visual J++. Só que adicionou extensões que funcionavam apenas no Windows e deixou de fora partes que a Sun considerava obrigatórias. Para a Sun, aquilo quebrava exatamente a promessa de portabilidade que tornava o Java valioso.

Em 1997 a Sun processou a Microsoft. O caso terminou em acordo em 2001, e a Microsoft foi obrigada a abandonar gradualmente sua versão de Java. Ficou um problema estratégico enorme: a empresa precisava de uma linguagem moderna, com memória gerenciada, orientada a objetos e segura, para a próxima geração de aplicações Windows e web. E não podia mais usar Java.

A resposta começou a ser desenhada em 1999, por uma equipe liderada por Hejlsberg, sob o nome provisório de Cool, sigla para C-like Object Oriented Language. A linguagem não viria sozinha. Ela seria a peça principal de uma plataforma inteira, que ganhou o nome de .NET, com uma máquina virtual, uma biblioteca padrão enorme e a capacidade de várias linguagens conversarem entre si.

O nome

Em julho de 2000, na conferência de desenvolvedores da Microsoft, o projeto foi apresentado ao público já com o nome definitivo: C#, pronunciado "C sharp". Na notação musical, o sustenido (♯) eleva uma nota em meio tom. A linguagem seria "o C um passo acima". Há também uma leitura tipográfica que os fãs adoram: o símbolo # lembra quatro sinais de + empilhados, como se fosse um "C++++".

Um detalhe prático: como o símbolo ♯ não existe no teclado, adotou-se oficialmente o caractere # (cerquilha). Em URLs e nomes de arquivo, onde o # tem significado especial, é comum ver "csharp" ou "cs". Por isso os arquivos de código C# terminam em .cs.

2002: o lançamento

Em fevereiro de 2002 a Microsoft lançou o .NET Framework 1.0 junto com o Visual Studio .NET, e com eles o C# 1.0. Pouco antes, em dezembro de 2001, a linguagem já tinha sido padronizada pela ECMA (norma ECMA-334) e, em 2003, viraria também norma ISO. Isso é importante: significa que, em tese, qualquer um podia implementar um compilador de C# sem pedir licença à Microsoft. Essa porta aberta seria usada em breve.

O C# 1.0 era, sim, bastante parecido com Java: classes, herança simples, interfaces, coleta de lixo, exceções. Mas já trazia diferenças que revelavam outra filosofia. Tinha propriedades e eventos como parte da linguagem, tipos de valor definidos pelo programador (struct), delegates (referências a métodos) e a possibilidade de usar ponteiros em blocos unsafe quando necessário. Hejlsberg nunca escondeu que o objetivo era manter a produtividade das linguagens gerenciadas sem abrir mão do controle quando ele fosse preciso.

Uma linguagem que não parou de crescer

O que realmente separou o C# do Java foi o ritmo de evolução. Cada versão acrescentou recursos que depois foram copiados por outras linguagens:

• C# 2.0 (2005): genéricos com informação de tipo preservada em tempo de execução, tipos anuláveis (int?), iteradores com yield.
• C# 3.0 (2007): o LINQ, consultas integradas à linguagem, e com ele as expressões lambda, a inferência de tipos com var e os métodos de extensão.
• C# 4.0 (2010): tipagem dinâmica (dynamic), parâmetros opcionais e nomeados.
• C# 5.0 (2012): async e await. Foi o C# que popularizou esse modelo de programação assíncrona, depois adotado por JavaScript, Python, Rust, Kotlin e muitas outras.
• C# 6.0 (2015): o novo compilador Roslyn, escrito em C# e de código aberto, e a interpolação de strings ($"Olá, {nome}").
• C# 7 (2017): tuplas e o início do pattern matching.
• C# 8.0 (2019): tipos de referência anuláveis, que atacam o famoso NullReferenceException.
• C# 9 e 10 (2020 e 2021): record, programas sem a cerimônia do Main e namespaces em uma linha.
• C# 11 a 13 (2022 a 2024): strings literais cruas, membros required, construtores primários e expressões de coleção.
• C# 14 (2025): membros de extensão e a palavra-chave field, que usaremos neste curso.

Hejlsberg acabou migrando para outro projeto seu, o TypeScript, e a liderança do desenho do C# passou para Mads Torgersen. Mas a filosofia continuou: evoluir sempre, sem quebrar o código que já existe.

Para sentir o tamanho dessa evolução, veja o mesmo problema resolvido duas vezes. O objetivo é imprimir os números pares de uma lista. Primeiro, no estilo do C# 1.0, que ainda compila hoje:

using System;
using System.Collections;

class Programa
{
    static void Main()
    {
        // C# 1.0: não existiam genéricos. ArrayList guarda qualquer coisa como "object".
        ArrayList numeros = new ArrayList();
        numeros.Add(1);
        numeros.Add(2);
        numeros.Add(3);
        numeros.Add(4);

        ArrayList pares = new ArrayList();
        foreach (object item in numeros)
        {
            int n = (int)item;   // conversão obrigatória: a lista não sabe que guarda inteiros
            if (n % 2 == 0)
                pares.Add(n);
        }

        foreach (object p in pares)
            Console.WriteLine(p);
    }
}

Agora no C# moderno:

// C# 12+: expressão de coleção, lambda e LINQ. Sem classe, sem Main explícito.
int[] numeros = [1, 2, 3, 4];

foreach (var par in numeros.Where(n => n % 2 == 0))
    Console.WriteLine(par);

Os dois imprimem 2 e 4. A segunda versão é mais curta, e também mais segura: o compilador sabe que a lista contém inteiros, então é impossível colocar uma string ali por engano. Na primeira versão, esse engano só explodiria com o programa rodando. Vamos entender cada peça da versão moderna ao longo da Fase 1 e da Fase 3.

Mono e a vida fora do Windows

Lembra da norma ECMA? Em 2001, o programador mexicano Miguel de Icaza, conhecido pelo projeto GNOME no Linux, anunciou o Mono: uma implementação independente e de código aberto do C# e do .NET para Linux e outros sistemas. O Mono chegou à versão 1.0 em 2004. Por anos foi a única forma de rodar C# fora do Windows.

O Mono teve dois filhos muito influentes. O primeiro foi o Xamarin, empresa fundada por Icaza em 2011 para escrever apps de iOS e Android em C#. A Microsoft a comprou em 2016. O segundo, talvez mais importante para a popularidade da linguagem, foi o Unity: o motor de jogos embutiu o Mono e adotou o C# como linguagem de script. Milhões de pessoas aprenderam C# fazendo jogos, sem nunca ter aberto o Visual Studio no Windows.

2014: a Microsoft abre o código

Durante a década de 2000, a Microsoft foi abertamente hostil ao software livre. Isso mudou com a chegada de Satya Nadella ao comando da empresa, em 2014. Naquele ano, o compilador Roslyn foi publicado como código aberto, a .NET Foundation foi criada, e a Microsoft anunciou algo que parecia impensável: uma nova versão do .NET, de código aberto e multiplataforma, desenvolvida em público no GitHub.

O .NET Core 1.0 saiu em 2016. Por alguns anos conviveram dois mundos: o antigo .NET Framework, só para Windows, e o novo .NET Core, para todos os sistemas. Em 2020 eles foram unificados no .NET 5. O número 4 foi pulado de propósito, para não confundir com o .NET Framework 4.x. Desde então sai uma versão nova todo novembro. As de número par (6, 8, 10) têm suporte de longo prazo (LTS), de três anos. As ímpares têm suporte mais curto. É por isso que este curso usa o .NET 10: é a LTS mais recente.

A mudança não foi só de licença. A equipe do .NET passou a tratar desempenho como prioridade absoluta. O ASP.NET Core aparece consistentemente entre os frameworks web mais rápidos nos benchmarks independentes da TechEmpower, e cada versão nova do .NET traz uma longa lista de otimizações medidas e publicadas.

Quem usa C# hoje

A resposta curta é: muito mais gente do que a fama sugere. Alguns exemplos concretos:

• A própria Microsoft, em serviços do Azure, no buscador Bing (que migrou para o .NET Core em 2018) e em boa parte das ferramentas de desenvolvimento.
• Stack Overflow, o site de perguntas e respostas que praticamente todo programador já usou, construído em C# com ASP.NET desde o início.
• Jogos em Unity: Hollow Knight, Cuphead, Among Us, Pokémon GO, Hearthstone, Cities: Skylines, Ori and the Blind Forest, entre milhares de outros. Toda a lógica desses jogos é escrita em C#.
• Jogos feitos com XNA e seus sucessores (FNA e MonoGame), como Stardew Valley, Terraria e Celeste.
• O motor Godot, que desde a versão 3 aceita C# como linguagem de primeira classe.
• A JetBrains, cujo ReSharper e boa parte do Rider, ferramentas usadas por milhões de desenvolvedores, são escritos em C#.
• Bancos, seguradoras, varejistas, ERPs e governos do mundo todo, inclusive no Brasil, onde C# é uma das linguagens mais pedidas em vagas corporativas.

Em 2023, o índice TIOBE, que mede a popularidade das linguagens, elegeu o C# como "linguagem do ano", pelo maior crescimento entre todas no período.

Mitos que ficaram para trás

Três ideias sobre C# ainda circulam e não são mais verdadeiras.

"C# só roda no Windows." Nunca foi exatamente verdade, porque o Mono rodava C# no Linux desde 2004, e deixou de ser de vez em 2016, com o .NET Core. Hoje o .NET roda em Linux, macOS e Windows, e a maioria das APIs C# em produção roda em contêineres Linux. Neste curso, tudo funciona em qualquer um dos três sistemas.

"C# é uma cópia do Java." Foi parecido em 2002. Depois, o C# introduziu genéricos reais, LINQ, async/await, tipos de valor definidos pelo usuário, pattern matching e records. Vários desses recursos chegaram ao Java anos depois, alguns com o C# citado como inspiração.

"Linguagem com coletor de lixo é lenta." O coletor tem custo, e vamos medi-lo com honestidade na aula sobre memória. Mas o .NET moderno oferece ferramentas (Span<T>, struct, pools de objetos, compilação nativa) que permitem escrever código com desempenho próximo ao de C++ nos trechos que importam. É exatamente assim que os jogos em Unity rodam a 60 quadros por segundo.

O que isso significa para você

A história explica o C# que você vai aprender. Ele foi desenhado por alguém obcecado por produtividade, então espere ferramentas excelentes e uma sintaxe que evita cerimônia. Ele evoluiu sem quebrar o passado, então você vai encontrar na internet código de 2008 que ainda compila, mas que não é mais a forma recomendada. Vou sempre mostrar a forma moderna e avisar quando você topar com a antiga. E ele se abriu para o mundo, então tudo que você aprender aqui serve em qualquer sistema operacional, na nuvem, no navegador, no celular e dentro de um motor de jogos.

Fontes e leituras recomendadas

• Histórico de versões do C# (Microsoft Learn): https://learn.microsoft.com/dotnet/csharp/whats-new/csharp-version-history. Traz a lista oficial do que cada versão da linguagem acrescentou.
• Norma ECMA-334, C# Language Specification: https://ecma-international.org/publications-and-standards/standards/ecma-334/. É a especificação formal da linguagem. Não é leitura para agora, mas é bom saber que existe.
• Repositório csharplang: https://github.com/dotnet/csharplang. Ali ficam as propostas e as atas das reuniões de design, com a história de cada recurso contada por quem o criou.
• Compilador Roslyn: https://github.com/dotnet/roslyn. É o compilador de C# que você vai usar, de código aberto e escrito em C#.
• Projeto Mono: https://www.mono-project.com. Registra a história da primeira implementação de C# fora do Windows.
• Jon Skeet, C# in Depth, 4ª edição (Manning, 2019): organizado versão por versão, é o melhor livro para entender por que cada recurso existe.

Exercícios

Exercício 1

Explique com suas palavras por que a Microsoft criou uma linguagem nova em vez de continuar investindo no Visual J++.

Exercício 2

Coloque em ordem cronológica: lançamento do .NET Core 1.0; padronização ECMA-334; unificação no .NET 5; lançamento do C# 1.0 com o .NET Framework; anúncio do Mono; compilador Roslyn aberto.

Exercício 3

Qual é a diferença entre "C#" e ".NET"? Por que é errado dizer que "C# é o .NET"?

Exercício 4

No exemplo do C# 1.0, o que aconteceria se alguém executasse numeros.Add("cinco"); antes do primeiro foreach? E na versão moderna?

Exercício 5

Escolha um jogo, site ou produto citado na seção "Quem usa C# hoje". Pesquise e descreva em duas ou três frases qual parte dele é escrita em C#.