Windows Phone开发（二）-- 框架结构和启动过程【转载】

<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" EntryPointAssembly="PhoneApp2" EntryPointType="PhoneApp2.App" RuntimeVersion="4.7.50308.0">
  <Deployment.Parts>
    <AssemblyPart x:Name="PhoneApp2" Source="PhoneApp2.dll" />
  </Deployment.Parts>
</Deployment>

<Application 
    x:Class="PhoneApp2.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"       
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">

    <!--Application Resources-->
    <Application.Resources>
    </Application.Resources>

    <Application.ApplicationLifetimeObjects>
        <!--Required object that handles lifetime events for the application-->
        <shell:PhoneApplicationService 
            Launching="Application_Launching" Closing="Application_Closing" 
            Activated="Application_Activated" Deactivated="Application_Deactivated"/>
    </Application.ApplicationLifetimeObjects>

</Application>

public PhoneApplicationFrame RootFrame { get; private set; }

public App()
{
    UnhandledException += Application_UnhandledException;
    InitializeComponent();
    InitializePhoneApplication();
    PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
}

public void InitializeComponent() 
{
    if (_contentLoaded)
    {
        return;
    }
    _contentLoaded = true;
    System.Windows.Application.LoadComponent(this, new System.Uri("/PhoneApp2;component/App.xaml", System.UriKind.Relative));
}

//部分代码
public static void LoadComponent(object component, Uri resourceLocator)
{
    XcpImports.CheckThread();
    Type componentType = null;
    uint hr = 0;

    if (IsComponentUri(resourceLocator))
    {
        string partName = null;
        string assemblyName = null;
        string assemblyVersion = null;
        string assemblyKey = null;
        if (!QuirksMode.ShouldUseSL3Parser())
        {
            ResourceManagerWrapper.GetAssemblyNameAndPart(resourceLocator, out partName, out assemblyName, out assemblyVersion, out assemblyKey);
        }
        if (componentType == null)
        {
            componentType = component.GetType();
        }
        UnmanagedMemoryStream resourceForUri = ResourceManagerWrapper.GetResourceForUri(resourceLocator, componentType) as UnmanagedMemoryStream;
        if (resourceForUri != null)
        {
            uint length = (uint) resourceForUri.Length;
            hr = XcpImports.Application_LoadComponent(ManagedObjectReference.ConditionalWrap(component), resourceLocator.OriginalString, resourceForUri, length, assemblyName);
            resourceForUri.Close();
        }
    }
    else
    {
        hr = XcpImports.Application_LoadComponent(ManagedObjectReference.ConditionalWrap(component), resourceLocator.OriginalString, null, 0, string.Empty);
    }
}

nternal static unsafe uint Application_LoadComponent(IManagedPeerBase componentAsDO, string resourceLocator, UnmanagedMemoryStream stream, uint numBytesToRead, string assemblyString)
{
    if (assemblyString == null)
    {
        assemblyString = string.Empty;
    }
    CheckThread();
    byte* pXamlStr = (stream != null) ? stream.PositionPointer : null;
    uint num = Application_LoadComponentNative(JoltHelper.Context, componentAsDO.NativeObject, (uint) resourceLocator.Length, resourceLocator, numBytesToRead, pXamlStr, (uint) assemblyString.Length, assemblyString);
    GC.KeepAlive(componentAsDO);
    return num;
}

[SecurityCritical, DllImport("agcore", EntryPoint="Application_LoadComponent")]
private static extern unsafe uint Application_LoadComponentNative(IntPtr pContext, IntPtr pComponent, uint cUriStringLength, [MarshalAs(UnmanagedType.LPWStr)] string uriString, uint cXamlStrLength, byte* pXamlStr, uint cAssemblyStrLength, [MarshalAs(UnmanagedType.LPWStr)] string assemblyStr);

internal Application(uint nativeTypeIndex)
{
    _current = this;
    IntPtr zero = IntPtr.Zero;
    zero = XcpImports.CreateObjectByTypeIndex(nativeTypeIndex);
    this.m_nativePtr = new NativeObjectSafeHandle();
    this.m_nativePtr.NativeObject = zero;
    ManagedPeerTable.Add(zero, this);
    this._coreTypeEventHelper = new CoreTypeEventHelper();
    Type type = base.GetType();
    uint isCustomType = 0;
    if (!TypeProxy.IsCoreType(type))
    {
        isCustomType = 1;
    }
    XcpImports.NotifyHasManagedPeer(zero, 11, isCustomType);
    this._hasElevatedPermissions = XcpImports.Application_GetHasElevatedPermissions();
    Deployment current = Deployment.Current;
    this.Starting += new StartupEventHandler(this.Application_Starting);
    this.Started += new EventHandler(this.Application_Started);
    this.Exiting += new EventHandler(this.Application_Exiting);
    this.Exited += new EventHandler(this.Application_Exited);
}

