C#: klíčové pojmy jazyka, vývoj .NET MAUI a Xamarin

Co je C#?

C# (vyslovuje se «sí šarp») — objektově orientovaný programovací jazyk s bezpečným typovým systémem, vyvinutý Microsoftem v roce 2000 pod vedením Anderse Hejlsberga. Název je inspirován hudební notací (křížek — zvýšení tónu). C# běží na platformě .NET, která zahrnuje Common Language Runtime (CLR) a rozsáhlou knihovnu tříd (BCL — Base Class Library).

V mobilním vývoji je C# používán prostřednictvím dvou technologií: Xamarin (2011–2024) a jeho nástupce .NET MAUI (2022+). Xamarin umožňoval vytvářet nativní aplikace pro Android a iOS se sdíleným kódem C#, s oddělenými platformovými projekty. .NET MAUI spojuje všechny platformy do jednoho projektu se společným značením XAML a přístupem k nativním API přes platformová rozhraní.

Klíčová vlastnost C# — přísná statická typizace s možností dynamického odesílání přes dynamic, klíčové slovo var (odvození typu) a výkonný systém generik. C# je plně spravovaný jazyk: paměť je spravována garbage collectorem (GC), hranice polí jsou kontrolovány, neinicializované proměnné jsou zakázány. To činí C# bezpečnějším než C++ při srovnatelném výkonu díky kompilaci AOT.

Verze C# a evoluce

C# 1.0 (2000) — základní OOP jazyk. C# 3.0 (2007) — LINQ, lambda výrazy, extension methods. C# 6.0 (2015) — string interpolation, null-conditional operátor. C# 8.0 (2019) — nullable reference types (zapnutí null bezpečnosti), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Každá verze přináší vylepšení relevantní pro mobilní vývoj.

Syntaxe C#: typy, třídy a LINQ

Syntaxe C# — podobná C, přísně typovaná. Všechno je objekt, včetně primitiv (int, double, bool — to jsou struktury dědící z ValueType). C# dělí typy na value types (int, double, bool, struct, enum — ukládány na zásobníku) a reference types (string, class, interface, delegate, array, record — ukládány na haldě). Nullable typy (int?) povolují null pro value types.

Datové typy a třídy

C# podporuje třídy (class), struktury (struct), záznamy (record), rozhraní (interface), výčty (enum) a delegáty (delegate). record — neměnný reference type s rovností založenou na hodnotě (dva recordy jsou stejné, pokud jsou všechna jejich pole stejná). record struct — hodnotová verze record, zavedená v C# 10. primary constructors (C# 12) spojují deklaraci a inicializaci do jednoho řádku.

// Základní typy a třídy C#
using System;
using System.Collections.Generic;

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

// Třída s nullable vlastnostmi
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

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

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

Záznam User s primary constructorem automaticky generuje equals, hashCode, ToString, Deconstruct a with-kopírování. Init-only settery (AppName) umožňují nastavit hodnotu pouze v inicializátoru. Expression body (=>) — stručný zápis pro jednoduché metody. Extension method IsValidEmail přidává metodu k string bez dědičnosti.

LINQ — Language Integrated Query

LINQ — vestavěný dotazovací jazyk pro kolekce, databáze, XML. LINQ to Objects — dotazy na kolekce IEnumerable. LINQ to SQL — na databáze. LINQ to XML — na XML. Syntaxe může být query (from u in users where u.Age > 18 select u) a method (users.Where(u => u.Age > 18).Select(u => u)). Líné načítání (deferred execution): dotaz se provádí při iteraci, ne při deklaraci.

// LINQ dotazy na kolekce
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"),
};

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

// Method syntax s několika operacemi
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ s asynchronním proudem (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");
}

