Partial class

Med partial kan du dela upp definitionen av en klass i flera filer. Kompilatorn sätter ihop dem till en klass när koden byggs.

När du läst detta ska du kunna

Förklara vad partial class är
Skriva en klass som är delad i två filer
Nämna när partial class används i praktiken

Grundexempel

public partial class Person
{
    public string Name  { get; set; }
    public int    Age { get; set; }
}

public partial class Person
{
    public void Present()
    {
        Console.WriteLine($"{Name}, {Age} år");
    }

    public bool IsAdult() => Age >= 18;
}

// Program.cs — klassen beter sig som en enda klass
var p = new Person { Name = "Anna", Age = 25 };
p.Present();                          // Anna, 25 år
Console.WriteLine(p.IsAdult());          // True

Output

Anna, 25 år
True

Varför dela upp en klass?

Praktiska skäl att använda partial:

Kod-generatorer: Windows Forms och WPF genererar Form1.Designer.cs automatiskt. Din kod hamnar i Form1.cs. Separationen skyddar genereringen från dina ändringar.
Stor klass under refaktorering: Under ett refaktoreringsarbete kan du tillfälligt dela upp en stor klass i logiska delar utan att bryta API:et.
Teamarbete: Olika team-medlemmar kan arbeta i separata filer på samma klass med färre merge-konflikter.

Vad partial INTE löser

En partial class är fortfarande en klass — den kan fortfarande bryta mot SRP
Det är inte ett substitut för att bryta ut logik i egna klasser
Undvik att använda partial för att dölja att en klass har blivit för stor — dela upp till separata klasser istället

Partial method

Inom en partial class kan du deklarera en partial metod — en signatur i en fil och implementationen (valfri) i en annan.

// Del 1
public partial class Logger
{
    partial void OnLoggad(string message);  // bara deklaration

    public void Log(string message)
    {
        Console.WriteLine($"[LOG] {message}");
        OnLoggad(message);  // anropas om implementerad, annars ignoreras
    }
}

// Del 2 (valfri implementation)
public partial class Logger
{
    partial void OnLoggad(string message)
    {
        // Extra åtgärd om man vill — annars raderas anropet av kompilatorn
        System.Diagnostics.Debug.WriteLine($"DEBUG: {message}");
    }
}

Precis som partial methods kan du deklarera en partial property — en deklaration i en fil och implementationen i en annan. Användbart när en kod-generator ska styra implementationen men du vill att API:et ska synas tydligt i klassens huvudfil:

// Fil: Person.cs — API:et är synligt här
public partial class Person
{
    public partial string Name { get; set; }
    public partial int    Age  { get; set; }
}

// Fil: Person.Generated.cs — implementationen (kanske genererad)
public partial class Person
{
    public partial string Name
    {
        get => field;
        set => field = value?.Trim() ?? throw new ArgumentNullException(nameof(value));
    }

    public partial int Age
    {
        get => field;
        set => field = value is >= 0 and <= 150
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value));
    }
}

var p = new Person { Name = "  Anna  ", Age = 30 };
Console.WriteLine(p.Name);   // "Anna" (trimmad)
Console.WriteLine(p.Age);    // 30

Deklarationen (utan kropp) och implementationen (med kropp) måste ha samma signatur. En partial property utan implementation ger kompileringsfel — till skillnad från partial methods som kan utelämnas.

TL;DR

partial class delar upp en klass i flera filer
Kompilatorn slår ihop filerna till en klass
Vanligast i kod-genererade klasser (Windows Forms, WPF, EF-scaffolding)
partial fungerar även på metoder och properties
Inte ett designmönster för att hantera stora klasser — det är ett verktyg för specifika situationer