public static Application Current
{
    [SecuritySafeCritical]
    get
    {
        IntPtr ptr;
        if (_current != null)
        {
            return _current;
        }
        XcpImports.Application_GetCurrent(out ptr);
        if (ptr != IntPtr.Zero)
        {
            Application application = (Application) ManagedPeerTable.EnsureManagedPeer(ptr, 0, typeof(Application));
            XcpImports.ReleaseNativeObject(ref ptr);
            return application;
        }
        return null;
    }
}

private static object EnsureManagedPeer(IntPtr unmanagedPointer, int typeIndex, Type type, bool preserveManagedObjectReference)
{
    if (unmanagedPointer == IntPtr.Zero)
    {
        return null;
    }
    object managedPeer = null;
    if (!TryGetManagedPeer(unmanagedPointer, preserveManagedObjectReference, out managedPeer))
    {
        XcpImports.CheckThread();
        if ((typeIndex == 0) && (type == null))
        {
            typeIndex = XcpImports.GetNativeTypeIndex(unmanagedPointer);
        }
        FrameworkCallbacks.Initialize();
        DependencyObject.StaticNativePointer = unmanagedPointer;
        managedPeer = (typeIndex > 0) ? CoreTypes.GetCoreWrapper(typeIndex) : (Activator.CreateInstance(type) as IManagedPeerBase);
        DependencyObject.StaticNativePointer = IntPtr.Zero;
    }
    return managedPeer;
}

private void InitializePhoneApplication()
{
    if (phoneApplicationInitialized)
        return;

    RootFrame = new PhoneApplicationFrame();
    RootFrame.Navigated +=   CompleteInitializePhoneApplication;

    RootFrame.NavigationFailed += RootFrame_NavigationFailed;

    phoneApplicationInitialized = true;
}

private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
{
    if (RootVisual != RootFrame)
        RootVisual = RootFrame;

    RootFrame.Navigated -= CompleteInitializePhoneApplication;
}

public UIElement RootVisual
{
    get
    {
        return (XcpImports.Application_GetVisualRoot() as UIElement);
    }
    [SecuritySafeCritical]
    set
    {
        XcpImports.CheckThread();
        if ((value == null) || !XcpImports.DependencyObject_IsPointerValid(value))
        {
            throw new InvalidOperationException(Resx.GetString("Application_InvalidRootVisual"));
        }
        XcpImports.Application_SetVisualRoot(value);
        this._rootVisual = value;
    }
}

public App()
{
    this.Startup += this.Application_Startup;
    this.Exit += this.Application_Exit;
    this.UnhandledException += this.Application_UnhandledException;

    InitializeComponent();
}

private void Application_Startup(object sender, StartupEventArgs e)
{
    this.RootVisual = new MainPage();
}

public Frame RootFrame { get; private set; }


private void Application_Startup(object sender, StartupEventArgs e)
{
    RootFrame = new Frame();
    this.RootVisual = RootFrame;
    RootFrame.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
    //this.RootVisual = new MainPage();
}

<Tasks>
    <DefaultTask  Name ="_default" NavigationPage="MainPage.xaml"/>
</Tasks>

private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
{
    if (RootVisual != RootFrame)
        //RootVisual = RootFrame;
        RootVisual = new MainPage();

    RootFrame.Navigated -= CompleteInitializePhoneApplication;
}

        private void Application_Startup(object sender, StartupEventArgs e)
        {
            //this.RootVisual = new Page1();
            RootFrame = new Frame();
            RootFrame.Navigated += new System.Windows.Navigation.NavigatedEventHandler(RootFrame_Navigated);
            bool ret = RootFrame.Navigate(new Uri("/Page1.xaml", UriKind.Relative));
            //RootFrame.Source = new Uri("/Page1.xaml", UriKind.Relative);
        }

        void RootFrame_Navigated(object sender, System.Windows.Navigation.NavigationEventArgs e)
        {
            RootFrame.Navigated -= RootFrame_Navigated;
            this.RootVisual = RootFrame;
        }