講講我在Windows10(uwp)開發中遇到的一些坑.

7月29日發布的Windows10正式版,當天安裝好以后,在網絡不太好的情況下,經過多次嘗試終於裝上了Visual Studio 2015和Windows 10 10240的SDK.這兩周一直在開發UWP,講講在其中遇到的一些坑,不定時更新,有興趣的可以關注下.

 

1.DataType在UWP中缺失的問題

在WPF中使用過MVVMLight的都知道,我們可以在App.xaml文件中通過DataType將ViewModel和View綁定在一起.

<DataTemplate DataType="{x:Type vm:MyViewModel}">
    <views:MyView/>
</DataTemplate>

但是在Windows10(包括WP7等),是沒有DataType的屬性的,這意味着我們不能用這種方式來實現ViewModel和View的綁定.但是我們可以曲線救國一下,通過key的方式來尋找DataTemplate來綁定.

首先,我們需要改變我們在UWP中的寫法.

<DataTemplate x:Key="MyViewModel">
    <view:MyView/>
</DataTemplate>

然后我們在我們的MainPage.xaml文件中加入一個ContentControl.

<ContentControl Content="{Binding CurrentViewModel}" ContentTemplate="{Binding Path=CurrentTemplate}" />

我們的各個Views是用Usercontrol實現的.我們需要在MainPageViewModel中添加相應的綁定項.

public ViewModelBase CurrentViewModel
{
    get
    {
        return currentViewModel;
    }
    set
    {
        if (currentViewModel == value)
        {
            return;

        }
        currentViewModel = value;
        RaisePropertyChanged(()=>CurrentViewModel);
        RaisePropertyChanged(()=>CurrentTemplate);
    }
}

public DataTemplate CurrentTemplate
{
    get
    {
        if (CurrentViewModel == null)
        {
            return null;
        }

        return Untils.DataTemplateSelector.GetTemplate(CurrentViewModel);
    }
}

DataTemplateSelector.GetTemplate是我們整個方法的核心.

public static class DataTemplateSelector
{
    public static DataTemplate GetTemplate(ViewModelBase param)
    {
        Type t = param.GetType();
        return App.Current.Resources[t.Name] as DataTemplate;
    }
}

通過查找Key的方式將ViewModel和View綁定在一起,這樣就實現了我們的功能.我們接下來只要關注App.xaml或者相關文件中聲明我們的Key就行了.

 

2.附加屬性解決WebView不能直接綁定Html內容的問題

WebView的Source屬性只能綁定微軟規定的一些地址協議,不能直接綁定HTML的內容.通過附加屬性可以解決這個問題,利用的是NavigateToString方法

public static readonly DependencyProperty SourceStringProperty =
DependencyProperty.RegisterAttached("SourceString", typeof(string), typeof(Untils), new PropertyMetadata("", OnSourceStringChanged));

public static string GetSourceString(DependencyObject obj) { return obj.GetValue(SourceStringProperty).ToString(); }
public static void SetSourceString(DependencyObject obj, string value) { obj.SetValue(SourceStringProperty, value); }

private static void OnSourceStringChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    WebView wv = d as WebView;
    if (wv != null)
    {
        wv.NavigateToString(e.NewValue.ToString());
    }
}

聲明一個SourceString的附加屬性,然后在變更事件中進行導航,然后Xaml文件中:

 <WebView Property:Untils.SourceString="{Binding Url,Mode=TwoWay}"/> 

這樣子,就可以直接綁定Html內容了.

 

3.異步(async)方法中的異常無法被App的UnhandledException捕獲的問題.

這是一個比較嚴重的問題.目前已知很多的做法就是局部try catch來解決這個問題.這樣做是很容易導致Process被強制終止然后引起閃退的問題的.

我這里用了一個線程同步模型類解決這個問題.

using System;
using System.Threading;
using Windows.UI.Xaml.Controls;

namespace AiJianShu.ExceptionHandler
{
    internal class ExceptionHandlingSynchronizationContext : SynchronizationContext
    {
        /// <summary>
        /// 注冊事件.  需要在OnLaunched和OnActivated事件中調用
        /// </summary>
        /// <returns></returns>
        public static ExceptionHandlingSynchronizationContext Register()
        {
            var syncContext = Current;
            if (syncContext == null)
                throw new InvalidOperationException("Ensure a synchronization context exists before calling this method.");


            var customSynchronizationContext = syncContext as ExceptionHandlingSynchronizationContext;


            if (customSynchronizationContext == null)
            {
                customSynchronizationContext = new ExceptionHandlingSynchronizationContext(syncContext);
                SetSynchronizationContext(customSynchronizationContext);
            }


            return customSynchronizationContext;
        }

