C#: a nyelv kulcsfogalmai, .NET MAUI és Xamarin fejlesztés

Mi az a C#?

C# (kiejtése «sí sárp») — egy objektumorientált programozási nyelv biztonságos típusrendszerrel, amelyet a Microsoft fejlesztett 2000-ben Anders Hejlsberg vezetésével. A név zenei notációból származik (kereszt — hangmagasság emelés). A C# a .NET platformon fut, amely magában foglalja a Common Language Runtime (CLR) rendszert és a kiterjedt osztálykönyvtárat (BCL — Base Class Library).

A mobilfejlesztésben a C# két technológián keresztül használatos: Xamarin (2011–2024) és annak utódja .NET MAUI (2022+). A Xamarin lehetővé tette natív Android és iOS alkalmazások létrehozását közös C# kóddal, platformprojektekre bontva. A .NET MAUI egyesíti az összes platformot egyetlen projektbe közös XAML jelöléssel és natív API-khoz való hozzáféréssel platforminterfészeken keresztül.

A C# kulcsjellemzője — szigorú statikus típusosság dinamikus küldéssel a dynamic kulcsszón keresztül, var kulcsszó (típuskövetkeztetés) és erős generikus rendszer. A C# teljesen felügyelt nyelv: a memóriát a szemétgyűjtő (GC) kezeli, a tömbhatárok ellenőrzésre kerülnek, a nem inicializált változók tiltottak. Ez biztonságosabbá teszi a C#-ot a C++-nál összehasonlítható teljesítménnyel az AOT fordítás révén.

C# verziók és evolúció

C# 1.0 (2000) — alap OOP nyelv. C# 3.0 (2007) — LINQ, lambda kifejezések, extension methods. C# 6.0 (2015) — string interpolation, null-conditional operátor. C# 8.0 (2019) — nullable reference types (null biztonság bekapcsolása), async streams, default interface methods. C# 10 (2021) — global usings, file-scoped namespaces, record struct. C# 12 (2023) — primary constructors, collection expressions, interceptors. Minden verzió a mobilfejlesztés szempontjából releváns fejlesztéseket hoz.

C# szintaxis: típusok, osztályok és LINQ

C# szintaxis — C-szerű, szigorúan típusos. Minden objektum, beleértve a primitíveket is (int, double, bool — ezek a ValueType-ból öröklődő struktúrák). A C# típusokat value types (int, double, bool, struct, enum — veremben tárolva) és reference types (string, class, interface, delegate, array, record — kupacban tárolva) osztja. A nullable típusok (int?) null értéket engedélyeznek a value types számára.

Adattípusok és osztályok

C# támogatja az osztályokat (class), struktúrákat (struct), rekordokat (record), interfészeket (interface), felsorolásokat (enum) és delegátusokat (delegate). A record — egy megváltoztathatatlan reference type értékalapú egyenlőséggel (két record egyenlő, ha minden mezőjük egyenlő). A record struct — a record értékverziója, a C# 10-ben bevezetve. A primary constructors (C# 12) egy sorban egyesíti a deklarációt és inicializálást.

// C# alaptípusok és osztályok
using System;
using System.Collections.Generic;

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

// Osztály nullable tulajdonságokkal
public class AppConfig
{
    public string AppName { get; init; }
    public string? ApiUrl { get; set; } // nullable reference type
    public int Version { get; init; }

    // Metódus expression body-val
    public string GetDisplayName() => $"{AppName} v{Version}";
}

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

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

A User rekord primary constructor-ral automatikusan generál equals, hashCode, ToString, Deconstruct és with-másolást. Az init-only setterek (AppName) csak az inicializálóban engedik az érték beállítását. Expression body (=>) — tömör írás egyszerű metódusokhoz. Az extension method IsValidEmail metódust ad a string-hez öröklés nélkül.

LINQ — Language Integrated Query

