How do I show an animation while creating user control

In a WPF 4 app, I have a very big user control full of controls which takes something l开发者_高级运维ike 4s to initialize on a fast machine. During this time the application is of course not responsive at all.

Is there a way to show an animation in the main window while this control is initialized?

I understand that I cannot create it on another thread. But is there maybe a way to create it with a lower priority from the Dispatcher so that I could show a spinning wheel or so on the main window which would still spin?

(The only solution I can think of right now would be to break the user control into further pieces and load them only when needed. But this will take a lot of development time to change.)

Update1

To be more clear: It is a simple WPF window using tab pages. When a new tab page is opened I'm initializing the user control which holds the controls for this tab page. One of these user controls is so full of controls that it takes 4s until the new tab page will be shown.

So I thought showing a spinning wheel would be better than having a blocked application.

I think you are going to have to break this user control up into pieces. What you can do is use a BackgroundWorker to coordinate the 'building' of this user control. Each time the DoWork event is fired, use Dispatcher.BeginInvoke to create an add the next control to your UI. This technique is described in the following blog post:

http://loekvandenouweland.com/index.php/2010/12/wp7-add-user-controls-graphics-in-background-thread/

This will allow you to show an animation during loading.

Why can't you initialize it on another thread? I see two scenarios:

1. Initialization is slow for non-WPF reasons that be preloaded/precomputed on another thread before entering the core WPF initialization.
2. WPF itself is consuming 4 seconds of CPU time (though, that's really WTF levels of CPU time...). If so, you can start another STA thread with it's own message pump that can display an independant UI (e.g: a spinning wheel) until the primary thread is done loading.

You can create "dialogs" which implicitly create a new Dispatcher and run on a background thread, or you can explicitly create your own Dispatcher (=message pump).

I use the following method to do so:

public static Dispatcher StartNewDispatcher(ThreadPriority cpuPriority = ThreadPriority.Normal) {
    using (var sem = new SemaphoreSlim(0)) {
        Dispatcher retval = null;
        var winThread = new Thread(() => {
            retval = Dispatcher.CurrentDispatcher;
            sem.Release();
            Dispatcher.Run();
        }) { IsBackground = true, Priority = cpuPriority };
        winThread.SetApartmentState(ApartmentState.STA);
        winThread.Start();
        sem.Wait();
        return retval;
    }
}

This gives you real multi-threaded UI; but it also means you can't databind or in any other way directly communicate between the two UI's: after all, WPF objects have thread-affinity.

Before you go this route, verify there aren't any slow components you can preload using a profiler: option 1 (preload heavy stuff before WPF init) is simpler and cleaner.

A solution could be to move the slow part (loading data? that doesn't belong IN the control) to another thread as you mentioned.

Or use a VirtualizingStackPanel to lazy load what is needed.

Could you elaborate on the reason for the delay?