private static async Task <bool> CallClassicOnNavigatingFrom(object viewmodel, NavigationMode mode, Page sourcePage, object sourceParameter, Type targetType, object targetParameter, bool suspending) { var deferral = new DeferralManager(); var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral) { Page = sourcePage, PageType = sourcePage?.GetType(), Parameter = sourceParameter, NavigationMode = mode, TargetPageType = targetType, TargetPageParameter = targetParameter, Suspending = suspending, }; try { var vm = viewmodel as Classic.INavigatingAwareAsync; if (vm != null) { await vm.OnNavigatingFromAsync(navigatingEventArgs); await deferral.WaitForDeferralsAsync(); } } catch { Debugger.Break(); } return(navigatingEventArgs.Cancel); }
private async void FacadeNavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e) { DebugWrite(); object parameter = null; try { parameter = SerializationService.Deserialize(e.Parameter?.ToString()); } catch (Exception ex) { throw new Exception("Your parameter must be serializable. If it isn't, then use SessionState.", ex); } var deferral = new DeferralManager(); var args = new NavigatingEventArgs(deferral, e, Content as Page, e.SourcePageType, parameter, e.Parameter); if (NavigationModeHint != NavigationMode.New) { args.NavigationMode = NavigationModeHint; } NavigationModeHint = NavigationMode.New; _navigatingEventHandlers.ForEach(x => x(this, args)); await deferral.WaitForDeferralsAsync().ConfigureAwait(false); e.Cancel = args.Cancel; }
public void NoDeferrals_IsCompleted() { var dm = new DeferralManager(); var task = dm.SignalAndWaitAsync(); Assert.IsTrue(task.IsCompleted); }
private async Task <bool> NavingFromAsync(Classic.INavigatingAwareAsync viewmodel, Page page, object currentParameter, bool suspending, NavigationMode navigationMode, Type targetPageType, object targetParameter) { var deferral = new DeferralManager(); var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral) { Page = page, Parameter = currentParameter, Suspending = suspending, NavigationMode = navigationMode, TargetPageType = targetPageType, TargetPageParameter = targetParameter, }; try { await viewmodel.OnNavigatingFromAsync(navigatingEventArgs); await deferral.WaitForDeferralsAsync(); } catch { Debugger.Break(); } return(navigatingEventArgs.Cancel); }
public NavigatingEventArgs(DeferralManager manager, NavigatingCancelEventArgs e, Page page, object parameter) : base() { NavigationMode = e.NavigationMode; PageType = e.SourcePageType; Page = page; Parameter = parameter; }
public async Task When_Completed_Asynchronously_With_Requests() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); var deferral1 = deferralManager.GetDeferral(); var deferral2 = deferralManager.GetDeferral(); bool lastDeferralCompleting = false; deferralManager.Completed += (s, e) => { Assert.IsTrue(lastDeferralCompleting); Assert.IsFalse(deferralManager.CompletedSynchronously); }; var completedSynchronously = deferralManager.EventRaiseCompleted(); Assert.IsFalse(completedSynchronously); Assert.IsFalse(deferralManager.CompletedSynchronously); await Task.Yield(); deferral2.Complete(); Assert.IsFalse(deferralManager.CompletedSynchronously); await Task.Yield(); Assert.IsFalse(deferralManager.CompletedSynchronously); lastDeferralCompleting = true; deferral1.Complete(); Assert.IsFalse(deferralManager.CompletedSynchronously); }
public void NoDeferrals_IsCompleted() { var dm = new DeferralManager(); var task = dm.WaitForDeferralsAsync(); Assert.True(task.IsCompleted); }
// before navigate (cancellable) async Task <bool> NavigatingFromAsync(bool suspending, NavigationMode mode) { DebugWrite($"Suspending: {suspending}"); var page = FrameFacadeInternal.Content as Page; if (page != null) { // force (x:bind) page bindings to update XamlUtils.UpdateBindings(page); // call navagable override (navigating) var dataContext = ResolveForPage(page); if (dataContext != null) { dataContext.NavigationService = this; dataContext.Dispatcher = this.GetDispatcherWrapper(); dataContext.SessionState = BootStrapper.Current.SessionState; var deferral = new DeferralManager(); var args = new NavigatingEventArgs(deferral) { NavigationMode = mode, PageType = FrameFacadeInternal.CurrentPageType, Parameter = FrameFacadeInternal.CurrentPageParam, Suspending = suspending, }; await deferral.WaitForDeferralsAsync(); await dataContext.OnNavigatingFromAsync(args); return(!args.Cancel); } } return(true); }
public void When_Completed_Synchronously_After_Event_Raise() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); Assert.IsTrue(deferralManager.EventRaiseCompleted()); Assert.IsTrue(deferralManager.CompletedSynchronously); }
public void When_Deferrals_Disposed() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); var deferral1 = deferralManager.GetDeferral(); var deferral2 = deferralManager.GetDeferral(); bool isCompleted = false; deferralManager.Completed += (s, e) => { isCompleted = true; }; deferralManager.EventRaiseCompleted(); Assert.IsFalse(isCompleted); deferral1.Dispose(); Assert.IsFalse(isCompleted); deferral2.Dispose(); Assert.IsTrue(isCompleted); }
public void When_Many_Deferrals() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); var random = new Random(42); var deferrals = new List <Deferral>(); for (int i = 0; i < 20; i++) { deferrals.Add(deferralManager.GetDeferral()); } bool isCompleted = false; deferralManager.Completed += (s, e) => { isCompleted = true; }; deferralManager.EventRaiseCompleted(); while (deferrals.Count > 0) { Assert.IsFalse(isCompleted); var randomIndex = random.Next(deferrals.Count); var randomDeferral = deferrals[randomIndex]; randomDeferral.Complete(); deferrals.RemoveAt(randomIndex); } Assert.IsTrue(isCompleted); }
public NavigatingEventArgs(DeferralManager manager, NavigatingCancelEventArgs e, Type targetPageType, object parameter, object targetPageParameter) : this(manager) { NavigationMode = e.NavigationMode; PageType = e.SourcePageType; Parameter = parameter; TargetPageType = targetPageType; TargetPageParameter = targetPageParameter; }
public async Task CompletedDeferralFollowedByIncompleteDeferral_PreventsCompletion() { var dm = new DeferralManager(); dm.DeferralSource.GetDeferral().Dispose(); var deferral = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); await AsyncAssert.NeverCompletesAsync(task); }
public SuspendingDeferral GetDeferral() { if (_deferralManager == null) { _deferralManager = new DeferralManager <SuspendingDeferral>(h => new SuspendingDeferral(h)); _deferralManager.Completed += (s, e) => _deferralDone?.Invoke(); } return(_deferralManager.GetDeferral()); }
public void IncompleteDeferral_PreventsCompletion() { AsyncContext.Run(async() => { var dm = new DeferralManager(); var deferral = dm.GetDeferral(); await AssertEx.NeverCompletesAsync(dm.SignalAndWaitAsync()); }); }
public async Task CompletedDeferralFollowedByIncompleteDeferral_PreventsCompletion() { DeferralManager dm = new DeferralManager(); dm.DeferralSource.GetDeferral().Dispose(); IDisposable deferral = dm.DeferralSource.GetDeferral(); Task task = dm.WaitForDeferralsAsync(); await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false); }
public async Task DeferralCompleted_Completes() { var dm = new DeferralManager(); var deferral = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); Assert.False(task.IsCompleted); deferral.Dispose(); await task; }
public void When_Completed_Synchronously_In_Event_Handler() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); deferralManager.Completed += (s, e) => { Assert.IsTrue(deferralManager.CompletedSynchronously); }; deferralManager.EventRaiseCompleted(); }
public async Task MultipleDeferralsWithOneIncomplete_PreventsCompletion() { DeferralManager dm = new DeferralManager(); IDisposable deferral1 = dm.DeferralSource.GetDeferral(); IDisposable deferral2 = dm.DeferralSource.GetDeferral(); Task task = dm.WaitForDeferralsAsync(); deferral1.Dispose(); await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false); }
public async Task MultipleDeferralsWithOneIncomplete_PreventsCompletion() { var dm = new DeferralManager(); var deferral1 = dm.DeferralSource.GetDeferral(); var deferral2 = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); deferral1.Dispose(); await AsyncAssert.NeverCompletesAsync(task); }
public Deferral GetDeferral() { if (_deferralManager == null) { _deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); _deferralManager.Completed += (s, e) => _complete(this); } return(_deferralManager.GetDeferral()); }
public async Task <bool> NavingFromCancelsAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending) { Services.NavigationService.NavigationService.DebugWrite(); if (sourcePage == null) { return(false); } else if (viewmodel == null) { return(false); } else if (viewmodel is Classic.INavigatingAwareAsync) { var deferral = new DeferralManager(); var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral) { Page = sourcePage, PageType = sourcePage?.GetType(), Parameter = sourceParameter, NavigationMode = mode, TargetPageType = targetType, TargetPageParameter = targetParameter, Suspending = suspending, }; try { var vm = viewmodel as Classic.INavigatingAwareAsync; await vm?.OnNavigatingFromAsync(navigatingEventArgs); await deferral.WaitForDeferralsAsync(); } catch { Debugger.Break(); } return(navigatingEventArgs.Cancel); } else if (viewmodel is Portable.IConfirmNavigationAsync) { var parameters = new Portable.NavigationParameters(); parameters.Add("NavigationMode", mode.ToPrismNavigationMode()); parameters.Add("SourceType", sourceType); parameters.Add("SourceParameter", sourceParameter); parameters.Add("TargetType", targetType); parameters.Add("TargetParameter", targetParameter); parameters.Add("Suspending", suspending); var vm = viewmodel as Portable.IConfirmNavigationAsync; return(!await vm?.CanNavigateAsync(parameters)); } else { return(true); } }
public async Task MultipleDeferralsWithAllCompleted_Completes() { var dm = new DeferralManager(); var deferral1 = dm.DeferralSource.GetDeferral(); var deferral2 = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); deferral1.Dispose(); deferral2.Dispose(); await task; }
public void MultipleDeferralsWithOneIncomplete_PreventsCompletion() { AsyncContext.Run(async() => { var dm = new DeferralManager(); var deferral1 = dm.GetDeferral(); var deferral2 = dm.GetDeferral(); var task = dm.SignalAndWaitAsync(); deferral1.Dispose(); await AssertEx.NeverCompletesAsync(task); }); }
public void DeferralCompleted_Completes() { AsyncContext.Run(async() => { var dm = new DeferralManager(); var deferral = dm.GetDeferral(); var task = dm.SignalAndWaitAsync(); Assert.IsFalse(task.IsCompleted); deferral.Dispose(); await task; }); }
public void TwoDeferralsWithOneCompletedTwice_PreventsCompletion() { Test.Async(async() => { var dm = new DeferralManager(); var deferral1 = dm.GetDeferral(); var deferral2 = dm.GetDeferral(); var task = dm.SignalAndWaitAsync(); deferral1.Dispose(); deferral1.Dispose(); await AssertEx.NeverCompletesAsync(task); }); }
public void MultipleDeferralsWithAllCompleted_Completes() { AsyncContext.Run(async() => { var dm = new DeferralManager(); var deferral1 = dm.GetDeferral(); var deferral2 = dm.GetDeferral(); var task = dm.SignalAndWaitAsync(); deferral1.Dispose(); deferral2.Dispose(); await task; }); }
protected async Task OnMyEventAsync() { if (MyEvent != null) { DeferralManager deferralManager = new DeferralManager(); MyEventArgs e = new MyEventArgs(deferralManager); MyEvent(this, e); await deferralManager.WaitForDeferralsAsync(); } if (e.Change) { Console.WriteLine("Change occured"); } }
public void When_Completed_Synchronously_With_Requests() { var deferralManager = new DeferralManager <Deferral>(h => new Deferral(h)); var deferral1 = deferralManager.GetDeferral(); var deferral2 = deferralManager.GetDeferral(); deferral2.Complete(); deferral1.Complete(); deferralManager.Completed += (s, e) => { Assert.IsTrue(deferralManager.CompletedSynchronously); }; Assert.IsTrue(deferralManager.EventRaiseCompleted()); Assert.IsTrue(deferralManager.CompletedSynchronously); }
/// <summary> /// Initializes a new instance of the <see cref="NavigatingEventArgs"/> class. /// </summary> /// <param name="manager"> /// The manager. /// </param> /// <param name="args"> /// The args. /// </param> /// <param name="page"> /// The page. /// </param> /// <param name="targetPageType"> /// The target page type. /// </param> /// <param name="parameter"> /// The parameter. /// </param> /// <param name="targetPageParameter"> /// The target page parameter. /// </param> public NavigatingEventArgs( DeferralManager manager, NavigatingCancelEventArgs args, Page page, Type targetPageType, object parameter, object targetPageParameter) : this(manager) { this.NavigationMode = args.NavigationMode; this.PageType = args.SourcePageType; this.Page = page; this.Parameter = parameter; this.TargetPageType = targetPageType; this.TargetPageParameter = targetPageParameter; }