Skip to main content

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.

A partial class in C# is a compile-time language feature that allows the declaration of a single class, struct, interface, or record to be divided across multiple physical source code files. During the compilation process, the C# compiler aggregates all constituent parts and emits them as a single, unified type definition within the resulting Intermediate Language (IL). The Common Language Runtime (CLR) has no concept of partial types; it only executes the merged, final type. To define a partial class, the partial contextual keyword is applied as a modifier to the class signature in every participating file. File1.cs 
namespace Enterprise.Models
{
    public partial class Employee
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        
        public void CalculatePay() 
        {
            // Implementation
        }
    }
}
File2.cs 
namespace Enterprise.Models
{
    public partial class Employee
    {
        public string Department { get; set; }
        
        public void Promote() 
        {
            // Implementation
        }
    }
}

​
Compilation Rules and Constraints

The C# compiler enforces strict rules when merging partial class definitions. Violating any of these constraints results in a compile-time error.
  • Keyword Requirement: Every part of the type must explicitly include the partial modifier.
  • Assembly and Module: All parts of the partial class must be compiled into the same assembly (.dll or .exe) and the same module. Partial classes cannot span across different assemblies.
  • Namespace: All parts must reside within the exact same namespace.
  • Access Modifiers: If an accessibility modifier (e.g., public, internal, private) is explicitly specified on multiple parts, those modifiers must match exactly. It is not required to explicitly declare the access modifier on every part; if omitted on a part, it inherits the accessibility defined by the other parts.
  • Type Modifiers: If any single part is declared abstract or sealed, the entire merged class inherits that restriction.
  • Base Classes: A class can only inherit from a single base class. If multiple parts specify a base class, they must specify the exact same base class. It is not required for all parts to specify the base class, as long as one does.
  • Interfaces: Interface implementations are cumulative. If Part A implements IDisposable and Part B implements IEquatable<T>, the merged class implements both.

​
Member Merging Behavior

When the compiler merges the partial definitions, the resulting type contains the union of all members declared across all parts.
  • Fields and Properties: All fields, properties, and events from all files are available to the entire class.
  • Attributes: Attributes applied to the individual parts are combined. If Part A has [Serializable] and Part B has [Obsolete], the compiled class will possess both attributes.
  • Nested Types: Partial classes can contain nested partial classes. The merging rules apply recursively to the nested types.

​
Partial Methods

Partial classes can also contain partial methods. This feature allows one part of a partial class to define a method signature (the declaration) while another part provides the method body (the implementation). 
using System;

// File1.cs - Declaration
public partial class Processor
{
    partial void OnProcessingStarted();
    
    public void Execute()
    {
        OnProcessingStarted();
        // Execution logic
    }
}

// File2.cs - Implementation
public partial class Processor
{
    partial void OnProcessingStarted()
    {
        Console.WriteLine("Processing initialized.");
    }
}
If the implementation is not provided in any of the partial class files, the compiler optimizes the code by completely removing the method signature and all calls to that method from the compiled IL. Because of this removal behavior, partial methods without an implementation must return void, cannot have out parameters, and are implicitly private. (Note: C# 9.0 introduced extended partial methods that bypass these restrictions, provided they have an accessibility modifier, which forces the compiler to require an implementation).
Master C# with Deep Grasping Methodology!Learn More