Comment travailler avec la réflexion en C #

La réflexion en C # est utilisée pour récupérer des métadonnées sur les types au moment de l'exécution. En d'autres termes, vous pouvez utiliser la réflexion pour inspecter les métadonnées des types de votre programme de manière dynamique - vous pouvez récupérer des informations sur les assemblys chargés et les types qui y sont définis. La réflexion en C # est similaire à RTTI (Runtime Type Information) de C ++.

Pour travailler avec la réflexion dans .Net, vous devez inclure l'espace de noms System.Reflection dans votre programme. En utilisant la réflexion, vous obtenez des objets du type «Type» qui peuvent être utilisés pour représenter des assemblages, des types ou des modules. Vous pouvez utiliser la réflexion pour créer dynamiquement une instance d'un type et même appeler des méthodes du type.

Les types définis dans l'espace de noms System.Reflection sont les suivants.

  • Assemblée
  • Module
  • Enum
  • MethodInfo
  • ConstructorInfo
  • MemberInfo
  • ParameterInfo
  • Type
  • FieldInfo
  • EventInfo
  • PropertyInfo

Explorons maintenant du code pour mettre la réflexion en action. Considérez la classe suivante appelée Customer.

public class Customer

    {

        public int Id

        {

            get; set;

        }

        public string FirstName

        {

            get; set;

        }

        public string LastName

        {

            get; set;

        }

        public string Address

        {

            get; set;

        }

    }

L'extrait de code suivant montre comment vous pouvez obtenir le nom de la classe et le nom de l'espace de noms de la classe Customer à l'aide de la réflexion:

Type type = typeof(Customer);

Console.WriteLine("Class: " + type.Name);

Console.WriteLine("Namespace: " + type.Namespace);

L'extrait de code suivant illustre comment vous pouvez récupérer la liste des propriétés de la classe Customer et afficher leurs noms dans la fenêtre de la console:

static void Main(string[] args)

        {

            Type type = typeof(Customer);

            PropertyInfo[] propertyInfo = type.GetProperties();

            Console.WriteLine("The list of properties of the Customer class are:--");

            foreach (PropertyInfo pInfo in propertyInfo)

            {

                Console.WriteLine(pInfo.Name);

            }

        }

La méthode GetProperties () de la classe Type renvoie un tableau de type PropertyInfo - il s'agit en fait d'une liste des propriétés publiques de votre type. Vous pouvez ensuite parcourir ce tableau et récupérer les noms de chacune des propriétés publiques définies dans votre type. Étant donné que la classe Customer définit trois propriétés, les noms de toutes ces trois propriétés seraient affichés dans la console lorsque ce programme est exécuté.

Voici comment afficher les métadonnées des constructeurs et des méthodes publiques d'un type à l'aide de la réflexion. Revisitons la classe Customer que nous avons créée précédemment et incorporons deux méthodes - un constructeur par défaut et une méthode appelée Validate qui est utilisée pour valider l'objet client qui lui est passé en tant que paramètre. Voici à quoi ressemblerait la version modifiée de la classe Customer.

public class Customer

    {

        public Customer()

        {

            //Default constructor

        }

        public int Id

        {

            get; set;

        }

        public string FirstName

        {

            get; set;

        }

        public string LastName

        {

            get; set;

        }

        public string Address

        {

            get; set;

        }

        public bool Validate(Customer customerObj)

        {

            //Code to validate the customer object

            return true;

        }

    }

L'extrait de code suivant peut être utilisé pour afficher les noms de tous les constructeurs appartenant à la classe Customer. Nous n'avons qu'un seul constructeur dans la classe Customer - par conséquent, un seul serait répertorié.

Type type = typeof(Customer);           

ConstructorInfo[] constructorInfo = type.GetConstructors();

Console.WriteLine("The Customer class contains the following Constructors:--");

foreach (ConstructorInfo c in constructorInfo)

  {

     Console.WriteLine(c);

  }

Notez que la méthode GetConstructors () de la classe Type renvoie un tableau de type ConstructorInfo qui contient la liste de tous les constructeurs publics définis dans le type qui est reflété.

D'ACCORD; affichons maintenant les noms de toutes les méthodes publiques de la classe Customer - encore une fois, nous en avons juste une pour que le nom d'une seule méthode soit affiché dans la console lorsque le programme donné ensuite est exécuté. Voici la liste des codes pour votre référence.

static void Main(string[] args)

 {

    Type type = typeof(Customer);

    MethodInfo[] methodInfo = type.GetMethods();

     Console.WriteLine("The methods of the Customer class are:--");

            foreach (MethodInfo temp in methodInfo)

            {

              Console.WriteLine(temp.Name);               

            }

            Console.Read();

        }

Notez que vous pouvez également afficher les noms de quelques méthodes supplémentaires (ToString, Equals, GetHashCode, GetType). Ces méthodes sont héritées de la classe Object - toute classe dans .Net dérive la classe Object par défaut.

Vous pouvez également parcourir les attributs d'une méthode. Si des attributs personnalisés ont été définis pour vos méthodes, vous pouvez utiliser la méthode GetCustomAttributes sur l'instance de la classe MethodInfo pour récupérer les attributs de la méthode. Voici comment vous pouvez y parvenir.

foreach (MethodInfo temp in methodInfo)

 {

    foreach (Attribute attribute in temp.GetCustomAttributes(true))

     {

         //Write your usual code here

     }

  }

Ainsi, si vous décorez vos objets métier à l'aide d'attributs dans votre application, vous pouvez profiter de la réflexion pour réfléchir sur le type, récupérer les attributs des méthodes de votre type, puis effectuer certaines actions en conséquence.