Enumeración con valor string


Estuve trabajando una aplicación con Base de datos y me vi en la necesidad que crear un tipo enumeración, ya que ciertos valores no necesariamente deberían ser registros de una tabla (bueno eso fue lo que me pidieron, en fin). Existía una tabla para almacenar los movimientos, llámese, Compras Locales, Importaciones, Salidas de Materiales a producción, etc., etc., en esta tabla se debería identificar si el tipo de movimiento es Ingreso, Salida, Transferencia, estos datos no son registros de ninguna tabla, además deberían identificarse por I = Ingreso, S = Salida, T = Transferencia.

Como sabemos el tipo enum almacenan un valor de tipo int y yo necesitaba almacenar un valor tipo string (pequeño problema a resolver). Buscando en el universo de información me encontré con una muy buena solución, el cual quiero compartir.

Vamos a crear un nuevo proyecto de tipo aplicación de consola.

Pues bien agreguemos una nueva clase y la llamaremos Movimiento, a esta clase agregaremos un tipo enum que se llamara TipoMovimiento, y agregamos las propiedades de la clase.

namespace EjemploCS
{
    public enum TipoMovimiento
    {
        Ingreso,
        Salida,
        Transferencia
    }
    public class Movimiento
    {
        public string Codigo { get; set; }
        public string Descripcion { get; set; }
        public TipoMovimiento Tipo { get; set; }
    }
}

En nuestro archivo Program.cs utilizaremos esta clase.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EjemploCS
{
    class Program
    {
        static void Main(string[] args)
        {
            //Creamos una nueva instancia Movimiento
            Movimiento m = new Movimiento
            {
                Codigo = "0001",
                Descripcion = "Compras Locales",
                Tipo = TipoMovimiento.Transferencia
            };
            //Consumimos la instancia
            Console.WriteLine("Codigo: {0}, Descripción: {1}, Tipo: {2}",
                m.Codigo, m.Descripcion, m.Tipo);

            Console.ReadLine();
        }
    }
}

Nuestro resultado seria

Si nos fijamos el valor tipo nos devuelve el valor Transferencia, nosotros deberíamos guardar el valor de ese tipo, para obtener el valor del tipo deberíamos hacer una conversión (recordemos que las enumeraciones almacenan un valor entero), entonces nuestro código seria

            //Consumimos la instancia
            Console.WriteLine("Codigo: {0}, Descripción: {1}, Tipo: {2}",
                m.Codigo, m.Descripcion, (int)m.Tipo);

El detalle hasta aquí es que en la base de datos deberíamos grabar el tipo con los valores I, S, T (Ingreso, Salida, Transferencia), mas la numeración nos devuelve valores enteros 0, 1, 2.

Solución a esto, vamos a agregar una clase llamada StringValueAttribute

Esta clase debe heredar de la clase Attribute

using System;

namespace EjemploCS
{
    public class StringValueAttribute : Attribute
    {
        public string StringValue { get; protected set; }

        public StringValueAttribute(string value)
        {
            this.StringValue = value;
        }
    }
}

Deberíamos extender el método GetStringValue, recordemos que los métodos de extensión son métodos estáticos. Entonces para esto creamos una clase estática.

    public static class Util
    {
        public static string GetStringValue(this Enum value)
        {
            Type type = value.GetType();
            FieldInfo fieldInfo = type.GetField(value.ToString());
            StringValueAttribute[] attribs = fieldInfo.GetCustomAttributes(
                typeof(StringValueAttribute), false) as StringValueAttribute[];

            return attribs.Length > 0 ? attribs[0].StringValue : null;
        }
    }

El código completo de la clase.

namespace EjemploCS
{
    public class StringValueAttribute : Attribute
    {
        public string StringValue { get; protected set; }

        public StringValueAttribute(string value)
        {
            this.StringValue = value;
        }
    }

    public static class Util
    {
        public static string GetStringValue(this Enum value)
        {
            Type type = value.GetType();
            FieldInfo fieldInfo = type.GetField(value.ToString());
            StringValueAttribute[] attribs = fieldInfo.GetCustomAttributes(
                typeof(StringValueAttribute), false) as StringValueAttribute[];

            return attribs.Length > 0 ? attribs[0].StringValue : null;
        }
    }
}

Ahora agregaremos el atributo a la enumeración.

    public enum TipoMovimiento
    {
        [StringValue("I")]
        Ingreso,
        [StringValue("S")]
        Salida,
        [StringValue("T")]
        Transferencia
    }

Y por ultimo para obtener el string almacenado deberíamos llamar al método GetStringValue

             //Consumimos la instancia
            Console.WriteLine("Codigo: {0}, Descripción: {1}, Tipo: {2}",
                m.Codigo, m.Descripcion, m.Tipo.GetStringValue());

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s