Expandir Minimizar
Este tema aún no ha recibido ninguna valoración - Valorar este tema

Type.FindInterfaces (Método)

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

Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)

public virtual Type[] FindInterfaces (
	TypeFilter filter,
	Object filterCriteria
)
public Type[] FindInterfaces (
	TypeFilter filter, 
	Object filterCriteria
)
public function FindInterfaces (
	filter : TypeFilter, 
	filterCriteria : Object
) : Type[]

Parámetros

filter

Delegado de TypeFilter que compara las interfaces con filterCriteria.

filterCriteria

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

Valor devuelto

Matriz de objetos Type que representa una lista filtrada de las interfaces implementadas o heredadas por el Type actual, o una matriz vacía de tipo Type si no hay ninguna interfaz que coincida con el filtro y que haya sido implementada o heredada por el Type actual.
Tipo de excepciónCondición

ArgumentNullException

El valor de filter es referencia de objeto null (Nothing en Visual Basic).

TargetInvocationException

Se llama a un inicializador estático y éste produce una excepción.

Este método puede ser reemplazado por una clase derivada.

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

Durante la búsqueda se tienen en cuenta todas las interfaces implementadas por esta clase, ya sean declaradas por una clase base o por esta misma clase.

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

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

NotaNota

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

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

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

import System.*;
import System.Xml.*;
import System.Reflection.*;

public class MyFindInterfacesSample
{
    public static void main(String[] args)
    {
        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[] { 
                "System.Collections.IEnumerable",
                "System.Collections.ICollection" };
            for (int index = 0; index < myInterfaceList.length; index++) {
                Type myInterfaces[] = myType.FindInterfaces(myFilter,
                     myInterfaceList.get_Item(index));
                if (myInterfaces.length > 0) {
                    Console.WriteLine("\n{0} implements the interface {1}.",
                        myType, myInterfaceList.get_Item(index));
                    for (int j = 0; j < myInterfaces.length; j++) {
                        Console.WriteLine("Interfaces supported: {0}.",
                            myInterfaces.get_Item(j).ToString());
                    }
                }
                else {
                    Console.WriteLine("\n{0} does not implement the"
                        + " interface {1}.", myType,
                        myInterfaceList.get_Item(index));
                }
            }
        }
        catch (ArgumentNullException e) {
            Console.WriteLine("ArgumentNullException: " + e.get_Message());
        }
        catch (TargetInvocationException e) {
            Console.WriteLine("TargetInvocationException: " + e.get_Message());
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: " + e.get_Message());
        }
    } //main

    public static boolean MyInterfaceFilter(Type typeObj, Object criteriaObj)
    {
        if (typeObj.ToString().Equals(criteriaObj.ToString())) {
            return true;
        }
        else {
            return false;
        }
    } //MyInterfaceFilter
} //MyFindInterfacesSample

Windows 98, Windows 2000 SP4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0
¿Te ha resultado útil?
(Caracteres restantes: 1500)

Adiciones de comunidad

AGREGAR
© 2013 Microsoft. Reservados todos los derechos.