C#: kluczowe pojęcia języka, .NET MAUI i rozwój z Xamarin

Czym jest C#?

C# (wymawiane «si szarp») — obiektowy język programowania z bezpiecznym systemem typów, opracowany przez Microsoft w 2000 roku pod kierownictwem Andersa Hejlsberga. Nazwa inspirowana notacją muzyczną (krzyżyk — podwyższenie tonu). C# działa na platformie .NET, która obejmuje Common Language Runtime (CLR) i rozbudowaną bibliotekę klas (BCL — Base Class Library).

W programowaniu mobilnym C# jest używany przez dwie technologie: Xamarin (2011–2024) i jego następcę .NET MAUI (2022+). Xamarin pozwalał tworzyć natywne aplikacje Android i iOS ze wspólnym kodem C#, rozdzielając projekty platformowe. .NET MAUI łączy wszystkie platformy w jeden projekt ze wspólnym znacznikiem XAML i dostępem do natywnych API przez interfejsy platformowe.

Kluczowa cecha C# — ścisłe statyczne typowanie z możliwością dynamicznego wysyłania przez dynamic, słowo kluczowe var (wnioskowanie typu) i potężny system typów generycznych. C# to fully managed język: pamięć zarządzana jest przez garbage collector (GC), granice tablic są sprawdzane, niezainicjalizowane zmienne są zabronione. To czyni C# bezpieczniejszym od C++ przy porównywalnej wydajności dzięki kompilacji AOT.

Wersje C# i ewolucja

C# 1.0 (2000) — podstawowy język OOP. C# 3.0 (2007) — LINQ, wyrażenia lambda, extension methods. C# 6.0 (2015) — string interpolation, null-conditional operator. C# 8.0 (2019) — nullable reference types (włączenie bezpieczeństwa null), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Każda wersja wprowadza ulepszenia istotne dla programowania mobilnego.

Składnia C#: typy, klasy i LINQ

Składnia C# — podobna do C, ściśle typowana. Wszystko jest obiektem, włączając prymitywy (int, double, bool — to struktury dziedziczące po ValueType). C# dzieli typy na value types (int, double, bool, struct, enum — przechowywane na stosie) i reference types (string, class, interface, delegate, array, record — przechowywane na stercie). Typy nullable (int?) dopuszczają null dla value types.

Typy danych i klasy

C# obsługuje klasy (class), struktury (struct), rekordy (record), interfejsy (interface), wyliczenia (enum) i delegaty (delegate). record — niemutowalny reference type z równością opartą na wartościach (dwa record są równe, jeśli wszystkie ich pola są równe). record struct — value-odpowiednik record, wprowadzony w C# 10. primary constructors (C# 12) łączą deklarację i inicjalizację w jednej linii.

// Podstawowe typy i klasy C#
using System;
using System.Collections.Generic;

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

// Klasa z właściwościami nullable
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Metoda z 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(".");
}

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

Record User z primary constructor automatycznie generuje equals, hashCode, ToString, Deconstruct i with-kopiowanie. Init-only settery (AppName) pozwalają ustawić wartość tylko w inicjalizatorze. Expression body (=>) — zwięzły zapis prostych metod. Extension method IsValidEmail dodaje metodę do string bez dziedziczenia.

LINQ — Language Integrated Query

LINQ — wbudowany język zapytań do kolekcji, baz danych, XML. LINQ to Objects — zapytania do kolekcji IEnumerable. LINQ to SQL — do baz danych. LINQ to XML — do XML. Składnia może być query (from u in users where u.Age > 18 select u) i method (users.Where(u => u.Age > 18).Select(u => u)). Opóźnione ładowanie (deferred execution): zapytanie wykonuje się przy iteracji, nie przy deklaracji.

// Zapytania LINQ do kolekcji
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"),
};

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

// Składnia method z wieloma operacjami
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ z async strumieniem (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");
}

