c# - switch - ¿Son los atributos personalizados para Enums peligrosos?

enum to list c#

Question

Estoy creando una aplicación que hace un uso intensivo de Enum s para datos personalizados. Esencialmente, un objeto se almacena en la base de datos con aproximadamente 28 atributos separados. Cada atributo es un campo de dos caracteres que se traduce del SQL directamente a un Enum .

Desafortunadamente, también necesito traducir estos valores en dos valores diferentes legibles por el hombre. Uno para una leyenda en una tabla de datos y otro para una clase CSS para diseñar una imagen en el front-end de la aplicación web.

Para hacer esto, configuré dos atributos personalizados y los apliqué al Enum cuando fue necesario. Por ejemplo:

Interfaz de atributo personalizado

public interface IAttribute<T>
{
    T Value { get; }
}

Ejemplo de atributo personalizado

public sealed class AbbreviationAttribute: Attribute, IAttribute<string>
{
    private readonly string value;

    public AbbreviationAttribute(string value)
    {
        this.value = value;
    }

    public string Value
    {
        get { return this.value; }
    }
}

Método para recuperar atributos personalizados de Enum

public static R GetAttributeValue<T, R>(IConvertible @enum)
{
    R attributeValue = default(R);

    if (@enum != null)
    {
        FieldInfo fi = @enum.GetType().GetField(@enum.ToString());

        if (fi != null)
        {
            T[] attributes = fi.GetCustomAttributes(typeof(T), false) as T[];

            if (attributes != null && attributes.Length > 0)
            {
                IAttribute<R> attribute = attributes[0] as IAttribute<R>;

                if (attribute != null)
                {
                    attributeValue = attribute.Value;
                }
            }
        }
    }

    return attributeValue;
}

Ejemplo Enum usando este patrón

public enum Download
{
    [Abbreviation("check")]
    [Description("Certified")]
    C = 1,

    [Abbreviation("no-formal")]
    [Description("No formal certification")]
    NF = 2,

    [Abbreviation("cert-prob")]
    [Description("Certified with potential problems")]
    CP = 3
}

Tanto la Abbreviation como la Description son atributos personalizados que implementan IAttribute<T> . Mi Enum real tiene 11 valores posibles, y como mencioné anteriormente, se utiliza en 28 propiedades separadas en mi objeto personalizado. Usar atributos personalizados parecía la mejor manera de asignar esta información de un lado a otro.

Ahora para la pregunta, ¿ es esta la mejor manera de lograr esto? Enum valor Enum ("C", "NF" o "CP" en el fragmento de código anterior) en la base de datos, pero necesito los valores de la abreviatura y la descripción en mi código. Además, dudo que este sea el conjunto final de atributos personalizados que necesitaré.

Antes de seguir adelante con este patrón ... ¿ es la forma correcta de hacer las cosas? Prefiero solucionar posibles problemas con este enfoque ahora que tener que rastrear y refactorizar más tarde.

Answer 1

¿Puedes alterar la base de datos? Creo que la mejor opción sería hacer una tabla (o tablas) para albergar los posibles valores de las enumeraciones y la clave foránea de los objetos principales (en lugar de usar códigos de caracteres, esto hace que sea más fácil tirar y normalizar su DB). . Asigne a la tabla una columna de Abbreviation y Description , luego jálelas y haga referencia a ellas por clave, y guárdelas en caché si las búsquedas son lentas.

Una cosa que es peligrosa sobre los atributos es que si alguna de esas cadenas tiene que cambiar alguna vez, es un completo despliegue de la aplicación. Si los convierte en valores de la base de datos, puede cambiarlos con una UPDATE simple.

Answer 2

Este es el mismo método que utilizo. El único inconveniente es la serialización. Los valores de los atributos personalizados no se serializan.

Me gusta el método del atributo personalizado sobre el método de la base de datos porque vincula los datos del atributo con la enumeración en lugar de tener que usar una tabla o clase de búsqueda, etc.

Answer 3

Probablemente construiría una tabla hash y un tipo especial para algo como esto. Es posible que ya hayas descartado la idea por alguna razón u otra, pero esto es lo que yo haría sin saber los detalles de tu aplicación.

class SpecialType {
  // include the fields and all attributes that you need to reference, ToString method for debugging, and any serialization you need
  public string foo { get; set; }
  public string bar { get; set; }
  public ToString() { return "SpecialType with foo ''" + foo + "'' and bar ''" + bar + "''"; }
}

Dictionary<int, SpecialType> myDict = new Dictionary<int, SpecialType> {
   { 1, new SpecialType { foo = "XA1B2", bar = "XC3D4" } },
   { 2, new SpecialType { foo = "ZA1B2", bar = "ZC3D4" } },
   { 3, new SpecialType { foo = "YA1B2", bar = "YC3D4" } },
}

Luego, podría guardar fácilmente entradas en mis otras clases para ahorrar memoria, averiguar si un valor en particular era válido al verificar la existencia en las Claves del Diccionario, todo ese jazz. Probablemente sería mucho más fácil hacer el enlace de datos si eventualmente va a usar WPF o leer / escribir en el disco, también.