HttpSimpleClientProtocol.BeginInvoke Método

Referência

Definição

Namespace:: System.Web.Services.Protocols

Assembly:: System.Web.Services.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicia uma invocação assíncrona de um método de um serviço Web XML.

protected:
 IAsyncResult ^ BeginInvoke(System::String ^ methodName, System::String ^ requestUrl, cli::array <System::Object ^> ^ parameters, AsyncCallback ^ callback, System::Object ^ asyncState);

protected IAsyncResult BeginInvoke (string methodName, string requestUrl, object[] parameters, AsyncCallback callback, object asyncState);

member this.BeginInvoke : string * string * obj[] * AsyncCallback * obj -> IAsyncResult

Protected Function BeginInvoke (methodName As String, requestUrl As String, parameters As Object(), callback As AsyncCallback, asyncState As Object) As IAsyncResult

Parâmetros

methodName: String

O nome do método de serviço Web XML.

requestUrl: String

A URL a ser usada durante a criação do WebRequest.

parameters: Object[]

Uma matriz de objetos que contém os parâmetros a serem passados para o método de serviço Web XML. A ordem dos valores na matriz corresponde à ordem dos parâmetros no método de chamada da classe derivada.

callback: AsyncCallback

O delegado a ser chamado quando a chamada de método assíncrono é concluída. Se callback for null, o delegado não será chamado.

asyncState: Object

As informações adicionais fornecidas por um cliente.

Retornos

IAsyncResult

Um IAsyncResult que pode ser passado para o método EndInvoke(IAsyncResult) para obter os valores retornados do método de serviço Web XML.

Exceções

Exception

A solicitação atingiu o computador do servidor, mas não foi processada com êxito.

Exemplos

O exemplo de código a seguir é um ASP.NET Web Form, que chama um serviço Web XML chamado Math. Dentro da EnterBtn_Click função , o Web Form inicia e conclui uma invocação assíncrona do método de Add serviço Web XML.

<%@ Page Language="VB" %>
<html>
    <script language="VB" runat="server">
    Sub EnterBtn_Click(Src As Object, E As EventArgs)
        Dim math As New MyMath.Math()
        
        ' Call to Add XML Web service method asynchronously.
        Dim result As IAsyncResult = math.BeginAdd(Convert.ToInt32(Num1.Text), Convert.ToInt32(Num2.Text), Nothing, Nothing)
        
        ' Wait for the asynchronous call to complete.
        result.AsyncWaitHandle.WaitOne()
        
        ' Complete the asynchronous call to the Add XML Web service method.
        Dim iTotal As Integer = math.EndAdd(result)
        
        Total.Text = "Total: " & iTotal.ToString()
    End Sub 'EnterBtn_Click
 
  </script>
 
    <body>
       <form action="MathClient.aspx" runat=server>
           
          Enter the two numbers you want to add and then press the Total button.
          <p>
          Number 1: <asp:textbox id="Num1" runat=server/>  +
          Number 2: <asp:textbox id="Num2" runat=server/> =
          <asp:button text="Total" Onclick="EnterBtn_Click" runat=server/>
          <p>
          <asp:label id="Total"  runat=server/>
          
       </form>
    </body>
 </html>

O exemplo de código a seguir é uma classe proxy gerada pela ferramenta Linguagem de Descrição dos Serviços Web (Wsdl.exe) para o Math serviço Web XML abaixo. Dentro do BeginAdd método da classe proxy, o BeginInvoke método inicia uma invocação assíncrona do Add método de serviço Web XML.