LINQ dotaz filteredUsers filtruje uživatele podle domény emailu a řadí podle jména. Method syntax .Where().OrderBy().Select() — řetězec metod, ekvivalentní query syntax. GroupBy seskupuje podle domény emailu. IAsyncEnumerable (C# 8) — asynchronní verze IEnumerable, užitečná pro streamování dat v mobilní aplikaci.

Xamarin a .NET MAUI: architektura

Xamarin (2011–2024) — první platforma Microsoftu pro multiplatformní mobilní vývoj v C#. Skládal se z Xamarin.Android (Mono runtime nad jádrem Linux) a Xamarin.iOS (AOT kompilace do ARM64 kvůli zákazu JIT na iOS). Xamarin.Forms — společná vrstva UI s XAML značením, překládající prvky do nativních (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) — nástupce Xamarinu, vydaný v roce 2022. Jednotný projekt .csproj, jedno XAML značení, jeden vstupní bod. Podporuje 5 platforem: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI používá novou architekturu Handler místo Renderer: každý XAML prvek je mapován na nativní komponentu přes platformový handler.

<!-- MainPage.xaml — deklarativní 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>

XAML značení .NET MAUI popisuje UI deklarativně. ScrollView — rolování, VerticalStackLayout — vertikální uspořádání. Label, Entry (vstup textu), Button — základní prvky. CollectionView — virtualizovaný seznam s DataTemplate pro zobrazení prvků. Událost Clicked je svázána s metodou OnSubmitClicked v code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind s logikou 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 dědí z ContentPage. InitializeComponent() načítá XAML značení. NameEntry.Text?.Trim() — null-conditional operátor (?.) pro bezpečný přístup. DisplayAlert — nativní dialog. ItemsView.ItemsSource — Binding na kolekci. async/await pro asynchronní načítání. Architektura MVVM (Model-View-ViewModel) je doporučena pro složité projekty.

C# v mobilním vývoji

Mobilní vývoj v C# nabízí tři přístupy: .NET MAUI (multiplatformní UI), Xamarin (starší) a Unity (hry). .NET MAUI — doporučená cesta pro nové projekty. Aplikace v C# se kompiluje do Intermediate Language (IL), který NativeAOT (.NET MAUI) nebo Mono (Xamarin) převádí na nativní ARM kód. iOS vyžaduje AOT kompilaci — JIT je zakázán politikami Apple.

Přístup k nativním API

.NET MAUI poskytuje jednotná API pro práci s platformovými možnostmi přes rozhraní: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Pro kód specifický pro platformu se používá podmíněná kompilace (#if ANDROID, #if IOS) nebo partial class.

// Geolokace v .NET MAUI s 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($"Chyba polohy: {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;
    }
}

Služba LocationService používá DI (vkládání závislosti IGeolocation). CheckAndRequestPermission kontroluje a žádá oprávnění geolokace. GetLastKnownLocationAsync — rychlá (ale ne vždy přesná) odpověď, GetLocationAsync — dotaz s parametry přesnosti a časového limitu. null kontroly (location == null) s nullable reference types. try-catch zpracovává výjimky platformy.

Výkon C# na mobilních zařízeních

C# na mobilních zařízeních dosahuje výkonu srovnatelného s Java/Kotlin na Androidu a Swift na iOS. NativeAOT (.NET 8+) kompiluje C# přímo do nativního kódu bez mezistupně IL — to snižuje dobu spouštění o 50 % a snižuje spotřebu paměti. GC v .NET MAUI je optimalizován pro mobilní platformy s krátkými pauzami (Workstation GC). Velikost APK — ~20-30 MB (s NativeAOT).

Platforma .NET a CLR

Platforma .NET — ekosystém pro provádění spravovaného kódu, zahrnující CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core pro serverový vývoj a .NET MAUI pro mobilní aplikace. .NET 8+ — jednotná platforma pro všechny typy aplikací: mobilní, desktopové, webové, cloudové, IoT, Hry (Unity).

CLR — virtuální stroj provádějící kód CIL (Common Intermediate Language). C#, VB.NET, F# se kompilují do CIL. JIT kompilátor CLR převádí CIL na strojový kód při prvním volání metody. NativeAOT (předběžná kompilace) kompiluje CIL do nativního kódu ve fázi sestavení — ideální pro mobilní platformy, kde může být JIT omezen (iOS).

Garbage collector GC .NET — generační (generace 0, 1, 2), automaticky uvolňuje nepoužívané objekty. Pro mobilní aplikace se doporučuje Workstation GC s minimálními pauzami. GC probíhá v samostatném vlákně, aniž by blokoval UI vlákno. Background GC — sběrač na pozadí minimalizující pauzy pro interaktivní aplikace.

Nástroje vývojáře C#

Nástroje vývojáře C# zahrnují Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 — hlavní IDE s návrhářem XAML, debuggrem pro spravovaný a nativní kód, profilerem CPU/paměti. .NET SDK obsahuje kompilátor csc, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — správce balíčků .NET, analogický k npm pro JS. 300 000+ balíčků, včetně CommunityToolkit.Maui (UI komponenty), SQLite-net (databáze), Firebase Cloud Messaging, ZXing.Net.Maui (QR kódy). .NET MAUI Community Toolkit — sada chování, převodníků, animací pro urychlení vývoje. RestSharp a Refit — HTTP klienti. Prism a MVVM Community Toolkit — architektonické rámce.

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

Soubor .csproj — konfigurace projektu .NET MAUI. TargetFrameworks vyjmenovává cílové platformy. UseMaui zapíná MAUI SDK. PackageReference — závislosti z NuGet. CommunityToolkit.Maui — UI komponenty (toasty, snackbary, Popup). sqlite-net-pcl — lokální databáze. Refit — typovaný HTTP klient založený na rozhraních. dotnet build/publish sestaví aplikaci pro všechny platformy.