Type.FindInterfaces(TypeFilter, Object) Methode

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

Parameters

Retouren

Een matrix van Type objecten die een gefilterde lijst vertegenwoordigen van de interfaces die zijn geïmplementeerd of overgenomen door de huidige Type, of een lege matrix als er geen interfaces die overeenkomen met het filter worden geïmplementeerd of overgenomen door de huidige Type.

Implementeringen

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de opgegeven interface gevonden die is geïmplementeerd of overgenomen door het opgegeven type en worden vervolgens de interfacenamen weergegeven.

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

Opmerkingen

Deze methode kan worden overschreven door een afgeleide klasse.

De Module.FilterTypeName en Module.FilterTypeNameIgnoreCase gedelegeerden die door de System.Reflection.Module klasse worden geleverd, kunnen ook worden gebruikt in plaats van de System.Reflection.TypeFilter gemachtigde.

Alle interfaces die door deze klasse worden geïmplementeerd, worden tijdens de zoekopdracht meegenomen, ongeacht of ze worden gedeclareerd door een basisklasse of deze klasse zelf.

Met deze methode wordt in de basisklassehiërarchie gezocht, waarbij elk van de overeenkomende interfaces wordt geretourneerd die elke klasse implementeert, evenals alle overeenkomende interfaces die elk van deze interfaces implementeert (de transitieve sluiting van de overeenkomende interfaces wordt geretourneerd). Er worden geen dubbele interfaces geretourneerd.

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, FindInterfaces doorzoekt u alle interfaces die zijn gedeclareerd in de beperkingen van de typeparameter en worden alle interfaces overgenomen via de interfaces die zijn gedeclareerd in de beperkingen. Als de huidige Type een typeargument van een algemeen type vertegenwoordigt, FindInterfaces doorzoekt u alle interfaces die door het type zijn geïmplementeerd, ongeacht of deze overeenkomen met beperkingen.

Zie ook

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