What are partial classes and partial members in C#? Explain how the parts are combined, why source generators depend on them, partial methods (classic and extended), partial properties (C# 13) and partial constructors and events (C# 14).

How I would answer this in an interview

Partial types let one class, struct, interface or record be declared across multiple files; the compiler merges them into a single type. Partial members let one part declare a member and another part implement it. They exist mainly so generated code and hand-written code can live side by side without editing each other — which is why source generators depend on them.

1. How the parts are combined

// Order.cs
public sealed partial class Order
{
    public OrderId Id { get; }
    public void Submit() { Validate(); /* ... */ }
}

// Order.Validation.cs
public sealed partial class Order
{
    private void Validate() { /* ... */ }
}

• All parts must use partial, be in the same assembly and namespace, and have the same kind (class/struct/record/interface).
• Modifiers, base class and interfaces are merged: if any part says sealed, abstract or declares a base class, it applies to the whole type; interface lists are unioned; conflicting base classes are an error.
• Attributes from all parts are combined.
• At compile time there's only one type — no run-time cost.

2. Why source generators depend on them

A Roslyn source generator can only add new source files to a compilation; it can't modify yours. Partial types let it add members to your type:

public static partial class Log
{
    [LoggerMessage(Level = LogLevel.Information, Message = "Order {OrderId} submitted")]
    public static partial void OrderSubmitted(ILogger logger, Guid orderId);   // generator implements this
}

[JsonSerializable(typeof(OrderDto))]
internal partial class AppJsonContext : JsonSerializerContext { }          // generator adds metadata members

public static partial class Patterns
{
    [GeneratedRegex(@"^\d{11}$")]
    public static partial Regex Abn();                                     // generator emits the regex code
}

This enables compile-time code generation for logging, JSON serialisation (needed for NativeAOT/trimming), regex, P/Invoke ([LibraryImport]), configuration binding, MVVM toolkits, Mapperly mappers and more. Older uses: WinForms/WPF designer files (Form1.Designer.cs) and EF Core scaffolding.

3. Partial methods

Classic partial methods (C# 3):

partial void OnNameChanged();          // declaration, no body

• Implicitly private, must return void, no out parameters.
• If no part implements them, the compiler removes the declaration and all calls — zero cost. Designed for generated code offering optional hooks.

Extended partial methods (C# 9):

public static partial Regex Abn();     // must be implemented by another part

• Can have access modifiers, non-void returns, and out parameters.
• Must have exactly one implementation — that's what generators provide.

4. Partial properties and indexers (C# 13)

public partial class SettingsViewModel
{
    [ObservableProperty]
    public partial string DisplayName { get; set; }   // declaration; generator implements with change notification
}

One part declares the property (signature only); another provides accessor bodies. This lets generators (e.g. MVVM toolkits) implement property logic without requiring fields-with-attributes tricks. [GeneratedRegex] also works on partial properties.

5. Partial constructors and events (C# 14)

C# 14 extends the same model to instance constructors and events: a declaring part provides the signature and a single implementing part provides the body (for events, the add/remove accessors). This lets generators implement constructor logic (e.g. dependency wiring, interop initialisation) or weak-event patterns while the user declares the shape.

6. Good and bad uses by hand

• Good: separating generated from hand-written code; very occasionally splitting a large type by concern (e.g. a big API client with nested parts) when it genuinely can't be split into separate types.
• Bad: using partial classes to hide that a class is too big. A 3,000-line class split into five files is still a 3,000-line class with too many responsibilities.

7. A production example

We migrated an API to NativeAOT for faster start-up in Azure Container Apps. Reflection-based System.Text.Json serialisation and some Regex usages produced trimming warnings. Adding a partial JsonSerializerContext with [JsonSerializable] attributes and converting hot regexes to [GeneratedRegex] partial methods removed the warnings, cut cold start noticeably, and made serialisation faster even in the JIT build. Partial members were the mechanism that let generated code slot into our types.