Como chamar um método translation from VPE for Csharp Visual de maneira assíncrona

Traduções deste artigo Traduções deste artigo
ID do artigo: 315582 - Exibir os produtos aos quais esse artigo se aplica.
Expandir tudo | Recolher tudo

Neste artigo

Sumário

O Microsoft .NET Framework torna mais fácil chamar funções de forma assíncrona. Chamar funções de forma assíncrona faz com que o sistema de executá-los no plano de fundo em um thread secundário, enquanto a função de chamada continuará a fazer outro trabalho. Em uma chamada típica função (síncrona), a função é executada imediatamente no mesmo thread que fez a chamada. A função de chamada aguarda a chamada concluir e recebe os resultados da chamada antes de continuar. Por outro lado, quando você faz uma chamada assíncrona, recupere os resultados da chamada assíncrona mais tarde. Este artigo demonstra como fazer isso usando translation from VPE for Csharp Visual.

Requisitos


A lista a seguir descreve o hardware recomendado, software, infra-estrutura de rede e service packs são necessários:
  • Microsoft Windows 2000 ou Microsoft Windows XP ou Microsoft Windows Server 2003
  • O Visual Studio .NET ou Visual Studio 2005
Este artigo pressupõe que você esteja familiarizado com os seguintes tópicos:
  • Chamando métodos no Visual translation from VPE for Csharp
  • Como usar delegados

Como fazer chamadas assíncronas

Chamadas assíncronas são feitas usando delegados. Um delegado é um objeto que encapsula uma função. Delegados fornecem uma função síncrona e também fornecem métodos para chamar a função quebra automática de forma assíncrona. Esses métodos são BeginInvoke() e EndInvoke() . As listas de parâmetro desses métodos variam dependendo da assinatura da função que envolve o representante. Observe que o Visual Studio recurso IntelliSense do .NET não exibe BeginInvoke() e EndInvoke() , para que você não ver apareçam na função listas à medida que você digita.

BeginInvoke() é usado para iniciar a chamada assíncrona. Ele tem os mesmos parâmetros da função de quebra automática, além de dois parâmetros adicionais que irão ser descritos posteriormente neste artigo. BeginInvoke() retorna imediatamente e não espere a chamada assíncrona concluir. BeginInvoke() retorna um objeto de IAsyncResult .

A função EndInvoke() é usada para recuperar os resultados da chamada assíncrona. Ele pode ser chamado a qualquer momento após BeginInvoke() . Se a chamada assíncrona não tiver concluído ainda, EndInvoke() blocos até que ela seja concluída. Os parâmetros da função EndInvoke() inclui o out e ref parâmetros que tem a função de quebra automática mais o objeto IAsyncResult retornado pelo BeginInvoke() .

A seguir está um exemplo de um delegado e seus métodos BeginInvoke() e EndInvoke() :
// The following delegate 
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;

// will have the following BeginInvoke() and EndInvoke methods:
IAsyncResult MethodDelegate.BeginInvoke(int iCallTime, out int iExecThread, AsyncCallback cb, object AsyncState); 

string MethodDelegate.EndInvoke (out int iExecThread, IAsyncResult ar) ;
				
há quatro formas comuns de usar BeginInvoke() e EndInvoke() para fazer chamadas assíncronas. Depois de chamar BeginInvoke() , você pode:
  • Opcionalmente algum outro trabalho e, em seguida, usar EndInvoke() .
  • Obter um WaitHandle fornecido pelo objeto IAsyncResult , use o método WaitOne para bloquear até que o WaitHandle é sinalizado e, em seguida, chamar EndInvoke() .
  • Pesquise o objeto IAsyncResult para determinar quando a chamada assíncrona for concluída e depois chamar EndInvoke() .
  • Que o sistema de chamar uma função de retorno de chamada que você especificar. Esta função de retorno de chamada chama EndInvoke() e processa os resultados da chamada assíncrona quando ela for concluída.
Os exemplos de código a seguir demonstram esses chamam padrões e contrastem-los com uma chamada síncrona usando a seguinte função:
string LongRunningMethod (int iCallTime, out int iExecThread)
{
	Thread.Sleep (iCallTime) ;
	iExecThread = AppDomain.GetCurrentThreadId ();
	return "MyCallTime was " + iCallTime.ToString() ;
}

				
LongRunningMethod() simula uma função que é executado por tempo por dormindo. Ele retorna o tempo de suspensão e a identificação do thread que executa. Se você chamá-lo assincronamente, você encontrar que o identificador do segmento do thread em execução é diferente do que o thread de chamada.

A primeira etapa é definir o delegado que encapsula a função:
delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;
				

Exemplo 1: Chamar um método de maneira síncrona

