Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Método Control.Invoke (Delegate)

 
System_CAPS_noteObservação

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Executa o delegado especificado no thread que possui o identificador de janela subjacente do controle.

Namespace:   System.Windows.Forms
Assembly:  System.Windows.Forms (em System.Windows.Forms.dll)

public object Invoke(
	Delegate method
)

Parâmetros

method
Type: System.Delegate

Um delegado que contém um método a ser chamado no contexto do thread do controle.

Valor Retornado

Type: System.Object

O valor retornado do delegado que está sendo invocado, ou null, se o delegado não tiver nenhum valor retornado.

Delegados são semelhantes a ponteiros de função em linguagens C ou C++. Delegados encapsulam uma referência a um método dentro de um objeto de representante. O objeto do representante pode ser passado para o código que chama o método referenciado e o método a ser invocado pode ser desconhecido no momento da compilação. Ao contrário de ponteiros de função em C ou C++, delegados são orientada a objeto, tipo seguro e mais seguro.

O Invoke método pesquisa cadeia do pai do controle até encontrar um controle ou formulário que tenha uma janela controlar se o identificador de janela subjacente do controle atual ainda não existir. Se nenhum identificador apropriado pode ser encontrado, o Invoke método lançará uma exceção. Exceções geradas durante a chamada serão propagadas de volta para o chamador.

System_CAPS_noteObservação

Além de InvokeRequired propriedade, há quatro métodos em um controle que são thread-safe: Invoke, BeginInvoke, EndInvoke, e CreateGraphics se o identificador para o controle já foi criado. Chamar CreateGraphics antes que o identificador do controle foi criado em um thread em segundo plano pode causar ilegal entre chamadas de thread. Para todas as outras chamadas de método, você deve usar um dos métodos invoke realizar marshaling da chamada para thread do controle.

O representante pode ser uma instância de EventHandler, caso em que o parâmetro do remetente conterá este controle e o parâmetro de evento conterá EventArgs.Empty. O representante também pode ser uma instância de MethodInvoker, ou qualquer outro representante que usa uma lista de parâmetros void. Uma chamada para um EventHandler ou MethodInvoker representante será mais rápido do que uma chamada para outro tipo de delegado.

System_CAPS_noteObservação

Uma exceção pode ser gerada se o thread que deve processar a mensagem não está mais ativo.

O exemplo de código a seguir mostra os controles que contêm um representante. O representante encapsula um método que adiciona itens à caixa de listagem e esse método é executado no thread que possui o identificador subjacente do formulário. Quando o usuário clica no botão, Invoke executa o delegado.

/*
The following example demonstrates the 'Invoke(Delegate)' method of 'Control class.
A 'ListBox' and a 'Button' control are added to a form, containing a delegate
which encapsulates a method that adds items to the listbox.This function is executed
on the thread that owns the underlying handle of the form. When user clicks on button
the above delegate is executed using 'Invoke' method.


*/

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;

   public class MyFormControl : Form
   {
      public delegate void AddListItem();
      public AddListItem myDelegate;
      private Button myButton;
      private Thread myThread;
      private ListBox myListBox;
      public MyFormControl()
      {
         myButton = new Button();
         myListBox = new ListBox();
         myButton.Location = new Point(72, 160);
         myButton.Size = new Size(152, 32);
         myButton.TabIndex = 1;
         myButton.Text = "Add items in list box";
         myButton.Click += new EventHandler(Button_Click);
         myListBox.Location = new Point(48, 32);
         myListBox.Name = "myListBox";
         myListBox.Size = new Size(200, 95);
         myListBox.TabIndex = 2;
         ClientSize = new Size(292, 273);
         Controls.AddRange(new Control[] {myListBox,myButton});
         Text = " 'Control_Invoke' example";
         myDelegate = new AddListItem(AddListItemMethod);
      }
      static void Main()
      {
         MyFormControl myForm = new MyFormControl();
         myForm.ShowDialog();
      }
      public void AddListItemMethod()
      {
         String myItem;
         for(int i=1;i<6;i++)
         {
            myItem = "MyListItem" + i.ToString();
            myListBox.Items.Add(myItem);
            myListBox.Update();
            Thread.Sleep(300);
         }
      }
      private void Button_Click(object sender, EventArgs e)
      {
         myThread = new Thread(new ThreadStart(ThreadFunction));
         myThread.Start();
      }
      private void ThreadFunction()
      {
         MyThreadClass myThreadClassObject  = new MyThreadClass(this);
         myThreadClassObject.Run();
      }
   }

// The following code assumes a 'ListBox' and a 'Button' control are added to a form, 
// containing a delegate which encapsulates a method that adds items to the listbox.

   public class MyThreadClass
   {
      MyFormControl myFormControl1;
      public MyThreadClass(MyFormControl myForm)
      {
         myFormControl1 = myForm;
      }

      public void Run()
      {
         // Execute the specified delegate on the thread that owns
         // 'myFormControl1' control's underlying window handle.
         myFormControl1.Invoke(myFormControl1.myDelegate);
      }
   }

.NET Framework
Disponível desde 1.1
Retornar ao início
Mostrar: