C# Form.Invoke方法代码示例

        public override void Run(ServiceController[] services, Form mainForm, DataGrid serviceGrid)
        {
            var addedMachine = QuickDialog2.DoQuickDialog("Add A Machine's Services", "Machine Name:",".","Pattern  ^(Enable|EPX):","");

            if (addedMachine != null)
            {

                MachineName = addedMachine[0];
                this.SearchPattern = addedMachine[1];
                try
                {
                    DataGrid dgrid = serviceGrid;

                    this.addView = (DataView)dgrid.DataSource;

                    CurrencyManager bm = (CurrencyManager)dgrid.BindingContext[this.addView];
                    ArrayList arrSelectedRows = new ArrayList();

                    this.addView = (DataView)bm.List;

                    mainForm.Invoke(new InvokeDelegate(this.AddMachineInGUIThread));

                    serviceGrid.Refresh();

                }
                finally
                {
                    addedMachine = null;
                    addView = null;
                }

            }
        }

        public MainWindow(Form parent, OGameBot bot, UGInfos forumInfos)
        {
            _bot = bot;
            _parent = parent;
            InitializeComponent();
            forumUserLabel.Text = @"User: " + forumInfos.User;
            forumUIDLabel.Text = @"Post: " + forumInfos.Post;
            forumPostLabel.Text = @"UID: " + forumInfos.UID;
            forumStatusLabel.Text = @"Status: " + forumInfos.Status;
            PopulateAddBuildingList();

            _bot.BeganBuild += (o, b) => DisplayLogMessage(@"Iniziata la costruzione di " + b.GetDescription());

            _bot.Built += (o, b) =>
                              {
                                  DisplayLogMessage(@"Terminata la costruzione di " + b.GetDescription());
                                  buildingListView.Invoke(new Action(() => buildingListView.Items.RemoveAt(0)));
                              };

            _bot.BuildingUnavaiable += (o, b) => DisplayLogMessage(@"Non puoi costruire " + b.GetDescription() + ", verrà spostato in fondo alla coda.");
            _bot.NotEnoughResources += (o, b) =>
                                           {
                                               if (_notEnoughResourcesCount == 0)
                                                   DisplayLogMessage(@"Risorse non sufficenti per " + b.GetDescription() +
                                                                     ", in attesa");
                                               _notEnoughResourcesCount = ++_notEnoughResourcesCount%20;
                                           };

            _bot.InConstruction += o =>
                                       {
                                           if (_inConstructionCount == 0)
                                               DisplayLogMessage(
                                                   @"E' già presente un edificio in costruzione, in attesa");
                                           _inConstructionCount = ++_inConstructionCount%20;
                                       };
            _bot.Stopped += o => _parent.Invoke(new Action(Close));
        }

 public static void Close(Form form)
 {
     if (form.InvokeRequired)
         form.Invoke(new CloseDelegate(Close), form);
     else
         form.Close();
 }

 /// <summary>
 /// Will open a form that will ask for connection details (with option for default props) and attempt to ping target to see if it is possible to establish connection
 /// </summary>
 /// <param name="parent">Parent form that this form will be opened on</param>
 /// <param name="default_details">The default connection details to be inserted</param>
 /// <param name="forceTesting"></param>
 public static ConnectionDetails GetDetails(Form parent, ConnectionDetails default_details, bool forceTesting = true) {
     UserConnectionDetailsRequester getter = null;
     parent.Invoke(() => {
                       getter = new UserConnectionDetailsRequester(forceTesting, default_details);
                       getter.ShowDialog(parent);
                   });
     return getter.Results();
 }

        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="mainApplicationForm">The application's main form</param>
        public UIActor(Form mainApplicationForm)
        {
            m_applicationForm = mainApplicationForm;

            m_applicationForm.Invoke((Action)(() =>
            {
                if (Actor.CurrentActor != null) Actor.CurrentActor = this;
            }));
        }

			private delegate void ShowErrorCallback(Form frmWindow, string strMessage, Exception objException); // Permite llamadas asíncronas para mostrar un mensaje
			
		/// <summary>
		///		Muestra un cuadro de mensaje
		/// </summary>
		public static void ShowMessage(Form frmWindow, string strMessage)
		{ // InvokeRequired compara el ID del hilo llamante con el ID del hilo creador, si son diferentes devuelve True
				if (frmWindow != null && frmWindow.InvokeRequired)
					{	ShowMessageCallback fncCallback = new ShowMessageCallback(ShowMessage);
					
							frmWindow.Invoke(fncCallback, new object[] { frmWindow, strMessage });
					}
				else
					MessageBox.Show(frmWindow, strMessage, Application.ProductName);
		}

 public DrawingSystem(Form form, EntityManager manager)
     : base(manager)
 {
     _form = form;
     _form.Invoke(new Action(() =>
     {
         _context = BufferedGraphicsManager.Current;
         _buffer = _context.Allocate(_form.CreateGraphics(), _form.DisplayRectangle);
     }));
 }

 public static void CloseForm(Form form)
 {
     // Check if the form need to be invoked.
     if (form.InvokeRequired)
         // Invoke the form with the appropiate delegate.
         form.Invoke(new Action<Form>(CloseForm), form);
     else
         // Directly close the form.
         form.Close();
 }

 public static void Invoke(Form form, AsyncAction action)
 {
     if (!form.InvokeRequired)
     {
         action();
     }
     else
     {
         form.Invoke((DispatcherInvoker)Invoke, form, action);
     }
 }

 public static void SetText(Form form, Control ctrl, string text)
 {
     if (ctrl.InvokeRequired)
     {
         SetTextCallback stc = SetText;
         form.Invoke(stc, new object[] {form, ctrl, text});
     }
     else
     {
         ctrl.Text = text;
     }
 }

        /// <summary>
        /// Initializes a new GameWindow class.
        /// </summary>
        /// <param name="handle">The Handle.</param>
        internal GameWindow(IntPtr handle)
        {
            _surface = (Form) Control.FromHandle(handle);
            _surfaceStyle = SurfaceStyle.Normal;
            _surfaceLayout = new SurfaceLayout(true, false, true);
            CursorVisibility = false;
            _surface.FormClosing += _surface_FormClosing;
            _surface.Activated += _surface_Activated;
            _surface.Deactivate += _surface_Deactivate;

            MethodInvoker br = delegate { _surface.KeyPreview = true; };
            _surface.Invoke(br);
        }

		/// <summary>
		/// Safely retrieves the window's handle. The events the InstanceManager are on a separate thread
		/// forcing us to marshall the calls back to the window's thread.
		/// </summary>
		/// <param name="window">The window to retrieve the handle for.</param>
		/// <returns></returns>
		public static IntPtr SafeGetWindowHandle(Form window)
		{
			if (window == null)
			{
				return IntPtr.Zero;
			}

			if (window.InvokeRequired)
			{
				return (IntPtr)window.Invoke(new GetWindowHandleDelegate(SafeGetWindowHandle), window);
			}

			return window.Handle;
		}

        private static void ActivateParentForm(Form parentForm)
        {
            if (parentForm != null)
            {
                //HandleRef href = new HandleRef(ParentForm, ParentForm.Handle);
                //SetForegroundWindow(href);

                parentForm.Invoke(new Action(() => { parentForm.Activate(); }));
            }
            else if (ApplicationService.Current.MainForm != null)
            {
                ApplicationService.Current.MainForm.Invoke(new Action(() => { ApplicationService.Current.MainForm.Activate(); }));
            }
        }

 public void PrintText(string txt, TextBox printBox, Form owner)
 {
     if (printBox.InvokeRequired)
     {
         invokeTextBox d = new invokeTextBox(PrintText);
         owner.Invoke(d, txt, printBox, owner);
     }
     else
     {
         printBox.Text += txt;
         printBox.Select(printBox.Text.Length, 0);
         printBox.ScrollToCaret();
     }
 }

        public static void SetControlText(this Control control, Form CFrom, string text)
        {
            if (CFrom.InvokeRequired)
            {
                ControlTextMethod controlTextMethod = SetControlText;
                CFrom.Invoke(controlTextMethod, new object[] { control, CFrom, text });
            }
            else
            {
                control.Text = text;
            }

            Application.DoEvents();
        }