Type.FindInterfaces(TypeFilter, Object) Método

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

Type.Helpers.cs

Devuelve una matriz de objetos Type que representa una lista filtrada de interfaces implementadas o heredadas por el objeto Type actual.

C#

public virtual Type[] FindInterfaces(System.Reflection.TypeFilter filter, object? filterCriteria);

Parámetros

filter

TypeFilter

Delegado que compara las interfaces con filterCriteria.

filterCriteria

Object

Criterios de búsqueda que determinan si una interfaz se debe incluir en la matriz devuelta.

Devoluciones

Type[]

Matriz de objetos Type que representa una lista filtrada de las interfaces implementadas o heredadas por el objeto Type actual, o bien una matriz vacía si el objeto Type actual no implementa ni hereda ninguna interfaz que coincida con el filtro.

Excepciones

ArgumentNullException

filter es null.

TargetInvocationException

Se invoca un inicializador estático y produce una excepción.

Ejemplos

En el ejemplo siguiente se busca la interfaz especificada implementada o heredada por el tipo especificado y, a continuación, se muestran los nombres de interfaz.

C#

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

Comentarios

Este método se puede invalidar mediante una clase derivada.

También se pueden usar los Module.FilterTypeName delegados y Module.FilterTypeNameIgnoreCase proporcionados por la System.Reflection.Module clase , en lugar del System.Reflection.TypeFilter delegado.

Todas las interfaces implementadas por esta clase se consideran durante la búsqueda, ya sea declaradas por una clase base o por esta clase en sí.

Este método busca en la jerarquía de clases base, devolviendo cada una de las interfaces coincidentes que implementa cada clase, así como todas las interfaces coincidentes que implementa cada una de esas interfaces (es decir, se devuelve el cierre transitivo de las interfaces coincidentes). No se devuelven interfaces duplicadas.

Si el actual Type representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, FindInterfaces busca en todas las interfaces declaradas en las restricciones en el parámetro de tipo y todas las interfaces heredadas a través de las interfaces declaradas en las restricciones. Si el objeto actual Type representa un argumento de tipo de un tipo genérico, FindInterfaces busca en todas las interfaces implementadas por el tipo, independientemente de si coinciden o no con restricciones.

Nota

FindInterfaces puede devolver interfaces genéricas, incluso en tipos que no son genéricos. Por ejemplo, un tipo no genérico podría implementar IEnumerable<int> (IEnumerable(Of Integer) en Visual Basic).

Se aplica a

Consulte también

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