Type.FindInterfaces(TypeFilter, Object) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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()Parameter
- filter
- TypeFilter
Der Delegat, der die Schnittstellen anhand der filterCriteria vergleicht.
- filterCriteria
- Object
Die Suchkriterien, die bestimmen, ob eine Schnittstelle in das zurückgegebene Array aufgenommen wird.
Gibt zurück
Ein Array von Type-Objekten, das eine gefilterte Liste von Schnittstellen darstellt, die durch den aktuellen Type implementiert oder geerbt wurden, oder ein leeres Array, wenn der aktuelle Type keine dem Filter entsprechende Schnittstellen implementiert oder erbt.
Implementiert
Ausnahmen
filter ist null.
Ein statischer Initialisierer wird aufgerufen und löst eine Ausnahme aus.
Beispiele
Im folgenden Beispiel wird die angegebene Schnittstelle durch den angegebenen Typ implementiert oder geerbt, und dann werden die Schnittstellennamen angezeigt.
#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
Hinweise
Diese Methode kann von einer abgeleiteten Klasse überschrieben werden.
Die Module.FilterTypeName von der System.Reflection.Module Klasse bereitgestellten Delegaten und Module.FilterTypeNameIgnoreCase können auch anstelle des System.Reflection.TypeFilter Delegaten verwendet werden.
Alle von dieser Klasse implementierten Schnittstellen werden während der Suche berücksichtigt, unabhängig davon, ob sie von einer Basisklasse oder von dieser Klasse selbst deklariert wurden.
Diese Methode durchsucht die Basisklassenhierarchie und gibt jede der übereinstimmenden Schnittstellen zurück, die jede Klasse implementiert, sowie alle übereinstimmenden Schnittstellen, die jede dieser Schnittstellen implementiert (d. a. die transitive Schließung der übereinstimmenden Schnittstellen wird zurückgegeben). Es werden keine doppelten Schnittstellen zurückgegeben.
Wenn der aktuelle einen Typparameter in der Definition eines generischen Typs oder einer generischen Type Methode darstellt, durchsucht alle Schnittstellen, FindInterfaces die in den Einschränkungen für den Typparameter deklariert sind, und alle Schnittstellen, die über die in den Einschränkungen deklarierten Schnittstellen geerbt werden. Wenn das aktuelle ein Typargument eines generischen Type Typs darstellt, durchsucht alle Schnittstellen, FindInterfaces die vom Typ implementiert werden, unabhängig davon, ob sie mit Einschränkungen übereinstimmen oder nicht.
Hinweis
FindInterfaces kann generische Schnittstellen zurückgeben, auch für Typen, die nicht generisch sind. Beispielsweise kann ein nicht generischer Typ (IEnumerable(Of Integer) in Visual Basic) implementieren IEnumerable<int> .
Gilt für:
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für