C#: Sprachliche Schlüsselkonzepte, .NET MAUI und Xamarin-Entwicklung

Was ist C#?

C# (ausgesprochen "C Sharp") ist eine objektorientierte Programmiersprache mit einem sicheren Typsystem, die von Microsoft im Jahr 2000 unter der Leitung von Anders Hejlsberg entwickelt wurde. Der Name ist von der musikalischen Notation inspiriert (Sharp — Erhöhung der Tonhöhe). C# läuft auf der .NET-Plattform, die die Common Language Runtime (CLR) und eine umfangreiche Klassenbibliothek (BCL — Base Class Library) umfasst.

In der mobilen Entwicklung wird C# über zwei Technologien eingesetzt: Xamarin (2011–2024) und seinen Nachfolger .NET MAUI (2022+). Xamarin ermöglichte die Erstellung nativer Android- und iOS-Anwendungen mit gemeinsamem C#-Code, wobei plattformspezifische Projekte getrennt wurden. .NET MAUI vereint alle Plattformen in einem einzigen Projekt mit gemeinsamem XAML-Markup und Zugriff auf native APIs über Plattformschnittstellen.

Ein Hauptmerkmal von C# ist die strenge statische Typisierung mit der Möglichkeit der dynamischen Dispatch über dynamic, das Schlüsselwort var (Typinferenz) und ein leistungsstarkes Generics-System. C# ist eine vollständig verwaltete Sprache: Der Speicher wird vom Garbage Collector (GC) verwaltet, Array-Grenzen werden überprüft, nicht initialisierte Variablen sind verboten. Dies macht C# sicherer als C++ bei vergleichbarer Leistung durch AOT-Kompilierung.

C#-Versionen und Entwicklung

C# 1.0 (2000) — grundlegende OOP-Sprache. C# 3.0 (2007) — LINQ, Lambda-Ausdrücke, Erweiterungsmethoden. C# 6.0 (2015) — Zeichenfolgeninterpolation, null-bedingter Operator. C# 8.0 (2019) — Nullable-Referenztypen (Nullsicherheit aktivieren), asynchrone Streams, Standard-Interface-Methoden. C# 10 (2021) — globale Usings, dateibezogene Namespaces, record struct. C# 12 (2023) — primäre Konstruktoren, Sammlungsausdrücke, Interceptors. Jede Version bringt für die mobile Entwicklung relevante Verbesserungen.

C#-Syntax: Typen, Klassen und LINQ

Die C#-Syntax ist C-ähnlich, streng typisiert. Alles ist ein Objekt, einschließlich Primitiven (int, double, bool — dies sind Strukturen, die von ValueType erben). C# unterteilt Typen in Wertetypen (int, double, bool, struct, enum — auf dem Stack gespeichert) und Referenztypen (string, class, interface, delegate, array, record — auf dem Heap gespeichert). Nullable-Typen (int?) erlauben null für Wertetypen.

Datentypen und Klassen

C# unterstützt Klassen (class), Strukturen (struct), Datensätze (record), Schnittstellen (interface), Aufzählungen (enum) und Delegaten (delegate). record ist ein unveränderlicher Referenztyp mit wertbasierter Gleichheit (zwei Datensätze sind gleich, wenn alle ihre Felder gleich sind). record struct ist die Wertversion von record, eingeführt in C# 10. Primäre Konstruktoren (C# 12) kombinieren Deklaration und Initialisierung in einer Zeile.

// Basistypen und Klassen in C#
using System;
using System.Collections.Generic;

// Datensatz mit primärem Konstruktor (C# 12)
public record User(int Id, string Name, string Email);

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

    // Methode mit Ausdruckskörper
    public string GetDisplayName() => $"{AppName} v{Version}";
}

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

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

Der Datensatz User mit primärem Konstruktor generiert automatisch equals, hashCode, ToString, Deconstruct und with-Kopieren. Init-only-Setter (AppName) erlauben das Festlegen eines Werts nur im Initialisierer. Der Ausdruckskörper (=>) ist eine prägnante Notation für einfache Methoden. Die Erweiterungsmethode IsValidEmail fügt string eine Methode ohne Vererbung hinzu.

