El blog de Jesús Velasco

ASP.Net Enviar correo electrónico con ficheros adjuntos

Jesús Velasco — Tue, 03 Jan 2012 13:16:26 GMT

Otra de las preguntas bastante frecuente por los foros de Microsoft es la posibilidad de enviar un correo electrónico desde una página pero que contenga uno o varios ficheros adjuntos. Aunque en una búsqueda genérica nos aparecen miles de entradas sobre el tema, intentaremos, en esta ocasión, crear un ejemplo lo más sencillo posible. El envío de un correo electrónico es relativamente sencillo, sobre todo, si nos abstraemos de la configuración del correo y dejamos los datos en el archivo web.config...(read more)

C# Encuadrar una imagen mediante GDI+

Jesús Velasco — Mon, 02 Jan 2012 12:44:21 GMT

En los foros de MSDN es frecuente leer alguna pregunta de cómo se puede encuadrar una fotografía para poder adaptarla a un determinado tamaño. A menudo las respuestas se enfocan al entorno de desarrollo, así por ejemplo, en el caso de ser en el foro de ASP.Net, la respuesta comúnmente se enfoca a la creación de un DIV que permita simular el cuadro externo, en caso de WinForms, un panel que recubra la imagen… No obstante, cuando tratamos de hacer algo así, casi siempre nos encontramos con problemas...(read more)

SSMS: No se permite guardar los cambios

Jesús Velasco — Mon, 26 Dec 2011 20:28:44 GMT

Igual el post actual causa algún tipo de controversia entre los DBA, y no existe nada más lejos de mi intención. Para un desarrollador como yo, si intentas hacer un cambio en una tabla de SQL Server (actualmente estoy con la versión 2008 R2) y el entorno te da un problema diciendo que no puedes hacerlo, realmente es un fastidio. Jesús, ¿de qué estás hablando?. Pues realmente es algo que es muy sencillo, pero que es bastante molesto cuando intentas evitarte problemas a la hora de desarrollar. Pongamos...(read more)

Leer variables Session desde una capa de Negocios

Jesús Velasco — Sun, 11 Sep 2011 17:46:42 GMT

En una reciente conversación en los foros de ms, desempolvé una vieja utilidad que en más de una ocasión me ha salvado de un apuro y que, aunque no tenía en el olvido, reconozco que no le di la importancia que tenía hasta que comprendí que mucha gente tiene los mismos problemas que tengo yo. Al fin y al cabo siempre pienso que soy más torpe que los demás y que lo que a mí me cuesta mucho rato desarrollar, el resto lo resuelven a la primera. Bueno, intento comentarlo con un ejemplo, que siempre es...(read more)

Internacionalizar las fechas (o parte de ellas)

Jesús Velasco — Wed, 10 Aug 2011 10:01:06 GMT

Nunca dejará de sorprenderme la librería de clases del .Net Framework. Ahora que andamos liados con el tema de internacionalización de un par de aplicaciones se nos presentaba la problemática de tener que mostrar, en algún momento, algún que otro control en el que se tiene que, por ejemplo, rellenar un combo con los meses del año en el idioma del usuario. Comúnmente, cuando he hecho esto con anterioridad siempre me he creado algún que otro método en la capa de negocios que devolviese los meses, los...(read more)

C#. Unidades de capacidad

Jesús Velasco — Tue, 19 Jul 2011 17:24:15 GMT

No será la primera vez que hemos creado algún sistema de visualización de archivos y, casi siempre solemos poner lo mismo, es decir, un grid en el que aparecen datos como Nombre, Extensión, Tamaño… Hoy me he fijado en el tamaño. La magnífica clase System.IO.FileInfo nos proporciona casi todos los elementos a los que solemos hacer referencia cuando trabajamos con algún que otro archivo. Las propiedades Name, FullName, Extension y Length quizás sean los elementos más socorridos a la hora de mostrar...(read more)

LastUpdateUser y LastUpdateDate en capa de negocios

Jesús Velasco — Wed, 13 Jul 2011 20:21:22 GMT

Desde los primeros programitas que desarrollé, algo que me ha gustado tener y que, en más de una ocasión me ha servido para descubrir algún que otro problemilla ha sido guardar en las tablas de la base de datos los campos LastUpdateUser y LastUpdateDate con la finalidad de almacenar el usuario y la fecha de la última modificación. Este proceso, ya desde los tiempos de VB5 era un proceso bastante sencillo desde cualquier apartado de la aplicación, fuese un fichero .EXE o una .DLL. En principio, si...(read more)

C#. NombrePropio

Jesús Velasco — Sat, 02 Jul 2011 12:31:33 GMT

Lamento tener tan abandonado el blog pero es que ando inmerso en un proyecto de aquellos que te absorben mucho más tiempo del que te gustaría. Intentaremos sacar algo de tiempo ahora que, por lo menos ya no tengo clases. Bueno, hoy le toca el turno a una de aquellas pequeñas cosas a las que, los que vais siguiendo el blog ya estáis acostumbrados. El caso es que el otro día, charlando con el jefe me comenta lo mal que queda que los clientes vean los datos unos en mayúscula, otros en formato Título...(read more)

