/// <summary>
/// Downloads the pdbs from the symbol server.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="symbolServer">The symbol server name.</param>
/// <param name="downloadDir">The download directory. Can be null.</param>
/// <returns>
/// true if all symbols could be downloaded. False otherwise.
/// </returns>
public bool DownloadPdbs(FileQuery query, string symbolServer, string downloadDir)
{
using (var t = new Tracer(myType, "DownloadPdbs"))
{
var lret = SymChkExecutor.bCanStartSymChk;
var currentFailCount = this.FailedPdbs.Count;
var fileQueue = query.EnumerateFiles;
var aggregator = new BlockingQueueAggregator <string>(fileQueue);
Action <string> downLoadPdbThread = (string fileName) =>
{
var pdbFileName = GetPdbNameFromBinaryName(fileName);
// delete old pdb to ensure that the new matching pdb is really downloaded. Symchk does not replace existing but not matching pdbs.
try
{
File.Delete(pdbFileName);
}
catch
{
}
if (!this.Executor.DownLoadPdb(fileName, symbolServer, downloadDir))
{
lock (this.FailedPdbs)
{
this.FailedPdbs.Add(Path.GetFileName(fileName));
}
}
else
{
lock (this.FailedPdbs)
{
this.SucceededPdbCount++;
}
}
};
var dispatcher = new WorkItemDispatcher <string>(this.myDownLoadThreadCount, downLoadPdbThread, "Pdb Downloader", aggregator, WorkItemOptions.AggregateExceptions);
try
{
dispatcher.Dispose();
}
catch (AggregateException ex)
{
t.Error(ex, "Got error during pdb download");
lret = false;
}
if (this.FailedPdbs.Count > currentFailCount)
{
t.Warning("The failed pdb count has increased by {0}", this.FailedPdbs.Count - currentFailCount);
lret = false;
}
return(lret);
}
}
public void ThrowException_On_Enqueue_WhenWorker_Has_Faulted()
{
bool bCalled = false;
BlockingQueue <string> work = new BlockingQueue <string>();
WorkItemDispatcher <string> dispatcher = new WorkItemDispatcher <string>(
5, // work in 5 threads
(data) =>
{
try
{
throw new Exception(ExceptionMessage);
}
finally
{
bCalled = true;
}
},
work
);
work.Enqueue("some work");
work.ReleaseWaiters();
while (!bCalled)
{
Thread.Sleep(10);
}
Thread.Sleep(10);
Assert.Throws <AggregateException>(() => dispatcher.Dispose());
}
public void Enqueue_Work_Without_WaitingForCompletion()
{
int count = 0;
int Runs = 100;
for (int k = 0; k < Runs; k++)
{
BlockingQueue <string> work = new BlockingQueue <string>();
WorkItemDispatcher <string> dispatcher = new WorkItemDispatcher <string>(
2, // work in 2 threads
(data) => Interlocked.Increment(ref count), // increment counter for each work item
work
);
for (int i = 0; i < Runs; i++)
{
work.Enqueue("Hello");
}
work.Enqueue(null);
}
for (int i = 0; i < 10; i++)
{
if (count == Runs * Runs)
{
break;
}
Thread.Sleep(100);
}
Assert.AreEqual(Runs * Runs, count, "All work items should be processed even when we do not wait for completion.");
}
public void Do_Not_Mask_Exceptions_When_Disposing()
{
Assert.Throws <DataMisalignedException>(() =>
{
bool bCalled = false;
BlockingQueue <string> work = new BlockingQueue <string>();
using (WorkItemDispatcher <string> dispatcher = new WorkItemDispatcher <string>(
5, // work in 5 threads
(data) =>
{
bCalled = true;
throw new Exception(ExceptionMessage);
},
work
))
{
work.Enqueue("some work");
while (!bCalled)
{
Thread.Sleep(10);
}
work.ReleaseWaiters();
throw new DataMisalignedException("Some other exception");
}
});
}
protected void GetFilesFromQueryMultiThreaded(List <FileQuery> fileQueries, Action <string> fileOperator)
{
BlockingQueue <string> [] queues = (from query in fileQueries
select query.EnumerateFiles).ToArray();
BlockingQueueAggregator <string> aggregator = new BlockingQueueAggregator <string>(queues);
var dispatcher = new WorkItemDispatcher <string>(myParsedArgs.ThreadCount, fileOperator, "File Loader", aggregator, WorkItemOptions.AggregateExceptions);
// Wait until work is done
dispatcher.Dispose();
}
public EffectRendererWorkItemQueue(WorkItemDispatcher dispatcher, WorkItemQueuePriority priority, int maxThreadCount) : base(dispatcher, priority)
{
this.sync = new object();
this.maxThreadCount = maxThreadCount;
this.queue = new ConcurrentQueue <Action>();
this.idleEvent = new ManualResetEvent(true);
MultithreadedWorkItemDispatcher dispatcher2 = dispatcher as MultithreadedWorkItemDispatcher;
if (dispatcher2 != null)
{
this.threadCountToken = dispatcher2.UseThreadCount(maxThreadCount);
}
}
public void RethrowException_On_Dispose_By_Default()
{
BlockingQueue <string> work = new BlockingQueue <string>();
WorkItemDispatcher <string> dispatcher = new WorkItemDispatcher <string>(
5, // work in 5 threads
(data) =>
{
throw new Exception(ExceptionMessage);
},
work
);
work.Enqueue("some work");
work.ReleaseWaiters();
Assert.Throws <AggregateException>(() => dispatcher.Dispose());
}
public void Do_Not_Throw_On_Enqueue_When_Aggregating()
{
int called = 0;
BlockingQueue <string> work = new BlockingQueue <string>();
WorkItemDispatcher <string> dispatcher = new WorkItemDispatcher <string>(
5, // work in 5 threads
(data) =>
{
Interlocked.Increment(ref called);
throw new Exception(ExceptionMessage);
},
work,
WorkItemOptions.AggregateExceptions
);
work.Enqueue("some work");
while (called == 0)
{
Thread.Sleep(10);
}
for (int i = 0; i < 100; i++)
{
work.Enqueue("other work");
}
work.ReleaseWaiters();
try
{
dispatcher.Dispose();
}
catch (AggregateException ex)
{
Assert.AreEqual(101, ex.InnerExceptions.Count);
}
}
public void Can_Use_WorkItemDispatcher_On_STA_Thread()
{
Exception cex = null;
Thread t = new Thread(() =>
{
try
{
var queue = new BlockingQueue <string>();
int processed = 0;
var dispatcher = new WorkItemDispatcher <string>(5,
(workstring) =>
{
Interlocked.Increment(ref processed);
},
"Tester", queue);
queue.Enqueue("Work1");
queue.Enqueue("Work2");
queue.ReleaseWaiters();
dispatcher.Dispose();
}
catch (Exception ex)
{
cex = ex;
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
if (cex != null)
{
Assert.Fail("Get Exception On STA Thread: " + cex);
}
}
public DocumentCanvasTileCache(DocumentCanvasLayer owner, IBitmapSource <ColorBgra32> source, int sourceTileEdgeLog2, int mipLevel, bool highQuality)
{
Validate.Begin().IsNotNull <DocumentCanvasLayer>(owner, "owner").IsNotNull <IBitmapSource <ColorBgra32> >(source, "source").Check();
if (sourceTileEdgeLog2 < 0)
{
ExceptionUtil.ThrowArgumentOutOfRangeException("sourceTileEdgeLog2");
}
if (mipLevel < 0)
{
ExceptionUtil.ThrowArgumentOutOfRangeException("mipLevel");
}
this.syncContext = SynchronizationContext.Current;
this.owner = owner;
this.source = source;
this.sourceSize = this.source.Size;
this.sourceBounds = this.source.Bounds();
this.isHighQuality = highQuality;
this.tileMathHelper = new PaintDotNet.Rendering.TileMathHelper(this.sourceSize.Width, this.sourceSize.Height, sourceTileEdgeLog2);
this.mipLevel = mipLevel;
this.tileIsValid = ArrayUtil.Create2D <bool>(this.tileMathHelper.TileRows, this.tileMathHelper.TileColumns);
this.invalidTileOffsets = new DequeSet <PointInt32>();
this.tileBuffers = ArrayUtil.Create2D <IBitmap <ColorPbgra32> >(this.tileMathHelper.TileRows, this.tileMathHelper.TileColumns);
for (int i = 0; i < this.tileMathHelper.TileRows; i++)
{
for (int j = 0; j < this.tileMathHelper.TileColumns; j++)
{
this.invalidTileOffsets.TryEnqueue(new PointInt32(j, i));
}
}
this.tilesRenderQueue = new DequeSet <PointInt32>();
this.tilesRenderingSet = new HashSet <PointInt32>();
this.tilesRenderingCancelledSet = new ConcurrentSet <PointInt32>();
this.tilesRenderedQueue = new ConcurrentDequeDictionary <PointInt32, RenderedTileInfo>();
this.processTileRenderQueueCallback = new SendOrPostCallback(this.ProcessTileRenderQueueCallback);
this.processTileRenderedQueueCallback = new SendOrPostCallback(this.ProcessTileRenderedQueueCallback);
this.workItemDispatcher = WorkItemDispatcher.Default;
this.workItemQueue = new EditableDataWorkItemQueue <PointInt32>(this.workItemDispatcher, new Action <PointInt32>(this.RenderTileWorkItem));
}
public void Can_Process_List_Of_Queues()
{
var q1 = new BlockingQueue <string>();
var q2 = new BlockingQueue <string>();
var q3 = new BlockingQueue <string>();
var queues = new BlockingQueue <string>[] { q1, q2, q3 };
var agg = new BlockingQueueAggregator <string>(queues);
int processed = 0;
var dispatcher = new WorkItemDispatcher <string>(5,
(workstring) =>
{
Interlocked.Increment(ref processed);
},
"Tester", agg);
const int Runs = 10;
for (int i = 0; i < Runs; i++)
{
for (int k = 0; k < queues.Length; k++)
{
queues[k].Enqueue("q" + k.ToString() + "_" + i.ToString());
}
}
// signal end of each queue
q1.Enqueue(null);
q2.Enqueue(null);
q3.Enqueue(null);
dispatcher.Dispose();
Assert.AreEqual(Runs * queues.Length, processed);
}
///// <summary>
///// Count Test Cases using a filter
///// </summary>
///// <param name="filter">The filter to apply</param>
///// <returns>The number of test cases found</returns>
//public int CountTestCases(TestFilter filter)
//{
// return this.suite.CountTestCases(filter);
//}
/// <summary>
/// Run selected tests and return a test result. The test is run synchronously,
/// and the listener interface is notified as it progresses.
/// </summary>
/// <param name="listener">Interface to receive EventListener notifications.</param>
/// <param name="filter">A test filter used to select tests to be run</param>
/// <returns></returns>
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
log.Info("Running tests");
if (_loadedTest == null)
{
throw new InvalidOperationException("Run was called but no test has been loaded.");
}
// Save Console.Out and Error for later restoration
TextWriter savedOut = Console.Out;
TextWriter savedErr = Console.Error;
TestExecutionContext initialContext = CreateTestExecutionContext(_settings);
#if NUNITLITE
initialContext.Listener = listener;
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
workItem.Execute();
_runComplete.WaitOne();
return(workItem.Result);
#else
QueuingEventListener queue = new QueuingEventListener();
if (_settings.Contains("CaptureStandardOutput"))
{
initialContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
}
if (_settings.Contains("CapureStandardError"))
{
initialContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
}
initialContext.Listener = queue;
int numWorkers = _settings.Contains("NumberOfTestWorkers")
? (int)_settings["NumberOfTestWorkers"]
: 0;
WorkItemDispatcher dispatcher = null;
if (numWorkers > 0)
{
dispatcher = new WorkItemDispatcher(numWorkers);
initialContext.Dispatcher = dispatcher;
}
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
using (EventPump pump = new EventPump(listener, queue.Events))
{
pump.Start();
if (dispatcher != null)
{
dispatcher.Dispatch(workItem);
dispatcher.Start();
}
else
{
workItem.Execute();
}
_runComplete.WaitOne();
}
Console.SetOut(savedOut);
Console.SetError(savedErr);
if (dispatcher != null)
{
dispatcher.Stop();
dispatcher = null;
}
return(workItem.Result);
#endif
}
/// <summary>
/// Run selected tests and return a test result. The test is run synchronously,
/// and the listener interface is notified as it progresses.
/// </summary>
/// <param name="listener">Interface to receive EventListener notifications.</param>
/// <param name="filter">A test filter used to select tests to be run</param>
/// <returns></returns>
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
log.Info("Running tests");
if (_loadedTest == null)
{
throw new InvalidOperationException("Run was called but no test has been loaded.");
}
// Save Console.Out and Error for later restoration
TextWriter savedOut = Console.Out;
TextWriter savedErr = Console.Error;
TestExecutionContext initialContext = CreateTestExecutionContext(_settings);
#if NUNITLITE
initialContext.Listener = listener;
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
workItem.Execute();
_runComplete.WaitOne();
return(workItem.Result);
#else
QueuingEventListener queue = new QueuingEventListener();
if (_settings.Contains("CaptureStandardOutput"))
{
initialContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
}
if (_settings.Contains("CapureStandardError"))
{
initialContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
}
initialContext.Listener = queue;
int levelOfParallelization = _settings.Contains("NumberOfTestWorkers")
? (int)_settings["NumberOfTestWorkers"]
: _loadedTest.Properties.ContainsKey(PropertyNames.LevelOfParallelization)
? (int)_loadedTest.Properties.Get(PropertyNames.LevelOfParallelization)
: Math.Max(Environment.ProcessorCount, 2);
WorkItemDispatcher dispatcher = null;
if (levelOfParallelization > 0)
{
dispatcher = new WorkItemDispatcher(levelOfParallelization);
initialContext.Dispatcher = dispatcher;
// Assembly does not have IApplyToContext attributes applied
// when the test is built, so we do it here.
// TODO: Generalize this
if (_loadedTest.Properties.ContainsKey(PropertyNames.ParallelScope))
{
initialContext.ParallelScope =
(ParallelScope)_loadedTest.Properties.Get(PropertyNames.ParallelScope) & ~ParallelScope.Self;
}
}
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
using (EventPump pump = new EventPump(listener, queue.Events))
{
pump.Start();
if (dispatcher != null)
{
dispatcher.Dispatch(workItem);
dispatcher.Start();
}
else
{
workItem.Execute();
}
_runComplete.WaitOne();
}
Console.SetOut(savedOut);
Console.SetError(savedErr);
if (dispatcher != null)
{
dispatcher.Stop();
dispatcher = null;
}
return(workItem.Result);
#endif
}
/// <summary>
/// Downloads the pdbs from the symbol server.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="symbolServer">The symbol server name.</param>
/// <param name="downloadDir">The download directory. Can be null.</param>
/// <returns>
/// true if all symbols could be downloaded. False otherwise.
/// </returns>
public bool DownloadPdbs(FileQuery query, string symbolServer, string downloadDir)
{
using (var t = new Tracer(myType, "DownloadPdbs"))
{
var lret = SymChkExecutor.bCanStartSymChk;
var currentFailCount = this.FailedPdbs.Count;
var fileQueue = query.EnumerateFiles;
var aggregator = new BlockingQueueAggregator<string>(fileQueue);
Action<string> downLoadPdbThread = (string fileName) =>
{
var pdbFileName = GetPdbNameFromBinaryName(fileName);
// delete old pdb to ensure that the new matching pdb is really downloaded. Symchk does not replace existing but not matching pdbs.
try
{
File.Delete(pdbFileName);
}
catch
{
}
if (!this.Executor.DownLoadPdb(fileName, symbolServer, downloadDir))
{
lock (this.FailedPdbs)
{
this.FailedPdbs.Add(Path.GetFileName(fileName));
}
}
else
{
lock (this.FailedPdbs)
{
this.SucceededPdbCount++;
}
}
};
var dispatcher = new WorkItemDispatcher<string>(this.myDownLoadThreadCount, downLoadPdbThread, "Pdb Downloader", aggregator, WorkItemOptions.AggregateExceptions);
try
{
dispatcher.Dispose();
}
catch (AggregateException ex)
{
t.Error(ex, "Got error during pdb download");
lret = false;
}
if (this.FailedPdbs.Count > currentFailCount)
{
t.Warning("The failed pdb count has increased by {0}", this.FailedPdbs.Count - currentFailCount);
lret = false;
}
return lret;
}
}
private void StartPart2(string mutexName, string[] remainingArgs)
{
IAnimationService animationService;
Memory.Initialize();
CultureInfo info = AppSettings.Instance.UI.Language.Value;
Thread.CurrentThread.CurrentUICulture = info;
CultureInfo.DefaultThreadCurrentUICulture = info;
AppSettings.Instance.UI.Language.Value = info;
PdnResources.Culture = info;
AppSettings.Instance.UI.ErrorFlagsAtStartup.Value = AppSettings.Instance.UI.ErrorFlags.Value;
WorkItemDispatcher.Initialize(AppSettings.Instance.Performance.ThreadUtilizationPolicy.Value);
UIUtil.IsGetMouseMoveScreenPointsEnabled = AppSettings.Instance.UI.EnableSmoothMouseInput.Value;
if (!OS.VerifyFrameworkVersion(4, 6, 0, OS.FrameworkProfile.Full))
{
string message = PdnResources.GetString("Error.FXRequirement");
MessageBoxUtil.ErrorBox(null, message);
string fxurl = "https://www.microsoft.com/en-us/download/details.aspx?id=53345";
() => ShellUtil.LaunchUrl2(null, fxurl).Eval <bool>().Observe();
}
else if (!OS.VerifyWindowsVersion(6, 1, 1))
{
string str4 = PdnResources.GetString("Error.OSRequirement");
MessageBoxUtil.ErrorBox(null, str4);
}
else if (!Processor.IsFeaturePresent(ProcessorFeature.SSE))
{
string str5 = PdnResources.GetString("Error.SSERequirement");
MessageBoxUtil.ErrorBox(null, str5);
}
else
{
string str;
if (MultithreadedWorkItemDispatcher.IsSingleThreadForced && PdnInfo.IsFinalBuild)
{
throw new PaintDotNet.InternalErrorException("MultithreadedWorkItemDispatcher.IsSingleThreadForced shouldn't be true for Final builds!");
}
if (RefTrackedObject.IsFullRefTrackingEnabled && PdnInfo.IsFinalBuild)
{
throw new PaintDotNet.InternalErrorException("Full ref tracking should not be enabled for non-expiring builds!");
}
PaintDotNet.Base.AssemblyServices.RegisterProxies();
PaintDotNet.Core.AssemblyServices.RegisterProxies();
PaintDotNet.Framework.AssemblyServices.RegisterProxies();
ObjectRefProxy.CloseRegistration();
remainingArgs = TryRemoveArg(remainingArgs, "/showCrashLog=", out str);
if (!string.IsNullOrWhiteSpace(str))
{
DialogResult?nullable = null;
try
{
string fullPath = Path.GetFullPath(str);
if (File.Exists(fullPath))
{
nullable = new DialogResult?(CrashManager.ShowCrashLogDialog(fullPath));
}
}
catch (Exception exception)
{
try
{
MessageBox.Show(exception.ToString(), null, MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
catch (Exception exception2)
{
Environment.FailFast(null, exception2);
}
}
DialogResult?nullable2 = nullable;
DialogResult oK = DialogResult.OK;
if ((((DialogResult)nullable2.GetValueOrDefault()) == oK) ? nullable2.HasValue : false)
{
string[] args = new string[] { "/sleep=1000" };
StartNewInstance(null, false, args);
}
}
else
{
string str2;
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Startup.OnCurrentDomainUnhandledException);
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException, true);
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException, false);
Application.ThreadException += new ThreadExceptionEventHandler(Startup.OnApplicationThreadException);
this.canUseCrashDialog = true;
remainingArgs = TryRemoveArg(remainingArgs, "/test", out str2);
if (str2 != null)
{
PdnInfo.IsTestMode = true;
}
SingleInstanceManager disposeMe = new SingleInstanceManager(mutexName);
animationService = null;
try
{
DirectWriteFactory.DefaultDirectWriteSettingsController defaultDirectWriteSettingsController;
DrawingContext.DefaultDrawingContextSettingsController defaultDrawingContextSettingsController;
IDisposable updatesServiceShutdown;
IUpdatesServiceHost updatesServiceHost;
PdnSynchronizationContext pdnSyncContext;
if (!disposeMe.IsFirstInstance)
{
disposeMe.FocusFirstInstance();
foreach (string str7 in remainingArgs)
{
disposeMe.SendInstanceMessage(str7, 30);
}
disposeMe.Dispose();
disposeMe = null;
}
else
{
CleanupService.Initialize();
ResourcesService.Initialize();
UserFilesService.Initialize();
UserPalettesService.Initialize();
animationService = AnimationService.Initialize();
animationService.IsEnabled = true;
Document.Initialize(PdnInfo.Version);
Layer.Initialize(PdnResources.GetString("Layer.BackgroundLayer.DefaultName"));
Effect.SetDefaultServiceProviderValueFactory(effect => new ServiceProviderForEffects());
defaultDirectWriteSettingsController = DirectWriteFactory.GetDefaultSettingsController();
defaultDirectWriteSettingsController.DefaultCulture = AppSettings.Instance.UI.Language.Value;
AppSettings.Instance.UI.Language.ValueChangedT += (sender, e) => (defaultDirectWriteSettingsController.DefaultCulture = e.NewValue);
AeroColors.CurrentScheme = AppSettings.Instance.UI.AeroColorScheme.Value;
AppSettings.Instance.UI.AeroColorScheme.ValueChangedT += (sender, e) => (AeroColors.CurrentScheme = e.NewValue);
defaultDrawingContextSettingsController = DrawingContext.GetDefaultSettingsController();
defaultDrawingContextSettingsController.DefaultTextAntialiasMode = AppSettings.Instance.UI.DefaultTextAntialiasMode.Value;
AppSettings.Instance.UI.DefaultTextAntialiasMode.ValueChangedT += delegate(object sender, ValueChangedEventArgs <TextAntialiasMode> e) {
defaultDrawingContextSettingsController.DefaultTextAntialiasMode = e.NewValue;
foreach (Form form in Application.OpenForms)
{
form.PerformLayoutRecursiveDepthFirst("TextAntialiasMode");
form.Invalidate(true);
}
};
defaultDrawingContextSettingsController.DefaultTextRenderingMode = AppSettings.Instance.UI.DefaultTextRenderingMode.Value;
AppSettings.Instance.UI.DefaultTextRenderingMode.ValueChangedT += delegate(object sender, ValueChangedEventArgs <TextRenderingMode> e) {
defaultDrawingContextSettingsController.DefaultTextRenderingMode = e.NewValue;
foreach (Form form in Application.OpenForms)
{
form.PerformLayoutRecursiveDepthFirst("TextRenderingMode");
form.Invalidate(true);
}
};
PaintDotNet.IndirectUI.ControlInfo.Initialize(Assembly.GetExecutingAssembly());
PdnBaseForm.SetStaticHelpRequestedHandler(delegate(object sender, HelpEventArgs e) {
HelpService.Instance.ShowHelp(sender as IWin32Window);
e.Handled = true;
});
Control control = new Control();
SynchronizationContext current = SynchronizationContext.Current;
PdnSynchronizationContextController controller = PdnSynchronizationContext.Install(new WaitForMultipleObjectsExDelegate(WaitHelper.WaitForMultipleObjectsEx), new SleepExDelegate(WaitHelper.SleepEx));
pdnSyncContext = controller.Instance;
this.mainForm = new MainForm(remainingArgs);
updatesServiceHost = this.mainForm.CreateUpdatesServiceHost();
updatesServiceShutdown = null;
EventHandler initUpdatesOnShown = null;
initUpdatesOnShown = delegate(object sender, EventArgs e) {
this.mainForm.Shown -= initUpdatesOnShown;
updatesServiceShutdown = UpdatesService.Initialize(updatesServiceHost);
};
this.mainForm.Shown += initUpdatesOnShown;
this.mainForm.SingleInstanceManager = disposeMe;
disposeMe = null;
int num = (int)Math.Floor((double)8.3333333333333339);
int intervalMs = (int)Math.Floor((double)50.0);
using (AnimationTimerUpdateThread timerThread = new AnimationTimerUpdateThread(intervalMs, false))
{
< > c__DisplayClass20_1 class_3;