Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Type.FindInterfaces-Methode: (TypeFilter, Object)

 

Veröffentlicht: Oktober 2016

Gibt ein Array von Type-Objekten zurück, die eine gefilterte Liste von Schnittstellen darstellen, die vom aktuellen Type implementiert oder geerbt wurden.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public virtual Type[] FindInterfaces(
	TypeFilter filter,
	object filterCriteria
)

Parameter

filter
Type: System.Reflection.TypeFilter

Der Delegat, der die Schnittstellen anhand der filterCriteria vergleicht.

filterCriteria
Type: System.Object

Die Suchkriterien, die bestimmen, ob eine Schnittstelle in das zurückgegebene Array aufgenommen wird.

Rückgabewert

Type: System.Type[]

Ein Array von Type-Objekten, die eine gefilterte Liste von Schnittstellen darstellt, die durch den aktuellen Type implementiert oder geerbt wurden, oder ein leeres Array vom Typ Type, wenn der aktuelle Type keine dem Filter entsprechenden Schnittstellen implementiert oder erbt.

Exception Condition
ArgumentNullException

filter ist null.

TargetInvocationException

Ein statischer Initialisierer wird aufgerufen und löst eine Ausnahme aus.

Diese Methode kann durch eine abgeleitete Klasse überschrieben werden.

Die Module.FilterTypeName und Module.FilterTypeNameIgnoreCase Delegaten angegeben wird, indem Sie die System.Reflection.Module Klasse kann auch verwendet werden, und in anstelle der der System.Reflection.TypeFilter delegieren.

Alle von dieser Klasse implementierten Schnittstellen werden während der Suche berücksichtigt, ob von einer Basisklasse oder von der Klasse selbst deklariert.

Diese Methode sucht in der Basisklasse-Hierarchie, die Rückgabe aller der entsprechenden Schnittstellen, die jede Klasse, sowie alle entsprechenden implementiert Schnittstellen für jede von diesen Schnittstellen implementiert (d. h. der transitive Abschluss von übereinstimmenden Schnittstellen wird zurückgegeben). Es sind keine doppelten Schnittstellen zurückgegeben.

Wenn die aktuelle Type stellt einen Typparameter in der Definition einer generischen Typ- oder Methodendefinition, FindInterfaces sucht alle Schnittstellen, die in die Einschränkungen für den Typparameter deklariert, und alle Schnittstellen, die durch die Schnittstellen geerbt, die in die Einschränkungen deklariert. Wenn die aktuelle Type stellt ein Typargument eines generischen Typs FindInterfaces sucht alle Schnittstellen, die durch den Typ implementiert, und zwar unabhängig davon, ob sie Einschränkungen entsprechen.

System_CAPS_noteHinweis

FindInterfaceskönnen generische Schnittstellen, auch auf Typen zurückgeben, die nicht generische sind. Beispielsweise kann ein nicht generischer Typ implementieren IEnumerable<int> (IEnumerable(Of Integer) in Visual Basic).

Das folgende Beispiel sucht die angegebene Schnittstelle implementiert oder geerbt werden, durch den angegebenen Typ und zeigt dann die Schnittstellennamen.

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;
    }
}

.NET Framework
Verfügbar seit 1.1
Zurück zum Anfang
Anzeigen: