how to create thread work with gui

Question

I'm novice in program with c#. I want to create thread that move label in the main UI without stuck the UI until the movement done I built something but it didnt work tell me what is my problem

private void button1_Click(object sender, EventArgs e)
    {
        Thread t = new Thread(Movelb);
        t.IsBackground = true;
        t.Start();enter code here
    }


private void DOsomeThing()
        {
            label2.Visible = true;
            label2.Location = new Point(0, 205);
            for (int i = 0; i < 533; i++)
            {
                label2.Location = new Point(i, 205);
                Thread.Sleep(10);
            }
            label1.Text="false";
        }
private void Movelb()
            {
                if (this.InvokeRequired)
                {
                    threadDel d = new threadDel(DOsomeThing);
                    this.BeginInvoke(d);
                }
                else
                    DOsomeThing();


    }

Answer 1

I also had an idea of doing some work in a thread - and while this hard job was carried out... the main-gui-form should be modified, so the user will spot a progress. Did some lookup and went into "delegates", "eventhandlers", and "very advanced pieces of code". It took me some time to fix, and I came up with this very simple example. Have a look.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ProcessingUI

// You will find a form with "button1": will do some work in a seperate thread, and
//   therefore you are allowed to do action in main-gui-form while this work is done, 
//   due to async. operation.
//   While work is done in seperate thread - the main-gui-form will have a label modified... 
//   having the steps: 1,2,3,0.


// Also found... "button2": will do some work in same thread as gui, and
//   therefore you are not allowed to do action in main-gui-form while this work is done,
//   due to sync. operation (only one thread is established).
//   While work is done in one-and-only-thread - the main-gui-form will have a label modified... 
//   having the steps: 1,2,3,0.


{

    public delegate void UpdateTextDelegate();

    public partial class Form1 : Form
    {

        public delegate void SetStatusText(string statusText);
        public SetStatusText mySetStatusTextDelegate;

        public Form1()
        {
            InitializeComponent();
            mySetStatusTextDelegate = new SetStatusText(SetStatusTextMethod);
        }

        private void button1_Click(object sender, EventArgs e)   // do work from new thread.
        {
            Worker w = new Worker(this);
            Thread thread1 = new Thread(new ThreadStart(w.DoWork));
            thread1.Start();
        }

        private void button2_Click(object sender, EventArgs e)   // do work from local class - form is locked during 1-3 steps.
        {
            SetStatusTextMethod("1");
            Thread.Sleep(3000);

            SetStatusTextMethod("2");
            Thread.Sleep(3000);

            SetStatusTextMethod("3");
            Thread.Sleep(3000);

            SetStatusTextMethod("0");
        }

        public void SetStatusTextMethod(string statusText)
        {
            label1.Text = statusText;
            label1.Refresh();
        }
    }

    public class Worker
    {
        Form1 guiForm;    // holds form where "control-to-be-changes" is found.
        public Worker(Form1 _guiForm)
        {
            guiForm = _guiForm;
        }

        public void DoWork()   // while steps are being done - form can easily be moved around... is not locked!
        {
            // put "1/3" on form.
            guiForm.Invoke(guiForm.mySetStatusTextDelegate, "1");
            Thread.Sleep(3000);

            // put "2/3" on form.
            guiForm.Invoke(guiForm.mySetStatusTextDelegate, "2");
            Thread.Sleep(3000);

            // put "3/3" on form.
            guiForm.Invoke(guiForm.mySetStatusTextDelegate, "3");
            Thread.Sleep(3000);

            guiForm.Invoke(guiForm.mySetStatusTextDelegate, "0");
        }
    }


}

Answer 2

You need to understand the event model first. In event-driven environments like Windows or Android or Linux etc... the "automatic " tasks such as animations of coordinates or other properties are usually done using Timers that keep re-sending events back to the handler that advances the animation/process. In your particular example - if you need to move label, use Widows.Forms.Timer. It is not appropriate to block UI thread that processes events with lengthy tasks as UI thread will stall and your app will freeze or become jerky. NOW, on the other hand there are many cases when adding extra threads DOES help a lot, when? Not in your case, because you only change the coordinate of the label that is nothing in terms of CPU in comparison to repaint, so your solution with extra thread is LESS efficient and much more complex than using timer. An extra thread is beneficial only when the logical work it performs on animation model is comparable or out-weights the paint work- imagine a game where 200 bugs need to be animated on screen according to many logical rules, in this case bug painting may be done in UI thread, but bug property changes/animations may be done in another thread if those computations are intense.

How Events work?

An OS has an infinite loop inside that gets interrupted by keyboard, mouse and other events but the loop spins indefinitely until you shut down Windows (or Android or XWidnws...). At the end of the loop the OS looks at "raw" mouse/key events and dispatches them into appropriate application queue. It knows it by inspecting every app windows list, who is on top and thus it knows what window/app was under such and such X,Y mouse coordinate. When event gets dispatched to your app your job is to handle it very fast and look for another event in your queue (queues are bound to UI Threads/Windows).

How Timers Work? A timer is a special kind of event that OS can keep sending to you periodically from its internal "infinite loop". OS keeps track of what apps requested to be notified and how often - when time comes, it adds a WM_TIMER(on MS Windows) into your windows queue. This way you don't block anything, but get a method in your code that gets called every X milliseconds. When you use .NET Timer class - it is just a wrapper around CreateTimer() KillTimer() (I dont recall exact func names) in Windows User APIs. .NET Timer also knows how to swallow the WM_TIMER and call a C# event/delegate for you.

I hope this helps!

Answer 3

Do not use threads to paint to forms or modify/update form contents. The recommended paradigm in Windows programming is One Thread Per Form or Window. If you want to create forms that run from separate threads, then you must

1. create the new thread first
2. create the Form on the new thread

In this way, the new thread will serve as the new Form's message handler. But even then, you should still do all manipulation of the Form within that thread (and if the form wants to modify contents in another form running on a different thread, then some additional thread-safe communication trickery may be required).

To animate window contents, you should use System.Windows.Forms.Timer instead, which executes on the Form's thread in lock-step with its other messages. You'll need to re-implement your animation as a state machine rather than a for() loop construct, though. That means the variables for Label position will need to be embedded into the Form class, so that updates can be preserved across Timer message invocations.

Answer 4

Your code does nothing useful. It just starts a new background thread, which, in turn, invokes a delegate, being executed at the same UI thread, which had started... the background thread.

In other words, you can't move the label in worker thread, because moving the label brings to repainting, which can't be done from background thread.