Generar fechas aleatorias con C#

Jesús Velasco — Wed, 18 May 2011 18:41:28 GMT

En los cursos suelo utilizar datos casi siempre aleatorios y, últimamente me ha dado por hacer los ficheros con C#. Hasta aquí, bien, pero me pasó una cosa curiosa ayer. El caso es que necesitaba crear un par de columnas con una serie de fechas aleatorias y, de buenas a primeras me quedé delante del ordenador, pensando. Me quedé en blanco porque, sencillamente, no se me ocurrían más que cosas en las que seguro que me tiraba un buen rato para una tontería como esta. Obtener un año aleatorio, calcular...(read more)

Modificar valores de las propiedades de una clase

Jesús Velasco — Wed, 27 Apr 2011 18:02:00 GMT

Estoy más que seguro que el post actual es una de aquellas cosas que casi todo el mundo conocía, pero a mí me ha dado una especie de subidón el descubrirlo. Explico el problema. En un programa que estoy haciendo me he encontrado en la situación de que tengo que importar unos datos que vienen de una serie de proveedores. Hasta aquí ha sido un poco aburrido puesto que unos lo envían en formato .txt, otros en Access y, por supuesto, cada uno con su formato...(read more)

Outlook 2010. El tamaño de los datos adjuntos excede el límite permitido

Jesús Velasco — Sun, 27 Mar 2011 17:06:00 GMT

Sé que no es un post de programación, pero me ha tenido un rato entretenido y he considerado oportuno comentarlo. Así, por un lado, si alguien puede aprovecharlo, bien y si no, seguro que me sirve de recordatorio cuando tenga que volver a utilizarlo. El caso es que necesitaba enviar un fichero por correo electrónico que ocupaba la friolera de 30 Mb. Hasta el momento, tanto mi servidor de correo como el de la persona a la que se lo enviaba aceptan tales tamaños pero esta vez la limitación no ha venido...(read more)

Codificación Unicode

Jesús Velasco — Thu, 10 Mar 2011 19:04:49 GMT

Ya que tengo alguna que otra primavera a cuestas y que suelo ganarme la vida, entre otras cosas, impartiendo clases, reconozco que tengo alguna que otra manía. Una de estas manías está estrechamente ligada con la ortografía (u hortografía, como vi no hace mucho en el escrito de un alumno). Hace poco, en la creación de una página web, el cliente solicitó uno de aquellos enlaces que, al hacer un clic sobre él, se abriera el cliente de correo. Para la mayor parte de clientes, sólo existe el Outlook...(read more)

C#: Nombre de fichero aleatorio

Jesús Velasco — Mon, 21 Feb 2011 23:20:47 GMT

Cuando escribes un post y tienes la responsabilidad de hacerlo en un lugar como puede ser geeks.ms, intentas que tenga un mínimo de calidad. En este caso sé que no es así, aunque no puedo evitar hacerlo, puesto que es un tema que me ha tocado las narices más de una vez. En más de una ocasión me he encontrado con la necesidad de tener que tocar un fichero temporal, tanto en WinForms como en WebForms para, por ejemplo, descomprimir un fichero, tratar un documento en la web para descargarlo posteriormente...(read more)

C#: Calcular Semana Santa

Jesús Velasco — Mon, 14 Feb 2011 19:54:36 GMT

Siempre he pensado que todo programador, de vez en cuando necesitamos alguna ida de olla y, sencillamente, nos sentamos delante del ordenador más por entretenimiento que por necesidad. En mi caso por lo menos, cuando ando muy agobiado con el resto del entorno, es algo que me libera bastante. Claro, que suele liberarme mucho más salir a tomar unas cuantas cervezas con los amiguetes, pero como en este caso no tenía ganas de estar resacoso a la mañana siguiente, pues opté por hacer algo que me entretuviese...(read more)

Validar un número de cuenta bancaria

Jesús Velasco — Sat, 05 Feb 2011 16:17:26 GMT

