Nesta postagem, vou analisar a implementação da sequência de Fibonacci em Python e C#, destacando as principais diferenças de sintaxe e conceitos de programação. Também vou explorar alguns princípios essenciais do C# para facilitar a transição para desenvolvedores Python. Tenho uma amiga que é apaixonada pelo .NET. Sempre que mostro a ela um trecho de código em Python, ela torce o nariz e diz: “Por que usar Python? O .NET é muito melhor!” Então, em homenagem a ela, resolvi converter esse código Python para C# e estudar as diferenças. Utilizei IA para gerar o código em C# e comentar o código, para me ajudar a entender. Achei esta abordagem fantástica para aprendizado, e pretendo me aprofundar em C# paralelamente utilizando esta forma de estudo.

Código em Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import time

cache = {0:0, 1:1}
calls = 0
cache_hits = 0

def fib(n: int) -> int:
    global calls, cache_hits
    if n in cache:
        cache_hits += 1
        return cache[n]
    else:
        calls += 1
        cache[n] = fib(n-1) + fib(n-2)
        return cache[n]

if __name__ == '__main__':
    n = 500

    start_time = time.perf_counter()
    result = fib(n)
    end_time = time.perf_counter()

    elapsed_time_ms = (end_time - start_time) * 1000

    print(f'{result}')
    print(f'{calls} chamadas de função e {cache_hits} acertos de cache.')
    print(f"Tempo decorrido: {elapsed_time_ms:.4f} ms")

Tradução para C#:

Abaixo o equivalente em C#:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

using System;
using System.Collections.Generic;
using System.Diagnostics;

public class Fibonacci
{
    private static Dictionary<int, long> cache = new Dictionary<int, long> { { 0, 0 }, { 1, 1 } };
    private static long calls = 0;
    private static long cacheHits = 0;

    public static long Fib(int n)
    {
        if (cache.ContainsKey(n))
        {
            cacheHits++;
            return cache[n];
        }
        else
        {
            calls++;
            cache[n] = Fib(n - 1) + Fib(n - 2);
            return cache[n];
        }
    }

    public static void Main(string[] args)
    {
        int n = 500;

        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();

        long result = Fib(n);

        stopwatch.Stop();
        double elapsedTimeMs = stopwatch.Elapsed.TotalMilliseconds;

        Console.WriteLine(result);
        Console.WriteLine($"{calls} chamadas de função e {cacheHits} acertos de cache.");
        Console.WriteLine($"Tempo decorrido: {elapsedTimeMs:F4} ms");
    }
}

Conceitos Chave para Desenvolvedores Python Transicionando para C#

Esta seção destaca os conceitos principais encontrados ao migrar do Python para o C#, com foco nas áreas onde as diferenças são mais pronunciadas.

• Tipagem Estática: Ao contrário da tipagem dinâmica do Python, o C# exige declarações de tipo explícitas (por exemplo, int idade = 30;). Isso impõe a segurança de tipo em tempo de compilação, detectando possíveis erros antecipadamente. É necessário familiarizar-se com os tipos de dados comuns do C#, como int, double, string, bool, char e long (usado para valores inteiros maiores).
• Paradigma de Programação Orientada a Objetos (POO): O C# é fundamentalmente orientado a objetos. O código é organizado em torno de classes, que servem como modelos para criar objetos. Os principais conceitos de POO a serem dominados incluem:
  • Classes e Objetos: Definir classes com propriedades (dados) e métodos (comportamento).
  • Encapsulamento: Proteger os dados dentro de uma classe e controlar o acesso usando modificadores de acesso (public, private, protected).
  • Herança: Criar novas classes com base em classes existentes, herdando suas características.
  • Polimorfismo: Permitir que objetos de diferentes classes respondam à mesma chamada de método de sua própria maneira.
• Namespaces: Organização do Código: Namespaces são como módulos Python, mas turbinados. Eles fornecem uma maneira hierárquica de organizar o código, evitando conflitos de nomenclatura e agrupando classes relacionadas. Usa-se a palavra-chave using para importar namespaces e acessar seu conteúdo (por exemplo, using System;).
• Métodos: Funções Vinculadas à Classe: Métodos são funções que pertencem a uma classe. Eles definem as ações que um objeto pode executar. Prestar atenção às assinaturas dos métodos, incluindo tipos de retorno, parâmetros e modificadores de acesso. A palavra-chave static permite definir métodos que pertencem à própria classe, em vez de a uma instância.
• Fluxo de Controle com Chaves: O C# usa chaves {} para definir blocos de código para instruções de fluxo de controle como if, else, for, while e switch. Esta é uma diferença sintática fundamental da abordagem baseada em indentação do Python.
• Coleções: Estruturas de Dados: O C# oferece um rico conjunto de classes de coleção para armazenar e gerenciar dados, incluindo arrays, listas (List<T>) e dicionários (Dictionary<TKey, TValue>).
• O Ecossistema .NET: O código C# é executado no runtime .NET. Compreender o básico do framework .NET, incluindo o Common Language Runtime (CLR) e a Base Class Library (BCL), fornece uma compreensão mais profunda de como o código C# é executado.

Lições Aprendidas: Principais Conclusões para Pythonistas

Após converter a sequência de Fibonacci e explorar esses conceitos básicos, aqui estão as lições mais significativas aprendidas:

• Abrace a Tipagem Estática: Embora possa parecer verboso no início, a tipagem estática leva a um código mais robusto e fácil de manter.
• POO é Fundamental: O C# é uma linguagem orientada a objetos de ponta a ponta.
• Aproveite o Framework .NET: O framework .NET fornece uma riqueza de classes e métodos pré-construídos que podem acelerar significativamente o desenvolvimento.
• A Sintaxe Importa: Prestar atenção à sintaxe, especialmente ao uso de chaves para blocos de código. Pequenos erros sintáticos podem impedir que o código seja compilado.
• IA como Acelerador de Aprendizagem: Usar ferramentas de IA para gerar código e explicar conceitos é maneira poderosa de aprender C#. Concentrar-se em entender o porquê por trás do código, em vez de apenas o como, é a diferença entre aprender de fato e deixar a IA fazer por você apenas.

Considerações Finais

Converter código Python para C# pode parecer intimidador no início, mas ao entender os conceitos principais e as diferenças de sintaxe, a transição se torna muito mais suave. Este exercício com a sequência de Fibonacci destaca a importância da tipagem estática, da programação orientada a objetos e da estrutura que os namespaces fornecem em C#. O que tornou essa experiência de aprendizado verdadeiramente poderosa foi o uso de IA para gerar o código C# inicial e fornecer explicações. Essa abordagem me permitiu focar em entender o porquê por trás do código, em vez de me perder em erros de sintaxe. Enquanto o Python oferece flexibilidade e prototipagem rápida, o C# traz robustez e desempenho, especialmente benéficos para aplicações maiores. É uma questão de saber qual linguagem utilizar em cada situação. Na minha opinião, o Python resolve a maioria dos problemas que não exijam desempenho e para tarefas rápidas. E, crucialmente, ao usar a IA como uma companheira de aprendizado, podemos acelerar o processo de dominar novas linguagens e paradigmas, tornando tarefas complexas como tradução entre linguagens e compreensão de conceitos significativamente mais acessíveis.