Comment puis-je récupérer des constantes de n'importe quel type de données à l'aide de Reflection ?

Comment acquérir des constantes de n'importe quel type de données à l'aide de la réflexion

Une question intrigante est de déterminer les constantes présentes dans un type de données spécifique pendant l'exécution . Examinons comment nous pouvons y parvenir en utilisant les principes de réflexion.

Plongez dans le royaume des constantes avec la réflexion

Pour percer le mystère de l'acquisition de constantes, nous utilisons le méthodes intrépides fournies par l’arsenal de réflexion. La réflexion nous permet d'examiner et de manipuler les types, nous permettant ainsi d'en extraire les joyaux cachés qu'ils recèlent.

Un guide exemplaire pour dévoiler les constantes

Pour se lancer dans cette aventure, nous fournissons une routine exemplaire qui plonge au cœur de tout type donné et en extrait son immuable constantes :

private FieldInfo[] GetConstants(System.Type type)
{
    // Initialize an assembly of constants
    ArrayList constants = new ArrayList();

    // Summon an army of field explorers to unearth all public, static gems
    FieldInfo[] fieldInfos = type.GetFields(
        // Command the retrieval of public and static fields
        BindingFlags.Public | BindingFlags.Static |
        // Extend the search to the depth of base types
        BindingFlags.FlattenHierarchy);

    // Patrol through the reconnaissance report, enlisting only the immutable constants
    foreach(FieldInfo fi in fieldInfos)
        // Assess if the field's value is immutable and endures from compile-time
        // Exclude any field that can be tampered with in the constructor
        if(fi.IsLiteral && !fi.IsInitOnly)
            constants.Add(fi);

    // Formulate an array of FieldInfos holding the unearthed constants
    return (FieldInfo[])constants.ToArray(typeof(FieldInfo));
}

Adopter les génériques et LINQ pour une touche de polissage

L'approche susmentionnée peut être affinée davantage avec l'élégance des génériques et la puissance de LINQ. Cette transformation nous offre une base de code plus propre et plus concise :

private List<FieldInfo> GetConstants(Type type)
{
    FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public |
         BindingFlags.Static | BindingFlags.FlattenHierarchy);

    return fieldInfos.Where(fi => fi.IsLiteral &amp;&amp; !fi.IsInitOnly).ToList();
}

Un coup de simplicité

En quête de minimalisme, nous condensons cette approche raffinée en une approche succincte- doublure :

type.GetFields(BindingFlags.Public | BindingFlags.Static |
               BindingFlags.FlattenHierarchy)
    .Where(fi => fi.IsLiteral && !fi.IsInitOnly).ToList();

Armé de cet arsenal de techniques, vous êtes désormais habilité à dévoiler les secrets cachés dans le au cœur même de tout type de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!