En el blog anterior tenía una serie de utilidades que intentaré revisar y traspasar al actual. En esta ocasión le ha tocado el turno a un clásico: la validación de un número de cuenta bancaria: using System; using System.Text.RegularExpressions; namespace JnSoftware.Validaciones { /// <summary> /// Servicios de validación de las cuentas bancarias españolas /// </summary> public static class CuentasBancarias { /// <summary> /// Validación de una cuenta bancaria española /// <...(read more)

C#: Implementar la Interface ICloneable

Jesús Velasco — Sun, 23 Jan 2011 19:51:02 GMT

No será la primera vez que me he encontrado en la tesitura de tener que duplicar todos los datos de una clase. Quizás, el ejemplo más claro lo encontremos cuando tenemos un grid creado y el usuario te sugiere la posibilidad de crear una nueva función que permita copiar una fila ya existente, con todos sus datos. De esta manera, modificando sólo los datos que varían, la creación de la nueva fila es mucho más sencilla. Reconozco que en alguna ocasión he llegado a implementar la Interface ICloneable...(read more)

ASP.Net: Crear un control de servidor. Ejemplo: JnTextBoxNif

Jesús Velasco — Tue, 11 Jan 2011 12:28:15 GMT

En el post anterior, Validar CIF, NIF, NIE me comprometí a explicar cómo hacer uso de la clase JnSoftware.Validaciones.NumeroNif para validar un documento introducido en una página ASP.NET. Debo confesar que el motivo inicial era crear un control de usuario en el que se validase dicho documento embebido dentro de un UpdatePanel. Como hasta el momento no había creado nunca un control de servidor, reconozco que ha podido más la curiosidad que otra cosa y al final, después de algún que otro problema...(read more)

C#. Validar CIF, NIF, NIE

Jesús Velasco — Mon, 03 Jan 2011 20:09:56 GMT

Imagino que, al igual que todos los que alguna vez hemos empezado en esto del desarrollo de aplicaciones, nuestro ego nos ha jugado alguna que otra mala pasada. Ya desde mis inicios de la mano de Access o de Visual Basic 3.0, veía con bastante desgana cómo se iban introduciendo CIFs del tipo A00000000 o A-00000000, o A-00.000.000; matrículas con formatos dispares: GGG0000 ó 0000GGG. Comento y quizás resalto “desgana”, puesto que es uno de los puntos menos valorados tanto por desarrolladores como por clientes. Si total, sólo vale para perder el tiempo y retrasar la finalización del programa. Claro, que el problema nos lo encontramos nosotros cuando llega el momento de obtener un listado ordenado o una simple búsqueda. No recuerdo si fue la versión 5 de VB la que ya incluía la posibilidad de crear OCX que, entre otras cosas, permitía separar un conjunto de controles con el objetivo de reutilizarlos del código de la aplicación.

El caso es que he tenido miles de peleas con los datos cuando éstos no estaban normalizados, así que un día me levanté y me puse manos a la obra con la finalidad de intentar homologar todos aquellos datos que sean susceptibles de tener un “formato igual”. En el blog anterior ya quedó alguno de estos intentos. Una de las rutinas que más me costó en su día fue el intento de poder validar, en un mismo campo, un CIF de empresa, un NIF de persona física y el Número de Identificación de Extranjería (NIE), sin tener que indicarle previamente el tipo de documento.

Como suele pasar cada vez que se empieza un nuevo proyecto, el primer boceto contenía múltiples errores. Algunos de ellos se fueron subsanando; otros, quizás por la falta de tiempo habitual, no quedaron pulidos del todo. Así, aprovechando el haber tenido un poco de tiempo estas fiestas, he intentado pulir el código, de tal manera que sea útil para cualquiera que lo precise.

Uno de los errores que tenía era la eliminación, en la normalización, de aquellos números que empezaban por 0 y la asignación de algún NIE cuando realmente no lo era. Lo único que he omitido de los comentarios que me hicieron en su día es un tema sobre el que anduve buscando información y no supe encontrar una solución bien documentada: los NIE están formados por una letra, ocho dígitos numéricos y el dígito de control. En su lugar, he optado por tomar la definición y la normativa publicada en Wikipedia a tal respecto.

Dejo el código tal cuál ha quedado ya reformado:

using System;
using System.Text.RegularExpressions;

/*
 * NumeroNif.cs
 * Servicios de validación de los números NIF
 * 
 * älskare, Ene/11
 */

namespace JnSoftware.Validaciones
{

    /// <summary>
    /// Representa un número. En la clase se desglosan las distintas opciones que se puedan
    /// encontrar
    /// </summary>
    public class NumeroNif
    {
        /// <summary>
        /// Tipos de Códigos.
        /// </summary>
        /// <remarks>Aunque actualmente no se utilice el término CIF, se usa en la enumeración
        /// por comodidad</remarks>
        private enum TiposCodigosEnum { NIF, NIE, CIF }

        // Número tal cual lo introduce el usuario
        private string numero;
        private TiposCodigosEnum tipo;

        /// <summary>
        /// Parte de Nif: En caso de ser un Nif intracomunitario, permite obtener el cógido del país
        /// </summary>
        public string CodigoIntracomunitario { get; internal set; }
        internal bool EsIntraComunitario { get; set; }

        /// <summary>
        /// Parte de Nif: Letra inicial del Nif, en caso de tenerla
        /// </summary>
        public string LetraInicial { get; internal set; }

        /// <summary>
        /// Parte de Nif: Bloque numérico del NIF. En el caso de un NIF de persona física,
        /// corresponderá al DNI
        /// </summary>
        public int Numero { get; internal set; }

        /// <summary>
        /// Parte de Nif: Dígito de control. Puede ser número o letra
        /// </summary>
        public string DigitoControl { get; internal set; }

        /// <summary>
        /// Valor que representa si el Nif introducido es correcto
        /// </summary>
        public bool EsCorrecto { get; internal set; }

        /// <summary>
        /// Cadena que representa el tipo de Nif comprobado:
        ///     - NIF : Número de identificación fiscal de persona física
        ///     - NIE : Número de identificación fiscal extranjería
        ///     - CIF : Código de identificación fiscal (Entidad jurídica)
        /// </summary>
        public string TipoNif { get { return tipo.ToString(); } }

        /// <summary>
        /// Constructor. Al instanciar la clase se realizan todos los cálculos
        /// </summary>
        /// <param name="numero">Cadena de 9 u 11 caracteres que contiene el DNI/NIF
        /// tal cual lo ha introducido el usuario para su verificación</param>
        private NumeroNif(string numero)
        {
            // Se eliminan los carácteres sobrantes
            numero = EliminaCaracteres(numero);

            // Todo en maýusculas
            numero = numero.ToUpper();

            // Comprobación básica de la cadena introducida por el usuario
            if (numero.Length != 9 && numero.Length != 11)
                throw new ArgumentException("El NIF no tiene un número de caracteres válidos");
           
            this.numero = numero;
            Desglosa();

            switch (tipo)
            {
                case TiposCodigosEnum.NIF:
                case TiposCodigosEnum.NIE:
                    this.EsCorrecto = CompruebaNif();
                    break;
                case TiposCodigosEnum.CIF:
                    this.EsCorrecto = CompruebaCif();
                    break;
            }
        }

        #region Preparación del número (desglose)

        /// <summary>
        /// Realiza un desglose del número introducido por el usuario en las propiedades
        /// de la clase
        /// </summary>
        private void Desglosa()
        {
            Int32 n;
            if (numero.Length == 11)
            {
                // Nif Intracomunitario
                EsIntraComunitario = true;
                CodigoIntracomunitario = numero.Substring(0, 2);
                LetraInicial = numero.Substring(2, 1);
                Int32.TryParse(numero.Substring(3, 7), out n);
                DigitoControl = numero.Substring(10, 1);
                tipo = GetTipoDocumento(LetraInicial[0]);
            }
            else
            {
                // Nif español
                tipo = GetTipoDocumento(numero[0]);
                EsIntraComunitario = false;
                if (tipo == TiposCodigosEnum.NIF)
                {
                    LetraInicial = string.Empty;
                    Int32.TryParse(numero.Substring(0, 8), out n);
                }
                else
                {
                    LetraInicial = numero.Substring(0, 1);
                    Int32.TryParse(numero.Substring(1, 7), out  n);
                }
                DigitoControl = numero.Substring(8, 1);
            }
            Numero = n;
        }

        /// <summary>
        /// En base al primer carácter del código, se obtiene el tipo de documento que se intenta
        /// comprobar
        /// </summary>
        /// <param name="letra">Primer carácter del número pasado</param>
        /// <returns>Tipo de documento</returns>
        private TiposCodigosEnum GetTipoDocumento(char letra)
        {
            Regex regexNumeros = new Regex("[0-9]");
            if (regexNumeros.IsMatch(letra.ToString()))
                return TiposCodigosEnum.NIF;

            Regex regexLetrasNIE = new Regex("[XYZ]");
            if (regexLetrasNIE.IsMatch(letra.ToString()))
                return TiposCodigosEnum.NIE;

            Regex regexLetrasCIF = new Regex("[ABCDEFGHJPQRSUVNW]");
            if (regexLetrasCIF.IsMatch(letra.ToString()))
                return TiposCodigosEnum.CIF;

            throw new ApplicationException("El código no es reconocible");
        }



        /// <summary>
        /// Eliminación de todos los carácteres no numéricos o de texto de la cadena
        /// </summary>
        /// <param name="numero">Número tal cual lo escribe el usuario</param>
        /// <returns>Cadena de 9 u 11 carácteres sin signos</returns>
        private string EliminaCaracteres(string numero)
        {
            // Todos los carácteres que no sean números o letras
            string caracteres = @"[^\w]";
            Regex regex = new Regex(caracteres);
            return regex.Replace(numero, "");
        }

        #endregion

        #region Cálculos

        private bool CompruebaNif()
        {
            return DigitoControl == GetLetraNif();
        }

        /// <summary>
        /// Cálculos para la comprobación del Cif (Entidad jurídica)
        /// </summary>
        private bool CompruebaCif()
        {
            string[] letrasCodigo = { "J", "A", "B", "C", "D", "E", "F", "G", "H", "I" };

            string n = Numero.ToString("0000000");
            Int32 sumaPares = 0;
            Int32 sumaImpares = 0;
            Int32 sumaTotal = 0;
            Int32 i = 0;
            bool retVal = false;

            // Recorrido por todos los dígitos del número
            for (i = 0; i < n.Length; i++)
            {
                Int32 aux;
                Int32.TryParse(n[i].ToString(), out aux);

                if ((i + 1) % 2 == 0)
                {
                    // Si es una posición par, se suman los dígitos
                    sumaPares += aux;
                }
                else
                {
                    // Si es una posición impar, se multiplican los dígitos por 2 
                    aux = aux * 2;

                    // se suman los dígitos de la suma
                    sumaImpares += SumaDigitos(aux);
                }
            }
            // Se suman los resultados de los números pares e impares
            sumaTotal += sumaPares + sumaImpares;

            // Se obtiene el dígito de las unidades
            Int32 unidades = sumaTotal % 10;

            // Si las unidades son distintas de 0, se restan de 10
            if (unidades != 0)
                unidades = 10 - unidades;

            switch (LetraInicial)
            {
                // Sólo números
                case "A":
                case "B":
                case "E":
                case "H":
                    retVal = DigitoControl == unidades.ToString();
                    break;

                // Sólo letras
                case "K":
                case "P":
                case "Q":
                case "S":
                    retVal = DigitoControl == letrasCodigo[unidades];
                    break;

                default:
                    retVal = (DigitoControl == unidades.ToString())
                            || (DigitoControl == letrasCodigo[unidades]);
                    break;
            }

            return retVal;

        }

        /// <summary>
        /// Obtiene la suma de todos los dígitos
        /// </summary>
        /// <returns>de 23, devuelve la suma de 2 + 3</returns>
        private Int32 SumaDigitos(Int32 digitos)
        {
            string sNumero = digitos.ToString();
            Int32 suma = 0;

            for (Int32 i = 0; i < sNumero.Length; i++)
            {
                Int32 aux;
                Int32.TryParse(sNumero[i].ToString(), out aux);
                suma += aux;
            }
            return suma;
        }

        /// <summary>
        /// Obtiene la letra correspondiente al Dni
        /// </summary>
        private string GetLetraNif()
        {
            int indice = Numero % 23;
            return "TRWAGMYFPDXBNJZSQVHLCKET"[indice].ToString();
        }

        /// <summary>
        /// Obtiene una cadena con el número de identificación completo
        /// </summary>
        public override string ToString()
        {
            string nif;
            string formato = "{0:0000000}";

            if (tipo == TiposCodigosEnum.CIF && LetraInicial == "")
                formato = "{0:00000000}";
            if (tipo == TiposCodigosEnum.NIF)
                formato = "{0:00000000}";
            
            nif = EsIntraComunitario ? CodigoIntracomunitario :
                string.Empty + LetraInicial + string.Format(formato,Numero ) + DigitoControl;
            return nif;
        }

        #endregion

        /// <summary>
        /// Comprobación de un número de identificación fiscal español
        /// </summary>
        /// <param name="numero">Numero a analizar</param>
        /// <returns>Instancia de <see cref="NumeroNif"/> con los datos del número.
        /// Destacable la propiedad <seealso cref="NumeroNif.EsCorrecto"/>, que contiene la verificación
        /// </returns>
        public static NumeroNif CompruebaNif(string numero)
        {
            return new NumeroNif(numero);
        }

    }

}

En el siguiente post intentaré comentar cómo podemos crear un control de usuario que nos valide la entrada de un CIF/NIF/NIE correcto en ASP Net. Digo intentaré porque últimamente me estoy oxidando mucho con el tema de los controles de ASP. ¿Cuál es la razón?, muy sencillo, que cada día soy más vago y últimamente me estoy habituando demasiado a trabajar con los controles de DevExpress que, tal como lo veo, ofrecen una gran cantidad de opciones que, de trabajar con controles estándares me costarían bastante de hacer.

CultureInfo. Personalizar formatos

Jesús Velasco — Wed, 22 Dec 2010 08:42:16 GMT

Recientemente publiqué un post en el que había creado una clase que facilitaba la labor de crear ficheros delimitados. Como suele ocurrir casi siempre, baso los artículos en vivencias de mi vida laboral. Es por esto que, tal como ha sucedido en el presente, en más de una ocasión, tras resolver un problema, surge otro nuevo.

El caso es que, hasta el momento, cuando había tenido que crear un fichero de este tipo para enviar al exterior, siempre estaba hablando con empresas españolas. En este caso, es distinto, puesto que el fichero irá a parar a una multinacional que, lógicamente, impone sus normas. En principio, estas normas no suelen dar muchos problemas, pero sí que representan algún trastorno en lo referente a los formatos numéricos y de fechas.

Reconozco que hasta el momento nunca me había preocupado mucho de estos temas de crear aplicaciones multilingües ni tal siquiera de cambiar determinados formatos, sobre todo numéricos, pero como ha llegado el momento de hacerlo, pues he empezado a interesarme, de momento, por alguna herramienta que nos ofrece el Framework. En esta ocasión no he pasado de la clase CultureInfo, aunque no descarto seguir con las interfaces IFormatProvider e ICustomFormater, que me han dado muy buenas vibraciones.

Bueno, vamos al grano, que siempre me disipo intentando entrar en situación. El caso es que necesito tener un modo más o menos centralizado en el que pueda definir cómo quedarán los formatos de fecha y numéricos, así que lo mejor que he sabido ver es crear una clase CulturaPropia, en la que pueda personalizar los formatos que necesito. Esta clase heredará de otra del Framework, la clase CultureInfo.

using System;
using System.Globalization;

namespace JnSoftware.Samples
{
    class CulturaPropia : CultureInfo
    {
        public CulturaPropia()
            : base("es-ES")
        {
            setFormatoNumerico();
            setFormatoMoneda();
            setFormatoFecha();
        }

        /// <summary>
        /// Establece formatos numéricos
        /// </summary>
        private void setFormatoNumerico()
        {
            NumberFormatInfo n = this.NumberFormat;
            n.NumberNegativePattern = 0;
            n.NumberGroupSeparator = ",";
            n.NumberDecimalSeparator = ".";
        }

        /// <summary>
        /// Establece formatos de Moneda
        /// </summary>
        private void setFormatoMoneda()
        {
            NumberFormatInfo n = this.NumberFormat;
            n.CurrencyPositivePattern = 3;
            n.CurrencySymbol = "EUR";
        }

        /// <summary>
        /// Establece formatos de fecha
        /// </summary>
        private void setFormatoFecha()
        {
            DateTimeFormatInfo d = this.DateTimeFormat;
            d.LongDatePattern = "'Montcada i Reixac, 'dd' de 'MMMM' de 'yyyy" ;
            d.ShortDatePattern = "dd.MMM.yyyy";
            d.FirstDayOfWeek = DayOfWeek.Monday;
            d.TimeSeparator = "/";
            d.DateSeparator = ".";
        }
    }
}

Como se puede apreciar, la clase es bien sencilla, puesto que, desde el mismo constructor, lo que intenta es “heredar” toda la información de una referencia cultural completa (en el ejemplo es-ES, correspondiente a España). A partir de aquí, tan sólo es cuestión de ir modificando aquellas propiedades de la clase que necesitemos.

Para la ejecución de las pruebas, he creado un proyecto de consola en el cual, sencillamente, muestro una comparación entre tres referencias diferentes: americana, española y la que he creado. Es posible que existan otras opciones de hacerlo, pero he visto que me resulta muy cómodo cambiar la referencia cultural al Thread actual, extraer los datos y volver a dejar tal cuál estaba la referencia.

using System;
using System.Globalization;

namespace JnSoftware.Samples
{
    class EjecucionPruebas
    {
        // Muestra diversa información en pantalla.
        public void MuestraEjemplo(string titulo, CultureInfo cultura)
        {
            DateTime fecha = DateTime.Now;
            double numero = 12345.6789;

            System.Threading.Thread.CurrentThread.CurrentCulture = cultura;
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine(new string('=', Console.WindowWidth - 1));
            Console.WriteLine(titulo);
            Console.WriteLine(new string('=', Console.WindowWidth - 1));
            Console.ResetColor();
            Console.WriteLine("Fecha 1  : \t{0:d}", fecha);
            Console.WriteLine("Fecha 2  : \t{0:D}", fecha);
            Console.WriteLine("General  : \t{0:G}", numero);
            Console.WriteLine("Moneda   : \t{0:C}", numero);
            Console.WriteLine("Decimal  : \t{0:D}", (int)numero);
            Console.WriteLine("Número   : \t{0:N}", numero);
            Console.WriteLine("P. Fijo  : \t{0:F}", numero);
        }

        // Ejecución de las pruebas.
        public static void Main()
        {
            // Lectura de la referencia actual
            CultureInfo actual = System.Threading.Thread.CurrentThread.CurrentCulture;
            Console.WindowHeight = 31;
            EjecucionPruebas test = new EjecucionPruebas();
            // Cambios de referencia culturales 
            test.MuestraEjemplo("en-US", new CultureInfo("en-US"));
            test.MuestraEjemplo("es-ES", new CultureInfo("es-ES"));
            test.MuestraEjemplo("Propia", new CulturaPropia());
            test = null;
            // Se establece la referencia inicial
            System.Threading.Thread.CurrentThread.CurrentCulture = actual;
            Console.ReadKey();
        }
    }
}

Tal como puede apreciarse, salvo algún ornamento añadido para que se muestre mejor la pantalla resultante, lo único que se hace en la aplicación es mostrar los mismos datos en las diferentes referencias culturales.

El resultado será el siguiente:

C# - Crear ficheros delimitados

Jesús Velasco — Sat, 18 Dec 2010 15:56:25 GMT

No será la primera vez que en alguna de mis aplicaciones he tenido que crear ficheros de texto para intercambiar información con otras empresas. Para bancos, cajas de ahorro, ayuntamientos y un conjunto grande de entidades es moneda de cambio el trabajar con este tipo de documentos.

Aunque no es un punto excesivamente complicado, cada vez que he tenido que hacer un fichero ASCII delimitado he creado algún procedimiento que se encargase de este trabajo. Hoy me he propuesto crearme una clase que me permita generalizarme un poco la labor.

Si cogemos un ejemplo, como puede ser la creación de un fichero de adeudo por domiciliaciones (Norma 19), podríamos resumir diciendo que tiene la siguiente estructura:

cabecera
lista de datos
resumen

Por tanto, con el fin de facilitar el trabajo, además de los procedimientos que necesitaremos para poder crear el fichero, deberemos tener unos métodos que nos permitan escribir una lista completa de datos o una línea de texto. Algo así como:

public class CamposDelimitados
 {
     /// <summary>
     /// Permite enviar todos los elementos de una lista al fichero de salida
     /// </summary>
     /// <param name="lista">Lista de elementos que deberán aparecer 
     /// en el fichero de salida</param>
     /// <remarks>La definición de la estructura de salida deberá especificarse 
     /// en el método ToString()</remarks>
     public void InsertaLista(IList lista)
     {
         throw new System.NotImplementedException();
     }


     /// <summary>
     /// Permite la inserción de una línea individual en el fichero de salida
     /// </summary>
     /// <param name="texto">Texto a incorporar en el fichero de salida</param>
     public void InsertaLinea(string texto)
     {
         throw new System.NotImplementedException();
     }
 }

Por tanto, una clase que tenga algún tipo de generalización y que sea útil para tal acción podría ser la siguiente:

using System.Collections;
using System.IO;
using System.Text;


namespace JnSoftware.Utiles
{

    /// <summary>
    /// Representa un escritor de ficheros delimitados.
    /// </summary>
    public class CamposDelimitados
    {

        private StringBuilder textoSalida = new StringBuilder();

        /// <summary>
        /// Permite enviar todos los elementos de una lista al 
        /// fichero de salida
        /// </summary>
        /// <param name="lista">Lista de elementos que deberán 
        /// aparecer en el fichero de salida</param>
        /// <remarks>La definición de la estructura de salida 
        /// deberá especificarse en el método ToString()</remarks>
        public void InsertaLista(IList lista)
        {
            foreach (object item in lista)
                InsertaLinea(item.ToString());
        }


        /// <summary>
        /// Permite la inserción de una línea.
        /// </summary>
        /// <param name="texto">Texto a incorporar en el fichero 
        /// de salida</param>
        public void InsertaLinea(string texto)
        {
            textoSalida.AppendLine(texto);
        }


        /// <summary>
        /// Crea el fichero de salida
        /// </summary>
        /// <param name="nombreFichero">Ruta completa del fichero 
        /// que contendrá los datos delimitados</param>
        public void creaFichero(string nombreFichero)
        {
            using (StreamWriter sw =
                new StreamWriter(nombreFichero, false, Encoding.UTF8))
            {
                sw.Write(textoSalida);
                sw.Flush();
                sw.Close();
            }
        }
    }
}

¿En qué me ayudará esta clase?. Es una pregunta sencilla de responder, puesto que fijándonos en el método InsertaLista, podremos deducir que bastará con crear una implementación propia del método ToString() de nuestras clases para definir la delimitación de los datos.

Claro que está que la implementación personalizada (o customizada, que últimamente está muy de moda este vocablo) del método ToString() representa un par de problemas adicionales, Por un lado, es algo personal ya que siempre me ha fastidiado bastante que hay empresas que suelen darte la columna inicial y la final y hay otras que te dan la longitud que deberá tener cada columna de datos; por otro lado, está la problemática de hacer que nuestras columnas de datos adquieran una longitud fija. Con la intención de solventar estos dos problemas, creo una serie de métodos estáticos en la misma clase para que agilicen la adaptación de los datos a la cadena resultante.

namespace JnSoftware.Utiles
{

    /// <summary>
    /// Describe el modo de alineación de un texto dentro 
    /// de un archivo delimitado
    /// </summary>
    public enum TextAlignment { Left, Right }


    /// <summary>
    /// Representa un escritor de ficheros delimitados.
    /// </summary>
    public class CamposDelimitados
    {

        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="inicio">Entero que representa la posición 
        /// inicial en la delimitación</param>
        /// <param name="fin">Entero que representa la posición final en 
        /// la delimitación</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(string campo, int inicio, int fin)
        {
            return PreparaLinea(campo, inicio, fin, TextAlignment.Left);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="longitudCampo">Longitud que deberá tener el campo 
        /// en la delimitación</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(string campo, int longitudCampo)
        {
            return PreparaLinea(campo, longitudCampo, TextAlignment.Left);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="inicio">Entero que representa la posición inicial 
        /// en la delimitación</param>
        /// <param name="fin">Entero que representa la posición inicial en 
        /// la delimitación</param>
        /// <param name="alineacion">Alineación del texto en el fichero 
        /// delimitado</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(
            string campo,
            int inicio,
            int fin,
            TextAlignment alineacion)
        {
            return PreparaLinea(campo, fin - inicio, alineacion);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="longitud">Longitud que deberá tener el campo en la 
        /// delimitación</param>
        /// <param name="alineacion">Alineación del texto en el fichero 
        /// delimitado</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(
            string campo,
            int longitud,
            TextAlignment alineacion
            )
        {
            string espacios = new string(' ', longitud - campo.Length);
            if (alineacion == TextAlignment.Left)
                return campo + espacios;
            else
                return espacios + campo;
        }
    }
}

Por tanto, podemos decir que la clase, una vez finalizada, será la siguiente:

using System.Collections;
using System.IO;
using System.Text;


namespace JnSoftware.Utiles
{

    /// <summary>
    /// Describe el modo de alineación de un texto dentro 
    /// de un archivo delimitado
    /// </summary>
    public enum TextAlignment { Left, Right }


    /// <summary>
    /// Representa un escritor de ficheros delimitados.
    /// </summary>
    public class CamposDelimitados
    {

        private StringBuilder textoSalida = new StringBuilder();

        /// <summary>
        /// Permite enviar todos los elementos de una lista al 
        /// fichero de salida
        /// </summary>
        /// <param name="lista">Lista de elementos que deberán 
        /// aparecer en el fichero de salida</param>
        /// <remarks>La definición de la estructura de salida 
        /// deberá especificarse en el método ToString()</remarks>
        public void InsertaLista(IList lista)
        {
            foreach (object item in lista)
                InsertaLinea(item.ToString());
        }


        /// <summary>
        /// Permite la inserción de una línea.
        /// </summary>
        /// <param name="texto">Texto a incorporar en el fichero 
        /// de salida</param>
        public void InsertaLinea(string texto)
        {
            textoSalida.AppendLine(texto);
        }


        /// <summary>
        /// Crea el fichero de salida
        /// </summary>
        /// <param name="nombreFichero">Ruta completa del fichero 
        /// que contendrá los datos delimitados</param>
        public void creaFichero(string nombreFichero)
        {
            using (StreamWriter sw =
                new StreamWriter(nombreFichero, false, Encoding.UTF8))
            {
                sw.Write(textoSalida);
                sw.Flush();
                sw.Close();
            }
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="inicio">Entero que representa la posición 
        /// inicial en la delimitación</param>
        /// <param name="fin">Entero que representa la posición final en 
        /// la delimitación</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(string campo, int inicio, int fin)
        {
            return PreparaLinea(campo, inicio, fin, TextAlignment.Left);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="longitudCampo">Longitud que deberá tener el campo 
        /// en la delimitación</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(string campo, int longitudCampo)
        {
            return PreparaLinea(campo, longitudCampo, TextAlignment.Left);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="inicio">Entero que representa la posición inicial 
        /// en la delimitación</param>
        /// <param name="fin">Entero que representa la posición inicial en 
        /// la delimitación</param>
        /// <param name="alineacion">Alineación del texto en el fichero 
        /// delimitado</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(
            string campo,
            int inicio,
            int fin,
            TextAlignment alineacion)
        {
            return PreparaLinea(campo, fin - inicio, alineacion);
        }


        /// <summary>
        /// Permite adaptar el contenido de un campo a un formato de tamaño fijo.
        /// </summary>
        /// <param name="campo">Contenido del campo en formato string</param>
        /// <param name="longitud">Longitud que deberá tener el campo en la 
        /// delimitación</param>
        /// <param name="alineacion">Alineación del texto en el fichero 
        /// delimitado</param>
        /// <returns>Cadena preparada para insertar en el fichero</returns>
        public static string PreparaLinea(
            string campo,
            int longitud,
            TextAlignment alineacion
            )
        {
            string espacios = new string(' ', longitud - campo.Length);
            if (alineacion == TextAlignment.Left)
                return campo + espacios;
            else
                return espacios + campo;
        }
    }
}

¿Cómo utilizar la clase?

Creo un pequeño ejemplo en el que se muestra cómo podemos hacer uso de la clase en la creación de un fichero delimitado. En este ejemplo queda claro cómo definir el método ToString() para que se adapte al formato deseado:

using System;
using System.Collections.Generic;
using JnSoftware.Utiles;

namespace TextosDelimitadosTest
{
    class CreacionFicheroDelimitado
    {

        public int Id { get; set; }
        public string Texto { get; set; }
        public DateTime Fecha { get; set; }

        public override string ToString()
        {
            // En el método ToString() indicamos cómo deberá aparecer la información
            return 
                CamposDelimitados.PreparaLinea(Id.ToString(),1, 7, TextAlignment.Right)
                + CamposDelimitados.PreparaLinea(Texto, 30)
                + CamposDelimitados.PreparaLinea(Fecha.ToShortDateString(), 10);
                ;
        }

        // Ejecución de las pruebas
        public static void Main()
        {
            // Fichero de salida
            string fichero = @"C:\Users\j.velasco\Desktop\exitTest\salida.txt";

            // Creación de una lista de ejemplo
            List<CreacionFicheroDelimitado> lista = 
                new List<CreacionFicheroDelimitado>();
            for (int i = 1; i < 20; i++)
            {
                lista.Add(
                    new CreacionFicheroDelimitado()
                    {
                        Id = i,
                        Texto = "Texto " + i.ToString(), 
                        Fecha = DateTime.Now 
                    }
                    );
            }

            // Creación del fichero
            CamposDelimitados cd = new CamposDelimitados();
            cd.InsertaLinea("-- Cabecera del texto");
            cd.InsertaLista(lista);
            cd.creaFichero(fichero);
        }
    }
}