DNM+ Online
dotnetmania 2.0
Yo formateo, tú formateas... ¡que formatee él! Cómo implementar clases que permitan formatos personalizados en .NET Framework
En este artículo veremos cómo implementar las diferentes versiones del método ToString para que, cuando sea preciso, el usuario de nuestras clases pueda utilizar los formatos personalizados que creamos conveniente aplicar a nuestros tipos de datos.

Cualquier programador de .NET Framework habrá usado en más de una ocasión formatos que las clases Console, String o StringBuilder nos permiten; incluso con más frecuencia usará formatos que algunos tipos del propio .NET exponen mediante el método ToString. Esa misma funcionalidad "formateadora" podemos dársela a nuestras propias clases (o tipos) mediante la definición del método ToString, particularmente implementando el definido en la interfaz IFormattable. Dar formato al estilo .NET Cuando hablamos de dar formato, nos estamos refiriendo a la posibilidad de hacer que el contenido de un tipo de .NET Framework se muestre de una forma particular. Por ejemplo, si queremos mostrar o usar el contenido de un tipo de datos que contiene una fecha, es posible que nos interese que se muestre en formato fecha corta o fecha larga o, lo que será más habitual, que se muestre según nuestras preferencias. Por ejemplo, si la fecha actual es el 3 de enero de 2005 y queremos mostrarla usando solamente dígitos, seguramente la forma de hacerlo sería "03/01/2005", pero si queremos mostrarla de forma que el mes se muestre usando tres letras, la representación sería "03/ene/2005". Como vemos, todo dependerá de nuestras preferencias o de las preferencias del usuario, ya que para un norteamericano sería mejor que se la mostremos empezando por el mes seguido del día y por último el año: "1-3-2005". Todas estas formas diferentes de mostrar una misma fecha podemos hacerla gracias a que el tipo de datos que mantiene una fecha en .NET está preparado para que se puedan usar diferentes formatos. Normalmente esos formatos los indicaremos como una cadena que le pasaremos al método ToString, ya que este método es el encargado de devolver una representación visual del contenido de un tipo de datos. Para conseguir una cadena usando los tres casos de formato que hemos comentado tendríamos que usar el siguiente código:

DateTime.Now.ToString("dd/MM/yyyy") DateTime.Now.ToString("dd/MMM/yyyy") DateTime.Now.ToString("M-d-yyyy")

