在WP7 UserControl中使用Caliburn会引发异常

Question

I'm trying to build a UserControl for a Windows Phone app using Caliburn Micro inside the control. The bootstrapper is usually setup in the App resources

  <Application.Resources>
     <local:AppBootstrapper x:Key="bootstrapper" />
  </Application.Resources>

I try to do this in the Xaml of the user control.

 <UserControl.Resources>
     <local:AppBootstrapper x:Key="bootstrapper" />
 </UserControl.Resources>

But this throws an exception during initialization when the component is loaded. The LoadComponent call throws the exception: "A first chance exception of type 'System.InvalidOperationException' occurred in Microsoft.Phone.ni.dll"

Where and when should the bootstrapper be initialised?

Answer 1

It's not intended to be used in a UserControl's resources, so I can't guarantee any good or bad behavior. The bootstrapper should be used in the application resources or you can instantiate it directly in code. Try creating it in the user control's ctor, just after the InitializeComponent call.

Answer 2

Since you are placing a bootstrapper on a UserControl it seems that the PhoneApplicationService is probably already instantiated - have you tried putting the boostrapper in the app resources section?

The CM source shows that CM creates a new instance of PhoneApplicationService when the bootstrapper initialises and that looks like the issue, the root of your application must have already created an instance.

Is there a reason you can't use the boostrapper in the standard way (in app resources)? Does your App.xaml contain an initialiser for PhoneApplicationService ?

Edit:

CM source where you are getting the error is in PrepareApplication . eg

protected override void PrepareApplication() {
        base.PrepareApplication();

            phoneService = new PhoneApplicationService();
            phoneService.Activated += OnActivate;
            phoneService.Deactivated += OnDeactivate;
            phoneService.Launching += OnLaunch;
            phoneService.Closing += OnClose;

            Application.ApplicationLifetimeObjects.Add(phoneService);

            if (phoneApplicationInitialized) {
                return;
            }

            RootFrame = CreatePhoneApplicationFrame();
            RootFrame.Navigated += OnNavigated;

            phoneApplicationInitialized = true;
        }

You could probably just subclass this and get away with not creating a new PhoneApplicationService but reusing the existing one:

    /// <summary>
    /// A custom bootstrapper designed to setup phone applications.
    /// </summary>
    public class CustomPhoneBootstrapper : Bootstrapper {
    bool phoneApplicationInitialized;
    PhoneApplicationService phoneService;

    /// <summary>
    /// The root frame used for navigation.
    /// </summary>
    public PhoneApplicationFrame RootFrame { get; private set; }

    /// <summary>
    /// Provides an opportunity to hook into the application object.
    /// </summary>
    protected override void PrepareApplication(PhoneApplicationService phoneAppService, PhoneApplicationFrame rootFrame) {
        base.PrepareApplication();

        phoneService = phoneAppService;
        phoneService.Activated += OnActivate;
        phoneService.Deactivated += OnDeactivate;
        phoneService.Launching += OnLaunch;
        phoneService.Closing += OnClose;

        Application.ApplicationLifetimeObjects.Add(phoneService);

        if (phoneApplicationInitialized) {
            return;
        }

        RootFrame = rootFrame;
        RootFrame.Navigated += OnNavigated;

        phoneApplicationInitialized = true;
    }

    void OnNavigated(object sender, NavigationEventArgs e) {
        if (Application.RootVisual != RootFrame) {
            Application.RootVisual = RootFrame;
        }
    }

    /// <summary>
    /// Occurs when a fresh instance of the application is launching.
    /// </summary>
    protected virtual void OnLaunch(object sender, LaunchingEventArgs e) { }

    /// <summary>
    /// Occurs when a previously tombstoned or paused application is resurrected/resumed.
    /// </summary>
    protected virtual void OnActivate(object sender, ActivatedEventArgs e) { }

    /// <summary>
    /// Occurs when the application is being tombstoned or paused.
    /// </summary>
    protected virtual void OnDeactivate(object sender, DeactivatedEventArgs e) { }

    /// <summary>
    /// Occurs when the application is closing.
    /// </summary>
    protected virtual void OnClose(object sender, ClosingEventArgs e) { }
}

Disclaimer: Not sure if any of this will work since I've never devved for Windows Phone but as far as I can see that should do what the original bootstrapper did but skip the creation of the application and the root frame. You just need to supply the app and the root frame (or maybe just the app if you can get the root frame from the application object - like I said, no idea what's possible)