Type.FindInterfaces(TypeFilter, Object) Methode

Definition

Gibt ein Array von Type-Objekten zurück, die eine gefilterte Liste von Schnittstellen darstellen, die vom aktuellen Type implementiert oder geerbt wurden.Returns an array of Type objects representing a filtered list of interfaces implemented or inherited by the current Type.

public:
 virtual cli::array <Type ^> ^ FindInterfaces(System::Reflection::TypeFilter ^ filter, System::Object ^ filterCriteria);
public virtual Type[] FindInterfaces (System.Reflection.TypeFilter filter, object filterCriteria);
abstract member FindInterfaces : System.Reflection.TypeFilter * obj -> Type[]
override this.FindInterfaces : System.Reflection.TypeFilter * obj -> Type[]
Public Overridable Function FindInterfaces (filter As TypeFilter, filterCriteria As Object) As Type()

Parameter

filter
TypeFilter

Der Delegat, der die Schnittstellen anhand der filterCriteria vergleicht.The delegate that compares the interfaces against filterCriteria.

filterCriteria
Object

Die Suchkriterien, die bestimmen, ob eine Schnittstelle in das zurückgegebene Array aufgenommen wird.The search criteria that determines whether an interface should be included in the returned array.

Gibt zurück

Type[]

Ein Array von Type-Objekten, das eine gefilterte Liste von Schnittstellen darstellt, die durch den aktuellen Type implementiert oder geerbt wurden, oder ein leeres Array, wenn der aktuelle Type keine dem Filter entsprechende Schnittstellen implementiert oder erbt.An array of Type objects representing a filtered list of the interfaces implemented or inherited by the current Type, or an empty array if no interfaces matching the filter are implemented or inherited by the current Type.

Implementiert

Ausnahmen

filter ist null.filter is null.

Ein statischer Initialisierer wird aufgerufen und löst eine Ausnahme aus.A static initializer is invoked and throws an exception.

Beispiele

Im folgenden Beispiel wird die angegebene, vom angegebenen Typ implementierte oder geerbte Schnittstelle gesucht, und dann werden die Schnittstellennamen angezeigt.The following example finds the specified interface implemented or inherited by the specified type, and then displays the interface names.

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

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

Imports System.Xml
Imports System.Reflection

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

Hinweise

Diese Methode kann von einer abgeleiteten Klasse überschrieben werden.This method can be overridden by a derived class.

Die Module.FilterTypeName - Module.FilterTypeNameIgnoreCase und-Delegaten System.Reflection.Module , die von der-Klasse bereitgestellt werden, System.Reflection.TypeFilter können auch anstelle des Delegaten verwendet werden.The Module.FilterTypeName and Module.FilterTypeNameIgnoreCase delegates supplied by the System.Reflection.Module class may also be used, in lieu of the System.Reflection.TypeFilter delegate.

Alle von dieser Klasse implementierten Schnittstellen werden während der Suche berücksichtigt, unabhängig davon, ob Sie von einer Basisklasse oder dieser Klasse deklariert wird.All of the interfaces implemented by this class are considered during the search, whether declared by a base class or this class itself.

Diese Methode durchsucht die Basisklassen Hierarchie und gibt alle übereinstimmenden Schnittstellen zurück, die von jeder Klasse implementiert werden, sowie alle übereinstimmenden Schnittstellen, die diese Schnittstellen implementieren (das heißt, die transitiv Schließung der übereinstimmenden Schnittstellen wird zurückgegeben).This method searches the base class hierarchy, returning each of the matching interfaces each class implements as well as all the matching interfaces each of those interfaces implements (that is, the transitive closure of the matching interfaces is returned). Doppelte Schnittstellen werden nicht zurückgegeben.No duplicate interfaces are returned.

Wenn der aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode FindInterfaces darstellt, durchsucht alle Schnittstellen, die in den Einschränkungen für den Typparameter deklariert sind, und alle Schnittstellen, die über die Schnittstellen geerbt wurden. in den Einschränkungen deklariert.If the current Type represents a type parameter in the definition of a generic type or generic method, FindInterfaces searches all the interfaces declared in the constraints on the type parameter, and all interfaces inherited through the interfaces declared in the constraints. Wenn der aktuelle Type ein Typargument eines generischen Typs FindInterfaces darstellt, durchsucht alle durch den Typ implementierten Schnittstellen, unabhängig davon, ob diese Einschränkungen entsprechen.If the current Type represents a type argument of a generic type, FindInterfaces searches all the interfaces implemented by the type, whether or not they match constraints.

Hinweis

FindInterfaceskann generische Schnittstellen zurückgeben, auch bei Typen, die nicht generisch sind.FindInterfaces can return generic interfaces, even on types that are not generic. Beispielsweise kann ein nicht generischer Typ ( IEnumerable<int> IEnumerable(Of Integer) in Visual Basic) implementieren.For example, a nongeneric type might implement IEnumerable<int> (IEnumerable(Of Integer) in Visual Basic).

Gilt für:

Siehe auch