C#: conceitos-chave da linguagem, desenvolvimento com .NET MAUI e Xamarin

O que é C#?

C# (pronuncia-se "si sharp") é uma linguagem de programação orientada a objetos com um sistema de tipos seguro, desenvolvida pela Microsoft em 2000 sob a liderança de Anders Hejlsberg. O nome é inspirado na notação musical (sustenido — elevação do tom). O C# funciona na plataforma .NET, que inclui o Common Language Runtime (CLR) e uma ampla biblioteca de classes (BCL — Base Class Library).

No desenvolvimento móvel, o C# é usado através de duas tecnologias: Xamarin (2011–2024) e seu sucessor .NET MAUI (2022+). O Xamarin permitia criar aplicações nativas para Android e iOS com código C# compartilhado, separando projetos específicos de cada plataforma. O .NET MAUI combina todas as plataformas em um único projeto com marcação XAML compartilhada e acesso a APIs nativas através de interfaces de plataforma.

Uma característica chave do C# é a tipagem estática estrita com possibilidade de despacho dinâmico através de dynamic, a palavra-chave var (inferência de tipos) e um poderoso sistema de genéricos. C# é uma linguagem totalmente gerenciada: a memória é gerenciada pelo coletor de lixo (GC), os limites de arrays são verificados e variáveis não inicializadas são proibidas. Isso torna o C# mais seguro que C++ com desempenho comparável através da compilação AOT.

Versões do C# e evolução

C# 1.0 (2000) — linguagem OOP básica. C# 3.0 (2007) — LINQ, expressões lambda, métodos de extensão. C# 6.0 (2015) — interpolação de strings, operador null-conditional. C# 8.0 (2019) — tipos de referência anuláveis (segurança contra nulos), fluxos assíncronos, métodos de interface padrão. C# 10 (2021) — global usings, namespaces por arquivo, record struct. C# 12 (2023) — construtores primários, expressões de coleção, interceptores. Cada versão traz melhorias relevantes para o desenvolvimento móvel.

Sintaxe C#: tipos, classes e LINQ

A sintaxe C# é semelhante a C, estritamente tipada. Tudo é um objeto, incluindo primitivos (int, double, bool — são structs que herdam ValueType). C# divide os tipos em tipos valor (int, double, bool, struct, enum — armazenados na pilha) e tipos referência (string, class, interface, delegate, array, record — armazenados no heap). Tipos anuláveis (int?) permitem null para tipos valor.

Tipos de dados e classes

C# suporta classes (class), structs (struct), registos (record), interfaces (interface), enumerações (enum) e delegados (delegate). record é um tipo referência imutável com igualdade baseada em valor (dois records são iguais se todos os seus campos forem iguais). record struct é a versão valor de record, introduzida em C# 10. Construtores primários (C# 12) combinam declaração e inicialização numa linha.

// Tipos básicos e classes em C#
using System;
using System.Collections.Generic;

// Record com construtor primário (C# 12)
public record User(int Id, string Name, string Email);

// Classe com propriedades anuláveis
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Método com corpo de expressão
    public string GetDisplayName() => $"{AppName} v{Version}";
}

// Método de extensão
public static class StringExtensions
{
    public static bool IsValidEmail(this string email) =>
        email.Contains("@") && email.Contains(".");
}

// Uso
var user = new User(1, "Alice", "alice@example.com");
bool validEmail = user.Email.IsValidEmail();

O record User com construtor primário gera automaticamente equals, hashCode, ToString, Deconstruct e cópia com. Os setters init-only (AppName) permitem definir um valor apenas no inicializador. O corpo de expressão (=>) é uma notação concisa para métodos simples. O método de extensão IsValidEmail adiciona um método a string sem herança.

LINQ — Language Integrated Query

LINQ é uma linguagem de consulta incorporada para coleções, bancos de dados, XML. LINQ to Objects — consultas a coleções IEnumerable. LINQ to SQL — a bancos de dados. LINQ to XML — a XML. A sintaxe pode ser de consulta (from u in users where u.Age > 18 select u) e de método (users.Where(u => u.Age > 18).Select(u => u)). Carregamento diferido (execução adiada): a consulta executa na iteração, não na declaração.

// Consultas LINQ a coleções
using System.Linq;

var users = new List<User>
{
    new User(1, "Alice", "alice@example.com"),
    new User(2, "Bob", "bob@test.com"),
    new User(3, "Charlie", "charlie@example.com"),
};

// Sintaxe de consulta
var filteredUsers = from u in users
                     where u.Email.Contains("example")
                     orderby u.Name
                     select u;

// Sintaxe de método com múltiplas operações
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

// GroupBy e agregação
var emailsByDomain = users
    .GroupBy(u => u.Email.Split('@')[1])
    .Select(g => new { Domain = g.Key, Count = g.Count() });