En estos casos lo que hacemos es pasar un formato al método ToString, ese método lo interpretará y devolverá la cadena correspondiente. Ni qué decir tiene que estos formatos están previamente establecidos y no son aleatorios, ni algo que existe porque sí, ya que, como sabemos, todo lo que ocurre en cualquier entorno de programación, ocurre porque alguien lo ha previsto y programado. De este último aspecto nos ocuparemos dentro de poco. Los formatos de las clases de .NET En los tipos de datos predefinidos en .NET podemos usar formatos que nos permiten dar distintos aspectos al contenido de los mismos. Anteriormente hemos visto tres ejemplos de formatos de fecha; en esos ejemplos hemos usado formatos mediante patrones definidos en la clase DateTime, (lo que la documentación de Visual Studio .NET llama "cadenas de formato personalizado DateTime"), pero también podemos usar cadenas con formatos predefinidos o formatos estándar; estos últimos suelen ser de una sola letra, por ejemplo, siguiendo con la fecha 3 de enero, si lo usamos de esta forma: DateTime.Now.ToString("D"), tendríamos este resultado: "lunes, 03 de enero de 2005". Por supuesto existen otros formatos predefinidos para las fechas, los cuales nos permiten mostrar tanto fechas como horas de diferente forma. Como es de esperar, también existen formatos para los tipos numéricos, y al igual que en las fechas nos encontramos con formatos ya predefinidos y otros que nos permiten componer un formato particular. Aunque debemos tener en cuenta que no todos los formatos son aplicables a todos los tipos numéricos. Por ejemplo, si trabajamos con valores de tipo entero, podremos usar el formato "x", (que sirve para devolver una representación en formato hexadecimal), pero ese formato no podremos aplicarlo a un valor de tipo Decimal o a uno de punto flotante. En el código que acompaña a este artículo (en "Material de apoyo" en www.dotnetmania.com), podemos ver algunos ejemplos de los diferentes formatos que podemos usar tanto con las fechas como con los números. ¿Cómo definir una clase que sea "formateable"? Los formatos que hemos comentado anteriormente, sólo son aplicables a los tipos numéricos y a los de fecha/hora. Cuando definimos nuestro propio tipo de datos, esos formatos no están disponibles. Al menos no lo estarán de forma predeterminada, por tanto, si queremos que nuestros propios tipos de datos acepten formatos mediante el método ToString, debemos programarlo nosotros. Esa personalización de los formatos a aplicar a nuestros propios tipos de datos podemos hacerla de dos formas diferentes. Definir el método ToString para dar formato La primera forma de permitir que nuestros propios tipos se puedan usar para dar diferentes formatos al valor contenido, es creando nuestra propia sobrecarga del método ToString, de forma que acepte un parámetro en el que indicaremos el formato a aplicar. Así podremos usarlo de la misma forma que los tipos definidos en .NET. Debido a que nuestros propios tipos siempre trabajarán con algún tipo de datos del propio .NET Framework, podremos usar el método ToString de ese tipo elemental para hacer el trabajo de dar formato al contenido interno de nuestro propio tipo, al menos salvo en el caso de que queramos dar formatos propios y únicos definidos en nuestro tipo. Pero para mantener las cosas simples (para que sea fácilmente comprensible), no vamos a inventarnos (al menos por ahora) ningún formato especial, sino que desde nuestro método llamaremos al del tipo usado internamente. Para clarificar las cosas, vamos a definir una estructura a la que llamaremos Moneda, la cual tendrá una sola propiedad (realmente un campo público) llamada Importe, y que será del tipo Decimal. La declaración de esta estructura y el método ToString que nos permita darle formato será tal como se muestra en el fuente 1. Para usar los formatos proporcionados por esta estructura, podemos hacerlo de la misma forma que haríamos con un tipo de datos Decimal. De hecho sólo permitirá las mismas cadenas de formato que el tipo subyacente. En el fuente 2 tenemos un par de ejemplos de cómo usar los formatos de nuestra estructura. Por supuesto, si pretendemos usar un formato no permitido por el tipo Decimal, obtendremos una excepción indicándonos que el formato no es válido, tal como ocurriría al intentar mostrarlo en formato hexadecimal (usando "x"). Definir nuestras propias cadenas de formato Si por cualquier razón se nos ocurre que sería interesante crear un nuevo formato para nuestra estructura o dar una funcionalidad distinta a los ya existentes, e incluso redefinir o permitir usar algunos no válidos (como el que permite mostrarlo en hexadecimal), simplemente tendríamos que añadir el código correspondiente y asunto arreglado. Para no alargar el artículo, y debido a que seguidamente vamos a definir nuestros propios formatos, en los proyectos formatos3VB y formatos3CS del código que acompaña al artículo puede ver un ejemplo tanto en Visual Basic como en C#. Pero aunque hayamos definido nuestra propia sobrecarga del método ToString para que acepte una cadena en la que podamos indicar el formato, no siempre va a funcionar como esperamos. Aclaremos esto último: tal como hemos visto en el fuente 2, podemos usar ToString con el método Write (o WriteLine) de la clase Console, pero tanto esos métodos de la clase Console como el método Format de la clase String o el método AppendFormat de la clase StringBuilder, permiten que usemos una variable de nuestro tipo e incluso permiten que podamos indicar formatos especiales para aplicar a nuestros tipos, de tal forma que podamos componer una cadena en la que se incluirá el contenido de la variable usando diferentes representaciones. Sí, mejor verlo con un ejemplo. En el fuente 3 tenemos varias formas de usar los métodos que hemos comentado utilizando diferentes formatos. En el código del fuente 3 hemos usado una variable de tipo entero y como ocurre con el resto de los tipos incluidos en la librería de clases de .NET, el método ToString está implementado completamente, o mejor dicho, tiene todas las posibilidades de implementación del método ToString. Y en esta ocasión aún no estamos hablando de formatos especiales como ocurre cuando usamos, por ejemplo, {0, 11:N}, sino de algo tan simple como el método ToString sin parámetros. Esta sería, o debería ser, una de las primeras cosas que tendríamos que hacer en nuestros propios tipos, ya que si no lo hacemos, nos podemos encontrar con algo inesperado al usar, por ejemplo, algo tan simple como una variable del tipo Moneda (definido en el fuente 1) con el método WriteLine de la clase Console: Console.WriteLine(m1). Lo que este código mostrará no es el contenido (o valor) de la variable m1, sino el nombre completo de la estructura Moneda, (que incluye el espacio de nombres y el nombre del tipo). ¿Qué es lo que ocurre aquí?Lo que ocurre es que el runtime de .NET, cuando no sabe cómo obtener una representación de un tipo, llama al método ToString y si no está redefinido usará la implementación de la clase base de todos los tipos de .NET: Object, y esa implementación simplemente devuelve el nombre completo de la clase. Por tanto, lo primero que deberíamos hacer al crear nuestras clases es redefinir el método ToString para que devuelva algo "coherente" con el valor que almacena. En nuestro ejemplo del tipo Moneda, podríamos definirlo para que simplemente devuelva el valor de la propiedad Importe, tal como podemos ver en el fuente 4. De esta forma nos aseguramos de que cuando alguien quiera obtener una cadena de una variable del tipo Moneda, realmente obtenga algo "válido"; en este caso el contenido de la propiedad Importe. Ahora veamos que es lo que habría que hacer para poder dar soporte al resto de formatos que hemos usado en el fuente 3 e incluso cómo podemos definir los nuestros propios para que se puedan usar dentro de las llaves en las cadenas usadas en los métodos que permiten formatos especiales. Definir formatos especiales para nuestros tipos De igual forma que .NET utiliza el método ToString sin parámetros cuando no se indica qué método usar de una clase, al menos en los casos en los que se deben usar como cadenas, los métodos Write/WriteLine de la clase Console o los métodos Format y AppendFormat de las clases String y StringBuilder respectivamente cuando se usa un marcador de formato (el número entre las llaves) en el que se indica un formato especial, como sería el caso al usar {0, 11:N}, en estos casos también se llama al método ToString, pero a una versión especial: el definido en la interfaz IFormattable. La interfaz IFormattable sólo tiene un método: ToString, el cual recibe dos parámetros (o argumentos), el primero indica una cadena con el formato a aplicar y el segundo será un objeto con el proveedor del formato, el cual en la mayoría de los casos podremos obviar. La cadena que indica el formato será parecida a la usada en la versión simple, la que sólo recibe un argumento. Es más, podemos implementar este método ToString para que internamente llame al método ToString del tipo usado para almacenar el valor de nuestro tipo. En el fuente 5 podemos ver la definición simple de nuestro tipo en el que hemos implementado la interfaz IFormattable. Debemos fijarnos que realmente no hemos hecho nada especial, simplemente indicarle al .NET que ahora nuestra clase implementa el método ToString definido en la interfaz IFormattable y que puede usarlo cada vez que un método necesite acceder a dicha implementación, pero esto es suficiente para que se puedan usar todos los formatos permitidos, en nuestro caso por el tipo Decimal, incluso el que indica la longitud o el número de posiciones que debe ocupar en la cadena, que es el valor numérico separado con una coma del marcador de posición, ya que ese comportamiento es algo "innato" de esos métodos formateadores, realmente el parámetro format del método ToString hace referencia al que se indica después de los dos puntos. Tal como hemos definido la implementación de ToString de la interfaz IFormattable, usaríamos solamente los formatos permitidos por el tipo Decimal, pero si queremos definir otros formatos, tendremos que escribir el código que lo interprete y que devuelva lo que nos interese devolver. Esto es útil sobre todo para tipos de datos cuyo contenido interno no es tan obvio como el de un valor numérico, por ejemplo que tengamos una clase Empleado en la que nos interesaría usar formatos diferentes para mostrar los distintos valores que dicha clase pueda almacenar, pero para seguir con la simplicidad, veamos cómo definir algunos formatos especiales e incluso, como ya comentamos, redefinir algunos ya existentes o no válidos para el tipo usado internamente para almacenar el valor del importe de nuestra estructura Moneda. En el fuente 6 tenemos la definición de los dos métodos ToString que reciben algún parámetro. Como recomendación final, decir que sólo deberíamos implementar los métodos "formateadores" en nuestras clases o tipos cuando realmente tenga algún sentido, ya que no siempre los usuarios de nuestros tipos los usarán para darles formatos especiales. El método que siempre deberíamos definir es el método ToString sin parámetros, ya que ese método tiene más usabilidad y en muchos casos nuestros usuarios querrán tener una representación imprimible del contenido de nuestro tipo.

blog comments powered by Disqus
autor
referencias