Type.FindInterfaces-Methode

Artikel
08/20/2007

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)

Syntax

'Declaration
Public Overridable Function FindInterfaces ( _
    filter As TypeFilter, _
    filterCriteria As Object _
) As Type()
'Usage
Dim instance As Type
Dim filter As TypeFilter
Dim filterCriteria As Object
Dim returnValue As Type()

returnValue = instance.FindInterfaces(filter, filterCriteria)

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

public:
virtual array<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.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentNullException	filter ist NULL (Nothing in Visual Basic).
TargetInvocationException	Ein statischer Initialisierer wird aufgerufen und löst eine Ausnahme aus.

Hinweise

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.

Hinweis

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.

Beispiel

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

Imports System
Imports System.Xml
Imports System.Reflection
Imports Microsoft.VisualBasic

Public Class MyFindInterfacesSample
    Public Shared Sub Main()
        Try
            Dim myXMLDoc As New XmlDocument()
            myXMLDoc.LoadXml("<book genre='novel' ISBN='1-861001-57-5'>" _
                & "<title>Pride And Prejudice</title>" & "</book>")
            Dim myType As Type = myXMLDoc.GetType()

            ' Specify the TypeFilter delegate that compares the 
            ' interfaces against filter criteria.
            Dim myFilter As New TypeFilter(AddressOf MyInterfaceFilter)
            Dim myInterfaceList() As String = _
                {"System.Collections.IEnumerable", _
                "System.Collections.ICollection"}
            Dim index As Integer
            For index = 0 To myInterfaceList.Length - 1
                Dim myInterfaces As Type() = _
                    myType.FindInterfaces(myFilter, myInterfaceList(index))
                If myInterfaces.Length > 0 Then
                    Console.WriteLine(ControlChars.Cr & _
                        "{0} implements the interface {1}.", _
                        myType, myInterfaceList(index))
                    Dim j As Integer
                    For j = 0 To myInterfaces.Length - 1
                        Console.WriteLine("Interfaces supported: {0}", _
                            myInterfaces(j).ToString())
                    Next j
                Else
                    Console.WriteLine(ControlChars.Cr & _
                        "{0} does not implement the interface {1}.", _
                        myType, myInterfaceList(index))
                End If
            Next index
        Catch e As ArgumentNullException
            Console.WriteLine("ArgumentNullException: " & e.Message)
        Catch e As TargetInvocationException
            Console.WriteLine("TargetInvocationException: " & e.Message)
        Catch e As Exception
            Console.WriteLine("Exception: " & e.Message)
        End Try
    End Sub 'Main
    Public Shared Function MyInterfaceFilter(ByVal typeObj As Type, _
        ByVal criteriaObj As [Object]) As Boolean
        If typeObj.ToString() = criteriaObj.ToString() Then
            Return True
        Else
            Return False
        End If
    End Function 'MyInterfaceFilter 
End Class 'MyFindInterfacesSample

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

#using <system.xml.dll>

using namespace System;
using namespace System::Xml;
using namespace System::Reflection;
public ref class MyFindInterfacesSample
{
public:
    static bool MyInterfaceFilter(Type^ typeObj, Object^ criteriaObj)
    {
        if(typeObj->ToString()->Equals(criteriaObj->ToString()))
            return true;
        else
            return false;
   }
};

int main()
{
    try
    {
        XmlDocument^ myXMLDoc = gcnew 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 = gcnew TypeFilter( 
            MyFindInterfacesSample::MyInterfaceFilter);
        array<String^>^myInterfaceList = {"System.Collections.IEnumerable",
            "System.Collections.ICollection"};
        for(int index = 0; index < myInterfaceList->Length; index++)
        {
            array<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]);
            }
            else
                Console::WriteLine(
                    "\n{0} does not implement the interface {1}.", 
                    myType, myInterfaceList[index]);

        }
    }
    catch(ArgumentNullException^ e) 
    {
        Console::WriteLine("ArgumentNullException: {0}", e->Message);
    }
    catch(TargetInvocationException^ e) 
    {
        Console::WriteLine("TargetInvocationException: {0}", e->Message);
    }
    catch(Exception^ e) 
    {
        Console::WriteLine("Exception: {0}", e->Message);
    }
}

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

Plattformen

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.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

Type-Klasse
Type-Member
System-Namespace
Module
TypeFilter
GetInterface
GetInterfaces

Freigeben über