        /// <summary>
        /// 將線程的上下文綁定到特定的Frame上面
        /// </summary>
        /// <param name="rootFrame"></param>
        /// <returns></returns>
        public static ExceptionHandlingSynchronizationContext RegisterForFrame(Frame rootFrame)
        {
            if (rootFrame == null)
                throw new ArgumentNullException("rootFrame");

            var synchronizationContext = Register();

            rootFrame.Navigating += (sender, args) => EnsureContext(synchronizationContext);
            rootFrame.Loaded += (sender, args) => EnsureContext(synchronizationContext);

            return synchronizationContext;
        }

        private static void EnsureContext(SynchronizationContext context)
        {
            if (Current != context)
                SetSynchronizationContext(context);
        }


        private readonly SynchronizationContext _syncContext;


        public ExceptionHandlingSynchronizationContext(SynchronizationContext syncContext)
        {
            _syncContext = syncContext;
        }


        public override SynchronizationContext CreateCopy()
        {
            return new ExceptionHandlingSynchronizationContext(_syncContext.CreateCopy());
        }


        public override void OperationCompleted()
        {
            _syncContext.OperationCompleted();
        }


        public override void OperationStarted()
        {
            _syncContext.OperationStarted();
        }


        public override void Post(SendOrPostCallback d, object state)
        {
            _syncContext.Post(WrapCallback(d), state);
        }


        public override void Send(SendOrPostCallback d, object state)
        {
            _syncContext.Send(d, state);
        }


        private SendOrPostCallback WrapCallback(SendOrPostCallback sendOrPostCallback)
        {
            return state =>
            {
                try
                {
                    sendOrPostCallback(state);
                }
                catch (Exception ex)
                {
                    if (!HandleException(ex))
                        throw;
                }
            };
        }

        private bool HandleException(Exception exception)
        {
            if (UnhandledException == null)
                return false;

            var exWrapper = new AysncUnhandledExceptionEventArgs
            {
                Exception = exception
            };

            UnhandledException(this, exWrapper);

#if DEBUG && !DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
            if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break();
#endif
            return exWrapper.Handled;
        }

        public event EventHandler<AysncUnhandledExceptionEventArgs> UnhandledException;
    }

    public class AysncUnhandledExceptionEventArgs : EventArgs
    {
        public bool Handled { get; set; }
        public Exception Exception { get; set; }
    }
}

使用實例:

public App()
{
    this.InitializeComponent();
    this.Suspending += OnSuspending;

    this.UnhandledException += App_UnhandledException;

}

private void RegisterExceptionHandlingSynchronizationContext()
{
    ExceptionHandlingSynchronizationContext
        .Register()
        .UnhandledException += SynchronizationContext_UnhandledException;
}

private async void App_UnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
{
    e.Handled = true;

    await new MessageDialog("Application Unhandled Exception:\r\n" + e.Exception.Message)
        .ShowAsync();
}

private async void SynchronizationContext_UnhandledException(object sender, AysncUnhandledExceptionEventArgs e)
{
    e.Handled = true;

    await new MessageDialog("Synchronization Context Unhandled Exception:\r\n" + e.Exception.Message)
        .ShowAsync();
}

protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    RegisterExceptionHandlingSynchronizationContext();

#if DEBUG
    if (System.Diagnostics.Debugger.IsAttached)
    {
        this.DebugSettings.EnableFrameRateCounter = true;
    }
#endif

    Frame rootFrame = Window.Current.Content as Frame;

    // 不要在窗口已包含內容時重復應用程序初始化，
    // 只需確保窗口處於活動狀態
    if (rootFrame == null)
    {
        // 創建要充當導航上下文的框架，並導航到第一頁
        rootFrame = new Frame();

        rootFrame.NavigationFailed += OnNavigationFailed;

        if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
        {
            //TODO: 從之前掛起的應用程序加載狀態
        }

        // 將框架放在當前窗口中
        Window.Current.Content = rootFrame;
    }

    if (rootFrame.Content == null)
    {
        // 當導航堆棧尚未還原時，導航到第一頁，
        // 並通過將所需信息作為導航參數傳入來配置
        // 參數
        rootFrame.Navigate(typeof(MainPage), e.Arguments);
    }
    // 確保當前窗口處於活動狀態
    Window.Current.Activate();
}

protected override void OnActivated(IActivatedEventArgs args)
{
    RegisterExceptionHandlingSynchronizationContext();
    base.OnActivated(args);
}

這樣全局的異常就都能在App.xaml.cs文件中被捕獲,不會導致閃退.

 

參考資料:

http://www.codeproject.com/Articles/113152/Applying-Data-Templates-Dynamically-by-Type-in-WP

http://www.markermetro.com/2013/01/technical/handling-unhandled-exceptions-with-asyncawait-on-windows-8-and-windows-phone-8/

https://github.com/kiwidev/WinRTExceptions