C#: språkets nyckelbegrepp, .NET MAUI och Xamarin-utveckling

Vad är C#?

C# (uttalas «si sharp») — ett objektorienterat programmeringsspråk med ett säkert typsystem, utvecklat av Microsoft år 2000 under ledning av Anders Hejlsberg. Namnet är inspirerat av musikalisk notation (kors — höjning av tonen). C# körs på .NET-plattformen, som inkluderar Common Language Runtime (CLR) och ett omfattande klassbibliotek (BCL — Base Class Library).

Inom mobilutveckling används C# genom två tekniker: Xamarin (2011–2024) och dess efterföljare .NET MAUI (2022+). Xamarin möjliggjorde skapandet av native Android- och iOS-appar med gemensam C#-kod, med separata plattformsprojekt. .NET MAUI förenar alla plattformar i ett enda projekt med gemensam XAML-markup och åtkomst till native API:er via plattformsgränssnitt.

Nyckelegenskapen hos C# — strikt statisk typning med möjlighet till dynamisk sändning via dynamic, nyckelordet var (typinferens) och ett kraftfullt generics-system. C# är ett fullständigt hanterat språk: minnet hanteras av garbage collectorn (GC), array-gränser kontrolleras, oinitierade variabler är förbjudna. Detta gör C# säkrare än C++ med jämförbar prestanda genom AOT-kompilering.

C#-versioner och evolution

C# 1.0 (2000) — grundläggande OOP-språk. C# 3.0 (2007) — LINQ, lambdauttryck, extension methods. C# 6.0 (2015) — string interpolation, null-conditional operator. C# 8.0 (2019) — nullable reference types (aktivering av null-säkerhet), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Varje version ger förbättringar relevanta för mobilutveckling.

C#-syntax: typer, klasser och LINQ

C#-syntax — C-liknande, strikt typad. Allt är ett objekt, inklusive primitiver (int, double, bool — det är strukturer som ärver ValueType). C# delar in typer i value types (int, double, bool, struct, enum — lagras på stacken) och reference types (string, class, interface, delegate, array, record — lagras på heapen). Nullable-typer (int?) tillåter null för value types.

Datatyper och klasser

C# stöder klasser (class), strukturer (struct), poster (record), gränssnitt (interface), uppräkningar (enum) och delegater (delegate). record — en oföränderlig reference type med värdebaserad likhet (två poster är lika om alla deras fält är lika). record struct — värdeversionen av record, introducerad i C# 10. primary constructors (C# 12) kombinerar deklaration och initiering på en rad.

// Grundläggande typer och klasser C#
using System;
using System.Collections.Generic;

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

// Klass med nullable-egenskaper
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Metod med 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(".");
}

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

Posten User med primary constructor genererar automatiskt equals, hashCode, ToString, Deconstruct och with-kopiering. Init-only setters (AppName) tillåter att värdet endast ställs in i initieraren. Expression body (=>) — kompakt notering för enkla metoder. Extension method IsValidEmail lägger till en metod till string utan arv.

LINQ — Language Integrated Query

LINQ — inbyggt frågespråk för samlingar, databaser, XML. LINQ to Objects — frågor till IEnumerable-samlingar. LINQ to SQL — till databaser. LINQ to XML — till XML. Syntaxen kan vara query (from u in users where u.Age > 18 select u) och method (users.Where(u => u.Age > 18).Select(u => u)). Lat laddning (deferred execution): frågan exekveras vid iteration, inte vid deklaration.

// LINQ-frågor till samlingar
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 med flera operationer
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

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

// LINQ med async-ström (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-frågan filteredUsers filtrerar användare efter e-postdomän och sorterar efter namn. Method syntax .Where().OrderBy().Select() — metodkedja, motsvarande query syntax. GroupBy grupperar efter e-postdomän. IAsyncEnumerable (C# 8) — asynkron version av IEnumerable, användbar för strömmande data i en mobilapp.

Xamarin och .NET MAUI: arkitektur

Xamarin (2011–2024) — Microsofts första plattform för plattformsoberoende mobilutveckling i C#. Bestod av Xamarin.Android (Mono runtime ovanpå Linux-kärnan) och Xamarin.iOS (AOT-kompilering till ARM64 på grund av JIT-förbud på iOS). Xamarin.Forms — gemensamt UI-lager med XAML-markup som översätter element till native (Android View / iOS UIView).

.NET MAUI (.NET Multi-platform App UI) — efterföljare till Xamarin, lanserad 2022. Ett .csproj-projekt, en XAML-markup, en ingångspunkt. Stöder 5 plattformar: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. .NET MAUI använder den nya Handler-arkitekturen istället för Renderer: varje XAML-element mappas till en native komponent via en plattformshandler.