LINQ — Language Integrated Query

LINQ ist eine integrierte Abfragesprache für Sammlungen, Datenbanken, XML. LINQ to Objects — Abfragen an IEnumerable-Sammlungen. LINQ to SQL — an Datenbanken. LINQ to XML — an XML. Die Syntax kann Abfragesyntax (from u in users where u.Age > 18 select u) und Methodensyntax (users.Where(u => u.Age > 18).Select(u => u)) sein. Verzögertes Laden (verzögerte Ausführung): Die Abfrage wird bei der Iteration ausgeführt, nicht bei der Deklaration.

// LINQ-Abfragen an Sammlungen
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"),
};

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

// Methodensyntax mit mehreren Operationen
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ mit asynchronem Stream (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");
}

Die LINQ-Abfrage filteredUsers filtert Benutzer nach E-Mail-Domain und sortiert nach Namen. Die Methodensyntax .Where().OrderBy().Select() ist eine Methodenkette, die der Abfragesyntax entspricht. GroupBy gruppiert nach E-Mail-Domain. IAsyncEnumerable (C# 8) ist eine asynchrone Version von IEnumerable, nützlich für das Streaming von Daten in mobilen Anwendungen.

Xamarin und .NET MAUI: Architektur

Xamarin (2011–2024) war Microsofts erste Plattform für plattformübergreifende mobile Entwicklung in C#. Es bestand aus Xamarin.Android (Mono-Laufzeit auf Linux-Kernel) und Xamarin.iOS (AOT-Kompilierung nach ARM64 aufgrund des JIT-Verbots auf iOS). Xamarin.Forms war eine gemeinsame UI-Ebene mit XAML-Markup, die Elemente in native (Android View / iOS UIView) übersetzte.

.NET MAUI (.NET Multi-platform App UI) ist der Nachfolger von Xamarin, veröffentlicht im Jahr 2022. Ein einziges .csproj-Projekt, ein XAML-Markup, ein Einstiegspunkt. Unterstützt 5 Plattformen: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI verwendet die neue Handler-Architektur anstelle von Renderer: Jedes XAML-Element wird über einen Plattform-Handler auf eine native Komponente abgebildet.

<!-- MainPage.xaml — deklarative .NET MAUI-Benutzeroberfläche -->
<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>

Das XAML-Markup von .NET MAUI beschreibt die UI deklarativ. ScrollView — Bildlauf, VerticalStackLayout — vertikale Anordnung. Label, Entry (Texteingabe), Button — grundlegende Elemente. CollectionView — virtualisierte Liste mit DataTemplate zur Anzeige von Elementen. Das Clicked-Ereignis wird an die Methode OnSubmitClicked im Code-Behind MainPage.xaml.cs gebunden.

// MainPage.xaml.cs — Code-Behind mit C#-Logik
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;
    }
}

Der Code-Behind MainPage erbt von ContentPage. InitializeComponent() lädt das XAML-Markup. NameEntry.Text?.Trim() — null-bedingter Operator (?.) für sicheren Zugriff. DisplayAlert — nativer Dialog. ItemsView.ItemsSource — Bindung an Sammlung. async/await für asynchrones Laden. Das MVVM-Muster (Model-View-ViewModel) wird für komplexe Projekte empfohlen.

C# in der mobilen Entwicklung

Mobile Entwicklung mit C# bietet drei Ansätze: .NET MAUI (plattformübergreifende UI), Xamarin (Legacy) und Unity (Spiele). .NET MAUI ist der empfohlene Weg für neue Projekte. Die C#-Anwendung wird in Intermediate Language (IL) kompiliert, die NativeAOT (.NET MAUI) oder Mono (Xamarin) in nativen ARM-Code umwandelt. iOS erfordert AOT-Kompilierung — JIT ist durch Apple-Richtlinien verboten.

Zugriff auf native APIs

