C#: Desenvolvimento Moderno com .NET

C# é uma linguagem de programação moderna, orientada a objetos e type-safe desenvolvida pela Microsoft. Desde seu lançamento em 2000, C# evoluiu para uma linguagem poderosa e versátil usada em desenvolvimento web, desktop, mobile, jogos (Unity), e cloud computing.

Por que C#? C# combina a produtividade de linguagens de alto nível com performance próxima de linguagens de sistema. Com o .NET Core/5+, agora é verdadeiramente multiplataforma.

Características Modernas

1. LINQ - Consultas integradas à linguagem
2. Async/Await - Programação assíncrona elegante
3. Pattern Matching - Correspondência de padrões expressiva
4. Records - Tipos imutáveis concisos
5. Nullable Reference Types - Segurança contra null
6. Source Generators - Geração de código em tempo de compilação

Fundamentos

Tipos e Variáveis

// Tipos primitivos
string nome = "Maria";
int idade = 25;
double altura = 1.68;
bool ativo = true;
char inicial = 'M';
decimal salario = 5000.50m;

// Inferência de tipo com var
var email = "[email protected]";
var lista = new List<int> { 1, 2, 3 };

// Nullable types
int? valorOpcional = null;
valorOpcional = 42;

// Arrays
int[] numeros = { 1, 2, 3, 4, 5 };
string[,] matriz = { { "a", "b" }, { "c", "d" } };

// Collections
var frutas = new List<string> { "maçã", "banana", "laranja" };
var usuarios = new Dictionary<string, int>
{
    ["alice"] = 25,
    ["bob"] = 30
};

// Tuplas
(string Nome, int Idade) pessoa = ("Maria", 25);
var (nome2, idade2) = pessoa; // Deconstruction

Classes e Objetos

// Classe tradicional
public class Usuario
{
    // Propriedades automáticas
    public int Id { get; set; }
    public string Nome { get; set; }
    public string Email { get; private set; }
    public DateTime CriadoEm { get; init; } // Init-only

    // Construtor
    public Usuario(int id, string nome, string email)
    {
        Id = id;
        Nome = nome;
        Email = email;
        CriadoEm = DateTime.UtcNow;
    }

    // Método
    public string Saudar() => $"Olá, {Nome}!";

    // Método com expressão
    public bool IsAtivo => CriadoEm > DateTime.UtcNow.AddDays(-30);
}

// Record (C# 9+) - imutável por padrão
public record Produto(string Nome, decimal Preco, int Quantidade)
{
    public decimal ValorTotal => Preco * Quantidade;
}

// Record struct (C# 10+)
public readonly record struct Coordenada(double X, double Y);

// Classe abstrata
public abstract class Forma
{
    public abstract double CalcularArea();
    public abstract double CalcularPerimetro();
    
    public void Descrever()
    {
        Console.WriteLine($"Área: {CalcularArea():F2}, Perímetro: {CalcularPerimetro():F2}");
    }
}

public class Retangulo : Forma
{
    public double Largura { get; }
    public double Altura { get; }

    public Retangulo(double largura, double altura)
    {
        Largura = largura;
        Altura = altura;
    }

    public override double CalcularArea() => Largura * Altura;
    public override double CalcularPerimetro() => 2 * (Largura + Altura);
}

Interfaces e Generics

// Interface
public interface IRepositorio<T> where T : class
{
    Task<T?> ObterPorIdAsync(int id);
    Task<IEnumerable<T>> ListarTodosAsync();
    Task AdicionarAsync(T entidade);
    Task AtualizarAsync(T entidade);
    Task RemoverAsync(int id);
}

// Implementação
public class UsuarioRepositorio : IRepositorio<Usuario>
{
    private readonly List<Usuario> _usuarios = new();

    public Task<Usuario?> ObterPorIdAsync(int id)
    {
        return Task.FromResult(_usuarios.FirstOrDefault(u => u.Id == id));
    }

    public Task<IEnumerable<Usuario>> ListarTodosAsync()
    {
        return Task.FromResult<IEnumerable<Usuario>>(_usuarios);
    }

