Type.FindInterfaces(TypeFilter, Object) Metodo

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

public virtual Type[] FindInterfaces (System.Reflection.TypeFilter filter, 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()

Parametri

Restituisce

Matrice di oggetti Type che rappresenta un elenco filtrato delle interfacce implementate o ereditate dall'oggetto Type corrente oppure matrice vuota se l'oggetto Type corrente non ha implementato né ereditato interfacce che corrispondono al filtro.

Implementazioni

Eccezioni

Esempio

Nell'esempio seguente viene trovata l'interfaccia specificata implementata o ereditata dal tipo specificato e quindi vengono visualizzati i nomi di interfaccia.

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

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

Commenti

Questo metodo può essere sottoposto a override da una classe derivata.

I Module.FilterTypeName delegati e Module.FilterTypeNameIgnoreCase forniti dalla System.Reflection.Module classe possono essere usati anche al posto del System.Reflection.TypeFilter delegato.

Tutte le interfacce implementate da questa classe vengono considerate durante la ricerca, indipendentemente dal fatto che sia dichiarata da una classe di base o da questa classe stessa.

Questo metodo esegue una ricerca nella gerarchia della classe di base, restituendo ognuna delle interfacce corrispondenti implementate da ogni classe e tutte le interfacce corrispondenti implementate da ognuna di queste interfacce, ovvero viene restituita la chiusura transitiva delle interfacce corrispondenti. Non vengono restituite interfacce duplicate.

Se l'oggetto corrente Type rappresenta un parametro di tipo nella definizione di un tipo generico o di un metodo generico, FindInterfaces cerca tutte le interfacce dichiarate nei vincoli sul parametro di tipo e tutte le interfacce ereditate tramite le interfacce dichiarate nei vincoli. Se l'oggetto corrente Type rappresenta un argomento di tipo di un tipo generico, FindInterfaces esegue una ricerca in tutte le interfacce implementate dal tipo, indipendentemente dal fatto che corrispondano o meno ai vincoli.

Si applica a

Vedi anche

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