Pourquoi l'utilisation de la réflexion en .NET est-elle recommandée?

Question

Est-ce vraiment une bonne pratique de l'utiliser?

Quelles sont quelques situations possibles dans un projet qui nécessitent de la réflexion?

Answer 1

La principale valeur de la Réflexion est qu'elle peut être utilisée pour inspecter des assemblies, des types et des membres. C'est un outil très puissant pour déterminer le contenu d'une assembly ou d'un objet inconnu et peut être utilisé dans une grande variété de cas.

Les opposants à la Réflexion argumenteront qu'elle est lente, ce qui est vrai par rapport à l'exécution de code statique - cependant la Réflexion est utilisée dans tout le framework .NET, et pour autant qu'elle ne soit pas abusée, elle peut être un outil très puissant dans la boîte à outils.

Quelques applications utiles:

• Déterminer les dépendances d'une assembly

• Trouver des types qui se conforment à une interface, dérivent d'une classe de base / abstraite et rechercher des membres par attributs

• (Test malodorant) - Si vous dépendez d'une classe qui n'est pas testable (c'est-à-dire qu'elle ne vous permet pas de facilement créer un faux), vous pouvez utiliser la Réflexion pour injecter des valeurs factices dans la classe - ce n'est pas joli, et ce n'est pas recommandé, mais cela peut être un outil pratique dans une impasse.

• Débogage - affichage d'une liste des assemblies chargées, de leurs références, des méthodes actuelles, etc...

Answer 2

Il existe de nombreuses utilisations de la réflexion :

1. Parcourir les propriétés d'un objet.
2. Appeler une méthode définie à l'exécution.
3. Beaucoup d'autres dans le même ordre d'idées.

Cependant, l'une de mes utilisations préférées de la réflexion est de trouver des propriétés qui ont été marquées avec des attributs.

Par exemple, j'ai écrit des attributs qui marquent quelles propriétés de mes classes doivent être indexées en utilisant Lucene. À l'exécution, je peux regarder n'importe quelle classe et déterminer quel champ doit être indexé en interrogeant simplement la classe pour les propriétés "marquées".

Answer 3

La réflexion est juste un moyen d'investiguer des objets lors de l'exécution. Vous ne devez pas l'utiliser si vous n'en avez pas besoin.

Answer 4

La réflexion permet à une application de recueillir des informations sur elle-même et aussi de manipuler sur elle-même. Elle peut être utilisée pour trouver tous les types dans une assembly et/ou invoquer dynamiquement des méthodes dans une assembly.

System.Reflection : l'espace de noms contient les classes et interfaces qui fournissent une vue gérée des types chargés, des méthodes et des champs, avec la capacité de créer et invoquer dynamiquement des types ; ce processus est connu sous le nom de Réflexion dans le framework .NET.

System.Type : la classe est la classe principale pour la fonctionnalité de Réflexion .NET et est le moyen principal d'accéder aux métadonnées. La classe System.Type est une classe abstraite et représente un type dans le Common Type System (CLS).

Elle représente les déclarations de type : types de classe, types d'interface, types de tableau, types de valeur, types d'énumération, paramètres de type, définitions de types génériques, et types génériques construits ou fermés.

Par exemple :

using System;
using System.Reflection;

static class ReflectionTest
{
    public static int Height;
    public static int Width;
    public static int Weight;
    public static string Name;

    public static void Write()
    {
    Type type = typeof(ReflectionTest); // Obtient le pointeur de type
    FieldInfo[] fields = type.GetFields(); // Obtient tous les champs
    foreach (var field in fields) // Boucle à travers les champs
    {
        string name = field.Name; // Obtient le nom de chaîne
        object temp = field.GetValue(null); // Obtenir la valeur
        if (temp is int) // Vérifiez s'il s'agit d'un entier.
        {
        int value = (int)temp;
        Console.Write(name);
        Console.Write(" (int) = ");
        Console.WriteLine(value);
        }
        else if (temp is string) // Vérifiez s'il s'agit d'une chaîne.
        {
        string value = temp as string;
        Console.Write(name);
        Console.Write(" (string) = ");
        Console.WriteLine(value);
        }
    }
    }
}

class Program
{
    static void Main()
    {
    ReflectionTest.Height = 100; // Définir la valeur
    ReflectionTest.Width = 50; // Définir la valeur
    ReflectionTest.Weight = 300; // Définir la valeur
    ReflectionTest.Name = "ShekharShete"; // Définir la valeur
    ReflectionTest.Write(); // Invoquer les méthodes de réflexion
    }
}

Résultat

Height (int) = 100
Width (int) = 50
Weight (int) = 300
Name (string) = ShekharShete

Answer 5

Vous pouvez utiliser la réflexion pour implémenter un système de plugins par exemple. Il suffit de rechercher toutes les DLL dans un dossier et par réflexion, de vérifier s'ils implémentent une certaine interface de plugin. C'est le principal objectif pour lequel j'ai utilisé la réflexion, mais je l'ai également utilisée pour mettre en œuvre une sérialisation d'objet faite maison générique, où les performances n'étaient pas la plus grande préoccupation.