Como: Manipular controles a partir de threads

Artigo
08/25/2010

The BackgroundWorker componente substitui e acrescenta funcionalidade para o BeginInvoke método; no entanto, o BeginInvoke método é mantido para compatibilidade com versões anteriores e para uso futuro, se você escolher. Para obter mais informações, consulte BackgroundWorker componente Overview.

Multithreading é mais adequado para executar procedimentos intensivo de processador dos módulos de classe.Ao contrário dos outros componentes, existem problemas com chamando diretamente métodos em controles de segmentos separados.Métodos que afetam controles devem ser executados somente no thread no qual o controle foi criado.Como o empacotamento de chamadas de um thread e enviá-las entre os limites do segmento para outro é muito caro em termos de recursos do sistema, você deve evitar repetidamente fazer chamadas a controles em outros segmentos.Na melhor das hipóteses, chamadas diretas de outros threads são caras e o desempenho do seu aplicativo será afetada.Na pior das hipóteses, podem ocorrer condições que causam um deadlock no aplicativo, congelar execução.

No entanto, pode haver ocasiões em que quando você desejar telefonar métodos de controles de seus threads.Por exemplo, talvez telefonar um método que desativa um botão ou atualiza uma exibição em um formulário em resposta a ação realizada por um thread.O .NET estrutura fornece métodos que são seguros para telefonar de qualquer segmento para chamar métodos que interagem com os controles pertencentes a outros segmentos.The Invoke método permite a execução assíncrono de métodos nos controles, enquanto o BeginInvoke método inicia a execução assíncrono. Para usar esses métodos, você deve declarar um delegado com a mesma assinatura do método que você invocando.E, em seguida, você pode telefonar o Invoke ou BeginInvoke método de qualquer controle no formulário, fornecendo o delegado apropriado para o método que você deseja telefonar. Todos os parâmetros obrigatórios são encapsulados em um Object e transmitido ao método.

Para chamar métodos que envolvem controles pertencentes a outros threads

Declare um delegado com uma assinatura idêntico ao método que deseja invocar.

O exemplo a seguir mostra como declarar um delegado com Integer e String parâmetros.
```
Public Delegate Sub myDelegate(ByVal anInteger as Integer, ByVal _
   aString as String)
```
```
public delegate void myDelegate(int anInteger, string aString);
```
Use qualquer controle para chamar métodos que manipulam controles pertencentes a outros segmentos.

Observação:

Parâmetros (se houver) necessários para o método podem ser fornecidos dentro de um Object.
- Se você deseja chamar métodos de forma síncrona, telefonar o Método controle.Invoke.
```
Label1.Invoke(New myDelegate(AddressOf myMethod), New _
   Object() {1, "This is the string"})
```
```
Label1.Invoke(new myDelegate(myMethod), new Object[] {1,
   "This is the string"});
```
- Se você deseja chamar métodos de forma assíncrona, entre em contato com o Método controle.BeginInvoke.
```
Label1.BeginInvoke(New myDelegate(AddressOf myMethod), _
   New Object() {1, "This is the string"})
```
```
Label1.BeginInvoke(new myDelegate(myMethod), new 
Object[] {1, "This is the string"});
```

Observação:
Parâmetros (se houver) necessários para o método podem ser fornecidos dentro de um Object.

Consulte também

Compartilhar via

Como: Manipular controles a partir de threads

Para chamar métodos que envolvem controles pertencentes a outros threads

Consulte também

Tarefas

Conceitos

Referência

Outros recursos

Recursos adicionais