C#: kernconcepten van de taal, .NET MAUI en Xamarin-ontwikkeling

Wat is C#?

C# (uitgesproken als «si sharp») — een objectgeoriënteerde programmeertaal met een veilig typesysteem, ontwikkeld door Microsoft in 2000 onder leiding van Anders Hejlsberg. De naam is geïnspireerd op muzieknotatie (kruis — verhoging van de toon). C# werkt op het .NET-platform, dat Common Language Runtime (CLR) en een uitgebreide klassenbibliotheek (BCL — Base Class Library) omvat.

In mobiele ontwikkeling wordt C# gebruikt via twee technologieën: Xamarin (2011–2024) en zijn opvolger .NET MAUI (2022+). Xamarin maakte het mogelijk native Android- en iOS-apps te maken met gedeelde C#-code, met gescheiden platformprojecten. .NET MAUI verenigt alle platforms in één project met gemeenschappelijke XAML-opmaak en toegang tot native API's via platforminterfaces.

Kernkenmerk van C# — strikte statische typering met dynamische dispatch via dynamic, het sleutelwoord var (type-inferentie) en een krachtig generics-systeem. C# is een fully managed taal: geheugen wordt beheerd door de garbage collector (GC), array-grenzen worden gecontroleerd, niet-geïnitialiseerde variabelen zijn verboden. Dit maakt C# veiliger dan C++ met vergelijkbare prestaties via AOT-compilatie.

C#-versies en evolutie

C# 1.0 (2000) — basis OOP-taal. C# 3.0 (2007) — LINQ, lambda-expressies, extension methods. C# 6.0 (2015) — string interpolation, null-conditional operator. C# 8.0 (2019) — nullable reference types (inschakelen van null-veiligheid), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Elke versie brengt verbeteringen die relevant zijn voor mobiele ontwikkeling.

C#-syntaxis: types, klassen en LINQ

C#-syntaxis — C-achtig, strikt getypeerd. Alles is een object, inclusief primitieven (int, double, bool — dit zijn structs die overerven van ValueType). C# verdeelt typen in value types (int, double, bool, struct, enum — opgeslagen op de stack) en reference types (string, class, interface, delegate, array, record — opgeslagen in de heap). Nullable-types (int?) staan null toe voor value types.

Gegevenstypen en klassen

C# ondersteunt klassen (class), structs (struct), records (record), interfaces (interface), enumeraties (enum) en delegates (delegate). record — een onveranderlijk reference type met value-based gelijkheid (twee records zijn gelijk als al hun velden gelijk zijn). record struct — de value-versie van record, geïntroduceerd in C# 10. primary constructors (C# 12) combineren declaratie en initialisatie in één regel.

// Basis typen en klassen C#
using System;
using System.Collections.Generic;

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

// Klasse met nullable-eigenschappen
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Methode met 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(".");
}

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

Record User met primary constructor genereert automatisch equals, hashCode, ToString, Deconstruct en with-kopiëren. Init-only setters (AppName) staan toe de waarde alleen in de initialisator in te stellen. Expression body (=>) — beknopte notatie voor eenvoudige methoden. Extension method IsValidEmail voegt een methode toe aan string zonder overerving.

LINQ — Language Integrated Query

LINQ — ingebouwde querytaal voor collecties, databases, XML. LINQ to Objects — query's op IEnumerable-collecties. LINQ to SQL — op databases. LINQ to XML — op XML. Syntaxis kan query (from u in users where u.Age > 18 select u) en method (users.Where(u => u.Age > 18).Select(u => u)) zijn. Lazy loading (deferred execution): de query wordt uitgevoerd bij iteratie, niet bij declaratie.