// LINQ com fluxo assíncrono (IAsyncEnumerable)
await foreach (var user in GetUsersAsync())
{
    Console.WriteLine(user.Name);
}

async IAsyncEnumerable<User> GetUsersAsync()
{
    yield return new User(1, "Alice", "alice@example.com");
    await Task.Delay(100);
    yield return new User(2, "Bob", "bob@test.com");
}

A consulta LINQ filteredUsers filtra utilizadores por domínio de email e ordena por nome. A sintaxe de método .Where().OrderBy().Select() é uma cadeia de métodos equivalente à sintaxe de consulta. GroupBy agrupa por domínio de email. IAsyncEnumerable (C# 8) é uma versão assíncrona de IEnumerable, útil para carregamento de dados em fluxo em aplicações móveis.

Xamarin e .NET MAUI: arquitetura

Xamarin (2011–2024) foi a primeira plataforma da Microsoft para desenvolvimento móvel multiplataforma em C#. Consistia em Xamarin.Android (runtime Mono sobre o kernel Linux) e Xamarin.iOS (compilação AOT para ARM64 devido à proibição de JIT no iOS). Xamarin.Forms era uma camada de UI compartilhada com marcação XAML, traduzindo elementos para nativos (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) é o sucessor do Xamarin, lançado em 2022. Um único projeto .csproj, uma marcação XAML, um ponto de entrada. Suporta 5 plataformas: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI usa a nova arquitetura Handler em vez de Renderer: cada elemento XAML mapeia para um componente nativo através de um handler de plataforma.

<!-- MainPage.xaml — UI declarativa do .NET MAUI -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyApp.MainPage">

    <ScrollView>
        <VerticalStackLayout Padding="30" Spacing="25">
            <Label Text="Welcome to .NET MAUI!"
                   FontSize="32"
                   HorizontalOptions="Center"/>

            <Entry x:Name="NameEntry"
                   Placeholder="Enter your name"/>

            <Button Text="Submit"
                    Clicked="OnSubmitClicked"
                    BackgroundColor="#512BD4"
                    TextColor="White"
                    CornerRadius="8"/>

            <CollectionView x:Name="ItemsView"
                          SelectionMode="Single">
                <CollectionView.ItemTemplate>
                    <DataTemplate>
                        <Grid Padding="10">
                            <Label Text="{Binding Name}"
                                   FontSize="18"/>
                        </Grid>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

A marcação XAML do .NET MAUI descreve a UI declarativamente. ScrollView — deslocamento, VerticalStackLayout — disposição vertical. Label, Entry (entrada de texto), Button — elementos básicos. CollectionView — lista virtualizada com DataTemplate para exibir itens. O evento Clicked liga-se ao método OnSubmitClicked no code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind com lógica C#
namespace MyApp;

public partial class MainPage : ContentPage
{
    private readonly List<User> _users = new();

    public MainPage()
    {
        InitializeComponent();
        LoadUsers();
    }

    private async void OnSubmitClicked(object? sender, EventArgs e)
    {
        var name = NameEntry.Text?.Trim();

        if (string.IsNullOrEmpty(name))
        {
            await DisplayAlert("Error", "Name is required", "OK");
            return;
        }

        _users.Add(new User(_users.Count + 1, name, $"{name}@example.com"));
        ItemsView.ItemsSource = null;
        ItemsView.ItemsSource = _users;
        NameEntry.Text = string.Empty;
    }

    private async void LoadUsers()
    {
        var apiService = new ApiService();
        var users = await apiService.GetUsersAsync();
        _users.AddRange(users);
        ItemsView.ItemsSource = _users;
    }
}

O code-behind MainPage herda de ContentPage. InitializeComponent() carrega a marcação XAML. NameEntry.Text?.Trim() — operador null-conditional (?.) para acesso seguro. DisplayAlert — diálogo nativo. ItemsView.ItemsSource — Binding à coleção. async/await para carregamento assíncrono. O padrão MVVM (Model-View-ViewModel) é recomendado para projetos complexos.

C# no desenvolvimento móvel

Desenvolvimento móvel com C# oferece três abordagens: .NET MAUI (UI multiplataforma), Xamarin (legado) e Unity (jogos). .NET MAUI é o caminho recomendado para novos projetos. A aplicação C# compila para Intermediate Language (IL), que NativeAOT (.NET MAUI) ou Mono (Xamarin) transforma em código ARM nativo. O iOS requer compilação AOT — o JIT é proibido pelas políticas da Apple.

Acesso a APIs nativas

.NET MAUI fornece APIs unificadas para trabalhar com capacidades da plataforma através de interfaces: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Para código específico de plataforma, usa-se compilação condicional (#if ANDROID, #if IOS) ou classe parcial.

// Geolocalização no .NET MAUI com DI
public class LocationService
{
    private readonly IGeolocation _geolocation;

    public LocationService(IGeolocation geolocation)
    {
        _geolocation = geolocation;
    }

    public async Task<Location?> GetCurrentLocation()
    {
        try
        {
            var permission = await CheckAndRequestPermission();
            if (permission != PermissionStatus.Granted)
                return null;

            var location = await _geolocation.GetLastKnownLocationAsync();

            if (location == null)
            {
                location = await _geolocation.GetLocationAsync(new GeolocationRequest
                {
                    DesiredAccuracy = GeolocationAccuracy.Medium,
                    Timeout = TimeSpan.FromSeconds(10)
                });
            }

            return location;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Erro de localização: {ex.Message}");
            return null;
        }
    }

    private async Task<PermissionStatus> CheckAndRequestPermission()
    {
        var status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();

        if (status != PermissionStatus.Granted)
        {
            status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();
        }

        return status;
    }
}

O serviço LocationService usa DI (injeção de dependência de IGeolocation). CheckAndRequestPermission verifica e solicita permissão de geolocalização. GetLastKnownLocationAsync — resposta rápida (nem sempre precisa), GetLocationAsync — solicitação com parâmetros de precisão e tempo limite. Verificações de null (location == null) com tipos de referência anuláveis. try-catch trata exceções da plataforma.

Desempenho do C# em dispositivos móveis

C# em dispositivos móveis apresenta desempenho comparável a Java/Kotlin no Android e Swift no iOS. NativeAOT (.NET 8+) compila C# diretamente para código nativo sem etapa IL intermediária — isto reduz o tempo de inicialização em 50% e diminui o consumo de memória. O GC no .NET MAUI é otimizado para plataformas móveis com pausas curtas (Workstation GC). O tamanho do APK é de ~20-30 MB (com NativeAOT).

Plataforma .NET e CLR

A plataforma .NET é um ecossistema para executar código gerenciado, incluindo CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core para desenvolvimento de servidores e .NET MAUI para aplicações móveis. .NET 8+ é uma plataforma unificada para todos os tipos de aplicações: móveis, desktop, web, cloud, IoT, jogos (Unity).

CLR é uma máquina virtual que executa código CIL (Common Intermediate Language). C#, VB.NET, F# compilam para CIL. O compilador JIT do CLR transforma CIL em código de máquina na primeira chamada ao método. NativeAOT (compilação antecipada) compila CIL em código nativo no tempo de compilação — ideal para plataformas móveis onde o JIT pode ser restrito (iOS).

O coletor de lixo GC do .NET é geracional (gerações 0, 1, 2), liberta automaticamente objetos não utilizados. Para aplicações móveis, recomenda-se Workstation GC com pausas mínimas. O GC executa numa thread separada, sem bloquear a thread de UI. Background GC é um coletor de fundo que minimiza pausas para aplicações interativas.

Ferramentas do desenvolvedor C#

Ferramentas do desenvolvedor C# incluem Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. O Visual Studio 2022 é o IDE principal com designer XAML, depurador de código gerenciado e nativo, profiler de CPU/memória. O .NET SDK inclui o compilador csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet é o gestor de pacotes .NET, semelhante ao npm para JS. Mais de 300 000 pacotes, incluindo CommunityToolkit.Maui (componentes UI), SQLite-net (base de dados), Firebase Cloud Messaging, ZXing.Net.Maui (códigos QR). .NET MAUI Community Toolkit é um conjunto de comportamentos, conversores e animações para acelerar o desenvolvimento. RestSharp e Refit são clientes HTTP. Prism e MVVM Community Toolkit são frameworks arquiteturais.

<!-- .csproj — configuração do projeto .NET MAUI -->
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFrameworks>net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>
    <OutputType>Exe</OutputType>
    <UseMaui>true</UseMaui>
    <ApplicationTitle>MyMAUIApp</ApplicationTitle>
    <ApplicationId>com.example.mymauiapp</ApplicationId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="CommunityToolkit.Maui" Version="9.0.0" />
    <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
    <PackageReference Include="Refit" Version="7.0.0" />
  </ItemGroup>

</Project>

O ficheiro .csproj é a configuração do projeto .NET MAUI. TargetFrameworks lista as plataformas alvo. UseMaui ativa o SDK MAUI. PackageReference especifica dependências do NuGet. CommunityToolkit.Maui fornece componentes UI (toasts, snackbars, Popup). sqlite-net-pcl é uma base de dados local. Refit é um cliente HTTP tipificado baseado em interfaces. dotnet build/publish compila a aplicação para todas as plataformas.