Erweitern Minimieren
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Type.FindInterfaces-Methode

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
)
public Type[] FindInterfaces (
	TypeFilter filter, 
	Object filterCriteria
)
public function FindInterfaces (
	filter : TypeFilter, 
	filterCriteria : Object
) : Type[]

Parameter

filter

Der TypeFilter-Delegat, der die Schnittstellen mit filterCriteria vergleicht.

filterCriteria

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

Rückgabewert

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.
AusnahmetypBedingung

ArgumentNullException

filter ist NULL (Nothing in Visual Basic).

TargetInvocationException

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

Diese Methode kann von einer abgeleiteten Klasse überschrieben werden.

Anstelle des System.Reflection.TypeFilter-Delegaten können auch der Module.FilterTypeName-Delegat und der Module.FilterTypeNameIgnoreCase-Delegat der System.Reflection.Module-Klasse verwendet werden.

Bei der Suche werden alle von dieser Klasse implementierten Schnittstellen berücksichtigt, unabhängig davon, ob sie von einer Basisklasse oder von der Klasse selbst deklariert wurden.

Diese Methode durchsucht die Hierarchie der Basisklasse und gibt sowohl alle entsprechenden von einer Klasse implementierten Schnittstellen als auch alle entsprechenden Schnittstellen zurück, die von diesen Schnittstellen implementiert werden, d.h., es wird die transitive Hülle der passenden Schnittstellen zurückgegeben. Es werden keine Schnittstellenduplikate zurückgegeben.

Wenn der aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht FindInterfaces alle in den Einschränkungen für den Typparameter deklarierten Schnittstellen sowie alle über die in den Einschränkungen deklarierten Schnittstellen geerbten Schnittstellen. Wenn der aktuelle Type ein Typparameter eines generischen Typs darstellt, durchsucht FindInterfaces alle vom Typ implementierten Schnittstellen unabhängig davon, ob diese den Einschränkungen entsprechen.

HinweisHinweis

FindInterfaces kann generische Schnittstellen zurückgeben, sogar für Typen, die nicht generisch sind. So könnte ein nicht generischer Typ z. B. IEnumerable<int> (IEnumerable(Of Integer) in Visual Basic) implementieren.

Im folgenden Beispiel wird die angegebene Schnittstelle gesucht, die vom angegebenen Typ implementiert oder geerbt wird, und anschließend werden die Schnittstellennamen angezeigt.

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

import System.*;
import System.Xml.*;
import System.Reflection.*;

public class MyFindInterfacesSample
{
    public static void main(String[] args)
    {
        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[] { 
                "System.Collections.IEnumerable",
                "System.Collections.ICollection" };
            for (int index = 0; index < myInterfaceList.length; index++) {
                Type myInterfaces[] = myType.FindInterfaces(myFilter,
                     myInterfaceList.get_Item(index));
                if (myInterfaces.length > 0) {
                    Console.WriteLine("\n{0} implements the interface {1}.",
                        myType, myInterfaceList.get_Item(index));
                    for (int j = 0; j < myInterfaces.length; j++) {
                        Console.WriteLine("Interfaces supported: {0}.",
                            myInterfaces.get_Item(j).ToString());
                    }
                }
                else {
                    Console.WriteLine("\n{0} does not implement the"
                        + " interface {1}.", myType,
                        myInterfaceList.get_Item(index));
                }
            }
        }
        catch (ArgumentNullException e) {
            Console.WriteLine("ArgumentNullException: " + e.get_Message());
        }
        catch (TargetInvocationException e) {
            Console.WriteLine("TargetInvocationException: " + e.get_Message());
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: " + e.get_Message());
        }
    } //main

    public static boolean MyInterfaceFilter(Type typeObj, Object criteriaObj)
    {
        if (typeObj.ToString().Equals(criteriaObj.ToString())) {
            return true;
        }
        else {
            return false;
        }
    } //MyInterfaceFilter
} //MyFindInterfacesSample

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
© 2013 Microsoft. Alle Rechte vorbehalten.