Type.FindInterfaces(TypeFilter, Object) Methode

Definition

Namespace:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Quelle:

Type.Helpers.cs

Gibt ein Array von Type Objekten zurück, das eine gefilterte Liste von Schnittstellen darstellt, die von der aktuellen Typeimplementiert oder geerbt werden.

public:
 virtual cli::array <Type ^> ^ FindInterfaces(System::Reflection::TypeFilter ^ filter, System::Object ^ filterCriteria);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces)]
public virtual Type[] FindInterfaces(System.Reflection.TypeFilter filter, object? filterCriteria);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces)>]
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

Die Stellvertretung, mit der die Schnittstellen verglichen filterCriteriawerden.

filterCriteria

Object

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

Gibt zurück

Type[]

Ein Array von Type Objekten, die eine gefilterte Liste der schnittstellen darstellen, die vom aktuellen TypeTypeimplementiert oder geerbt werden, oder ein leeres Array, wenn keine Schnittstellen, die dem Filter entsprechen, implementiert oder geerbt werden.

Attribute

DynamicallyAccessedMembersAttribute

Ausnahmen

ArgumentNullException

filter ist null.

TargetInvocationException

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

Beispiele

Im folgenden Beispiel wird die angegebene Schnittstelle gefunden, 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;
    }
}

open System
open System.Xml
open System.Reflection

let myInterfaceFilter (typeObj: Type) (criteriaObj: obj) =
    string typeObj = string criteriaObj

try
    let myXMLDoc = XmlDocument()
    myXMLDoc.LoadXml("<book genre='novel' ISBN='1-861001-57-5'>" + "<title>Pride And Prejudice</title>" + "</book>")
    let myType = myXMLDoc.GetType()

    // Specify the TypeFilter delegate that compares the
    // interfaces against filter criteria.
    let myFilter = TypeFilter myInterfaceFilter
    let myInterfaceList =
        [ "System.Collections.IEnumerable"
          "System.Collections.ICollection" ]
    for i in myInterfaceList do
        let myInterfaces = myType.FindInterfaces(myFilter, i)
        if myInterfaces.Length > 0 then
            printfn $"\n{myType} implements the interface {i}."
            for j in myInterfaces do
                printfn $"Interfaces supported: {j}."
        else
            printfn $"\n{myType} does not implement the interface {i}."
with
| :? ArgumentNullException as e ->
    printfn $"ArgumentNullException: {e.Message}"
| :? TargetInvocationException as e ->
    printfn $"TargetInvocationException: {e.Message}"
| e ->
    printfn $"Exception: {e.Message}"

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.

Die Module.FilterTypeName von der Module.FilterTypeNameIgnoreCase Klasse bereitgestellten Stellvertretungen und System.Reflection.Module Stellvertretungen können auch anstelle der System.Reflection.TypeFilter Stellvertretung verwendet werden.

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

Diese Methode durchsucht die Basisklassenhierarchie und gibt jede der übereinstimmenden Schnittstellen zurück, die jede Klasse implementiert, sowie alle übereinstimmenden Schnittstellen, die jede dieser Schnittstellen implementiert (d. a. die transitive Schließung der übereinstimmenden Schnittstellen wird zurückgegeben). Es werden keine doppelten Schnittstellen zurückgegeben.

Wenn der aktuelle Type Parameter einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht alle Schnittstellen, FindInterfaces die in den Einschränkungen für den Typparameter deklariert sind, und alle Schnittstellen, die durch die in den Einschränkungen deklarierten Schnittstellen geerbt wurden. Wenn der aktuelle Wert ein Typargument eines generischen Type Typs darstellt, FindInterfaces werden alle vom Typ implementierten Schnittstellen durchsucht, unabhängig davon, ob sie mit Einschränkungen übereinstimmen.

Note

FindInterfaces kann generische Schnittstellen zurückgeben, auch bei Typen, die nicht generisch sind. Beispielsweise kann ein nichtgenerischer Typ IEnumerable<int> implementieren (IEnumerable(Of Integer) in Visual Basic).

Weitere Informationen

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