Partial Types in C#

What are Partial Types in C#?

Partial Types in C# allow a single class, struct, or interface to be split across multiple files. This is useful for large projects where multiple developers work on the same class.

Key Features of Partial Types

• Allows a class, struct, or interface to be split across multiple files.
• Each part of the partial type must use the partial keyword.
• All parts must be in the same namespace.
• Commonly used in auto-generated code (e.g., Windows Forms, Entity Framework).

Example: Using Partial Classes

The following example demonstrates how to define and use a partial class in two separate files.

Example: Partial Class in Multiple Files

// File 1: Employee_Part1.cs
public partial class Employee
{
    public string Name { get; set; }
    public int ID { get; set; }
}

// File 2: Employee_Part2.cs
public partial class Employee
{
    public void Display()
    {
        Console.WriteLine($"Employee Name: {Name}, ID: {ID}");
    }
}

// Usage
class Program
{
    static void Main()
    {
        Employee emp = new Employee { Name = "Alice", ID = 101 };
        emp.Display();
    }
}

// Output:
// Employee Name: Alice, ID: 101
        

Here, the Employee class is split across two files but works as a single unit.

Partial Methods in C#

Partial methods allow method declarations in one part of a partial class and their implementation in another.

Example: Partial Method Implementation

// File 1: Car_Part1.cs
public partial class Car
{
    public string Model { get; set; }

    partial void ShowModel(); // Declaration
}

// File 2: Car_Part2.cs
public partial class Car
{
    partial void ShowModel() // Implementation
    {
        Console.WriteLine($"Car Model: {Model}");
    }

    public void Display()
    {
        ShowModel();
    }
}

// Usage
class Program
{
    static void Main()
    {
        Car car = new Car { Model = "Tesla" };
        car.Display();
    }
}

// Output:
// Car Model: Tesla
        

The ShowModel method is declared in one part and implemented in another part of the Car class.

Partial Interfaces and Structs

Similar to classes, interfaces and structs can also be defined using the partial keyword.

Example: Partial Interface

// File 1: IAnimal_Part1.cs
public partial interface IAnimal
{
    void MakeSound();
}

// File 2: IAnimal_Part2.cs
public partial interface IAnimal
{
    void Move();
}

// Implementing the interface
public class Dog : IAnimal
{
    public void MakeSound() => Console.WriteLine("Dog Barks!");
    public void Move() => Console.WriteLine("Dog Runs!");
}

// Usage
class Program
{
    static void Main()
    {
        Dog dog = new Dog();
        dog.MakeSound();
        dog.Move();
    }
}

// Output:
// Dog Barks!
// Dog Runs!
        

The IAnimal interface is split into two files but works as a single unit when implemented.

When to Use Partial Types?

• When multiple developers work on the same class.
• To separate auto-generated and manually written code (e.g., Windows Forms, Entity Framework).
• For better organization of large classes.
• When defining interfaces across multiple files.