    public Task AdicionarAsync(Usuario entidade)
    {
        _usuarios.Add(entidade);
        return Task.CompletedTask;
    }

    public Task AtualizarAsync(Usuario entidade)
    {
        var index = _usuarios.FindIndex(u => u.Id == entidade.Id);
        if (index >= 0) _usuarios[index] = entidade;
        return Task.CompletedTask;
    }

    public Task RemoverAsync(int id)
    {
        _usuarios.RemoveAll(u => u.Id == id);
        return Task.CompletedTask;
    }
}

LINQ

var produtos = new List<Produto>
{
    new("Laptop", 3500, 2),
    new("Mouse", 150, 10),
    new("Teclado", 300, 5),
    new("Monitor", 1200, 3)
};

// Query syntax
var caros = from p in produtos
            where p.Preco > 500
            orderby p.Preco descending
            select p;

// Method syntax
var baratos = produtos
    .Where(p => p.Preco <= 500)
    .OrderBy(p => p.Nome)
    .ToList();

// Agregações
var total = produtos.Sum(p => p.ValorTotal);
var media = produtos.Average(p => p.Preco);
var maisBarato = produtos.MinBy(p => p.Preco);

// Agrupamento
var porFaixaPreco = produtos
    .GroupBy(p => p.Preco switch
    {
        < 200 => "Barato",
        < 1000 => "Médio",
        _ => "Caro"
    })
    .ToDictionary(g => g.Key, g => g.ToList());

// Projeção
var resumo = produtos.Select(p => new
{
    p.Nome,
    p.Preco,
    Categoria = p.Preco > 1000 ? "Premium" : "Standard"
});

Async/Await

public class ServicoHttp
{
    private readonly HttpClient _client = new();

    // Método assíncrono
    public async Task<string> BuscarDadosAsync(string url)
    {
        try
        {
            var response = await _client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsStringAsync();
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"Erro: {ex.Message}");
            throw;
        }
    }

    // Múltiplas tarefas em paralelo
    public async Task<IEnumerable<string>> BuscarVariosAsync(IEnumerable<string> urls)
    {
        var tarefas = urls.Select(url => BuscarDadosAsync(url));
        return await Task.WhenAll(tarefas);
    }

    // Cancelamento
    public async Task<string> BuscarComTimeoutAsync(string url, CancellationToken ct)
    {
        using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
        cts.CancelAfter(TimeSpan.FromSeconds(10));

        return await _client.GetStringAsync(url, cts.Token);
    }
}

Pattern Matching

// Switch expression
public static string DescreverObjeto(object obj) => obj switch
{
    null => "Nulo",
    string s => $"String: {s}",
    int n when n > 0 => $"Inteiro positivo: {n}",
    int n => $"Inteiro: {n}",
    { } x => $"Objeto: {x.GetType().Name}"
};

// Property patterns
public record Pedido(string Status, decimal Total, bool Prioritario);

public static decimal CalcularDesconto(Pedido pedido) => pedido switch
{
    { Status: "VIP", Total: > 1000 } => pedido.Total * 0.20m,
    { Prioritario: true, Total: > 500 } => pedido.Total * 0.15m,
    { Total: > 1000 } => pedido.Total * 0.10m,
    _ => 0
};

// List patterns (C# 11)
public static string AnalisarLista(int[] numeros) => numeros switch
{
    [] => "Vazia",
    [var unico] => $"Um elemento: {unico}",
    [var primeiro, .., var ultimo] => $"De {primeiro} a {ultimo}",
};

Checklist de Aprendizado

• Dominar tipos, classes e interfaces
• Aprender LINQ e expressões lambda
• Estudar async/await e Task
• Explorar pattern matching
• Praticar com ASP.NET Core
• Entender dependency injection
• Construir uma API REST completa

Recursos Essenciais

• C# Documentation
• .NET Learn
• C# Guide

Citação

“C# foi projetado para ser uma linguagem de propósito geral simples, moderna e orientada a objetos.” - Anders Hejlsberg

---

C# é uma pasta excelente para desenvolvimento empresarial, jogos com Unity e aplicações cloud-native!