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;
}