Este exemplo demonstra como chamar LongRunningMethod() maneira síncrona usando um representante MethodDelegate . Outros exemplos Compare isso fazendo chamadas de forma assíncrona.
  1. Inicie o Microsoft Visual Studio .NET ou Microsoft Visual Studio 2005.
  2. Crie um novo projeto de Visual translation from VPE for Csharp Console Application chamado AsyncDemo.
  3. Adicionar uma classe chamada AsyncDemo é definido como a seguir para o projeto em um novo arquivo .cs:
    using System;
    using System.Threading ; 
    using System.Windows.Forms ;
    
    public class AsyncDemo
    {
    	string LongRunningMethod (int iCallTime, out int iExecThread)
    	{
    		Thread.Sleep (iCallTime) ;
    		iExecThread = AppDomain.GetCurrentThreadId ();
    		return "MyCallTime was " + iCallTime.ToString() ;
    	}
    
    	delegate string MethodDelegate(int iCallTime, out int iExecThread)  ;
    
    	public void DemoSyncCall()
    	{
    		string s ;
    		int iExecThread;
    
    		// Create an instance of a delegate that wraps LongRunningMethod.
    		MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;  
    			
    		// Call LongRunningMethod using the delegate.
    		s = dlgt(3000, out iExecThread);  
    			
    		MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\", 
                                            and the thread ID {1}", s, iExecThread.ToString() ) );
    	}
    }
    					
    mais tarde, essa classe demonstra como fazer chamadas assíncronas. Inicialmente, no entanto, ele só contém o método DemoSyncCall() , que demonstra como chamar o delegado em sincronia.
  4. Adicione o seguinte código no corpo da função principal que o Visual Studio cria automaticamente no seu projeto:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoSyncCall() ;
    }
    					
  5. Pressione CTRL+F5 para executar seu aplicativo.

Exemplo 2: Chamar um método de forma assíncrona usando o padrão de chamada EndInvoke()

Nesta seção, o exemplo chama o mesmo método assíncrona. O padrão de chamada é usado é chamada BeginInvoke , fazer algumas trabalhar no thread principal e, em seguida, chamar EndInvoke() . Observe que EndInvoke() não retorna até que a chamada assíncrona seja concluída. Esse padrão de chamada é útil quando você deseja ter o thread de chamada trabalhar ao mesmo tempo que a chamada assíncrona está em execução. Ter trabalho ocorrer ao mesmo tempo pode melhorar o desempenho de vários aplicativos. Tarefas comuns para execução assíncrona dessa forma são operações de arquivo ou na rede.
  1. Adicione um método chamado DemoEndInvoke() à classe AsyncDemo . A função DemoEndInvoke demonstra como chamar o delegado assincronamente.
    public void DemoEndInvoke()
    {
    	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;
    	string s ;
    	int iExecThread;
    
    	// Initiate the asynchronous call.
    	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null);  
    
    	// Do some useful work here. This would be work you want to have
    	// run at the same time as the asynchronous call.
    
    	// Retrieve the results of the asynchronous call.
    	s = dlgt.EndInvoke (out iExecThread, ar) ;  
    
    	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\", 
                                   and the number {1}", s, iExecThread.ToString() ) );
    }
    					
  2. Edite o código-fonte para principal para que contenha o código a seguir:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoEndInvoke() ;
    }
    					
  3. Pressione CTRL+F5 para executar seu aplicativo.

Exemplo 3: Chamar um método de forma assíncrona e usando um WaitHandle para aguardar para a chamada para concluir


Nesta seção, o exemplo chama o método de forma assíncrona e aguarda um WaitHandle antes de chamar EndInvoke() . O IAsyncResult retornado pelo BeginInvoke() tem uma propriedade AsyncWaitHandle . Essa propriedade retornará um WaitHandle que é sinalizado quando a chamada assíncrona for concluída. Aguardando um WaitHandle é uma técnica de sincronização de segmento comum. O thread de chamada aguarda WaitHandle usando o método WaitOne() de WaitHandle . blocos de WaitOne() até WaitHandle é sinalizado. Quando WaitOne() retorna, você pode fazer algum trabalho adicional antes de chamar EndInvoke() . Como no exemplo anterior, essa técnica é útil para executar operações de arquivo ou na rede caso contrário poderiam bloquear o thread principal chamado.
  1. Adicione uma função chamada DemoWaitHandle() à classe AsyncDemo . A função DemoWaitHandle() demonstra como chamar o delegado assincronamente.
    public void DemoWaitHandle ()
    {
    	string s ;
    	int iExecThread;
    
    	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;
    
    	// Initiate the asynchronous call.
    	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null); 
    
    	// Do some useful work here. This would be work you want to have
    	// run at the same time as the asynchronous call.
    
    	// Wait for the WaitHandle to become signaled.
    	ar.AsyncWaitHandle.WaitOne() ;
    
    	// Get the results of the asynchronous call.
    	s = dlgt.EndInvoke (out iExecThread, ar) ;
    			
    	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\", 
                                     and the number {1}", s, iExecThread.ToString() ) );
    }
    					
  2. Edite o código-fonte para principal para que contenha o código a seguir:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoWaitHandle () ;
    }
    					
  3. Pressione CTRL+F5 para executar seu aplicativo.

Exemplo 4: Chamar um método de forma assíncrona usando o padrão de pesquisa chamada

