MethodBase.GetParameters Methode

Definition

Ruft beim Überschreiben in einer abgeleiteten Klasse die Parameter der angegebenen Methode oder des angegebenen Konstruktors ab.When overridden in a derived class, gets the parameters of the specified method or constructor.

public:
 abstract cli::array <System::Reflection::ParameterInfo ^> ^ GetParameters();
public abstract System.Reflection.ParameterInfo[] GetParameters ();
abstract member GetParameters : unit -> System.Reflection.ParameterInfo[]
Public MustOverride Function GetParameters () As ParameterInfo()

Gibt zurück

Ein Array vom Typ ParameterInfo, das Informationen enthält, die mit der Signatur der durch diese MethodBase-Instanz reflektierten Methode (oder des Konstruktors) übereinstimmen.An array of type ParameterInfo containing information that matches the signature of the method (or constructor) reflected by this MethodBase instance.

Implementiert

Beispiele

Im folgenden Beispiel wird die GetParameters-Methode verwendet, um die Parameter der Invoke-Methode eines Delegaten abzurufen.The following example uses the GetParameters method to retrieve the parameters of the Invoke method of a delegate.

Im Beispiel wird ein Delegat mit dem Namen MyDelegate und ein Ereignis namens ev vom Typ MyDelegatedefiniert.The example defines a delegate named MyDelegate and an event named ev of type MyDelegate. Der Code in der Main-Methode ermittelt die Ereignis Signatur durch Abrufen des Delegattyps des Ereignisses, Abrufen der Invoke-Methode des Delegattyps und anschließendes Abrufen und Anzeigen der Parameter.The code in the Main method discovers the event signature by getting the delegate type of the event, getting the Invoke method of the delegate type, and then retrieving and displaying the parameters.

// The following example uses instances of classes in
// the System::Reflection namespace to discover an event argument type.
using namespace System;
using namespace System::Reflection;

public delegate void MyDelegate( int i );
public ref class MainClass
{
public:
   event MyDelegate^ ev;
};

int main()
{
   Type^ delegateType = MainClass::typeid->GetEvent( "ev" )->EventHandlerType;
   MethodInfo^ invoke = delegateType->GetMethod( "Invoke" );
   array<ParameterInfo^>^pars = invoke->GetParameters();
   System::Collections::IEnumerator^ myEnum = pars->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      ParameterInfo^ p = safe_cast<ParameterInfo^>(myEnum->Current);
      Console::WriteLine( p->ParameterType );
   }
}
// The example displays the following output:
//       System.Int32
// The following example uses instances of classes in 
// the System.Reflection namespace to discover an event argument type.
using System;
using System.Reflection;

public delegate void MyDelegate(int i);
public class MainClass 
{
    public event MyDelegate ev;

    public static void Main() 
    {
        Type delegateType = typeof(MainClass).GetEvent("ev").EventHandlerType;
        MethodInfo invoke = delegateType.GetMethod("Invoke");
        ParameterInfo[] pars = invoke.GetParameters();
        foreach (ParameterInfo p in pars) 
        {
            Console.WriteLine(p.ParameterType);
        }
    }
}
// The example displays the following output:
//       System.Int32
Imports System.Reflection

Public Delegate Sub MyDelegate(ByVal i As Integer)

Public Class MainClass
    Public Event ev As MyDelegate

    Public Shared Sub Main()
        Dim delegateType As Type = GetType(MainClass).GetEvent("ev").EventHandlerType
        Dim invoke As MethodInfo = delegateType.GetMethod("Invoke")
        Dim pars As ParameterInfo() = invoke.GetParameters()
        For Each p As ParameterInfo In pars
            Console.WriteLine(p.ParameterType)
        Next 
    End Sub 
End Class 
' The example displays the following output:
'     System.Int32

Gilt für:

Siehe auch