// LINQ-query's op collecties
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 met meerdere operaties
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ met async stroom (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-query filteredUsers filtert gebruikers op emaildomein en sorteert op naam. Method syntax .Where().OrderBy().Select() — keten van methoden, equivalent aan query syntax. GroupBy groepeert op emaildomein. IAsyncEnumerable (C# 8) — asynchrone versie van IEnumerable, handig voor het streamen van gegevens in een mobiele app.

Xamarin en .NET MAUI: architectuur

Xamarin (2011–2024) — het eerste Microsoft-platform voor cross-platform mobiele ontwikkeling in C#. Het bestond uit Xamarin.Android (Mono runtime bovenop de Linux-kernel) en Xamarin.iOS (AOT-compilatie naar ARM64 vanwege het JIT-verbod op iOS). Xamarin.Forms — gemeenschappelijke UI-laag met XAML-opmaak die elementen vertaalt naar native (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) — opvolger van Xamarin, uitgebracht in 2022. Eén .csproj-project, één XAML-opmaak, één toegangspunt. Ondersteunt 5 platforms: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI gebruikt de nieuwe Handler-architectuur in plaats van Renderer: elk XAML-element wordt via een platform-handler naar een native component gemapt.

<!-- MainPage.xaml — declaratieve 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-opmaak van .NET MAUI beschrijft UI declaratief. ScrollView — scrollen, VerticalStackLayout — verticale indeling. Label, Entry (tekstinvoer), Button — basiselementen. CollectionView — gevirtualiseerde lijst met DataTemplate voor het weergeven van elementen. Het Clicked-event wordt gekoppeld aan de methode OnSubmitClicked in de code-behind MainPage.xaml.cs.

// MainPage.xaml.cs — code-behind met C#-logica
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 erft van ContentPage. InitializeComponent() laadt de XAML-opmaak. NameEntry.Text?.Trim() — null-conditional operator (?.) voor veilige toegang. DisplayAlert — native dialoog. ItemsView.ItemsSource — Binding naar een collectie. async/await voor asynchroon laden. MVVM (Model-View-ViewModel) architectuur wordt aanbevolen voor complexe projecten.

C# in mobiele ontwikkeling

C# mobiele ontwikkeling biedt drie benaderingen: .NET MAUI (cross-platform UI), Xamarin (legacy) en Unity (games). .NET MAUI — aanbevolen pad voor nieuwe projecten. Een C#-app wordt gecompileerd naar Intermediate Language (IL), die NativeAOT (.NET MAUI) of Mono (Xamarin) omzet in native ARM-code. iOS vereist AOT-compilatie — JIT is verboden door Apple-beleid.

Toegang tot native API's

.NET MAUI biedt uniforme API's voor werken met platformmogelijkheden via interfaces: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Voor platformspecifieke code wordt conditionele compilatie (#if ANDROID, #if IOS) of partial class gebruikt.

// Geolocatie in .NET MAUI met 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($"Locatiefout: {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;
    }
}

Service LocationService gebruikt DI (dependency injection IGeolocation). CheckAndRequestPermission controleert en vraagt geolocatietoestemming. GetLastKnownLocationAsync — snel (maar niet altijd nauwkeurig) antwoord, GetLocationAsync — query met parameters voor nauwkeurigheid en timeout. null-controles (location == null) met nullable reference types. try-catch vangt platformuitzonderingen af.

C#-prestaties op mobiele apparaten

C# op mobiele apparaten levert prestaties vergelijkbaar met Java/Kotlin op Android en Swift op iOS. NativeAOT (.NET 8+) compileert C# direct naar native code zonder IL-tussenfase — dit vermindert de opstarttijd met 50% en verlaagt het geheugengebruik. GC in .NET MAUI is geoptimaliseerd voor mobiele platforms met korte pauzes (Workstation GC). APK-grootte — ~20-30 MB (met NativeAOT).

.NET-platform en CLR

.NET-platform — ecosysteem voor het uitvoeren van managed code, met CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core voor serverontwikkeling en .NET MAUI voor mobiele apps. .NET 8+ — uniform platform voor alle soorten apps: mobiel, desktop, web, cloud, IoT, Games (Unity).

CLR — virtuele machine die CIL (Common Intermediate Language) code uitvoert. C#, VB.NET, F# worden naar CIL gecompileerd. De JIT-compiler van CLR zet CIL om in machinecode bij de eerste aanroep van een methode. NativeAOT (voorcompilatie) compileert CIL naar native code in de bouwfase — ideaal voor mobiele platforms waar JIT beperkt kan zijn (iOS).

Garbage collector GC van .NET — generationeel (generaties 0, 1, 2), maakt ongebruikte objecten automatisch vrij. Voor mobiele apps wordt Workstation GC met minimale pauzes aanbevolen. GC vindt plaats in een aparte thread zonder de UI-thread te blokkeren. Background GC — achtergrondverzamelaar die pauzes minimaliseert voor interactieve apps.

Tools voor C#-ontwikkelaars

Tools voor C#-ontwikkelaars omvatten Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 — primaire IDE met XAML-ontwerper, debugger voor managed en native code, CPU/geheugen-profiler. .NET SDK bevat de csc-compiler, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — .NET-pakketbeheerder, analoog aan npm voor JS. 300.000+ pakketten, waaronder CommunityToolkit.Maui (UI-componenten), SQLite-net (database), Firebase Cloud Messaging, ZXing.Net.Maui (QR-codes). .NET MAUI Community Toolkit — verzameling gedragingen, converters, animaties om ontwikkeling te versnellen. RestSharp en Refit — HTTP-cliënten. Prism en MVVM Community Toolkit — architectuurframeworks.

<!-- .csproj — configuratie .NET MAUI-project -->
<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>

Bestand .csproj — configuratie van .NET MAUI-project. TargetFrameworks somt de doelplatforms op. UseMaui schakelt MAUI SDK in. PackageReference — afhankelijkheden uit NuGet. CommunityToolkit.Maui — UI-componenten (toasts, snackbars, Popup). sqlite-net-pcl — lokale database. Refit — getypeerde HTTP-client op basis van interfaces. dotnet build/publish bouwt de app voor alle platforms.