Método Type.FindInterfaces() en C# con ejemplos

El método Type.FindInterfaces(TypeFilter, Object) se usa para devolver una array de objetos Type que representa una lista filtrada de interfaces implementadas o heredadas por el Type actual . Todas las interfaces implementadas por esta clase se consideran durante la búsqueda, ya sean declaradas por una clase base o por esta clase misma.
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.

Sintaxis:

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

Parámetros:

  • filter : el delegado que compara las interfaces con filterCriteria .
  • filterCriteria : el criterio de búsqueda que determina si una interfaz debe incluirse en la array devuelta.

Valor de retorno: este método devuelve una array de objetos de tipo que representan una lista filtrada de las interfaces implementadas o heredadas por el tipo actual, o una array vacía de tipo Type si el tipo actual no implementa o hereda ninguna interfaz que coincida con el filtro.

Excepción: este método lanza ArgumentNullException si el filtro es nulo.

Los siguientes programas ilustran el uso del método mencionado anteriormente:

Ejemplo 1:

// C# program to demonstrate the
// Type.FindInterfaces(TypeFilter,
// Object) Method
using System;
using System.Globalization;
using System.Reflection;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
  
        // Creating try-catch block 
        // to handle exceptions
        try {
  
            // Declaring and initializing 
            // object Type Datatype
            Type type = typeof(System.String);
  
            // Declaring and initializing the object 
            // of TypeFilter Datatype which help the
            // delegate that compares the interfaces 
            // against filterCriteria
            TypeFilter myFilter = new TypeFilter(MyInterfaceFilter);
  
            // Declaring and initializing filterCriteria 
            // object. It is used to search the criteria 
            // that determines whether an interface should
            // be included in the returned array.
            object filterCriteria = "System.Collections.IEnumerable";
  
            // Getting the filtered list of interface
            // using FindInterfaces() method
            Type[] myInterfaces = type.FindInterfaces(myFilter,
                                               filterCriteria);
  
            // Display the interfaces
            for (int j = 0; j < myInterfaces.Length; j++)
                Console.WriteLine("filtered list of interface : {0}.",
                                          myInterfaces[j].ToString());
        }
  
        // catch ArgumentNullException here
        catch (ArgumentNullException e) 
        {
            Console.Write("Exception Thrown: ");
            Console.Write("{0}", e.GetType(), e.Message);
        }
    }
  
    // Defining MyInterfaceFilter
    // which helps to fix the certain 
    // condition on which filtration
    // took place
    public static bool MyInterfaceFilter(Type typeObj,
                                   Object criteriaObj)
    {
        if (typeObj.ToString() == criteriaObj.ToString())
            return true;
        else
            return false;
    }
}
Producción:

filtered list of interface : System.Collections.IEnumerable.

Ejemplo 2:

// C# program to demonstrate the
// Type.FindInterfaces(TypeFilter,
// Object) Method
using System;
using System.Globalization;
using System.Reflection;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // Creating try-catch block 
        // to handle exceptions
        try {
  
            // Declaring and initializing 
            // object Type Datatype
            Type type = typeof(System.String);
  
            // Declaring and initializing object 
            // of TypeFilter Datatype
            // which help the delegate that compares
            // the interfaces against filterCriteria.
            TypeFilter myFilter = null;
  
            // Declaring and initializing filterCriteria 
            // object. It is used to search the criteria 
            // that determines whether an interface should
            // be included in the returned array.
            object filterCriteria = "System.Collections.IEnumerable";
  
            // Getting the filtered list of interface
            // using FindInterfaces() method
            Type[] myInterfaces = type.FindInterfaces(myFilter,
                                               filterCriteria);
  
            // Display the interfaces
            for (int j = 0; j < myInterfaces.Length; j++)
                Console.WriteLine("filtered list of interface : {0}.",
                                          myInterfaces[j].ToString());
        }
  
        // catch ArgumentNullException here
        catch (ArgumentNullException e) 
       {
            Console.WriteLine("myFilter should not be null");
            Console.Write("Exception Thrown: ");
            Console.Write("{0}", e.GetType(), e.Message);
        }
    }
}
Producción:

myFilter should not be null
Exception Thrown: System.ArgumentNullException

Referencia:

Publicación traducida automáticamente

Artículo escrito por RohitPrasad3 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *