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檔案中被捕獲,不會導致閃退.

來自開發者交流群：53078485，期待您的加入！