LogicalMethodInfo.InParameters-Eigenschaft

Ruft die Parameter ab, die an die durch die Instanz von LogicalMethodInfo dargestellte Methode übergeben werden.

Namespace: System.Web.Services.Protocols
Assembly: System.Web.Services (in system.web.services.dll)

Syntax

'Declaration
Public ReadOnly Property InParameters As ParameterInfo()
'Usage
Dim instance As LogicalMethodInfo
Dim value As ParameterInfo()

value = instance.InParameters

public ParameterInfo[] InParameters { get; }

public:
property array<ParameterInfo^>^ InParameters {
    array<ParameterInfo^>^ get ();
}

/** @property */
public ParameterInfo[] get_InParameters ()

public function get InParameters () : ParameterInfo[]

Eigenschaftenwert

Ein Array vom Typ ParameterInfo mit den Parametern, die an die durch die Instanz von LogicalMethodInfo dargestellte Methode übergeben werden.

Hinweise

Verwenden Sie eine Instanz von ParameterInfo, um Informationen über den Datentyp des Parameters, den Standardwert usw. abzurufen.

InParameters gibt ein Array von ParameterInfo-Objekten zurück, die die an eine Methode übergebenen Parameter in der Übergabereihenfolge darstellen.

Beispiel

Imports System
Imports System.Reflection
Imports System.Web.Services.Protocols
Imports Microsoft.VisualBasic

Public Class MyService
   
   Public Sub MyMethod(inParameter As Integer, ByRef outParameter As Integer)
      outParameter = inParameter
   End Sub 'MyMethod
End Class 'MyService

Public Class LogicalMethodInfo_Create
   
   Public Shared Sub Main()
      Dim myType As Type = GetType(MyService)
      Dim myMethodInfo As MethodInfo = myType.GetMethod("MyMethod")
      Dim myLogicalMethodInfo As LogicalMethodInfo = _
                             LogicalMethodInfo.Create(New MethodInfo() {myMethodInfo})(0)
      
      Console.WriteLine _
        (ControlChars.Newline + "Printing parameters for the method : {0}", myLogicalMethodInfo.Name)
      
      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 in parameters of the method {0} are :" + _
                                               ControlChars.Newline, myLogicalMethodInfo.Name)
      myParameters = myLogicalMethodInfo.InParameters

      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 out parameters of the method {0} are :" + _
                                                    ControlChars.Newline, myLogicalMethodInfo.Name)
      myParameters = myLogicalMethodInfo.OutParameters

      For i = 0 To myParameters.Length - 1
         Console.WriteLine(ControlChars.Tab + myParameters(i).Name + " : " + _
                                                     myParameters(i).ParameterType.toString())
      Next i
      
      If myLogicalMethodInfo.IsVoid Then
         Console.WriteLine(ControlChars.Newline + "The return type is void")
      Else
         Console.WriteLine _
             (ControlChars.Newline + "The return type is {0}", myLogicalMethodInfo.ReturnType)
      End If
   End Sub 'Main 
End Class 'LogicalMethodInfo_Create

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

public class MyService
{
   public void MyMethod(int inParameter, out int outParameter)
   {
      outParameter = inParameter;
   }
}

public class LogicalMethodInfo_Create
{
   public static void Main()
   {
      Type myType = typeof(MyService);
      MethodInfo myMethodInfo = myType.GetMethod("MyMethod");
      LogicalMethodInfo myLogicalMethodInfo = 
         (LogicalMethodInfo.Create(new MethodInfo[] {myMethodInfo}))[0];

      Console.WriteLine("\nPrinting parameters for the method : {0}",
                           myLogicalMethodInfo.Name);

      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 in parameters of the method {0} are :\n",
         myLogicalMethodInfo.Name);
      myParameters = myLogicalMethodInfo.InParameters;
      for(int i = 0; i < myParameters.Length; i++)
      {
         Console.WriteLine("\t" + myParameters[i].Name +
            " : " + myParameters[i].ParameterType);
      }

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

      if(myLogicalMethodInfo.IsVoid)
         Console.WriteLine("\nThe return type is void");
      else
         Console.WriteLine("\nThe return type is {0}",
                                 myLogicalMethodInfo.ReturnType);

   }
}

#using <System.Web.Services.dll>

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

public ref class MyService
{
public:
   void MyMethod( int inParameter, [Out]interior_ptr<int> outParameter )
   {
       *outParameter = inParameter;
   }
};

