Clase parcial de C#

Introducción

En C#, el concepto de clases parciales permite dividir una única definición de clase en varias partes, repartidas en diferentes archivos o bloques de código. Esta funcionalidad se utiliza principalmente para gestionar clases grandes o complejas, mejorando la capacidad de mantenimiento y permitiendo una mejor colaboración entre varios desarrolladores. Al utilizar la palabra clave partial, los desarrolladores pueden descomponer el código de lógica empresarial, las definiciones de control de interfaz de usuario y otros componentes complejos en partes manejables.

Una clase parcial se refiere esencialmente a una definición de clase que está dividida en más de un archivo fuente. Todas estas partes o fragmentos se combinan en tiempo de compilación para formar la clase completa, que se comporta como si estuviera escrita en un único archivo. Esta potente función puede resultar extremadamente útil cuando se trabaja con código fuente generado automáticamente, ya que permite separar la lógica escrita manualmente del código generado por herramientas como LINQ to SQL o el código generado por diseñadores.

Tim (0:00) presenta las clases parciales y explica que el objetivo del vídeo es ofrecer una comprensión rápida de lo que son las clases parciales, cómo funcionan y cuándo utilizarlas.

Paseo por la aplicación demo

A las (0:25), Tim comienza creando un nuevo archivo llamado Demo.cs en un proyecto de aplicación de consola. Hace que la clase sea parcial usando la palabra clave partial. Esto permite dividir la clase en varios archivos.

// Demo.cs
public partial class Demo
{
    public void FromDemo()
    {
        Console.WriteLine("This is from Demo");
    }
}

// OtherDemo.cs
public partial class Demo
{
    public void FromOtherDemoFile()
    {
        Console.WriteLine("This is from OtherDemo file");
    }
}

// Demo.cs
public partial class Demo
{
    public void FromDemo()
    {
        Console.WriteLine("This is from Demo");
    }
}

// OtherDemo.cs
public partial class Demo
{
    public void FromOtherDemoFile()
    {
        Console.WriteLine("This is from OtherDemo file");
    }
}

Tim explica que, aunque los nombres de los archivos sean diferentes, los nombres de las clases deben coincidir para que se consideren partes de la misma clase parcial. En tiempo de compilación, el compilador de C# combina estas definiciones parciales de clase en una única clase.

Uso de clases parciales

Tim a las (3:01) demuestra cómo instanciar y usar la clase parcial en el archivo Program.cs.

class Program
{
    static void Main(string[] args)
    {
        Demo demo = new Demo();
        demo.FromDemo();
        demo.FromOtherDemoFile();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Demo demo = new Demo();
        demo.FromDemo();
        demo.FromOtherDemoFile();
    }
}

Este código muestra que los métodos de ambos Demo.cs y OtherDemo.cs son accesibles a través de una única instancia de la clase Demo.

Implementación de interfaces

Tim explica en (4:01) que las interfaces implementadas en una parte de una clase parcial se aplican a toda la clase. Por ejemplo, si una parte de la clase parcial implementa IDisposable, se aplica a toda la clase.

// Demo.cs
public partial class Demo : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Dispose method called");
    }
}

// Demo.cs
public partial class Demo : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Dispose method called");
    }
}

Limitaciones de las clases parciales

Tim (5:02) señala algunas limitaciones de las clases parciales. Por ejemplo, todas las partes de una clase parcial deben tener los mismos modificadores de acceso. No puede tener una parte marcada como public y otra como internal o private.

Caso de uso práctico: Windows Forms

Tim (5:29) comenta un caso práctico de uso de clases parciales, especialmente en aplicaciones Windows Forms. Muestra cómo el código generado por el diseñador de Windows Forms utiliza clases parciales para separar el código autogenerado del código escrito por el usuario.

// Form1.cs
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

// Form1.Designer.cs
partial class Form1
{
    private void InitializeComponent()
    {
        this.SuspendLayout();
        // 
        // Form1
        // 
        this.ClientSize = new System.Drawing.Size(800, 450);
        this.Name = "Form1";
        this.ResumeLayout(false);
    }
}

// Form1.cs
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

// Form1.Designer.cs
partial class Form1
{
    private void InitializeComponent()
    {
        this.SuspendLayout();
        // 
        // Form1
        // 
        this.ClientSize = new System.Drawing.Size(800, 450);
        this.Name = "Form1";
        this.ResumeLayout(false);
    }
}

La separación permite al diseñador gestionar el código de diseño, mientras que el usuario puede centrarse en la lógica de la aplicación en la clase principal del formulario.

Cuándo usar clases parciales

Tim concluye comentando las situaciones típicas en las que son útiles las clases parciales. Suelen utilizarse en situaciones en las que el código se genera automáticamente o en proyectos de gran envergadura que requieren una separación clara de las preocupaciones. Un ejemplo es el código autogenerado, como el código del diseñador de Windows Forms, en el que separar el código de diseño de la lógica de la aplicación evita conflictos y facilita el mantenimiento.

También menciona que, aunque las clases parciales pueden ser útiles en algunas situaciones, no se utilizan con frecuencia en el desarrollo cotidiano.