Type.FindInterfaces(TypeFilter, Object) Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Type.Helpers.cs

Geçerli Typetarafından uygulanan veya devralınan Type arabirimlerin filtrelenmiş listesini temsil eden bir nesne dizisi döndürür.

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

Parametreler

filter

TypeFilter

Arabirimleri ile filterCriteriakarşılaştıran temsilci.

filterCriteria

Object

Bir arabirimin döndürülen diziye dahil edilip edilmeyeceğini belirleyen arama ölçütleri.

Döndürülenler

Type[]

Geçerli tarafından uygulanan veya devralınan arabirimlerin filtrelenmiş listesini temsil eden bir nesne dizisi Type veya geçerli TypeTypetarafından filtreyle eşleşen arabirim uygulanmaz veya devralınmazsa boş bir dizi.

Öznitelikler

DynamicallyAccessedMembersAttribute

Özel durumlar

ArgumentNullException

filter, null'e eşittir.

TargetInvocationException

Statik başlatıcı çağrılır ve bir özel durum oluşturur.

Örnekler

Aşağıdaki örnek, belirtilen tür tarafından uygulanan veya devralınan belirtilen arabirimi bulur ve ardından arabirim adlarını görüntüler.

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

Açıklamalar

Bu yöntem türetilmiş bir sınıf tarafından geçersiz kılınabilir.

Module.FilterTypeName sınıfı tarafından Module.FilterTypeNameIgnoreCase sağlanan ve System.Reflection.Module temsilcileri, temsilci yerine System.Reflection.TypeFilter de kullanılabilir.

Bu sınıf tarafından uygulanan tüm arabirimler, bir temel sınıf veya bu sınıfın kendisi tarafından bildirilen arama sırasında dikkate alınır.

Bu yöntem, her sınıfın uyguladığı eşleşen arabirimlerin yanı sıra bu arabirimlerin her birinin uyguladığı tüm eşleşen arabirimleri (eşleşen arabirimlerin geçişli kapanışı) döndürerek temel sınıf hiyerarşisinde arama yapar. Yinelenen arabirim döndürülmüyor.

Geçerli Type , genel bir tür veya genel yöntemin tanımında tür parametresini temsil ederse, FindInterfaces tür parametresindeki kısıtlamalarda bildirilen tüm arabirimleri ve kısıtlamalarda bildirilen arabirimler aracılığıyla devralınan tüm arabirimleri arar. Geçerli Type , genel bir türün tür bağımsız değişkenini temsil ederse, FindInterfaces kısıtlamalarla eşleşse de eşleşmese de türü tarafından uygulanan tüm arabirimleri arar.

Note

FindInterfaces genel olmayan türlerde bile genel arabirimler döndürebilir. Örneğin, genel olmayan bir tür IEnumerable<int> (Visual Basic'da IEnumerable(Of Integer)) uygulayabilir.

Ayrıca bkz.

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