Type.FindInterfaces(TypeFilter, Object) Méthode

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Type.Helpers.cs

Retourne un tableau d'objets Type représentant une liste filtrée d'interfaces implémentées ou héritées par le Type actuel.

C#

public virtual Type[] FindInterfaces(System.Reflection.TypeFilter filter, object? filterCriteria);

Paramètres

filter

TypeFilter

Délégué qui compare les interfaces à filterCriteria.

filterCriteria

Object

Critère de recherche qui détermine si une interface doit être incluse dans le tableau retourné.

Retours

Type[]

Tableau d’objets Type qui représente une liste filtrée des interfaces implémentées ou héritées par le Type actuel ou un tableau vide si aucune interface correspondant au filtre n’est implémentée ou héritée par le Type actuel.

Exceptions

ArgumentNullException

filter a la valeur null.

TargetInvocationException

Un initialiseur de classe est appelé et lève une exception.

Exemples

L’exemple suivant recherche l’interface spécifiée implémentée ou héritée par le type spécifié, puis affiche les noms d’interface.

C#

using System;
using System.Xml;
using System.Reflection;

public class MyFindInterfacesSample
{
    public static void Main()
    {
        try
        {
            XmlDocument myXMLDoc = new XmlDocument();
            myXMLDoc.LoadXml("<book genre='novel' ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" + "</book>");
            Type myType = myXMLDoc.GetType();

            // Specify the TypeFilter delegate that compares the
            // interfaces against filter criteria.
            TypeFilter myFilter = new TypeFilter(MyInterfaceFilter);
            String[] myInterfaceList = new String[2]
                {"System.Collections.IEnumerable",
                "System.Collections.ICollection"};
            for(int index=0; index < myInterfaceList.Length; index++)
            {
                Type[] myInterfaces = myType.FindInterfaces(myFilter,
                    myInterfaceList[index]);
                if (myInterfaces.Length > 0)
                {
                    Console.WriteLine("\n{0} implements the interface {1}.",
                        myType, myInterfaceList[index]);	
                    for(int j =0;j < myInterfaces.Length;j++)
                        Console.WriteLine("Interfaces supported: {0}.",
                            myInterfaces[j].ToString());
                }
                else
                    Console.WriteLine(
                        "\n{0} does not implement the interface {1}.",
                        myType,myInterfaceList[index]);	
            }
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException: " + e.Message);
        }
        catch(TargetInvocationException e)
        {
            Console.WriteLine("TargetInvocationException: " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: " + e.Message);
        }
    }

    public static bool MyInterfaceFilter(Type typeObj,Object criteriaObj)
    {
        if(typeObj.ToString() == criteriaObj.ToString())
            return true;
        else
            return false;
    }
}

Remarques

Cette méthode peut être remplacée par une classe dérivée.

Les Module.FilterTypeName délégués et Module.FilterTypeNameIgnoreCase fournis par la System.Reflection.Module classe peuvent également être utilisés, à la place du System.Reflection.TypeFilter délégué.

Toutes les interfaces implémentées par cette classe sont prises en compte pendant la recherche, qu’elles soient déclarées par une classe de base ou par cette classe elle-même.

Cette méthode recherche la hiérarchie de classe de base, en retournant chacune des interfaces correspondantes implémentées par chaque classe, ainsi que toutes les interfaces correspondantes implémentées par chacune de ces interfaces (autrement dit, la fermeture transitive des interfaces correspondantes est retournée). Aucune interface en double n’est retournée.

Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, FindInterfaces recherche toutes les interfaces déclarées dans les contraintes sur le paramètre de type et toutes les interfaces héritées via les interfaces déclarées dans les contraintes. Si le actuel Type représente un argument de type générique, FindInterfaces recherche toutes les interfaces implémentées par le type, qu’elles correspondent ou non aux contraintes.

Notes

FindInterfaces peut retourner des interfaces génériques, même sur des types qui ne sont pas génériques. Par exemple, un type non générique peut implémenter IEnumerable<int> (IEnumerable(Of Integer) en Visual Basic).

S’applique à

Voir aussi

• Module
• TypeFilter
• GetInterface(String)
• GetInterfaces()