Task - run on UI thread (update UI)

Working with Tasks is pretty easy. You can do very easy things that would be pretty complicated to do using threads. In today post I want to talk a little bit about UI threads and tasks.
If you are working on a Windows Store App, Windows Phone or WPF application then you will have the following case:
From a task I want to be able to update a UI component (a label for example).
By default this is not possible, if you are trying to run the task from the UI thread then you don’t resolve the problem. The task will still run on the UI thread and if you have a long task then you will block the UI.
The solution is to run only the lines of code that update the UI components on a task that runs on UI. If the code that updates the UI is at the end of the task then you can have something like this:

var blueTask = Task<string>.Run(() =>
  {
    ...
    return value;
  })
  .ContinueWith(value =>
  {
    ...
    this.MyLabel.Text = value;
  }, TaskScheduler.FromCurrentSynchronizationContext());

If the code has to display a dialog box and you need a response then you can create a task inside your task that runs on the UI task:

var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext;
var blueTask = Task<string>.Run(() =>
  {
    ...
     await Task.Factory.StartNew(
              () => this.MyLabel.Text = value,
              CancellationToken.None, TaskCreationOptions.None, uiScheduler);

    return value;
  });

Enjoy!

Read More

Lambda expression and threads

If you are working with C# I’m pretty sure that you used a lambda expression (an action, a predicate, a delegate or a function). Basically you can define a block of code inline (function) and execute this code when you need it.
For all of you, that already used this features of C# I have a simple question:
     Does the lambda expression executes on the same thread or is executing on a different thread?
This information can be very important because running code on a different thread can be expensive. Not only this, there are times when we can have content that is static on the thread and not on our current process.
The simplest way to check this is to write a simple console application that displays the thread id.

class Program
{
    static void Main(string[] args)
    {
        DisplayCurrentThreadId();
        Action myAction = DisplayCurrentThreadId;
        myAction.Invoke();
        myAction.Invoke();
        DisplayCurrentThreadId();

        Console.ReadKey();
    }

    static void DisplayCurrentThreadId()
   {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
    }
}

The output of this was:

We saw that the lambda expression is executed on the same thread.
But what do you think about calling a lambda expression in an async manner? Does the code be executed on the same thread or on a different thread? To be able to test this we will modify our test code:

class Program
{
    static void Main(string[] args)
    {
        DisplayCurrentThreadId();
        Action myAction = DisplayCurrentThreadId;
        myAction.BeginInvoke(new AsyncCallback((r) => { }), null);
        myAction.BeginInvoke(new AsyncCallback((r) => { }), null);
        DisplayCurrentThreadId();
        Console.ReadKey();
    }
    static void DisplayCurrentThreadId()
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
    }
}

The output is:

By calling more than one time the lambda expression in an async method we can notice that there are cases when the async calls are executed on the same thread or on different thread. This thread are managed by .NET core and are reused when is possible.
In conclusion, executing a lambda expression in a sync way will execute the code on the same thread as the caller.

Read More

Cand sa folosim System.Thread.Timer

In .NET putem sa alegem din 3 tipuri de timer:

• System.Timer - thread timer;
• System.Thread.Timer - server base timer;
• System.Windows.Forms.Timer - windows base timer;

System.Windows.Forms.Timer se foloseste in general pe UI, cand trebuie sa facem update. System.Timer o sa il folosim de obicei de obicei pe partea de server cand vrem mai multe flexibilitate si mai mult optiuni. Din cele trei timer-uri, acesta are cele mai multe optiuni.
System.Thread.Timer, care rulează un nou thread pentru operațiile sale. Acesta este folositor când vrem sa facem operații asyncron.

System.Threading.Timer timer = new System.Threading.Timer(new TimerCallback(ExecutaCeva), null, 0, 2000);
...
private void ExecutaCeva(object obj)
{
....
}

Pentru a face disable/enable putem sa folosim:
timer.Change(Timeout.Infinite, Timeout.Infinite); //Disable.
timer.Change(0, 2000); //Enable.
Cea ce mi s-a parut foarte folositor la acest imer sunt parametrii lui Change si ultimii doi parametrii a contructorului. Prin intermediul lor putem sa specificam dupa ce perioada sa se apeleze metoda ExecutaCeva, iar apoi la ce interval de timp aceasta sa fie executa.
Sunt cazuri cand vrem ca primul apel ExecutaCeva sa fie facut dupa 1 secunda, iar apoi timer-ul sa apeleze aceasta metoda la 10 secunte. Pentru acest lucru daac am folostii System.Timer ar fi nevoie sa oprim timer-ul dupa prima executie, sa setam din nou intervalul de timp, iar apoi sa îl pornim din nou.

System.Thread.Timer ne permite sa facem in felul urmator:
System.Threading.Timer timer = new System.Threading.Timer(new TimerCallback(ExecutaCeva), null, 1000,10000);

varianta care o prefer eu este:

System.Threading.Timer timer = new System.Threading.Timer(new TimerCallback(ExecutaCeva), null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(10));

Este bine de stiut ca orice moment cand apelam metoda Change, timpul pana cand se apeleaza ExecutaCeva se modifica. Daca prima valoare este 0, atunci metoda pentru callback se apeleaza imediat, iar daca este Timer.Infinite atunci timer-ul este disable.
Cand al doilea parametru este 0 sau Timer.Infine, atuci timer-ul se executa o singura data.

Read More