Type.FindInterfaces(TypeFilter, Object) Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
public:
virtual cli::array <Type ^> ^ FindInterfaces(System::Reflection::TypeFilter ^ filter, System::Object ^ filterCriteria);public virtual Type[] FindInterfaces (System.Reflection.TypeFilter filter, 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()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
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.
Implementaciones
Excepciones
filter es null.
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.
#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
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
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de