int main()
{
   Type^ myType = MyService::typeid;
   MethodInfo^ myMethodInfo = myType->GetMethod( "MyMethod" );
   array<MethodInfo^>^temparray = {myMethodInfo};
   LogicalMethodInfo^ myLogicalMethodInfo = (LogicalMethodInfo::Create( temparray ))[ 0 ];
   Console::WriteLine( "\nPrinting parameters for the method : {0}", myLogicalMethodInfo->Name );
   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( String::Concat( "\t ", myParameters[ i ]->Name, " : ", myParameters[ i ]->ParameterType ) );

   }
   Console::WriteLine( "\nThe in parameters of the method {0} are :\n", myLogicalMethodInfo->Name );
   myParameters = myLogicalMethodInfo->InParameters;
   for ( int i = 0; i < myParameters->Length; i++ )
   {
      Console::WriteLine( String::Concat( "\t ", myParameters[ i ]->Name, " : ", myParameters[ i ]->ParameterType ) );

   }
   Console::WriteLine( "\nThe out parameters of the method {0} are :\n", myLogicalMethodInfo->Name );
   myParameters = myLogicalMethodInfo->OutParameters;
   for ( int i = 0; i < myParameters->Length; i++ )
   {
      Console::WriteLine( String::Concat( "\t ", myParameters[ i ]->Name, " : ", myParameters[ i ]->ParameterType ) );

   }
   if ( myLogicalMethodInfo->IsVoid )
      Console::WriteLine( "\nThe return type is void" );
   else
      Console::WriteLine( "\nThe return type is {0}", myLogicalMethodInfo->ReturnType );
}

import System.*;
import System.Reflection.*;
import System.Web.Services.Protocols.*;
public class MyService
{
    public void MyMethod(int inParameter, /** @ref */int outParameter)
    {
        outParameter = inParameter;
    } //MyMethod
} //MyService

public class LogicalMethodInfo_Create
{
    public static void main(String[] args)
    {
        Type myType = MyService.class.ToType();
        MethodInfo myMethodInfo = myType.GetMethod("MyMethod");
        LogicalMethodInfo myLogicalMethodInfo = (LogicalMethodInfo)
            LogicalMethodInfo.Create(new MethodInfo[] { myMethodInfo }).
            get_Item(0);

        Console.WriteLine("\nPrinting parameters for the method : {0}", 
            myLogicalMethodInfo.get_Name());
        Console.WriteLine("\nThe parameters of the method {0} are :\n", 
            myLogicalMethodInfo.get_Name());
        ParameterInfo myParameters[] = myLogicalMethodInfo.get_Parameters();
        for (int i = 0; i < myParameters.length; i++) {
            Console.WriteLine("\t"  
                + ((ParameterInfo)myParameters.get_Item(i)).get_Name() + " : "  
                + ((ParameterInfo)myParameters.get_Item(i)).get_ParameterType());
        }

        Console.WriteLine("\nThe in parameters of the method {0} are :\n", 
            myLogicalMethodInfo.get_Name());
        myParameters = myLogicalMethodInfo.get_InParameters();
        for (int i = 0; i < myParameters.length; i++) {
            Console.WriteLine("\t" 
                + ((ParameterInfo)myParameters.get_Item(i)).get_Name() + " : " 
                + ((ParameterInfo)myParameters.get_Item(i)).
                get_ParameterType());
        }

        Console.WriteLine("\nThe out parameters of the method {0} are :\n", 
            myLogicalMethodInfo.get_Name());
        myParameters = myLogicalMethodInfo.get_OutParameters();
        for (int i = 0; i < myParameters.length; i++) {
            Console.WriteLine("\t"  
                + ((ParameterInfo)myParameters.get_Item(i)).get_Name() + " : " 
                + ((ParameterInfo)myParameters.get_Item(i)).
                get_ParameterType());
        }

        if (myLogicalMethodInfo.get_IsVoid()) {
            Console.WriteLine("\nThe return type is void");
        }
        else {
            Console.WriteLine("\nThe return type is {0}", 
                myLogicalMethodInfo.get_ReturnType());
        }
    } //main 
} //LogicalMethodInfo_Create

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

LogicalMethodInfo-Klasse
LogicalMethodInfo-Member
System.Web.Services.Protocols-Namespace
Parameters
OutParameters