Tipos parciales en C# 2.0

Artículo
10/14/2008

Por Alvaro Torres Tatis

La nueva versión de C# es la 2.0, y vendrá integrada con la nueva versión del entorno de desarrollo Visual Studio .NET 2005, denominado hasta ahora Whidbey. En este artículo se expondrá una de sus nuevas características llamada "Clases parciales".

Contenido

Definición
Implementando tipos parciales
Algunas observaciones
Parciales en Visual Studio
Ejemplo
Conclusión

Definición

C# 2.0 nos ofrece la posibilidad de declarar tipos parciales (class, struct o interface) de un mismo tipo en varios archivos; es decir, dividir la implementación de una clase en más de un archivo de código fuente. Cada archivo contiene una sección de la definición de la clase, cada una de las cuales se mezclarán en una sola al momento de compilar.

Una de las ventajas más notables de usar tipos parciales es cuando se utiliza un generador de código como Visual Studio. Los tipos parciales permiten combinar el código generado con sus propias adiciones a la clase. De esta forma, se pueden mantener ambos archivos separados y no tendrás que preocuparte por cambiar inadvertidamente algo del código generado automáticamente.

Implementando tipos parciales

Para "partir" una definición de clase se debe utilizar el modificador partial antes de la palabra clave class, struct, o interface. Ejemplo:

// Archivo: Class1.cs
public partial class MyClass
{
    public void MetodoEn1() 
    {
    }
}
// Archivo: Class2.cs
public partial class MyClass
{
    public void MetodoEn2() 
    {
    }
}

Algunas observaciones

Hay varias reglas a seguir cuando se trabaja con definiciones de clases parciales:

Si se declara un tipo parcial, todas las definiciones del mismo deben ser parciales.
```
public partial class MyClass { } 
```

public class MyClass { } // Error, la clase debe ser parcial.

El modificador partial debe aparecer siempre antes de las palabras class, struct, o interface.
```
public class partial MyClass {} // Error. El modificador debe preceder a class. 
```
Todos los tipos parciales se deben definir en el mismo Assembly.
Los tipos parciales jerarquizados están permitidos. Ejemplo:
```
// Archivo: Class1.cs
```

public partial class MyClass1 { partial class MyClass2 {} } // Archivo: Class2.cs public partial class MyClass1 { partial class MyClass2 {} }

Los atributos son determinados por combinación. Ejemplo:
```
[PrimerAttribute]
```

partial class MyClass{} [SegundoAttribute] partial class MyClass{} Se traduce a: [PrimerAttribute] [SegundoAttribute] class MyClass{}

Se pueden declarar genéricos parciales. Ejemplo:
```
partial class Dictionary<K, V>
```

where K : IComparable<k> where V : IKeyProvider<k>, Ipersistable{} partial class Dictionary<K, V> where K : IKeyProvider<k>, Ipersistable where V : IComparable<k>{}

Los comentarios XML, interfaces, atributos de clase y miembros se combinan al momento de compilar. Ejemplo:
```
partial class D: MyBaseClass, IMyInterface1{}
```

partial class D: IMyInterface2{} Se traduce a: partial class D: MyBaseClass, IMyInterface1, IMyInterface2{}

Parciales en Visual Studio

La utilización de clases parciales comienza desde el mismo Visual Studio. Por ejemplo, al diseñar un Windows Form, Visual Studio crea dos archivos para almacenar la definición del mismo (presentación y lógica, Ver Figura 1 y Figura 2):

Bb972195.art201-img01-548x607(es-es,MSDN.10).jpg
Figura 1: Form1.Designer.cs. Volver al texto.

Bb972195.art201-img02-485x252(es-es,MSDN.10).jpg
Figura 2: Form1.cs. Volver al texto.

De esta forma es más fácil dividir el trabajo en equipos, ya que en grandes proyectos varios programadores podrían trabajar sobre una misma clase al mismo tiempo.

Ejemplo

Para demostrar el uso de partial, agregaremos un nuevo archivo al proyecto llamado Class1.cs, en donde definiremos un método con el nombre Alert para mostrar un MessageBox al usuario (Ver Figura 3):

Bb972195.art201-img03-570x192(es-es,MSDN.10).jpg
Figura 3: Class1.cs. Volver al texto.

Ahora añadiremos un botón de comando al formulario y llamaremos al método Alert desde el evento clic del mismo (Ver Figura 4):

Bb972195.art201-img04-520x327(es-es,MSDN.10).jpg
Figura 4: Form1.cs. Volver al texto.

Como se puede observar, la definición del método Alert no aparece en el archivo Form1.cs. Sin embargo, el compilador no genera ningún error ya que ubica este método en el archivo Class1.cs y hasta lo presenta en el IntelliSense (Ver Figura 5):

Bb972195.art201-img05-506x447(es-es,MSDN.10).jpg
Figura 5: Form1.cs. Volver al texto.

En ASP .NET también se han convertido las clases para los WebForms a partial. De esta manera (para una simple forma con un botón que hace Response) pasamos de esto en VS 2003 (Ver Figura 6) ... :

Bb972195.art201-img06-570x615(es-es,MSDN.10).jpg
Figura 6: Visual Studio 2003. Volver al texto.

... A esto que es mucho más limpio y claro (Figura 7):

Bb972195.art201-img07-420x307(es-es,MSDN.10).jpg
Figura 7: Visual Web Developer 2005.Volver al texto.

Conclusión

Si bien el uso de tipos parciales puede resolver algunas situaciones en el ciclo de desarrollo de algunos proyectos, no es tampoco recomendable hacer parciales todas las clases que se diseñen. Esta característica resulta útil en escenarios de trabajo con herramientas de generación de código automático y entornos de desarrollo distribuido o de trabajo en grupo.

Alvaro Torres Tatis es estudiante de 3º año de la Ingeniería de Sistemas de Escuela de Administración de Negocios, Bogotá, Colombia. Trabaja como Analista de Sistemas desarrollando aplicaciones Web con VB .net y C#. Posee una vasta experiencia en herramientas de desarrollo tales como Visual FoxPro, Visual Basic, ASP, SQL Server y Oracle. Cuenta con la certificación MCP en desarrollo de aplicaciones Web con Visual Basic .net. Ha obtenido la 4a. Estrella del programa Desarrollador Cinco Estrellas de MSDN.