private static void Main(string[] args)
{
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress +=
(sender, e) =>
{
e.Cancel = true;
cts.Cancel();
};
// Since Console apps do not have a SyncronizationContext, we're leveraging the built-in support
// in WPF to pump the messages via the Dispatcher.
// See the following for additional details:
// http://blogs.msdn.com/b/pfxteam/archive/2012/01/21/10259307.aspx
// https://github.com/DotNetAnalyzers/StyleCopAnalyzers/pull/1362
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var context = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
DispatcherFrame dispatcherFrame = new DispatcherFrame();
Task mainTask = MainAsync(args, cts.Token);
mainTask.ContinueWith(task => dispatcherFrame.Continue = false);
Dispatcher.PushFrame(dispatcherFrame);
mainTask.GetAwaiter().GetResult();
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
void EnsureInitialized()
{
if (_dispatcher != null && _context != null)
{
return;
}
lock (initializationLock)
{
if (_dispatcher != null && _context != null)
{
return;
}
try
{
_dispatcher = Deployment.Current.Dispatcher;
_context = new DispatcherSynchronizationContext(_dispatcher);
}
catch (InvalidOperationException)
{
throw new Exception("Initialised called from non-UI thread.");
}
}
}
private void EnsureInitialized()
{
if (dispatcher != null && context != null)
{
return;
}
lock (initializationLock)
{
if (dispatcher != null && context != null)
{
return;
}
try
{
#if SILVERLIGHT
dispatcher = System.Windows.Deployment.Current.Dispatcher;
#else
dispatcher = Dispatcher.CurrentDispatcher;
#endif
context = new DispatcherSynchronizationContext(dispatcher);
}
catch (InvalidOperationException)
{
throw new Exception("Initialised called from non-UI thread.");
}
}
}
private static void Main(string[] args)
{
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress +=
(sender, e) =>
{
e.Cancel = true;
cts.Cancel();
};
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var context = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
DispatcherFrame dispatcherFrame = new DispatcherFrame();
Task mainTask = MainAsync(args, cts.Token);
mainTask.ContinueWith(task => dispatcherFrame.Continue = false);
Dispatcher.PushFrame(dispatcherFrame);
mainTask.GetAwaiter().GetResult();
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public override Task<RunSummary> RunAsync(IMessageSink diagnosticMessageSink, IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
var sta = StaTaskScheduler.DefaultSta;
var task = Task.Factory.StartNew(async () =>
{
Debug.Assert(sta.Threads.Length == 1);
Debug.Assert(sta.Threads[0] == Thread.CurrentThread);
using (await _wpfTestSerializationGate.DisposableWaitAsync())
{
try
{
// Sync up FTAO to the context that we are creating here.
ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = new ForegroundThreadData(
Thread.CurrentThread,
StaTaskScheduler.DefaultSta,
ForegroundThreadDataKind.StaUnitTest);
// All WPF Tests need a DispatcherSynchronizationContext and we dont want to block pending keyboard
// or mouse input from the user. So use background priority which is a single level below user input.
var dispatcherSynchronizationContext = new DispatcherSynchronizationContext();
// xUnit creates its own synchronization context and wraps any existing context so that messages are
// still pumped as necessary. So we are safe setting it here, where we are not safe setting it in test.
SynchronizationContext.SetSynchronizationContext(dispatcherSynchronizationContext);
// Just call back into the normal xUnit dispatch process now that we are on an STA Thread with no synchronization context.
var baseTask = base.RunAsync(diagnosticMessageSink, messageBus, constructorArguments, aggregator, cancellationTokenSource);
do
{
var delay = Task.Delay(TimeSpan.FromMilliseconds(10), cancellationTokenSource.Token);
var completed = await Task.WhenAny(baseTask, delay).ConfigureAwait(false);
if (completed == baseTask)
{
return await baseTask.ConfigureAwait(false);
}
// Schedule a task to pump messages on the UI thread.
await Task.Factory.StartNew(
() => WaitHelper.WaitForDispatchedOperationsToComplete(DispatcherPriority.ApplicationIdle),
cancellationTokenSource.Token,
TaskCreationOptions.None,
sta).ConfigureAwait(false);
}
while (true);
}
finally
{
ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = null;
// Cleanup the synchronization context even if the test is failing exceptionally
SynchronizationContext.SetSynchronizationContext(null);
}
}
}, cancellationTokenSource.Token, TaskCreationOptions.None, sta);
return task.Unwrap();
}
object RunOnUIThread(DispatcherOperationCallback dispatcherMethod, bool async)
{
if (Application.Current != null)
{
if (Application.Current.Dispatcher.Thread == Thread.CurrentThread)
{
// This avoids dispatching to the UI thread if we are already in the UI thread.
// Without this runing a command like 1/0 was throwing due to nested dispatches.
return dispatcherMethod.Invoke(null);
}
}
Exception e = null;
object returnValue = null;
SynchronizationContext sync = new DispatcherSynchronizationContext(Dispatcher);
if (sync == null) { return null; }
if (async)
{
sync.Post(
new SendOrPostCallback(delegate(object obj)
{
try
{
returnValue = dispatcherMethod.Invoke(obj);
}
catch (Exception uiException)
{
e = uiException;
}
}),
null);
}
else
{
sync.Send(
new SendOrPostCallback(delegate(object obj)
{
try
{
returnValue = dispatcherMethod.Invoke(obj);
}
catch (Exception uiException)
{
e = uiException;
}
}),
null);
}
if (e != null)
{
throw new System.Reflection.TargetInvocationException(e.Message, e);
}
return returnValue;
}
public void UserSuppliedDispatcher ()
{
Assert.Throws<ArgumentNullException> (delegate {
new DispatcherSynchronizationContext (null);
}, ".ctor(null)");
Dispatcher d = Application.Current.RootVisual.Dispatcher;
DispatcherSynchronizationContext dsc = new DispatcherSynchronizationContext (d);
Assert.AreNotSame (dsc, dsc.CreateCopy (), "CreateCopy");
}
public void Initialize(Dispatcher dispatcher)
{
if (dispatcher == null)
throw new ArgumentNullException("dispatcher");
lock (initializationLock)
{
this._dispatcher = dispatcher;
_context = new DispatcherSynchronizationContext(dispatcher);
}
}
protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
{
if (Application.Current == null)
{
throw new InvalidOperationException("Must have an application");
}
DispatcherSynchronizationContext syncContext = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
object dataContext = context.DataContext;
Action showDelegate = () => syncContext.Send(Show, dataContext);
context.UserState = showDelegate;
return showDelegate.BeginInvoke(callback, state);
}
public void Post ()
{
DispatcherSynchronizationContext dsc = new DispatcherSynchronizationContext ();
// that would throw a NRE but we can't catch it
//dsc.Post (null, this);
bool complete = false;
dsc.Post (delegate (object obj) {
Assert.IsNull (obj, "Post");
complete = true;
}, null);
EnqueueConditional (() => complete);
EnqueueTestComplete ();
}
static void Main()
{
var ctx = new DispatcherSynchronizationContext();
// SynchronizationContext.SetSynchronizationContext(ctx);
// CallerWithAsync();
// CallerWithContinuationTask();
// CallerWithAwaiter();
// MultipleAsyncMethods();
// MultipleAsyncMethodsWithCombinators1();
// MultipleAsyncMethodsWithCombinators2();
ConvertingAsyncPattern();
Console.ReadLine();
}
private static void VerifySynchronizationContext()
{
if (SynchronizationContext.Current != null)
{
return;
}
if (IsRunningInTest())
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
return;
}
var context = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
SynchronizationContext.SetSynchronizationContext(context);
}
static void Main(string[] args)
{
#if NET46
var ctx = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(ctx);
#endif
if (args.Length != 1)
{
Usage();
return;
}
switch (args[0].ToLower())
{
case "-async":
CallerWithAsync();
break;
case "-cont":
CallerWithContinuationTask();
break;
case "-awaiter":
CallerWithAwaiter();
break;
case "-masync":
MultipleAsyncMethods();
break;
case "-comb":
MultipleAsyncMethodsWithCombinators1();
break;
case "-comb2":
MultipleAsyncMethodsWithCombinators2();
break;
#if NET46
case "-casync":
ConvertingAsyncPattern();
break;
#endif
default:
Usage();
break;
}
ReadLine();
}
public void Send ()
{
DispatcherSynchronizationContext dsc = new DispatcherSynchronizationContext ();
// SL throw an NRE while moonlight does not
#if false
Assert.Throws<NullReferenceException> (delegate {
dsc.Send (null, this);
}, "Send(null,object)");
#endif
bool complete = false;
dsc.Send (delegate (object obj) {
Assert.IsNull (obj, "Send");
complete = true;
}, null);
EnqueueConditional (() => complete);
EnqueueTestComplete ();
}
public static void RunInWpfSyncContext(Func<Task> function) {
if (function == null) throw new ArgumentNullException("function");
var prevCtx = SynchronizationContext.Current;
try {
var syncCtx = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncCtx);
var task = function();
if (task == null) throw new InvalidOperationException();
var frame = new DispatcherFrame();
var t2 = task.ContinueWith(x => { frame.Continue = false; }, TaskScheduler.Default);
Dispatcher.PushFrame(frame); // execute all tasks until frame.Continue == false
task.GetAwaiter().GetResult(); // rethrow exception when task has failed
} finally {
SynchronizationContext.SetSynchronizationContext(prevCtx);
}
}
protected override void OnStartup(StartupEventArgs e)
{
// run bootstrapper
Bootstrapper bootstrapper = new Bootstrapper();
bootstrapper.Run();
// set shut down mode
ShutdownMode = ShutdownMode.OnExplicitShutdown;
MainContext = (DispatcherSynchronizationContext)DispatcherSynchronizationContext.Current;
MainWindow.Closing += (sender, args) =>
MainContext.Send(o => Shutdown(), null);
// handle exceptions
DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(App_DispatcherUnhandledException);
base.OnStartup(e);
MainWindow.Show();
}
public static bool Show(Exception exception, object owner = null)
{
var depObj = owner as DependencyObject;
var result = false;
SendOrPostCallback action =
obj =>
{
var w = new ExceptionDialog((Exception)obj);
try
{
w.Owner = depObj == null ? Application.Current.MainWindow : GetWindow(depObj);
}
catch (InvalidOperationException)
{
}
result = w.ShowDialog() == true;
};
var context = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
context.Send(action, exception);
return result;
}
/// <summary>
/// Create a copy of this SynchronizationContext.
/// </summary>
public override SynchronizationContext CreateCopy()
{
DispatcherSynchronizationContext copy;
if (BaseCompatibilityPreferences.GetReuseDispatcherSynchronizationContextInstance())
{
copy = this;
}
else
{
if (BaseCompatibilityPreferences.GetFlowDispatcherSynchronizationContextPriority())
{
copy = new DispatcherSynchronizationContext(_dispatcher, _priority);
}
else
{
copy = new DispatcherSynchronizationContext(_dispatcher, DispatcherPriority.Normal);
}
}
return(copy);
}
public static void Run(Func<Task> func)
{
var prevCtx = SynchronizationContext.Current;
try
{
var syncCtx = new DispatcherSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncCtx);
var t = func();
if (t == null) throw new InvalidOperationException();
var frame = new DispatcherFrame();
t.ContinueWith(_ => { frame.Continue = false; }, TaskScheduler.Default);
Dispatcher.PushFrame(frame);
t.GetAwaiter().GetResult();
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevCtx);
}
}
private void InvokeImpl()
{
SynchronizationContext oldSynchronizationContext = SynchronizationContext.Current;
try
{
// We are executing under the "foreign" execution context, but the
// SynchronizationContext must be for the correct dispatcher and
// priority.
DispatcherSynchronizationContext newSynchronizationContext;
if(BaseCompatibilityPreferences.GetReuseDispatcherSynchronizationContextInstance())
{
newSynchronizationContext = Dispatcher._defaultDispatcherSynchronizationContext;
}
else
{
if(BaseCompatibilityPreferences.GetFlowDispatcherSynchronizationContextPriority())
{
newSynchronizationContext = new DispatcherSynchronizationContext(_dispatcher, _priority);
}
else
{
newSynchronizationContext = new DispatcherSynchronizationContext(_dispatcher, DispatcherPriority.Normal);
}
}
SynchronizationContext.SetSynchronizationContext(newSynchronizationContext);
// Win32 considers timers to be low priority. Avalon does not, since different timers
// are associated with different priorities. So we promote the timers before we
// invoke any work items.
_dispatcher.PromoteTimers(Environment.TickCount);
if(_useAsyncSemantics)
{
try
{
_result = InvokeDelegateCore();
}
catch(Exception e)
{
// Remember this for the later call to InvokeCompletions.
_exception = e;
}
}
else
{
// Invoke the delegate and route exceptions through the dispatcher events.
_result = _dispatcher.WrappedInvoke(_method, _args, _numArgs, null);
// Note: we do not catch exceptions, they flow out the the Dispatcher.UnhandledException handling.
}
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldSynchronizationContext);
}
}
public void SetSyncContext(Dispatcher dispatcher)
{
_syncContext = new DispatcherSynchronizationContext(App.Current.RootVisual.Dispatcher);
}
/// <summary>
/// Create a copy of this SynchronizationContext.
/// </summary>
public override SynchronizationContext CreateCopy()
{
DispatcherSynchronizationContext copy;
if(BaseCompatibilityPreferences.GetReuseDispatcherSynchronizationContextInstance())
{
copy = this;
}
else
{
if(BaseCompatibilityPreferences.GetFlowDispatcherSynchronizationContextPriority())
{
copy = new DispatcherSynchronizationContext(_dispatcher, _priority);
}
else
{
copy = new DispatcherSynchronizationContext(_dispatcher, DispatcherPriority.Normal);
}
}
return copy;
}
public void AddControl_DifferentThreadInContextUsingConfiguration_UsesAmbientContext()
{
var window = new DummyWindow();
var client = container.Resolve<ClassUsingWindowInAmbientContext>();
ExecuteInThread(() =>
{
var dispatcherCtx = new DispatcherSynchronizationContext(window.Dispatcher);
SynchronizationContext.SetSynchronizationContext(dispatcherCtx);
client.DoWork(window.Panel);
});
Assert.IsNull(uncaughtException, "Expected no exception");
}
public void Initialize(Dispatcher dispatcher)
{
ArgumentValidator.AssertNotNull(dispatcher, "dispatcher");
lock (initializationLock)
{
this.dispatcher = dispatcher;
context = new DispatcherSynchronizationContext(dispatcher);
}
}
private Dispatcher()
{
_queue = new PriorityQueue<DispatcherOperation>();
_tlsDispatcher = this; // use TLS for ownership only
_dispatcherThread = Thread.CurrentThread;
// Add ourselves to the map of dispatchers to threads.
lock(_globalLock)
{
_dispatchers.Add(new WeakReference(this));
}
_unhandledExceptionEventArgs = new DispatcherUnhandledExceptionEventArgs(this);
_exceptionFilterEventArgs = new DispatcherUnhandledExceptionFilterEventArgs(this);
_dispatcherSynchronizationContext = new DispatcherSynchronizationContext(this);
// Create the message-only window we use to receive messages
// that tell us to process the queue.
MessageOnlyHwndWrapper window = new MessageOnlyHwndWrapper();
_window = new SecurityCriticalData<MessageOnlyHwndWrapper>( window );
_hook = new HwndWrapperHook(WndProcHook);
_window.Value.AddHook(_hook);
}
public static bool? Show(
string message,
string header,
MessageBoxButton button = MessageBoxButton.OK,
MessageBoxImage image = MessageBoxImage.Asterisk,
object owner = null)
{
switch (button)
{
case MessageBoxButton.OK:
SystemSounds.Asterisk.Play();
break;
case MessageBoxButton.OKCancel:
case MessageBoxButton.YesNo:
case MessageBoxButton.YesNoCancel:
SystemSounds.Exclamation.Play();
break;
}
bool? result = null;
SendOrPostCallback action = obj =>
{
var depObj = owner as DependencyObject;
var w = new MessageDialog(message, header, button, image);
var windowOwner = depObj == null ? Application.Current.MainWindow : GetWindow(depObj);
try
{
w.Owner = windowOwner;
}
catch (InvalidOperationException)
{
}
var view = owner as IView;
if (view != null && view.ImageSource != null)
w.Icon = view.ImageSource;
else if (owner != null && windowOwner != null)
w.Icon = windowOwner.Icon;
w.ShowDialog();
result = w._result;
};
var context = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
context.Send(action, null);
return result;
}
public void Default ()
{
DispatcherSynchronizationContext dsc = new DispatcherSynchronizationContext ();
Assert.AreNotSame (dsc, dsc.CreateCopy (), "CreateCopy");
}
public WpfDispatchService(DispatcherObject app)
{
Dispatcher = app.Dispatcher;
SyncContext = new DispatcherSynchronizationContext(Dispatcher);
}
public MainWindow()
{
InitializeComponent();
SearchResults = new ThreadSafeObservableCollection<SearchResult>(null, 750000);
DisplaySearchResults = new ThreadSafeObservableCollection<SearchResult>();
_uiSynchronizationContext = new DispatcherSynchronizationContext(Application.Current.Dispatcher);
_taskConsumer = Task.Factory.StartNew(() => ConsumeTasks(_tasks));
_updateFilter = new DeferredAction(FilterResults);
_journals = new List<UsnJournal>();
// TODO: Convert to a user setting
string[] drives = { "C" };
DataContext = this;
if (DesignerProperties.GetIsInDesignMode(this))
{
return;
}
_predicates = new Dictionary<PredicateOption, Func<SearchResult, bool>>
{
{
PredicateOption.None,
result => SearchCaseInsensitive(result.Name)
},
{
PredicateOption.MultipleTerms,
result => SearchCaseInsensitiveMultiple(result.Name)
},
{
PredicateOption.CaseSensitive,
result => Search(result.Name)
},
{
PredicateOption.CaseSensitive | PredicateOption.MultipleTerms,
result => SearchMultiple(result.Name)
}
};
_searchTermNotifier = new PropertyChangeNotifier(this, "SearchTerm");
_searchTermNotifier.ValueChanged += OnSearchTermChanged;
AddTask(() => EnumerateJournals(drives), "Enumerating journals");
}
public void Run()
{
if (DataSetInfos.Count == 0)
{
return;
}
OnStart();
foreach (var uploadParam in DataSetInfos)
{
uploadParam.Reset();
}
_synchronizationContext = new DispatcherSynchronizationContext();
RunNext();
}
