How to update a GameObject before launch of external process.

Hi to everyone.
My issue follows:
I’ve created a canvas in a scene. This canvas contains a message for the user like “process is working”. This canvas is setted as not Active and I set it as Active before the launch of an external process. The problem is that the process starts and dies (it take some seconds) before that canvas is shown. Is there a way to wait some time for canvas showing?
Tanks to all (and sorry for my English ^^)

[update]
Heilà?! No one have a solution for my issue?

First of all, see How do you keep your game running even when you switch out of it? - Questions & Answers - Unity Discussions

Otherwise the engine will stop when you switch out to the launched process.

Then you can use a thread to run the process without locking unity; but remember unity is single threaded; you must push the results back to the ‘main thread’ before you do anything with it.

For example:

using UnityEngine;
using System;
using System.Threading;
using System.Diagnostics;
using System.Collections.Generic;

/// A mutex controlled bidirection <U, V> pump to a remote thread
public class Channel<U, V> {

  /// The remote channel instance
  public Channel<V, U> remote;

  /// Lock
  private Mutex lock_;

  /// The U queue for the remote side
  private Queue<V> incoming = new Queue<V>();

  public Channel() {
    lock_ = new Mutex();
    remote = new Channel<V, U>(lock_, this);
  }

  public Channel(Mutex m, Channel<V, U> remote) {
    lock_ = m;
    this.remote = remote;
  }

  /// Add an object into our local incoming object pool
  public void Receive(V value) {
    lock_.WaitOne();
    incoming.Enqueue(value);
    lock_.ReleaseMutex();
  }

  public void Push(U value) {
    remote.Receive(value);
  }

  public V Pop() {
    lock_.WaitOne();
    if (incoming.Count > 0) {
      return incoming.Dequeue();
    }
    lock_.ReleaseMutex();
    return default(V);
  }
}

/// A remote thread task
public abstract class Task<U, V> {

  /// The thread instance
  private Thread thread;

  /// The remote channel instance
  protected Channel<V, U> channel;

  /// The function to overload with a task
  public abstract void Run();

  /// Actual runner
  private void Runner(object remoteChannel) {
    channel = remoteChannel as Channel<V, U>;
    Run();
  }

  /// Spawn a task
  public Channel<U, V> Spawn() {
    var rtn = new Channel<U, V>();
    thread = new Thread(this.Runner);
    thread.Start(rtn.remote);
    return rtn;
  }
}

public class TestTask : Task<bool, bool> {
  public override void Run() {
    var proc = new Process {
      StartInfo = new ProcessStartInfo {
        FileName = "notepad.exe",
        Arguments = "command line arguments to your executable",
        UseShellExecute = false,
        RedirectStandardOutput = true,
        CreateNoWindow = true
      }
    };

    proc.Start();
    while (!proc.StandardOutput.EndOfStream) {
      string line = proc.StandardOutput.ReadLine();
    }

    channel.Push(true); // Done
  }
}

public class Example : MonoBehaviour {

  private Channel<bool, bool> channel = null;

  public void Start() {
    UnityEngine.Debug.Log("Process started");
    channel = new TestTask().Spawn();
  }

  public void Update() {
    if (channel != null) {
      if (channel.Pop()) {
        UnityEngine.Debug.Log("Process finished");
        channel = null;
      }
      else {
        UnityEngine.Debug.Log("Step?");
      }
    }
  }
}