Implement Splash Screen with WPF

• Download demo - 23.06 KB

Introduction

Now almost all applications have a splash screen. This screen will be shown when the application starts, after the main window of the application is shown, this screen will be closed.

Background

WPF has provided an easy way to implement splash screen. Using this way, we should add an image as resource to the project, and set its BuildAction property to “SplashScreen”. This feature is only supported on .NET Framework 3.5. When the application starts, the image will be shown at first as the splash screen. I know this way is implemented via WinForm technology.

The above method is easy, but it is too simple and doesn’t meet my requirements. My requirements of splash screen are:

• The way of show the screen is reusable, thus each application I made can use the same way to show a splash screen
• The splash screen is easy to customize, thus each application I made can have different splash screens and I can make it as beautiful as I can
• The splash screen can show messages to the user, for example show the loading progress of the application
• The splash screen may not be a regular shape, it may be a circle and other not rectangle shape, but this is not necessary and important to me

Normally a splash screen has the below features:

• The splash screen doesn’t show in the task bar
• The splash screen is always shown at the center of the screen
• The splash screen doesn’t have window title bar and border, it is not resizable

My Design

To meet the above requirements, my design is as below:

• App

  App class inherits from Application class and provides the application entry.
  When entering the Main method, initialize the splash screen and show it by calling the Splasher class, and then run the application, show the main window.

  /// <summary>
      /// 
      /// </summary>
      class App: Application
      {
          /// <summary>
          /// 
          /// </summary>
          [STAThread ( )]
          static void Main ( )
          {
              Splasher.Splash = new SplashScreen ( );
              Splasher.ShowSplash ( ); 
  
              // Simulate application loading
              for ( int i = 0; i < 5000; i++ )
              {
                  MessageListener.Instance.ReceiveMessage 
  			( string.Format ( "Load module {0}", i ) );
                  Thread.Sleep ( 1 );
              } 
              new App ( );
          }
           /// <summary>
          /// 
          /// </summary>
          public App ( )
          {         
              StartupUri = new System.Uri ( "MainWindow.xaml", UriKind.Relative ); 
              Run ( );            
          }
      } 

• MainWindow

  Application’s main window, it’s just a normal window.

• SplashScreen

  Splash screen window, it’s just a normal window, this window has the special features that a splash screen should have. I have mentioned it above.

• Splasher

  A helper class to show and close splash screen window, the splash screen window should be initialized by the application. With this class, I don't care which window is the splash screen, and it’s reusable.

  /// <summary>
  /// Helper to show or close given splash window
  /// </summary>
  public static class Splasher
  {
      /// <summary>
      /// 
      /// </summary>
      private static Window mSplash; 
      /// <summary>
      /// Get or set the splash screen window
      /// </summary>
      public static Window Splash
      {
          get
          {
              return mSplash;
          }
          set
          {
              mSplash = value;
          }
      } 
      /// <summary>
      /// Show splash screen
      /// </summary>
      public static void ShowSplash ( )
      {
          if ( mSplash != null )
          {
              mSplash.Show ( );
          }
      }
      /// <summary>
      /// Close splash screen
      /// </summary>
      public static void CloseSplash ( )
      {
          if ( mSplash != null )
          {
              mSplash.Close ( ); 
              if ( mSplash is IDisposable )
                  ( mSplash as IDisposable ).Dispose ( );
          }
      }
  } 

• DispatcherHelper

  This is a helper class, implement DoEvents method like System.Windows.Forms.Application’s DoEvents method, if there is no such function, the loading message of the splash will not be refreshed correctly. The code is shown below:

  /// <summary>
  /// Simulate Application.DoEvents function of 
  /// <see cref=" System.Windows.Forms.Application"/> class.
  /// </summary>
  [SecurityPermissionAttribute ( SecurityAction.Demand, 
  	Flags = SecurityPermissionFlag.UnmanagedCode )]
  public static void DoEvents ( )
  {
      DispatcherFrame frame = new DispatcherFrame ( );
      Dispatcher.CurrentDispatcher.BeginInvoke ( DispatcherPriority.Background,
                  new DispatcherOperationCallback ( ExitFrames ), frame ); 
      try
      {
          Dispatcher.PushFrame ( frame );
      }
      catch ( InvalidOperationException )
      {
      }
  } 

• MessageListener

  This class inherit from DependencyObject, WPF’s UI element can easily bind to its property and update correctly. This class just receives a string message. To show the loading progress message in the splash screen, I add a TextBlock element to the window, and bind its Text property to listener’s Message property, and when the application is loading, I write messages to the listener.

Final Effect

The final splash screen looks like below. I define the window with a WPF window, the Label at the bottom of the window shows the loading tip messages (progress) of the application.

A very simple main window.

History

• Version 1.0 2009.07.20