C#: conceptos clave del lenguaje, desarrollo con .NET MAUI y Xamarin

¿Qué es C#?

C# (se pronuncia "si sharp") es un lenguaje de programación orientado a objetos con un sistema de tipos seguro, desarrollado por Microsoft en el año 2000 bajo la dirección de Anders Hejlsberg. El nombre está inspirado en la notación musical (sostenido — elevación del tono). C# funciona en la plataforma .NET, que incluye Common Language Runtime (CLR) y una amplia biblioteca de clases (BCL — Base Class Library).

En el desarrollo móvil, C# se utiliza a través de dos tecnologías: Xamarin (2011–2024) y su sucesor .NET MAUI (2022+). Xamarin permitía crear aplicaciones nativas para Android e iOS con código compartido en C#, separando proyectos específicos de cada plataforma. .NET MAUI combina todas las plataformas en un solo proyecto con marcado XAML compartido y acceso a API nativas a través de interfaces de plataforma.

Una característica clave de C# es la tipificación estática estricta con posibilidad de despacho dinámico mediante dynamic, la palabra clave var (inferencia de tipos) y un potente sistema de genéricos. C# es un lenguaje totalmente administrado: la memoria es gestionada por el recolector de basura (GC), los límites de los arrays se verifican y las variables no inicializadas están prohibidas. Esto hace que C# sea más seguro que C++ con un rendimiento comparable mediante compilación AOT.

Versiones de C# y evolución

C# 1.0 (2000) — lenguaje OOP básico. C# 3.0 (2007) — LINQ, expresiones lambda, métodos de extensión. C# 6.0 (2015) — interpolación de cadenas, operador null-conditional. C# 8.0 (2019) — tipos de referencia anulables (seguridad frente a nulos), flujos asíncronos, métodos de interfaz predeterminados. C# 10 (2021) — global usings, espacios de nombres por archivo, record struct. C# 12 (2023) — constructores primarios, expresiones de colección, interceptores. Cada versión aporta mejoras relevantes para el desarrollo móvil.

Sintaxis de C#: tipos, clases y LINQ

La sintaxis de C# es similar a C, estrictamente tipificada. Todo es un objeto, incluidos los primitivos (int, double, bool — son estructuras que heredan ValueType). C# divide los tipos en tipos valor (int, double, bool, struct, enum — se almacenan en la pila) y tipos referencia (string, class, interface, delegate, array, record — se almacenan en el montón). Los tipos anulables (int?) permiten null para tipos valor.

Tipos de datos y clases

C# admite clases (class), estructuras (struct), registros (record), interfaces (interface), enumeraciones (enum) y delegados (delegate). record es un tipo referencia inmutable con igualdad basada en valor (dos records son iguales si todos sus campos lo son). record struct es la versión valor de record, introducida en C# 10. Los constructores primarios (C# 12) combinan declaración e inicialización en una línea.

// Tipos básicos y clases de C#
using System;
using System.Collections.Generic;

// Record con constructor primario (C# 12)
public record User(int Id, string Name, string Email);

// Clase con propiedades anulables
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Método con cuerpo de expresión
    public string GetDisplayName() => $"{AppName} v{Version}";
}

// Método de extensión
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();

El record User con constructor primario genera automáticamente equals, hashCode, ToString, Deconstruct y copia con. Los setters init-only (AppName) permiten establecer un valor solo en el inicializador. El cuerpo de expresión (=>) es una notación concisa para métodos simples. El método de extensión IsValidEmail añade un método a string sin herencia.

LINQ — Language Integrated Query

LINQ es un lenguaje de consultas integrado para colecciones, bases de datos y XML. LINQ to Objects — consultas a colecciones IEnumerable. LINQ to SQL — a bases de datos. LINQ to XML — a XML. La sintaxis puede ser de consulta (from u in users where u.Age > 18 select u) y de método (users.Where(u => u.Age > 18).Select(u => u)). Carga diferida (ejecución diferida): la consulta se ejecuta al iterar, no al declarar.

// Consultas LINQ a colecciones
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"),
};

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

// Sintaxis de método con múltiples operaciones
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

// GroupBy y agregación
var emailsByDomain = users
    .GroupBy(u => u.Email.Split('@')[1])
    .Select(g => new { Domain = g.Key, Count = g.Count() });

// LINQ con flujo así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");
}

La consulta LINQ filteredUsers filtra usuarios por dominio de email y ordena por nombre. La sintaxis de método .Where().OrderBy().Select() es una cadena de métodos equivalente a la sintaxis de consulta. GroupBy agrupa por dominio de email. IAsyncEnumerable (C# 8) es una versión asíncrona de IEnumerable, útil para carga de datos por flujo en aplicaciones móviles.

Xamarin y .NET MAUI: arquitectura

Xamarin (2011–2024) fue la primera plataforma de Microsoft para desarrollo móvil multiplataforma en C#. Constaba de Xamarin.Android (runtime Mono sobre el núcleo Linux) y Xamarin.iOS (compilación AOT a ARM64 debido a la prohibición de JIT en iOS). Xamarin.Forms era una capa de UI compartida con marcado XAML, que traducía elementos a nativos (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) es el sucesor de Xamarin, lanzado en 2022. Un proyecto único .csproj, un marcado XAML, un punto de entrada. Admite 5 plataformas: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI utiliza la nueva arquitectura Handler en lugar de Renderer: cada elemento XAML se asigna a un componente nativo a través de un handler de plataforma.

<!-- MainPage.xaml — UI declarativa de .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>

El marcado XAML de .NET MAUI describe la UI de forma declarativa. ScrollView — desplazamiento, VerticalStackLayout — disposición vertical. Label, Entry (entrada de texto), Button — elementos básicos. CollectionView — lista virtualizada con DataTemplate para mostrar elementos. El evento Clicked se vincula al método OnSubmitClicked en el code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind con 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;
    }
}