LINQ — beépített lekérdezőnyelv gyűjteményekhez, adatbázisokhoz, XML-hez. LINQ to Objects — lekérdezések IEnumerable gyűjteményekhez. LINQ to SQL — adatbázisokhoz. LINQ to XML — XML-hez. A szintaxis lehet query (from u in users where u.Age > 18 select u) és method (users.Where(u => u.Age > 18).Select(u => u)). Lustá betöltés (deferred execution): a lekérdezés iterációkor hajtódik végre, nem deklarációkor.

// LINQ lekérdezések gyűjteményekhez
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 szintaxis
var filteredUsers = from u in users
                     where u.Email.Contains("example")
                     orderby u.Name
                     select u;

// Method szintaxis több művelettel
var result = users
    .Where(u => u.Email.Contains("example"))
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

// GroupBy és aggregáció
var emailsByDomain = users
    .GroupBy(u => u.Email.Split('@')[1])
    .Select(g => new { Domain = g.Key, Count = g.Count() });

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

A filteredUsers LINQ lekérdezés szűri a felhasználókat email domain alapján és rendezi név szerint. Method syntax .Where().OrderBy().Select() — metóduslánc, amely egyenértékű a query syntax-szal. A GroupBy email domain szerint csoportosít. IAsyncEnumerable (C# 8) — az IEnumerable aszinkron verziója, hasznos adatok streameléséhez mobilalkalmazásban.

Xamarin és .NET MAUI: architektúra

Xamarin (2011–2024) — a Microsoft első platformja cross-platform mobilfejlesztéshez C#-ban. A Xamarin.Android (Mono runtime a Linux kernel felett) és Xamarin.iOS (AOT fordítás ARM64-re a JIT iOS-en való tiltása miatt) alkotta. Xamarin.Forms — közös UI réteg XAML jelöléssel, amely elemeket natívra (Android View / iOS UIView) fordít.

.NET MAUI (.NET Multi-platform App UI) — a Xamarin utódja, 2022-ben kiadva. Egyetlen .csproj projekt, egyetlen XAML jelölés, egyetlen belépési pont. 5 platformot támogat: iOS, Android, Windows (WinUI 3), macOS (Mac Catalyst), Tizen. A .NET MAUI az új Handler architektúrát használja a Renderer helyett: minden XAML elem egy platform-handleren keresztül natív komponensre képeződik le.

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

A .NET MAUI XAML jelölése deklaratívan írja le az UI-t. ScrollView — görgetés, VerticalStackLayout — függőleges elrendezés. Label, Entry (szövegbevitel), Button — alapelemek. CollectionView — virtualizált lista DataTemplate-tel elemek megjelenítéséhez. A Clicked esemény az OnSubmitClicked metódushoz van kötve a MainPage.xaml.cs code-behind-ben.

// MainPage.xaml.cs — code-behind C# logikával
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;
    }
}

A MainPage code-behind a ContentPage-ből örököl. Az InitializeComponent() betölti a XAML jelölést. NameEntry.Text?.Trim() — null-conditional operátor (?.) biztonságos hozzáféréshez. DisplayAlert — natív párbeszédpanel. ItemsView.ItemsSource — Binding gyűjteményhez. async/await aszinkron betöltéshez. Az MVVM (Model-View-ViewModel) architektúra összetett projektekhez ajánlott.

C# a mobilfejlesztésben

C# mobilfejlesztés három megközelítést kínál: .NET MAUI (cross-platform UI), Xamarin (örökölt) és Unity (játékok). .NET MAUI — ajánlott út új projektekhez. A C# alkalmazás Intermediate Language (IL) formába fordul, amelyet a NativeAOT (.NET MAUI) vagy a Mono (Xamarin) natív ARM kóddá alakít. Az iOS AOT fordítást igényel — a JIT az Apple irányelvei által tiltott.

Hozzáférés natív API-khoz

.NET MAUI egységes API-kat biztosít a platformképességekkel való munkához interfészeken keresztül: IAccelerometer, IBarometer, IBattery, IConnectivity, IDeviceInfo, IFilePicker, IGeolocation, IMediaPicker, IPermissions, ISpeechRecognizer, IVibration. Platformspecifikus kódhoz feltételes fordítás (#if ANDROID, #if IOS) vagy partial class használatos.

// Geolokáció .NET MAUI-ban DI-vel
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($"Helymeghatározási hiba: {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;
    }
}

