C# reflexiona sobre la enumeración a través de la cadena de tipo de enumeración

Reflejar cualquier tipo por cadena de tipo

Old Gu escribió un blog antes: mediante la reflexión y el uso de cadenas, se pueden reflejar todos los tipos disponibles en el proyecto actual, incluidos los tipos genéricos. Los amigos que necesiten recuperar lecciones pueden ver el artículo anterior de Lao Gu " C# Crear objetos de cualquier tipo (incluidos los genéricos) basados ​​en la cadena Typename ".

Aunque el propio Lao Gu dijo que usar este método es generalmente su elección para caer al pozo, de hecho se usa a veces.

tipo enumerado

Generalmente, en los programas desarrollados por nosotros mismos, para datos limitados específicos, generalmente hacemos un tipo de enumeración para estandarizar a todos los pequeños socios que participan en el proyecto y evitar ambigüedades o contenidos irregulares.

Por ejemplo, el estado de un pedido se puede dividir en varias etapas según el proceso empresarial:

Enviar
Pedido pendiente Recibido Pendiente
Pago Pagado Pendiente Envío Envío Envío completado Pedido completo

Y así sucesivamente con un conjunto finito de estados.

Por ejemplo, al acceder a los recursos de la red, se devolverán algunos códigos de estado, como 200, 404, 401, 500, etc. Estos son estados finitos, por lo que generalmente podemos usar Enum para definir un conjunto de enumeración para estandarizar los datos.

Este tipo de operación tiene como objetivo principal evitar que algunos socios pequeños escriban pendientes de pago, algunos socios pequeños escriban sin pagar y algunos escriban pendientes de pago. . . En resumen, Dios sabe cuántos datos con el mismo significado aparecerán sin la especificación de enumeración.

Blog de CSDN analfabeto Lao Gu , https://blog.csdn.net/superwfei
Comunidad personal de Lao Gu , https://bbs.csdn.net/forums/bfba6c5031e64c13aa7c60eebe858a5f?category=10003&typeId=3364713

Invocar una enumeración a través de la reflexión

La mayoría de las veces, cuando usamos una enumeración, conocemos claramente su tipo, por lo que generalmente usamos directamente Enum.GetName (tipo de enumeración, valor) para obtener la descripción de texto correspondiente.

Sin embargo, ocasionalmente, la posición donde necesitamos llamar a la enumeración no es nuestro código escrito a mano, sino algo así como una definición de plantilla. Por ejemplo, ahora Lao Gu tiene dicha definición de plantilla:

404.enum.httpestado

404 es el valor, enum es la enumeración que llama y httpsstate es el tipo de enumeración

Si está escrito normalmente en el programa, entonces debería ser así

Enum.GetName(httpstate,404)

Pero las palabras en la plantilla. . . Este httpsstate se puede analizar, pero ¿qué pasa si hay varias plantillas y los tipos de enumeración son inconsistentes?

Por ejemplo, existe un contenido de plantilla de este tipo:

html symbols: ^lt,enum,htmlsymbols^ ^trage,enum,htmlsymbols^ ^gt,enum,htmlsymbols^
http state: ^200.enum.httpstate^ ^403.enum.httpstate^ ^500.enum.httpstate^ 
bidstate: ^11.enum.trade^ ^91.enum.trade^ ^99.enum.trade^

Luego, hay tres tipos enumerados aquí. Si hay pocos, es posible usar el programa para bifurcar uno por uno, o cambiar, si hay pocos, pero si hay nuevos tipos, todavía es muy doloroso y a menudo requiere Cambió el código.

Por lo tanto, todavía implementamos llamadas de enumeración mediante reflexión.

¿GetTypeByName (EnumName) está vacío?

Usamos directamente el método GetTypeByName definido previamente para llamar a la clase a través de la cadena del nombre de la clase, y los parámetros que contiene son de tipo enumeración. . . resultado. . . ¿No puedes obtener el tipo de enumeración? ¿El tipo devuelve nulo? ?

Incluso descubrí los genéricos, ¿me dices que no se pueden usar enumeraciones?

                        foreach (Type st in ts)
                        {
    
    
                            if (RegexExpand.IsMatch(st.FullName, @"\." + RegexExpand.FormatRegExp(source) + @"(`?\d+)?$"))
                            {
    
    
                                return st;
                            }
                        }

Abra el código original, en la línea RegexExpand.IsMatch, Lao Gu alcanzó un punto de interrupción y luego encontró el tipo de cadena de la enumeración Enum. . . Un poco desconcertante.

Bueno, para las clases, FullName es la forma de xxx.yyy.zzz, genérico es la forma de xxx.yyy.zzz`n, como resultado, tipo de enumeración, le has dado una forma de xxx.yyy+zzz. . . .

Por lo tanto, es muy sencillo de modificar, simplemente reemplace el @“\.” normal en el código de ahora con @"[\.+]" .

Luego, podemos llamar a la enumeración para procesar el contenido normalmente:

                        try
                        {
    
    
                            Type t = Common.GetTypeByName(枚举类型字符串);
                            return Enum.GetName(t, int.Parse(枚举值));
                        }
                        catch (Exception ex)
                        {
    
    
                            return ex.Message;
                        }

resumen

Bueno, no hay mucho que resumir, solo el formato de Nombre Completo, que es un poco inesperado, tal vez existan otras formas de Nombre Completo. En definitiva, es mejor saber más.

Además, permítame agregar que puede modificar directamente RegexExpand a Regex, que es una clase estática definida por Lao Gu, que hereda y expande Regex.

El método FormatRegExp consiste en convertir una cadena en una expresión regular, similar a re.escape en py

        public static string FormatRegExp(string str)
        {
    
    
            return str.Replace("\\", @"\\").Replace("(", "\\(").Replace(")", "\\)").Replace("{", "\\{").Replace("}", "\\}").Replace("[", "\\[").Replace("]", "\\]").Replace(".", "\\.").Replace("+", "\\+").Replace("-", "\\-").Replace("^", "\\^").Replace("$", "\\$").Replace("?", "\\?").Replace("*", "\\*").Replace("|", "\\|");
        }

De hecho, es sólo cuestión de reemplazar algunos caracteres y puedes colocarlos donde quieras.