Type.FindInterfaces(TypeFilter, Object) Metode

Definisi

Ruang nama:

System

Rakitan:

System.Runtime.dll

Sumber:

Type.Helpers.cs

Mengembalikan array Type objek yang mewakili daftar antarmuka yang difilter yang diimplementasikan atau diwarisi oleh saat ini 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

Delegasi yang membandingkan antarmuka dengan filterCriteria.

filterCriteria

Object

Kriteria pencarian yang menentukan apakah antarmuka harus disertakan dalam array yang dikembalikan.

Mengembalikan

Type[]

Array Type objek yang mewakili daftar antarmuka yang difilter yang diimplementasikan atau diwarisi oleh saat ini Type, atau array kosong jika tidak ada antarmuka yang cocok dengan filter yang diimplementasikan atau diwarisi oleh saat ini Type.

Pengecualian

ArgumentNullException

filteradalah null.

TargetInvocationException

Penginisialisasi statis dipanggil dan melemparkan pengecualian.

Contoh

Contoh berikut menemukan antarmuka yang ditentukan yang diimplementasikan atau diwarisi oleh jenis yang ditentukan, lalu menampilkan nama antarmuka.

#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

Keterangan

Metode ini dapat ditimpa oleh kelas turunan.

Delegasi Module.FilterTypeName dan Module.FilterTypeNameIgnoreCase yang disediakan oleh System.Reflection.Module kelas juga dapat digunakan, sebagai pengganti System.Reflection.TypeFilter delegasi.

Semua antarmuka yang diterapkan oleh kelas ini dipertimbangkan selama pencarian, baik dideklarasikan oleh kelas dasar atau kelas ini sendiri.

Metode ini mencari hierarki kelas dasar, mengembalikan masing-masing antarmuka yang cocok yang diterapkan setiap kelas serta semua antarmuka yang cocok yang diterapkan masing-masing antarmuka tersebut (yaitu, penutupan transitif antarmuka yang cocok dikembalikan). Tidak ada antarmuka duplikat yang dikembalikan.

Jika saat ini Type mewakili parameter jenis dalam definisi jenis generik atau metode generik, FindInterfaces mencari semua antarmuka yang dideklarasikan dalam batasan pada parameter jenis, dan semua antarmuka yang diwarisi melalui antarmuka yang dideklarasikan dalam batasan. Jika saat ini Type mewakili argumen jenis dari jenis generik, FindInterfaces cari semua antarmuka yang diterapkan oleh jenis , apakah cocok dengan batasan atau tidak.

Catatan

FindInterfaces dapat mengembalikan antarmuka generik, bahkan pada jenis yang tidak generik. Misalnya, jenis nongenerik mungkin mengimplementasikan IEnumerable<int> (IEnumerable(Of Integer) di Visual Basic).

Lihat juga

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