El code-behind MainPage hereda de ContentPage. InitializeComponent() carga el marcado XAML. NameEntry.Text?.Trim() — operador null-conditional (?.) para acceso seguro. DisplayAlert — diálogo nativo. ItemsView.ItemsSource — Binding a la colección. async/await para carga asíncrona. El patrón MVVM (Model-View-ViewModel) se recomienda para proyectos complejos.

C# en el desarrollo móvil

El desarrollo móvil con C# ofrece tres enfoques: .NET MAUI (UI multiplataforma), Xamarin (legado) y Unity (juegos). .NET MAUI es la ruta recomendada para nuevos proyectos. La aplicación en C# se compila a Intermediate Language (IL), que NativeAOT (.NET MAUI) o Mono (Xamarin) transforman en código ARM nativo. iOS requiere compilación AOT — JIT está prohibido por las políticas de Apple.

Acceso a API nativas

.NET MAUI proporciona API unificadas para trabajar con capacidades de la plataforma a través de interfaces: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Para código específico de plataforma se usa compilación condicional (#if ANDROID, #if IOS) o clase parcial.

// Geolocalización en .NET MAUI con 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($"Error de ubicación: {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;
    }
}

El servicio LocationService usa DI (inyección de dependencia de IGeolocation). CheckAndRequestPermission verifica y solicita permiso de geolocalización. GetLastKnownLocationAsync — respuesta rápida (no siempre precisa), GetLocationAsync — solicitud con parámetros de precisión y tiempo de espera. Comprobaciones de null (location == null) con tipos de referencia anulables. try-catch maneja excepciones de la plataforma.

Rendimiento de C# en móviles

C# en dispositivos móviles muestra un rendimiento comparable a Java/Kotlin en Android y Swift en iOS. NativeAOT (.NET 8+) compila C# directamente a código nativo sin etapa intermedia IL — esto reduce el tiempo de inicio en un 50% y disminuye el consumo de memoria. El GC en .NET MAUI está optimizado para plataformas móviles con pausas cortas (Workstation GC). El tamaño del APK es de ~20-30 MB (con NativeAOT).

Plataforma .NET y CLR

La plataforma .NET es un ecosistema para ejecutar código administrado, que incluye CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core para desarrollo de servidores y .NET MAUI para aplicaciones móviles. .NET 8+ es una plataforma unificada para todos los tipos de aplicaciones: móviles, de escritorio, web, nube, IoT, juegos (Unity).

CLR es una máquina virtual que ejecuta código CIL (Common Intermediate Language). C#, VB.NET, F# se compilan a CIL. El compilador JIT de CLR transforma CIL en código máquina en la primera llamada al método. NativeAOT (compilación anticipada) compila CIL en código nativo en tiempo de compilación — ideal para plataformas móviles donde JIT puede estar restringido (iOS).

El recolector de basura GC de .NET es generacional (generaciones 0, 1, 2), libera automáticamente objetos no utilizados. Para aplicaciones móviles se recomienda Workstation GC con pausas mínimas. GC se ejecuta en un hilo separado, sin bloquear el hilo de UI. Background GC es un recolector de fondo que minimiza las pausas para aplicaciones interactivas.

Herramientas del desarrollador C#

Las herramientas del desarrollador C# incluyen Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 es el IDE principal con diseñador XAML, depurador de código administrado y nativo, perfilador de CPU/memoria. .NET SDK incluye el compilador csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet es el gestor de paquetes de .NET, similar a npm para JS. Más de 300 000 paquetes, incluyendo CommunityToolkit.Maui (componentes UI), SQLite-net (base de datos), Firebase Cloud Messaging, ZXing.Net.Maui (códigos QR). .NET MAUI Community Toolkit es un conjunto de comportamientos, convertidores y animaciones para acelerar el desarrollo. RestSharp y Refit son clientes HTTP. Prism y MVVM Community Toolkit son marcos arquitectónicos.

<!-- .csproj — configuración del proyecto .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>

El archivo .csproj es la configuración del proyecto .NET MAUI. TargetFrameworks enumera las plataformas destino. UseMaui habilita el SDK de MAUI. PackageReference especifica dependencias de NuGet. CommunityToolkit.Maui proporciona componentes UI (toasts, snackbars, Popup). sqlite-net-pcl es una base de datos local. Refit es un cliente HTTP tipificado basado en interfaces. dotnet build/publish compila la aplicación para todas las plataformas.