A LocationService szolgáltatás DI-t (IGeolocation függőséginjektálás) használ. A CheckAndRequestPermission ellenőrzi és kéri a geolokációs engedélyt. GetLastKnownLocationAsync — gyors (de nem mindig pontos) válasz, GetLocationAsync — lekérdezés pontossági és időtúllépési paraméterekkel. null ellenőrzések (location == null) nullable reference types-szal. try-catch kezeli a platform kivételeket.

C# teljesítmény mobil eszközökön

C# mobil eszközökön a Java/Kotlin Androidon és a Swift iOSen teljesítményével összehasonlítható teljesítményt mutat. A NativeAOT (.NET 8+) közvetlenül natív kódba fordítja a C#-ot IL köztes lépés nélkül — ez 50%-kal csökkenti az indítási időt és mérsékli a memóriafogyasztást. A GC a .NET MAUI-ban rövid szünetekkel optimalizált mobil platformokhoz (Workstation GC). APK méret — ~20-30 MB (NativeAOT-val).

.NET platform és CLR

.NET platform — ökoszisztéma felügyelt kód végrehajtásához, amely magában foglalja a CLR-t (Common Language Runtime), BCL-t (Base Class Library), ASP.NET Core-t szerverfejlesztéshez és .NET MAUI-t mobilalkalmazásokhoz. .NET 8+ — egységes platform minden alkalmazástípushoz: mobil, asztali, web, felhő, IoT, Játékok (Unity).

CLR — virtuális gép, amely CIL (Common Intermediate Language) kódot hajt végre. C#, VB.NET, F# CIL-be fordulnak. A CLR JIT-fordítója a CIL-t gépkóddá alakítja a metódus első hívásakor. A NativeAOT (előzetes fordítás) a CIL-t a build fázisban natív kódba fordítja — ideális mobil platformokhoz, ahol a JIT korlátozott lehet (iOS).

A .NET GC szemétgyűjtője — generációs (0, 1, 2 generációk), automatikusan felszabadítja a nem használt objektumokat. Mobilalkalmazásokhoz a Workstation GC ajánlott minimális szünetekkel. A GC külön szálban történik, nem blokkolja az UI szálat. Background GC — háttérgyűjtő, amely minimalizálja a szüneteket interaktív alkalmazások számára.

C# fejlesztői eszközök

C# fejlesztői eszközök magukban foglalják a Visual Studio-t, .NET SDK-t, dotnet CLI-t, NuGet-et, JetBrains Rider-t. Visual Studio 2022 — elsődleges IDE XAML tervezővel, felügyelt és natív kód hibakeresővel, CPU/memória profilozóval. .NET SDK tartalmazza a csc fordítót, dotnet CLI-t (dotnet new, dotnet build, dotnet publish, dotnet test).

NuGet — .NET csomagkezelő, analóg az npm-mel JS-hez. 300 000+ csomag, beleértve a CommunityToolkit.Maui (UI komponensek), SQLite-net (adatbázis), Firebase Cloud Messaging, ZXing.Net.Maui (QR kódok). .NET MAUI Community Toolkit — viselkedések, konverterek, animációk gyűjteménye a fejlesztés gyorsításához. RestSharp és Refit — HTTP kliensek. Prism és MVVM Community Toolkit — architekturális keretrendszerek.

<!-- .csproj — .NET MAUI projekt konfigurációja -->
<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>

A .csproj fájl — a .NET MAUI projekt konfigurációja. A TargetFrameworks felsorolja a célplatformokat. A UseMaui bekapcsolja a MAUI SDK-t. PackageReference — függőségek a NuGet-ből. CommunityToolkit.Maui — UI komponensek (toast, snackbar, Popup). sqlite-net-pcl — helyi adatbázis. Refit — interfész-alapú típusos HTTP kliens. dotnet build/publish az alkalmazást minden platformra felépíti.