<!-- MainPage.xaml — deklarativ 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-markup för .NET MAUI beskriver UI deklarativt. ScrollView — rullning, VerticalStackLayout — vertikal layout. Label, Entry (textinmatning), Button — grundläggande element. CollectionView — virtualiserad lista med DataTemplate för att visa element. Händelsen Clicked binds till metoden OnSubmitClicked i code-behind MainPage.xaml.cs.

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

Code-behind MainPage ärver ContentPage. InitializeComponent() laddar XAML-markupen. NameEntry.Text?.Trim() — null-conditional operator (?.) för säker åtkomst. DisplayAlert — native dialogruta. ItemsView.ItemsSource — Binding till en samling. async/await för asynkron laddning. MVVM-arkitektur (Model-View-ViewModel) rekommenderas för komplexa projekt.

C# i mobilutveckling

Mobilutveckling i C# erbjuder tre tillvägagångssätt: .NET MAUI (plattformsoberoende UI), Xamarin (äldre) och Unity (spel). .NET MAUI — rekommenderad väg för nya projekt. En C#-app kompileras till Intermediate Language (IL), som NativeAOT (.NET MAUI) eller Mono (Xamarin) omvandlar till native ARM-kod. iOS kräver AOT-kompilering — JIT är förbjudet enligt Apples policy.

Åtkomst till native API:er

.NET MAUI tillhandahåller enhetliga API:er för arbete med plattformsfunktioner via gränssnitt: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. För plattformsspecifik kod används villkorlig kompilering (#if ANDROID, #if IOS) eller partial class.

// Geolokalisering i .NET MAUI med 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($"Platsfel: {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;
    }
}

Tjänsten LocationService använder DI (beroendeinjektion av IGeolocation). CheckAndRequestPermission kontrollerar och begär geolokaliseringstillstånd. GetLastKnownLocationAsync — snabbt (men inte alltid exakt) svar, GetLocationAsync — fråga med parametrar för noggrannhet och timeout. null-kontroller (location == null) med nullable reference types. try-catch hanterar plattformsundantag.

C#-prestanda på mobila enheter

C# på mobila enheter visar prestanda jämförbar med Java/Kotlin på Android och Swift på iOS. NativeAOT (.NET 8+) kompilerar C# direkt till native kod utan IL-mellansteg — detta minskar starttiden med 50 % och sänker minnesförbrukningen. GC i .NET MAUI är optimerat för mobila plattformar med korta pauser (Workstation GC). APK-storlek — ~20-30 MB (med NativeAOT).

.NET-plattformen och CLR

.NET-plattformen — ekosystem för exekvering av hanterad kod, inklusive CLR (Common Language Runtime), BCL (Base Class Library), ASP.NET Core för serverutveckling och .NET MAUI för mobilappar. .NET 8+ — enhetlig plattform för alla typer av appar: mobil, desktop, webb, moln, IoT, Spel (Unity).

CLR — virtuell maskin som exekverar CIL-kod (Common Intermediate Language). C#, VB.NET, F# kompileras till CIL. CLR:s JIT-kompilator omvandlar CIL till maskinkod vid första anropet av en metod. NativeAOT (förkompilering) kompilerar CIL till native kod i byggfasen — idealiskt för mobila plattformar där JIT kan vara begränsat (iOS).

Garbage collectorn GC i .NET — generationsbaserad (generation 0, 1, 2), frigör automatiskt oanvända objekt. För mobilappar rekommenderas Workstation GC med minimala pauser. GC sker i en separat tråd utan att blockera UI-tråden. Background GC — bakgrundssamlare som minimerar pauser för interaktiva appar.

C#-utvecklarverktyg

C#-utvecklarverktyg inkluderar Visual Studio, .NET SDK, dotnet CLI, NuGet, JetBrains Rider. Visual Studio 2022 — primär IDE med XAML-designer, debugger för hanterad och native kod, CPU/minnesprofilerare. .NET SDK innehåller csc-kompilatorn, dotnet CLI (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — .NET-pakethanterare, analog med npm för JS. 300 000+ paket, inklusive CommunityToolkit.Maui (UI-komponenter), SQLite-net (databas), Firebase Cloud Messaging, ZXing.Net.Maui (QR-koder). .NET MAUI Community Toolkit — samling beteenden, omvandlare, animationer för att snabba upp utvecklingen. RestSharp och Refit — HTTP-klienter. Prism och MVVM Community Toolkit — arkitekturramverk.

<!-- .csproj — konfiguration av .NET MAUI-projekt -->
<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>

Fil .csproj — konfiguration av .NET MAUI-projekt. TargetFrameworks listar målplattformarna. UseMaui aktiverar MAUI SDK. PackageReference — beroenden från NuGet. CommunityToolkit.Maui — UI-komponenter (toast, snackbar, Popup). sqlite-net-pcl — lokal databas. Refit — typad HTTP-klient baserad på gränssnitt. dotnet build/publish bygger appen för alla plattformar.