.NET MAUI bietet einheitliche APIs für die Arbeit mit Plattformfunktionen über Schnittstellen: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Für plattformspezifischen Code wird bedingte Kompilierung (#if ANDROID, #if IOS) oder partielle Klasse verwendet.

// Geolokalisierung in .NET MAUI mit 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($"Standortfehler: {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;
    }
}

Der Dienst LocationService verwendet DI (Abhängigkeitsinjektion von IGeolocation). CheckAndRequestPermission überprüft und fordert die Geolokalisierungsberechtigung an. GetLastKnownLocationAsync — schnelle (aber nicht immer genaue) Antwort, GetLocationAsync — Anforderung mit Genauigkeits- und Zeitüberschreitungsparametern. Null-Prüfungen (location == null) mit Nullable-Referenztypen. try-catch behandelt Plattformausnahmen.

Leistung von C# auf Mobilgeräten

C# zeigt auf Mobilgeräten eine Leistung, die mit Java/Kotlin auf Android und Swift auf iOS vergleichbar ist. NativeAOT (.NET 8+) kompiliert C# direkt in nativen Code ohne IL-Zwischenstufe — dies reduziert die Startzeit um 50% und senkt den Speicherverbrauch. Der GC in .NET MAUI ist für mobile Plattformen mit kurzen Pausen optimiert (Workstation GC). Die APK-Größe beträgt ~20-30 MB (mit NativeAOT).

.NET-Plattform und CLR

Die .NET-Plattform ist ein Ökosystem zur Ausführung von verwaltetem Code, das CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core für die Serverentwicklung und .NET MAUI für mobile Anwendungen umfasst. .NET 8+ ist eine einheitliche Plattform für alle Anwendungstypen: Mobil, Desktop, Web, Cloud, IoT, Spiele (Unity).

CLR ist eine virtuelle Maschine, die CIL-Code (Common Intermediate Language) ausführt. C#, VB.NET, F# werden in CIL kompiliert. Der JIT-Compiler der CLR wandelt CIL beim ersten Methodenaufruf in Maschinencode um. NativeAOT (Vorabkompilierung) kompiliert CIL zur Build-Zeit in nativen Code — ideal für mobile Plattformen, auf denen JIT eingeschränkt sein kann (iOS).

Der Garbage Collector GC von .NET ist generational (Generationen 0, 1, 2) und gibt nicht verwendete Objekte automatisch frei. Für mobile Anwendungen wird Workstation GC mit minimalen Pausen empfohlen. Der GC läuft in einem separaten Thread, ohne den UI-Thread zu blockieren. Background GC ist ein Hintergrundcollector, der Pausen für interaktive Anwendungen minimiert.

C#-Entwicklerwerkzeuge

C#-Entwicklerwerkzeuge umfassen Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 ist die wichtigste IDE mit XAML-Designer, Debugger für verwalteten und nativen Code, CPU-/Speicherprofiler. Das .NET SDK enthält den csc-Compiler, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet ist der Paketmanager für .NET, ähnlich wie npm für JS. Über 300.000 Pakete, darunter CommunityToolkit.Maui (UI-Komponenten), SQLite-net (Datenbank), Firebase Cloud Messaging, ZXing.Net.Maui (QR-Codes). .NET MAUI Community Toolkit ist eine Sammlung von Verhaltensweisen, Konvertern und Animationen zur Beschleunigung der Entwicklung. RestSharp und Refit sind HTTP-Clients. Prism und MVVM Community Toolkit sind Architektur-Frameworks.

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

Die .csproj-Datei ist die Konfiguration des .NET MAUI-Projekts. TargetFrameworks listet die Zielplattformen auf. UseMaui aktiviert das MAUI SDK. PackageReference gibt NuGet-Abhängigkeiten an. CommunityToolkit.Maui bietet UI-Komponenten (Toasts, Snackbars, Popup). sqlite-net-pcl ist eine lokale Datenbank. Refit ist ein typisierter HTTP-Client auf Basis von Schnittstellen. dotnet build/publish erstellt die Anwendung für alle Plattformen.