Nesta seção, o exemplo monitora o objeto IAsyncResult para saber quando a chamada assíncrona for concluída. O objeto IAsyncResult retornado pelo BeginInvoke() tem uma propriedade IsCompleted que retorna True após a chamada assíncrona. Em seguida, você pode chamar EndInvoke() . Esse padrão de chamada é útil se o aplicativo faz o trabalho contínuo que deseja ter bloqueado por uma chamada de função de execução demorada. Um aplicativo do Microsoft Windows é um exemplo disso. O thread principal do aplicativo Windows pode continuar a lidar com entrada do usuário enquanto executa uma chamada assíncrona. Ele pode verificar periodicamente IsCompleted para ver se a chamada foi concluída. Ele chama EndInvoke quando IsCompleted retorna True . Porque EndInvoke() bloqueia até que a operação assíncrona seja concluída, o aplicativo não chama-lo até que ele sabe que a operação é concluída.
  1. Adicione uma função chamada DemoPolling() à classe AsyncDemo . A função DemoPolling() demonstra como chamar o delegado assincronamente e usar a pesquisa para ver se o processo for concluído.
    public void DemoPolling()
    {
    	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;
    	string s ;
    	int iExecThread;
    
    	// Initiate the asynchronous call.
    	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, null, null); 
    
    	// Poll IAsyncResult.IsCompleted
    	while(ar.IsCompleted == false)
    	{
    		Thread.Sleep (10) ;  // pretend to so some useful work
    	}
    	s = dlgt.EndInvoke (out iExecThread, ar) ;
    
    	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\", 
                                    and the number {1}", s, iExecThread.ToString() ) );
    }
    
    					
  2. Edite o código-fonte para principal . Substituir o conteúdo da função com o seguinte código:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoPolling () ;
    }
    					
  3. Pressione CTRL+F5 para executar seu aplicativo.

Exemplo 5: Executar um retorno de chamada quando conclui um método assíncrono

Nesta seção, o exemplo fornece um delegado de retorno de chamada para a função BeginInvoke() que o sistema executa quando a chamada assíncrona for concluída. O retorno de chamada chama EndInvoke() e processa os resultados da chamada assíncrona. Esse padrão de chamada é útil se o segmento que inicia a chamada assíncrona não precisa processar os resultados da chamada. O sistema chama o retorno de chamada em um thread diferente do thread de inicialização quando a chamada assíncrona for concluída.

Para usar esse padrão de chamada, você deve passar um delegado do tipo AsyncCallback como o segundo ao último parâmetro da função BeginInvoke() . BeginInvoke() também tem um parâmetro final do objeto no qual você pode passar qualquer objeto digite. Este objeto está disponível para sua função de retorno de chamada quando é chamado. Um uso importante para este parâmetro é passar o delegado é usado para iniciar a chamada. A função de retorno de chamada, em seguida, pode utilizar a função EndInvoke() desse delegado para completar a chamada. Esse padrão de chamada é demonstrado abaixo.
  1. Adicione um dois métodos chamados DemoCallback() e MyAsyncCallback() à classe AsyncDemo . O método DemoCallback() demonstra como chamar o delegado assincronamente. Ele usa um delegado para quebrar o método MyAsyncCallback() , que o sistema chama quando a operação assíncrona for concluída. MyAsyncCallback() chama EndInvoke() .
    public void DemoCallback()
    {
    	MethodDelegate dlgt = new MethodDelegate (this.LongRunningMethod) ;
    	string s ;
    	int iExecThread;
    
    	// Create the callback delegate.
    	AsyncCallback cb = new AsyncCallback(MyAsyncCallback);
    
    	// Initiate the Asynchronous call passing in the callback delegate
    	// and the delegate object used to initiate the call.
    	IAsyncResult ar = dlgt.BeginInvoke(3000, out iExecThread, cb, dlgt); 
    }
    
    public void MyAsyncCallback(IAsyncResult ar)
    {
    	string s ;
    	int iExecThread ;
    
    	// Because you passed your original delegate in the asyncState parameter
    	// of the Begin call, you can get it back here to complete the call.
    	MethodDelegate dlgt = (MethodDelegate) ar.AsyncState;
    
    	// Complete the call.
    	s = dlgt.EndInvoke (out iExecThread, ar) ;
    
    	MessageBox.Show (string.Format ("The delegate call returned the string:   \"{0}\", 
                                    and the number {1}", s, iExecThread.ToString() ) );
    }
    
    					
  2. Edite o código-fonte para principal . Substituir o conteúdo da função com o seguinte código:
    static void Main(string[] args)
    {
    	AsyncDemo ad = new AsyncDemo () ;
    	ad.DemoCallback() ;
    }
    					
  3. Pressione CTRL+F5 para executar seu aplicativo.

Propriedades

ID do artigo: 315582 - Última revisão: segunda-feira, 11 de dezembro de 2006 - Revisão: 4.3
A informação contida neste artigo aplica-se a:
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
Palavras-chave: 
kbmt kbhowtomaster KB315582 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 315582

Submeter comentários

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com