LogicalMethodInfo.Invoke(Object, Object[]) Methode

Definition

Namespace:

System.Web.Services.Protocols

Assembly:

System.Web.Services.dll

Ruft die durch die aktuelle LogicalMethodInfo dargestellte Methode auf.

public:
 cli::array <System::Object ^> ^ Invoke(System::Object ^ target, cli::array <System::Object ^> ^ values);

public object[] Invoke (object target, object[] values);

member this.Invoke : obj * obj[] -> obj[]

Public Function Invoke (target As Object, values As Object()) As Object()

Parameter

target

Object

Die Instanz des Object zum Aufrufen der Methode.

values

Object[]

Eine Argumentliste für die aufgerufene Methode. Dies ist ein Array von Objekten mit derselben Nummer, derselben Reihenfolge und demselben Typ wie die Parameter der Methode. Wenn für die Methode keine Parameter erforderlich sind, sollte der values-Parameter null sein.

Gibt zurück

Object[]

Ein Array vom Typ Object, das den Rückgabewert und die Out-Parameter der aufgerufenen Methode darstellt.

Ausnahmen

TargetException

Der target-Parameter ist null.

ArgumentException

Anzahl, Typ und Reihenfolge der Parameter im values-Parameter stimmen nicht mit der Signatur der aufgerufenen Methode überein.

MemberAccessException

Der Aufrufer verfügt nicht über die Berechtigung zum Aufrufen der Methode.

TargetInvocationException

Die aufgerufene Methode löst eine Ausnahme aus.

Beispiele

#using <System.Web.Services.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Web::Services::Protocols;

public ref class MyService
{
public:
   int Add( int xValue, int yValue )
   {
      return (xValue + yValue);
   }

};

int main()
{
   Type^ myType = MyService::typeid;
   MethodInfo^ myMethodInfo = myType->GetMethod( "Add" );
   LogicalMethodInfo^ myLogicalMethodInfo = gcnew LogicalMethodInfo( myMethodInfo );
   Console::WriteLine( "\nPrinting properties of method : {0}\n", myLogicalMethodInfo );
   Console::WriteLine( "\nThe declaring type of the method {0} is :\n", myLogicalMethodInfo->Name );
   Console::WriteLine( "\t {0}", myLogicalMethodInfo->DeclaringType );
   Console::WriteLine( "\nThe parameters of the method {0} are :\n", myLogicalMethodInfo->Name );
   array<ParameterInfo^>^myParameters = myLogicalMethodInfo->Parameters;
   for ( int i = 0; i < myParameters->Length; i++ )
   {
      Console::WriteLine( "\t {0}", String::Concat( myParameters[ i ]->Name, " : ", myParameters[ i ]->ParameterType ) );
   }
   Console::WriteLine( "\nThe return type of the method {0} is :\n", myLogicalMethodInfo->Name );
   Console::WriteLine( "\t {0}", myLogicalMethodInfo->ReturnType );
   MyService^ service = gcnew MyService;
   Console::WriteLine( "\nInvoking the method {0}\n", myLogicalMethodInfo->Name );
   array<Object^>^values = gcnew array<Object^>(2);
   values[ 0 ] = 10;
   values[ 1 ] = 10;
   Console::WriteLine( "\tThe sum of 10 and 10 is : {0}", myLogicalMethodInfo->Invoke( service, values ) );
}

using System;
using System.Reflection;
using System.Security.Permissions;
using System.Web.Services.Protocols;

public class MyService
{
   public int Add(int xValue, int yValue)
   {
      return (xValue + yValue);
   }
}

class LogicalMethodInfo_Constructor
{
   [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
   static void Run()
   {
      Type myType = typeof(MyService);
      MethodInfo myMethodInfo = myType.GetMethod("Add");
      LogicalMethodInfo myLogicalMethodInfo =
                  new LogicalMethodInfo(myMethodInfo);

      Console.WriteLine("\nPrinting properties of method : {0}\n",
                              myLogicalMethodInfo.ToString());

      Console.WriteLine("\nThe declaring type of the method {0} is :\n",
                              myLogicalMethodInfo.Name);
      Console.WriteLine("\t" + myLogicalMethodInfo.DeclaringType);

      Console.WriteLine("\nThe parameters of the method {0} are :\n",
                              myLogicalMethodInfo.Name);
      ParameterInfo[] myParameters = myLogicalMethodInfo.Parameters;
      for(int i = 0; i < myParameters.Length; i++)
      {
         Console.WriteLine("\t" + myParameters[i].Name +
                                 " : " + myParameters[i].ParameterType);
      }

      Console.WriteLine("\nThe return type of the method {0} is :\n",
                              myLogicalMethodInfo.Name);
      Console.WriteLine("\t" + myLogicalMethodInfo.ReturnType);

      MyService service = new MyService();
      Console.WriteLine("\nInvoking the method {0}\n",
                              myLogicalMethodInfo.Name);
      Console.WriteLine("\tThe sum of 10 and 10 is : {0}",
                              myLogicalMethodInfo.Invoke(service,
                                                   new object[] {10, 10}));
   }

   static void Main()
   {
      Run();
   }
}

Imports System.Reflection
Imports System.Security.Permissions
Imports System.Web.Services.Protocols

Public Class MyService
   
   Public Function Add(xValue As Integer, yValue As Integer) As Integer
      Return xValue + yValue
   End Function 'Add
End Class

Class LogicalMethodInfo_Constructor

<PermissionSetAttribute(SecurityAction.Demand, Name := "FullTrust")>  _
   Shared Sub Run()
      Dim myType As Type = GetType(MyService)
      Dim myMethodInfo As MethodInfo = myType.GetMethod("Add")
      Dim myLogicalMethodInfo As New LogicalMethodInfo(myMethodInfo)
      
      Console.WriteLine(ControlChars.NewLine + "Printing properties of method : {0}" + _
                              ControlChars.NewLine, myLogicalMethodInfo.ToString())
      
      Console.WriteLine(ControlChars.NewLine + "The declaring type of the method {0} is :" + _
                                    ControlChars.NewLine, myLogicalMethodInfo.Name)
      Console.WriteLine(ControlChars.Tab + myLogicalMethodInfo.DeclaringType.ToString())
      
      Console.WriteLine(ControlChars.NewLine + "The parameters of the method {0} are :" + _
                                    ControlChars.NewLine, myLogicalMethodInfo.Name)
      Dim myParameters As ParameterInfo() = myLogicalMethodInfo.Parameters
      Dim i As Integer
      For i = 0 To myParameters.Length - 1
         Console.WriteLine(ControlChars.Tab + myParameters(i).Name + " : " + _
                                                      myParameters(i).ParameterType.ToString())
      Next i
      
      Console.WriteLine(ControlChars.NewLine + "The return type of the method {0} is :" + _
                                             ControlChars.NewLine, myLogicalMethodInfo.Name)
      Console.WriteLine(ControlChars.Tab + myLogicalMethodInfo.ReturnType.ToString())
      
      Dim service As New MyService()
      Console.WriteLine(ControlChars.NewLine + "Invoking the method {0}" + _
                                                ControlChars.NewLine, myLogicalMethodInfo.Name)
      Console.WriteLine(ControlChars.Tab + "The sum of 10 and 10 is : {0}", _
                                    myLogicalMethodInfo.Invoke(service, New Object() {10, 10}))

   End Sub
   
   Shared Sub Main()
      Run()
   End Sub
End Class