Zapytanie LINQ filteredUsers filtruje użytkowników po domenie email i sortuje po nazwie. Method syntax .Where().OrderBy().Select() — łańcuch metod, równoważny query syntax. GroupBy grupuje po domenie email. IAsyncEnumerable (C# 8) — asynchroniczna wersja IEnumerable, przydatna do strumieniowego ładowania danych w aplikacji mobilnej.

Xamarin i .NET MAUI: architektura

Xamarin (2011–2024) — pierwsza platforma Microsoft do wieloplatformowego programowania mobilnego w C#. Składał się z Xamarin.Android (Mono runtime na jądrze Linux) i Xamarin.iOS (kompilacja AOT do ARM64 z powodu zakazu JIT na iOS). Xamarin.Forms — wspólna warstwa UI z znacznikami XAML, tłumacząca elementy na natywne (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) — następca Xamarin, wydany w 2022 roku. Jeden projekt .csproj, jeden znacznik XAML, jeden punkt wejścia. Obsługuje 5 platform: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI używa nowej architektury Handler zamiast Renderer: każdy element XAML mapuje się na komponent natywny przez platformowy handler.

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

Znacznik XAML .NET MAUI opisuje UI deklaratywnie. ScrollView — przewijanie, VerticalStackLayout — układ pionowy. Label, Entry (wprowadzanie tekstu), Button — podstawowe elementy. CollectionView — zwirtualizowana lista z DataTemplate do wyświetlania elementów. Zdarzenie Clicked jest przypisywane do metody OnSubmitClicked w code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind z logiką 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 dziedziczy po ContentPage. InitializeComponent() ładuje znacznik XAML. NameEntry.Text?.Trim() — null-conditional operator (?.) dla bezpiecznego dostępu. DisplayAlert — natywne okno dialogowe. ItemsView.ItemsSource — Binding do kolekcji. async/await do asynchronicznego ładowania. Architektura MVVM (Model-View-ViewModel) jest zalecana dla złożonych projektów.

C# w programowaniu mobilnym

Programowanie mobilne w C# oferuje trzy podejścia: .NET MAUI (wieloplatformowe UI), Xamarin (starsze) i Unity (gry). .NET MAUI — zalecana ścieżka dla nowych projektów. Aplikacja w C# kompiluje się do Intermediate Language (IL), który NativeAOT (.NET MAUI) lub Mono (Xamarin) przekształcają w natywny kod ARM. iOS wymaga kompilacji AOT — JIT jest zabroniony przez politykę Apple.

Dostęp do natywnych API

.NET MAUI zapewnia jednolite API do pracy z możliwościami platformy przez interfejsy: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Dla kodu specyficznego dla platformy używa się kompilacji warunkowej (#if ANDROID, #if IOS) lub partial class.

// Geolokalizacja w .NET MAUI z 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($"Błąd lokalizacji: {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;
    }
}

Serwis LocationService używa DI (wstrzykiwanie zależności IGeolocation). CheckAndRequestPermission sprawdza i żąda uprawnienia geolokalizacji. GetLastKnownLocationAsync — szybka (ale nie zawsze dokładna) odpowiedź, GetLocationAsync — zapytanie z parametrami dokładności i czasu oczekiwania. null-sprawdzenia (location == null) z nullable reference types. try-catch obsługuje wyjątki platformy.

Wydajność C# na urządzeniach mobilnych

C# na urządzeniach mobilnych osiąga wydajność porównywalną z Java/Kotlin na Androidzie i Swift na iOS. NativeAOT (.NET 8+) kompiluje C# bezpośrednio do kodu natywnego bez etapu IL — zmniejsza to czas uruchamiania o 50% i obniża zużycie pamięci. GC w .NET MAUI jest zoptymalizowany dla platform mobilnych z krótkimi pauzami (Workstation GC). Rozmiar APK — ~20-30 MB (z NativeAOT).

Platforma .NET i CLR

Platforma .NET — ekosystem do wykonywania managed-kodu, obejmujący CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core do programowania serwerowego i .NET MAUI dla aplikacji mobilnych. .NET 8+ — jednolita platforma dla wszystkich typów aplikacji: mobilne, desktopowe, webowe, chmurowe, IoT, Gry (Unity).

CLR — maszyna wirtualna wykonująca kod CIL (Common Intermediate Language). C#, VB.NET, F# kompilują się do CIL. JIT-kompilator CLR przekształca CIL w kod maszynowy przy pierwszym wywołaniu metody. NativeAOT (kompilacja wstępna) kompiluje CIL do kodu natywnego na etapie budowania — idealne dla platform mobilnych, gdzie JIT może być ograniczony (iOS).

Garbage collector GC .NET — generational (pokolenia 0, 1, 2), automatycznie zwalnia nieużywane obiekty. Dla aplikacji mobilnych zalecany jest Workstation GC z minimalnymi pauzami. GC odbywa się w osobnym wątku, nie blokując wątku UI. Background GC — tło garbage collector, minimalizujący pauzy dla aplikacji interaktywnych.

Narzędzia programisty C#

Narzędzia programisty C# obejmują Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 — główne IDE z projektantem XAML, debuggerem managed i natywnego kodu, profilerem CPU/pamięci. .NET SDK zawiera kompilator csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — menedżer pakietów .NET, analogiczny do npm dla JS. 300 000+ pakietów, w tym CommunityToolkit.Maui (komponenty UI), SQLite-net (baza danych), Firebase Cloud Messaging, ZXing.Net.Maui (kody QR). .NET MAUI Community Toolkit — zbiór zachowań, konwerterów, animacji przyspieszających rozwój. RestSharp i Refit — klienty HTTP. Prism i MVVM Community Toolkit — frameworki architektoniczne.

<!-- .csproj — konfiguracja projektu .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>

Plik .csproj — konfiguracja projektu .NET MAUI. TargetFrameworks wymienia docelowe platformy. UseMaui włącza MAUI SDK. PackageReference — zależności z NuGet. CommunityToolkit.Maui — komponenty UI (tosty, snackbary, Popup). sqlite-net-pcl — lokalna baza danych. Refit — typowany klient HTTP oparty na interfejsach. dotnet build/publish buduje aplikację dla wszystkich platform.