Réflexion dans le .NET Framework pour les applications du Windows Store

À compter de .NET Framework 4.5, .NET Framework fournit un ensemble de types et membres de réflexion à utiliser dans les applications Windows 8.x Store. Ces types et ces membres sont disponibles dans le .NET Framework complet, ainsi que dans .NET pour les applications du Windows Store. Ce document explique les principales différences entre celles-ci et leurs équivalents dans .NET Framework 4 et les versions antérieures.

Si vous créez une application Windows 8.x Store, vous devez utiliser les types et les membres de réflexion dans .NET pour les applications Windows 8.x Store. Ces types et ces membres sont également disponibles, mais pas obligatoires, pour une utilisation dans les applications de bureau. Vous pouvez donc utiliser le même code pour les deux types d’applications.

TypeInfo et chargement des assemblys

Dans les applications du .NET pour Windows 8.x Store, la TypeInfo classe contient certaines des fonctionnalités de la classe .NET Framework 4 Type . Un Type objet représente une référence à une définition de type, tandis qu’un TypeInfo objet représente la définition de type elle-même. Cela vous permet de manipuler des Type objets sans nécessairement exiger que le runtime charge l’assembly qu’ils référencent. L'obtention de l'objet TypeInfo associé force le chargement de l'assembly.

TypeInfo contient la plupart des membres disponibles sur Type, et de nombreuses propriétés de réflexion des applications .NET pour Windows 8.x Store retournent des collections d’objets TypeInfo. Pour obtenir un TypeInfo objet à partir d’un Type objet, utilisez la GetTypeInfo méthode.

Méthodes de requête

Dans les applications du .NET pour Windows 8.x Store, vous utilisez les propriétés de réflexion qui retournent des collections IEnumerable<T> au lieu de méthodes qui retournent des tableaux. Les contextes de réflexion peuvent implémenter le parcours différé de ces collections pour de grands assemblys ou types.

Les propriétés de réflexion retournent uniquement les méthodes déclarées sur un objet particulier au lieu de parcourir l’arborescence d’héritage. De plus, ils n’utilisent BindingFlags pas de paramètres pour le filtrage. Au lieu de cela, le filtrage se produit dans le code utilisateur, à l’aide de requêtes LINQ sur les collections retournées. Pour les objets de réflexion qui proviennent du runtime (par exemple, comme le résultat de typeof(Object)), la traversée de l’arborescence d’héritage est mieux réalisée à l’aide des méthodes auxiliaires de la classe RuntimeReflectionExtensions. Les consommateurs d’objets issus de contextes de réflexion personnalisés ne peuvent pas utiliser ces méthodes et doivent parcourir eux-mêmes l’arborescence d’héritage.

Restrictions

Dans une application Windows 8.x Store, l’accès à certains types et membres .NET Framework est restreint. Par exemple, vous ne pouvez pas appeler des méthodes .NET Framework qui ne sont pas incluses dans .NET pour les applications du Windows 8.x Store à l’aide d’un MethodInfo objet. En outre, certains types et membres qui ne sont pas considérés comme sécurisés dans le contexte d'une application Windows 8.x Store sont bloqués, ainsi que les membres Marshal et WindowsRuntimeMarshal. Cette restriction affecte uniquement les types et les membres du .NET Framework ; vous pouvez appeler votre code ou votre code tiers comme vous le feriez normalement.

Exemple :

Cet exemple utilise les types et membres de réflexion dans .NET pour Windows 8.x Store pour récupérer les méthodes et propriétés du type Calendar, y compris les méthodes et propriétés héritées. Pour exécuter ce code, collez-le dans le fichier de code d’une page Windows 8.x Store qui contient un Windows.UI.Xaml.Controls.TextBlock contrôle nommé textblock1 dans un projet nommé Reflection. Si vous collez ce code à l’intérieur d’un projet portant un autre nom, veillez simplement à modifier le nom de l’espace de noms pour qu’il corresponde à votre projet.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Navigation;
using System.Reflection;
using System.Globalization;
using System.Text;

namespace Reflection
{
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
           this.InitializeComponent();
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            TypeInfo t = typeof(Calendar).GetTypeInfo();
            IEnumerable<PropertyInfo> pList = t.DeclaredProperties;
            IEnumerable<MethodInfo> mList = t.DeclaredMethods;

            StringBuilder sb = new StringBuilder();

            sb.Append("Properties:");
            foreach (PropertyInfo p in pList)
            {

                sb.Append("\n" + p.DeclaringType.Name + ": " + p.Name);
            }
            sb.Append("\nMethods:");
            foreach (MethodInfo m in mList)
            {
                sb.Append("\n" + m.DeclaringType.Name + ": " + m.Name);
            }

            textblock1.Text = sb.ToString();
        }
    }
}

Imports Windows.UI.Xaml.Navigation
Imports System.Reflection
Imports System.Globalization
Imports System.Text

Public NotInheritable Class MainPage
    Inherits Page

    Protected Overrides Sub OnNavigatedTo(e As NavigationEventArgs)
        Dim t As TypeInfo = GetType(Calendar).GetTypeInfo()
        Dim pList As IEnumerable(Of PropertyInfo) = t.DeclaredProperties
        Dim mList As IEnumerable(Of MethodInfo) = t.DeclaredMethods

        Dim sb As New StringBuilder()

        sb.Append("Properties:")
        For Each p As PropertyInfo In pList

            sb.Append((vbLf + p.DeclaringType.Name & ": ") + p.Name)
        Next
        sb.Append(vbLf & "Methods:")
        For Each m As MethodInfo In mList
            sb.Append((vbLf + m.DeclaringType.Name & ": ") + m.Name)
        Next

        textblock1.Text = sb.ToString()

    End Sub
End Class

Voir aussi

• Réflexion