namespace MyMath
{
   [XmlRootAttribute("snippet1>",Namespace="http://MyMath/",IsNullable=false)]
   public ref class Math: public HttpGetClientProtocol
   {
   public:
      Math()
      {
         this->Url = "http://www.contoso.com/math.asmx";
      }

      [HttpMethodAttribute(System::Web::Services::Protocols::XmlReturnReader::typeid,
      System::Web::Services::Protocols::UrlParameterWriter::typeid)]
      int Add( String^ num1, String^ num2 )
      {
         array<Object^>^temp0 = {num1,num2};
         return  *dynamic_cast<int^>(this->Invoke( "Add", String::Concat( this->Url, "/Add" ), temp0 ));
      }

      IAsyncResult^ BeginAdd( String^ num1, String^ num2, AsyncCallback^ callback, Object^ asyncState )
      {
         array<Object^>^temp1 = {num1,num2};
         return this->BeginInvoke( "Add", String::Concat( this->Url, "/Add" ), temp1, callback, asyncState );
      }

      int EndAdd( IAsyncResult^ asyncResult )
      {
         return  *dynamic_cast<int^>(this->EndInvoke( asyncResult ));
      }
   };
}

namespace MyMath
{
    [XmlRootAttribute("int", Namespace = "http://MyMath/", IsNullable = false)]
    public class Math : HttpGetClientProtocol
    {
        public Math()
        {
            this.Url = "http://www.contoso.com/math.asmx";
        }

        [HttpMethodAttribute(typeof(System.Web.Services.Protocols.XmlReturnReader),
            typeof(System.Web.Services.Protocols.UrlParameterWriter))]
        public int Add(int num1, int num2)
        {
            return ((int)(this.Invoke("Add", ((this.Url) + ("/Add")),
                new object[] { num1, num2 })));
        }

        public IAsyncResult BeginAdd(int num1, int num2, AsyncCallback callback, object asyncState)
        {
            return this.BeginInvoke("Add", ((this.Url) + ("/Add")),
                new object[] { num1, num2 }, callback, asyncState);
        }

        public int EndAdd(IAsyncResult asyncResult)
        {
            return ((int)(this.EndInvoke(asyncResult)));
        }
    }
}

Namespace MyMath
    <XmlRootAttribute("int", Namespace := "http://MyMath/", IsNullable := False)> _
    Public Class Math
        Inherits HttpGetClientProtocol
        
        Public Sub New()
            Me.Url = "http://www.contoso.com/math.asmx"
        End Sub
        
        <HttpMethodAttribute(GetType(XmlReturnReader), GetType(UrlParameterWriter))> _
        Public Function Add(num1 As String, num2 As String) As Integer
            Return CInt(Me.Invoke("Add", Me.Url + "/Add", New Object() {num1, num2}))
        End Function 'Add
        
        
        Public Function BeginAdd(num1 As String, num2 As String, callback As AsyncCallback, asyncState As Object) As IAsyncResult
            Return Me.BeginInvoke("Add", Me.Url + "/Add", New Object() {num1, num2}, callback, asyncState)
        End Function 'BeginAdd
        
        
        Public Function EndAdd(asyncResult As IAsyncResult) As Integer
            Return CInt(Me.EndInvoke(asyncResult))
        End Function 'EndAdd
    End Class
End Namespace 'MyMath

O exemplo de código a seguir é o Math serviço Web XML, do qual a classe proxy anterior foi criada.

<%@ WebService Language="C#" Class="Math"%>
 using System.Web.Services;
 using System;
 
 public class Math {
      [ WebMethod ]
      public int Add(int num1, int num2) {
          return num1+num2;
          }
 }

<%@ WebService Language="VB" Class="Math"%>
Imports System.Web.Services
Imports System

Public Class Math
    <WebMethod()> _
    Public Function Add(num1 As Integer, num2 As Integer) As Integer
        Return num1 + num2
    End Function 'Add
End Class 'Math

Comentários

O methodName parâmetro é usado para localizar os tipos dos parâmetros e os valores retornados do método que está invocando o BeginInvoke método . Ele também é usado para localizar atributos personalizados que podem ter sido adicionados ao método . SoapDocumentMethodAttribute, SoapRpcMethodAttributee XmlElementAttribute fornecem informações adicionais sobre o método derivado necessário para o protocolo HTTP.

asyncState é passado para callback e está incluído no IAsyncResult que é retornado do BeginInvoke método . É útil para passar informações do contexto da chamada assíncrona para o tratamento do resultado assíncrono em callback.

Aplica-se a

Confira também

IAsyncResult

Partilhar via