C#: concepte cheie ale limbajului, dezvoltare .NET MAUI și Xamarin

Ce este C#?

C# (pronunțat «si șarp») — un limbaj de programare orientat pe obiecte cu un sistem de tipuri sigur, dezvoltat de Microsoft în anul 2000 sub conducerea lui Anders Hejlsberg. Numele este inspirat din notația muzicală (diez — ridicarea tonului). C# funcționează pe platforma .NET, care include Common Language Runtime (CLR) și o bibliotecă extinsă de clase (BCL — Base Class Library).

În dezvoltarea mobilă, C# este utilizat prin două tehnologii: Xamarin (2011–2024) și succesorul său .NET MAUI (2022+). Xamarin permitea crearea de aplicații native Android și iOS cu cod C# comun, separând proiectele pe platforme. .NET MAUI unește toate platformele într-un singur proiect cu marcare XAML comună și acces la API-uri native prin interfețe de platformă.

Caracteristica cheie a C# — tipizare statică strictă cu posibilitatea de expediere dinamică prin dynamic, cuvântul cheie var (inferență de tip) și un sistem puternic de generice. C# este un limbaj complet gestionat: memoria este gestionată de colectorul de gunoi (GC), limitele array-urilor sunt verificate, variabilele neinițializate sunt interzise. Acest lucru face C# mai sigur decât C++ cu performanță comparabilă prin compilarea AOT.

Versiuni C# și evoluție

C# 1.0 (2000) — limbaj OOP de bază. C# 3.0 (2007) — LINQ, expresii lambda, extension methods. C# 6.0 (2015) — string interpolation, operator null-conditional. C# 8.0 (2019) — nullable reference types (activarea siguranței null), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Fiecare versiune aduce îmbunătățiri relevante pentru dezvoltarea mobilă.

Sintaxa C#: tipuri, clase și LINQ

Sintaxa C# — asemănătoare cu C, strict tipizată. Totul este un obiect, inclusiv primitivele (int, double, bool — sunt structuri care moștenesc ValueType). C# împarte tipurile în value types (int, double, bool, struct, enum — stocate pe stivă) și reference types (string, class, interface, delegate, array, record — stocate în heap). Tipurile nullable (int?) permit null pentru value types.

Tipuri de date și clase

C# suportă clase (class), structuri (struct), înregistrări (record), interfețe (interface), enumerări (enum) și delegați (delegate). record — un reference type imutabil cu egalitate bazată pe valoare (două record sunt egale dacă toate câmpurile lor sunt egale). record struct — versiunea de valoare a record, introdusă în C# 10. primary constructors (C# 12) combină declarația și inițializarea într-o singură linie.

// Tipuri de bază și clase C#
using System;
using System.Collections.Generic;

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

// Clasă cu proprietăți nullable
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Metodă cu expression body
    public string GetDisplayName() => $"{AppName} v{Version}";
}

// Extension method
public static class StringExtensions
{
    public static bool IsValidEmail(this string email) =>
        email.Contains("@") && email.Contains(".");
}

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

Înregistrarea User cu primary constructor generează automat equals, hashCode, ToString, Deconstruct și copierea with. Setter-ele init-only (AppName) permit setarea valorii doar în inițializator. Expression body (=>) — scriere concisă pentru metode simple. Extension method IsValidEmail adaugă o metodă la string fără moștenire.

LINQ — Language Integrated Query

LINQ — limbaj de interogare încorporat pentru colecții, baze de date, XML. LINQ to Objects — interogări pentru colecții IEnumerable. LINQ to SQL — pentru baze de date. LINQ to XML — pentru XML. Sintaxa poate fi query (from u in users where u.Age > 18 select u) și method (users.Where(u => u.Age > 18).Select(u => u)). Încărcare lentă (deferred execution): interogarea se execută la iterație, nu la declarație.

// Interogări LINQ la colecții
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"),
};

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

// Sintaxa method cu mai multe operații
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ cu flux asincron (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");
}

