> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# Partial Method
A partial method is a method declared within a `partial` type (class, struct, interface, or record) where the method signature is defined in one part of the type, and its implementation is provided in another part.
The `partial` keyword instructs the compiler to merge the signature and the implementation during the compilation process.
```csharp theme={"dark"}
using System;
// File1.cs - Declaration
public partial class DataProcessor
{
// Method signature
partial void InitializeProcessing();
public void Start()
{
InitializeProcessing(); // Invocation site
}
}
// File2.cs - Implementation
public partial class DataProcessor
{
// Method implementation
partial void InitializeProcessing()
{
Console.WriteLine("Initialization complete.");
}
}
```
## Compiler Behavior and Rules
The rules governing partial methods depend entirely on whether an explicit access modifier is applied to the method signature. C# 9.0 introduced "Extended Partial Methods," creating two distinct sets of constraints.
### 1. Implicitly Private Partial Methods (Pre-C# 9.0 Behavior)
If a partial method is declared **without** an explicit access modifier, it is subject to strict limitations:
* **Access Level:** It is implicitly `private`.
* **Return Type:** It must return `void`.
* **Parameters:** It cannot contain `out` parameters (though `ref` and `in` are permitted).
* **Modifiers:** It cannot be marked as `virtual`, `override`, `sealed`, `new`, or `extern`.
* **IL Erasure:** If no implementation is provided in any part of the partial type, the compiler completely removes the method signature and all invocation sites from the emitted Intermediate Language (IL). No runtime overhead is incurred for unimplemented partial methods.
### 2. Extended Partial Methods (C# 9.0+)
If a partial method is declared **with** an explicit access modifier (including `private`), the compiler treats it as an extended partial method, lifting the strict constraints but enforcing implementation:
* **Access Level:** Can use any access modifier (`public`, `internal`, `protected`, `private`, etc.).
* **Return Type:** Can return any type, including `void`.
* **Parameters:** Can contain `out` parameters.
* **Mandatory Implementation:** Because the method might return a value, have `out` parameters, or be invoked externally, the compiler **requires** an implementation. If the implementation is missing, the compiler throws a build error (`CS8795`).
```csharp theme={"dark"}
// File1.cs - Declaration with access modifier and return type
public partial class DataProcessor
{
// Because it is public and returns a string, it MUST be implemented
public partial string GetProcessorState(out int statusCode);
}
// File2.cs - Implementation
public partial class DataProcessor
{
public partial string GetProcessorState(out int statusCode)
{
statusCode = 200;
return "Active";
}
}
```
## Signature Matching Requirements
When providing the implementation for a partial method, the structural signature must exactly match the declaration. This includes:
* Method name.
* Return type.
* Access modifiers.
* Parameter types and modifiers (`ref`, `in`, `out`, `params`).
* The number of generic type parameters and their constraints.
**Naming Exceptions:**
Parameter names and generic type parameter names do **not** need to match between the declaration and the implementation. The names defined in the defining declaration are exposed to callers (e.g., for named arguments), while the names defined in the implementation are used locally within the method body.
Attributes applied to the method declaration and the method implementation are merged by the compiler into a single attribute set in the final compiled assembly.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