Interogarea LINQ filteredUsers filtrează utilizatorii după domeniul email și sortează după nume. Method syntax .Where().OrderBy().Select() — lanț de metode, echivalent cu query syntax. GroupBy grupează după domeniul email. IAsyncEnumerable (C# 8) — versiunea asincronă a IEnumerable, utilă pentru încărcarea în flux a datelor într-o aplicație mobilă.

Xamarin și .NET MAUI: arhitectură

Xamarin (2011–2024) — prima platformă Microsoft pentru dezvoltare mobilă cross-platform în C#. Era compus din Xamarin.Android (Mono runtime pe nucleul Linux) și Xamarin.iOS (compilare AOT în ARM64 din cauza interzicerii JIT pe iOS). Xamarin.Forms — strat UI comun cu marcare XAML, traducând elementele în elemente native (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) — succesorul Xamarin, lansat în 2022. Un singur proiect .csproj, o singură marcare XAML, un singur punct de intrare. Suportă 5 platforme: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI folosește noua arhitectură Handler în loc de Renderer: fiecare element XAML se mapează la o componentă nativă printr-un handler de platformă.

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

Marcarea XAML .NET MAUI descrie UI declarativ. ScrollView — derulare, VerticalStackLayout — aranjare verticală. Label, Entry (introducere text), Button — elemente de bază. CollectionView — listă virtualizată cu DataTemplate pentru afișarea elementelor. Evenimentul Clicked este legat de metoda OnSubmitClicked în code-behind MainPage.xaml.cs.

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

Code-behind MainPage moștenește ContentPage. InitializeComponent() încarcă marcarea XAML. NameEntry.Text?.Trim() — operatorul null-conditional (?.) pentru acces sigur. DisplayAlert — dialog nativ. ItemsView.ItemsSource — Binding la o colecție. async/await pentru încărcare asincronă. Arhitectura MVVM (Model-View-ViewModel) este recomandată pentru proiecte complexe.

C# în dezvoltarea mobilă

Dezvoltarea mobilă în C# oferă trei abordări: .NET MAUI (UI cross-platform), Xamarin (moștenit) și Unity (jocuri). .NET MAUI — calea recomandată pentru proiecte noi. Aplicația C# este compilată în Intermediate Language (IL), pe care NativeAOT (.NET MAUI) sau Mono (Xamarin) îl transformă în cod nativ ARM. iOS necesită compilare AOT — JIT este interzis de politicile Apple.

Acces la API-uri native

.NET MAUI oferă API-uri unificate pentru lucrul cu capacitățile platformei prin interfețe: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Pentru cod specific platformei se folosește compilarea condiționată (#if ANDROID, #if IOS) sau partial class.

// Geolocație în .NET MAUI cu 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($"Eroare de locație: {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;
    }
}

Serviciul LocationService folosește DI (injecție de dependență IGeolocation). CheckAndRequestPermission verifică și solicită permisiunea de geolocație. GetLastKnownLocationAsync — răspuns rapid (dar nu întotdeauna exact), GetLocationAsync — interogare cu parametri de precizie și timeout. Verificări null (location == null) cu nullable reference types. try-catch gestionează excepțiile platformei.

Performanța C# pe dispozitive mobile

C# pe dispozitive mobile arată performanță comparabilă cu Java/Kotlin pe Android și Swift pe iOS. NativeAOT (.NET 8+) compilează C# direct în cod nativ fără etapa intermediară IL — aceasta reduce timpul de pornire cu 50% și scade consumul de memorie. GC în .NET MAUI este optimizat pentru platforme mobile cu pauze scurte (Workstation GC). Dimensiunea APK — ~20-30 MB (cu NativeAOT).

Platforma .NET și CLR

Platforma .NET — ecosistem pentru executarea codului gestionat, incluzând CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core pentru dezvoltare server și .NET MAUI pentru aplicații mobile. .NET 8+ — platformă unică pentru toate tipurile de aplicații: mobile, desktop, web, cloud, IoT, Jocuri (Unity).

CLR — mașină virtuală care execută cod CIL (Common Intermediate Language). C#, VB.NET, F# sunt compilate în CIL. Compilatorul JIT al CLR transformă CIL în cod mașină la prima apelare a metodei. NativeAOT (compilare prealabilă) compilează CIL în cod nativ în faza de construire — ideal pentru platforme mobile unde JIT poate fi limitat (iOS).

Colectorul de gunoi GC .NET — generațional (generațiile 0, 1, 2), eliberează automat obiectele neutilizate. Pentru aplicații mobile se recomandă Workstation GC cu pauze minime. GC are loc într-un fir separat, fără a bloca firul UI. Background GC — colector de fond care minimizează pauzele pentru aplicații interactive.

Instrumente pentru dezvoltatorul C#

Instrumente pentru dezvoltatorul C# includ Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 — IDE principal cu designer XAML, depanator pentru cod gestionat și nativ, profilator CPU/memorie. .NET SDK include compilatorul csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — manager de pachete .NET, analog cu npm pentru JS. Peste 300.000 de pachete, inclusiv CommunityToolkit.Maui (componente UI), SQLite-net (bază de date), Firebase Cloud Messaging, ZXing.Net.Maui (coduri QR). .NET MAUI Community Toolkit — set de comportamente, convertoare, animații pentru accelerarea dezvoltării. RestSharp și Refit — clienți HTTP. Prism și MVVM Community Toolkit — framework-uri arhitecturale.

<!-- .csproj — configurare proiect .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>

Fișierul .csproj — configurația proiectului .NET MAUI. TargetFrameworks enumeră platformele țintă. UseMaui activează MAUI SDK. PackageReference — dependințe din NuGet. CommunityToolkit.Maui — componente UI (toast-uri, snackbar-uri, Popup). sqlite-net-pcl — bază de date locală. Refit — client HTTP tipizat bazat pe interfețe. dotnet build/publish construiește aplicația pentru toate platformele.