ThreadPool

system\console.cs (1)

1758if (!ThreadPool.QueueUserWorkItem(controlCCallback, delegateData)) {

system\io\filestream.cs (3)

271ThreadPool.QueueUserWorkItem(state => ((FileStreamAsyncResult)state).CallUserCallbackWorker(), this); 913b = ThreadPool.BindHandle(_handle); 1050b = ThreadPool.BindHandle(_handle);

system\runtime\compilerservices\AsyncMethodBuilder.cs (1)

1034ThreadPool.QueueUserWorkItem(state => ((ExceptionDispatchInfo)state).Throw(), edi);

system\runtime\compilerservices\YieldAwaitable.cs (2)

113ThreadPool.QueueUserWorkItem(s_waitCallbackRunAction, continuation); 117ThreadPool.UnsafeQueueUserWorkItem(s_waitCallbackRunAction, continuation);

system\runtime\remoting\crossappdomainchannel.cs (1)

608ThreadPool.QueueUserWorkItem(threadFunc);

system\runtime\remoting\crosscontextchannel.cs (1)

292ThreadPool.QueueUserWorkItem(threadFunc);

system\runtime\remoting\lease.cs (1)

478ThreadPool.QueueUserWorkItem(threadFunc, iar);

system\runtime\remoting\remotingproxy.cs (1)

522ThreadPool.QueueUserWorkItem(

system\runtime\remoting\synchronizeddispatch.cs (1)

261_waitHandle = ThreadPool.RegisterWaitForSingleObject(

system\threading\SemaphoreSlim.cs (1)

838ThreadPool.UnsafeQueueCustomWorkItem(waiterTask, forceGlobal: false);

system\threading\synchronizationcontext.cs (1)

131ThreadPool.QueueUserWorkItem(new WaitCallback(d), state);

system\threading\Tasks\ConcurrentExclusiveSchedulerPair.cs (1)

216ThreadPool.QueueUserWorkItem(state =>

system\threading\Tasks\FutureFactory.cs (1)

742ThreadPool.RegisterWaitForSingleObject(

system\threading\Tasks\Task.cs (3)

3631ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false); 3716ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false); 7226ThreadPool.UnsafeQueueUserWorkItem(state =>

system\threading\Tasks\TaskContinuation.cs (3)

626ThreadPool.UnsafeQueueCustomWorkItem(this, forceGlobal: false); 836ThreadPool.UnsafeQueueCustomWorkItem(atc, forceGlobal: false); 858ThreadPool.QueueUserWorkItem(s => ((ExceptionDispatchInfo)s).Throw(), edi);

system\threading\Tasks\ThreadPoolTaskScheduler.cs (5)

69ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue); 85if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task)) 107return ThreadPool.TryPopCustomWorkItem(task); 113return FilterTasksFromWorkItems(ThreadPool.GetQueuedWorkItems()); 132ThreadPool.NotifyWorkItemProgress();

system\threading\threadpool.cs (7)

57public static bool tpHosted = ThreadPool.IsThreadPoolHosted(); 586ThreadPool.RequestWorkerThread(); 805ThreadPool.ReportThreadStatus(true); 814ThreadPool.ReportThreadStatus(false); 827if (!ThreadPool.NotifyWorkItemComplete()) 1805ThreadPool.InitializeVMTp(ref ThreadPoolGlobals.enableWorkerTracking); 1851ThreadPool.InitializeVMTp(ref ThreadPoolGlobals.enableWorkerTracking);

system\threading\timer.cs (1)

436ThreadPool.UnsafeQueueUserWorkItem(callback, timer);

Shared\MS\Internal\SafeSecurityHelper.cs (1)

526ThreadPool.QueueUserWorkItem(callback, state);

src\Framework\MS\Internal\Data\DefaultAsyncDataDispatcher.cs (1)

36ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessRequest), request);

src\Framework\System\Windows\Data\ObjectDataProvider.cs (1)

306ThreadPool.QueueUserWorkItem(new WaitCallback(QueryWorker), null);

src\Framework\System\Windows\Data\XmlDataProvider.cs (3)

315ThreadPool.QueueUserWorkItem(new WaitCallback(BuildNodeCollectionAsynch), 382ThreadPool.QueueUserWorkItem(new WaitCallback(CreateDocFromExternalSourceAsynch), 430ThreadPool.QueueUserWorkItem(new WaitCallback(CreateDocFromInlineXmlAsync),

System\ServiceModel\Activation\ListenerAdapter.cs (1)

811ThreadPool.UnsafeRegisterWaitForSingleObject(wasConnected, Fx.ThunkCallback(new WaitOrTimerCallback(WasConnected)), null, ListenerConstants.WasConnectTimeout, true);

net\System\Net\_Connection.cs (4)

198ThreadPool.UnsafeQueueUserWorkItem(s_InvokeConnectionCallback, returnResult); 1540ThreadPool.UnsafeQueueUserWorkItem(m_PostReceiveDelegate, this); 1605ThreadPool.UnsafeQueueUserWorkItem(m_PostReceiveDelegate, this); 3584ThreadPool.UnsafeQueueUserWorkItem(m_PostReceiveDelegate, this);

net\System\Net\_LazyAsyncResult.cs (1)

409ThreadPool.QueueUserWorkItem(new WaitCallback(WorkerThreadComplete));

net\System\Net\_NetworkingPerfCounters.cs (1)

255if (!ThreadPool.QueueUserWorkItem(instance.Initialize))

net\System\Net\_TLSstream.cs (2)

513ThreadPool.QueueUserWorkItem(new WaitCallback(StartWakeupPendingIO), null); 604ThreadPool.QueueUserWorkItem(new WaitCallback(ResumeIOWorker), lazyResult);

net\System\Net\DNS.cs (2)

744ThreadPool.UnsafeQueueUserWorkItem(resolveCallback, asyncResult); 779ThreadPool.UnsafeQueueUserWorkItem(resolveCallback, asyncResult);

net\System\Net\filewebrequest.cs (2)

243ThreadPool.QueueUserWorkItem(s_GetRequestStreamCallback, m_ReadAResult); 277ThreadPool.QueueUserWorkItem(s_GetResponseCallback,m_WriteAResult);

net\System\Net\HttpListener.cs (1)

769ThreadPool.BindHandle(DangerousGetHandle());

net\System\Net\HttpWebRequest.cs (2)

3255ThreadPool.UnsafeQueueUserWorkItem(s_AbortWrapper, context); 4482ThreadPool.UnsafeQueueUserWorkItem(s_EndWriteHeaders_Part2Callback, thisHttpWebRequest);

net\System\Net\Internal.cs (1)

75ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);

net\System\Net\NetWebProxyFinder.cs (2)

97ThreadPool.UnsafeQueueUserWorkItem(abortWrapper, request); 542ThreadPool.UnsafeQueueUserWorkItem(abortWrapper, context);

net\System\Net\NetworkInformation\NetworkAddressChange.cs (2)

287s_registeredWait = ThreadPool.UnsafeRegisterWaitForSingleObject( 315s_registeredWait = ThreadPool.UnsafeRegisterWaitForSingleObject(

net\System\Net\NetworkInformation\ping.cs (2)

427ThreadPool.QueueUserWorkItem(new WaitCallback(ContinueAsyncSend), state); 667registeredWait = ThreadPool.RegisterWaitForSingleObject (pingEvent, new WaitOrTimerCallback (PingCallback), this, -1, true);

net\System\Net\NetworkInformation\TeredoHelper.cs (1)

188ThreadPool.UnsafeQueueUserWorkItem(RunCallback, null);

net\System\Net\SecureProtocols\_SslState.cs (4)

1176ThreadPool.QueueUserWorkItem(new WaitCallback(CompleteRequestWaitCallback), obj); 1255ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncResumeHandshakeRead), request); 1326ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncResumeHandshake), obj); 1419ThreadPool.QueueUserWorkItem(new WaitCallback(CompleteRequestWaitCallback), obj);

net\System\Net\Sockets\_BaseOverlappedAsyncResult.cs (1)

476ThreadPool.UnsafeRegisterWaitForSingleObject(

net\System\Net\Sockets\_MultipleConnectAsync.cs (1)

327ThreadPool.QueueUserWorkItem(CallAsyncFail);

net\System\Net\Sockets\Socket.cs (6)

5190ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(CompleteAcceptResults), null); 5320ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(AcceptCallback), nullState); 6402ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(((LazyAsyncResult)m_AcceptQueueOrConnectResult).InvokeCallback), new SocketException(SocketError.OperationAborted)); 6408ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(CompleteAcceptResults), null); 7541m_RegisteredWait = ThreadPool.UnsafeRegisterWaitForSingleObject(m_AsyncEvent, s_RegisteredWaitCallback, this, Timeout.Infinite, true); 7652ThreadPool.BindHandle(m_Handle);

services\io\system\io\FileSystemWatcher.cs (1)

1005ThreadPool.BindHandle(directoryHandle);

services\monitoring\system\diagnosticts\EventLogInternal.cs (1)

572info.registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(info.waitHandle, new WaitOrTimerCallback(StaticCompletionCallback), info, -1, false);

services\monitoring\system\diagnosticts\Process.cs (1)

1412this.registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(this.waitHandle,

sys\system\io\ports\SerialStream.cs (4)

757if (!ThreadPool.BindHandle(_handle)) 1841ThreadPool.QueueUserWorkItem(callErrorEvents, errors); 1847ThreadPool.QueueUserWorkItem(callPinEvents, nativeEvents); 1851ThreadPool.QueueUserWorkItem(callReceiveEvents, nativeEvents);

System.Activities.Presentation\System\Activities\Presentation\TaskDispatcher.cs (1)

31ThreadPool.QueueUserWorkItem(work, state);

System\Diagnostics\Eventing\Reader\EventLogWatcher.cs (1)

193this.registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(

System\IO\Pipes\Pipe.cs (1)

1476ThreadPool.QueueUserWorkItem(new WaitCallback(CallUserCallbackWorker));

System\IO\Pipes\PipeStream.cs (2)

162b = ThreadPool.BindHandle(handle); 1335ThreadPool.QueueUserWorkItem(new WaitCallback(CallUserCallbackWorker));

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\TaskDispatcher.cs (1)

31ThreadPool.QueueUserWorkItem(work, state);

fx\src\data\System\Data\ProviderBase\DbConnectionPool.cs (1)

1685ThreadPool.QueueUserWorkItem(_poolCreateRequest);

fx\src\data\System\Data\SqlClient\SqlDependencyListener.cs (1)

1382ThreadPool.QueueUserWorkItem(new WaitCallback(AppDomainUnloading), appDomainKey);

System\IO\Log\LogStore.cs (1)

177if (!ThreadPool.BindHandle(this.logFile))

System\IO\Log\OverlappedAsyncResult.cs (1)

117!ThreadPool.QueueUserWorkItem(InvokeUserCallback, this))

managementeventwatcher.cs (1)

734ThreadPool.QueueUserWorkItem(new WaitCallback(Cancel2));// Cancel(); //

System\Messaging\MessageQueue.cs (1)

4480ThreadPool.BindHandle(ReadHandle);

net\PeerToPeer\Collaboration\CollaborationHelperFunctions.cs (3)

442regPresenceChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(presenceChangedEvent, //Event that triggers the callback 500regAppChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(appChangedEvent, //Event that triggers the callback 558regObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(objChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\ContactManager.cs (6)

246m_regSubLstChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_subLstChangedEvent, //Event that triggers the callback 447m_regNameChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_nameChangedEvent, //Event that triggers the callback 654m_regPresenceChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_presenceChangedEvent, //Event that triggers the callback 868m_regAppChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_appChangedEvent, //Event that triggers the callback 1082m_regObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_objChangedEvent, //Event that triggers the callback 1546ThreadPool.QueueUserWorkItem(new WaitCallback(CreateContactAsyncHelper), new CreateContactAsyncState(peerNearMe, userToken));

net\PeerToPeer\Collaboration\MyContact.cs (3)

81PresenceChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(PresenceChangedEvent, //Event that triggers the callback 247AppChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(AppChangedEvent, //Event that triggers the callback 410ObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(ObjChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\Peer.cs (2)

1086m_RegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_InviteEvent, //Event that triggers the callback 1415ThreadPool.QueueUserWorkItem(new WaitCallback(ContinueCancelCallback), state);

net\PeerToPeer\Collaboration\PeerApplication.cs (1)

255m_regAppChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_appChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\PeerCollaboration.cs (1)

1043s_regNameChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(s_nameChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\PeerContact.cs (4)

570ThreadPool.QueueUserWorkItem(new WaitCallback(InternalSubscribe), true); 1237AppChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_appChangedEvent, //Event that triggers the callback 1487ObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_objChangedEvent, //Event that triggers the callback 1741PresenceChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_presenceChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\PeerEndPoint.cs (1)

220m_regNameChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_nameChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\PeerNearMe.cs (2)

463ThreadPool.QueueUserWorkItem(new WaitCallback(InternalRefreshData), true); 560s_registeredPNMWaitHandle = ThreadPool.RegisterWaitForSingleObject(s_peerNearMeChangedEvent, //Event that triggers the callback

net\PeerToPeer\Collaboration\PeerObject.cs (1)

207m_regObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_objChangedEvent, //Event that triggers the callback

net\PeerToPeer\PeerNameResolver.cs (2)

206m_RegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_EndPointInfoAvailableEvent, //Event that triggers the callback 449ThreadPool.QueueUserWorkItem(new WaitCallback(ContineCancelCallback));

channels\core\requestqueue.cs (3)

96ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); 148ThreadPool.UnsafeQueueUserWorkItem(_workItemCallback, null); 160ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);

channels\core\socketcache.cs (2)

370ThreadPool.UnsafeRegisterWaitForSingleObject( 393ThreadPool.UnsafeRegisterWaitForSingleObject(

channels\ipc\ipcport.cs (2)

43ThreadPool.BindHandle(_handle.Handle); 355ThreadPool.QueueUserWorkItem(new WaitCallback(CallUserCallbackWorker));

channels\ipc\portcache.cs (2)

57ThreadPool.UnsafeRegisterWaitForSingleObject( 81ThreadPool.UnsafeRegisterWaitForSingleObject(

channels\tcp\tcpserverchannel.cs (1)

366ThreadPool.QueueUserWorkItem(new WaitCallback(this.AcceptSocketCallbackAsync), ar);

System\ServiceModel\Channels\MsmqQueue.cs (2)

90ThreadPool.BindHandle(this.handle); 848ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped);

System\ServiceModel\Channels\OverlappedContext.cs (3)

91ThreadPool.UnsafeRegisterWaitForSingleObject(this.rootedHolder.EventHolder, OverlappedContext.cleanupCallback, this, Timeout.Infinite, true); 210this.registration = ThreadPool.UnsafeRegisterWaitForSingleObject(this.completionEvent, OverlappedContext.eventCallback, this, Timeout.Infinite, true); 289ThreadPool.UnsafeRegisterWaitForSingleObject(this.completionEvent, OverlappedContext.cleanupCallback, this, Timeout.Infinite, true);

System\ServiceModel\Channels\PipeConnection.cs (2)

682ThreadPool.BindHandle(this.pipe); 2119ThreadPool.BindHandle(pipeHandle);

System\ServiceModel\Channels\RequestChannel.cs (1)

379this.waitHandle = ThreadPool.RegisterWaitForSingleObject(this.requestChannel.closedEvent, completeWaitCallBack, this, TimeoutHelper.ToMilliseconds(timeout), true);

System\ServiceModel\Description\MetadataExchangeClient.cs (1)

887ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle,

System\Runtime\IOThreadScheduler.cs (1)

647ThreadPool.UnsafeQueueNativeOverlapped(this.nativeOverlapped);

System\Transactions\Oletx\OletxTransactionManager.cs (1)

537ThreadPool.UnsafeRegisterWaitForSingleObject(

System\Transactions\TransactionState.cs (2)

3631if ( !ThreadPool.QueueUserWorkItem( SignalMethod, tx )) 4788if (!ThreadPool.QueueUserWorkItem(SignalMethod, tx))

System\Transactions\VolatileEnlistmentMultiplexing.cs (4)

126if (!ThreadPool.QueueUserWorkItem(PrepareCallback, demux)) 186if (!ThreadPool.QueueUserWorkItem(CommitCallback, demux)) 246if (!ThreadPool.QueueUserWorkItem(RollbackCallback, demux)) 306if (!ThreadPool.QueueUserWorkItem(InDoubtCallback, demux))

Compilation\BuildResultCache.cs (2)

274ThreadPool.QueueUserWorkItem(new WaitCallback(MemoryBuildResultCache.ShutdownCallBack), "BuildResult change, cache key=" + key); 609ThreadPool.QueueUserWorkItem(new WaitCallback(DiskBuildResultCache.ShutdownCallBack));

Compilation\ClientBuildManager.cs (2)

713ThreadPool.QueueUserWorkItem(_onAppDomainUnloadedCallback); 745ThreadPool.QueueUserWorkItem(_onAppDomainShutdown, reason);

Hosting\ApplicationManager.cs (3)

648ThreadPool.UnsafeQueueUserWorkItem(_ => { 695ThreadPool.QueueUserWorkItem(_onRespondToPingWaitCallback); 1550ThreadPool.UnsafeQueueUserWorkItem(_tpCallback, this);

Hosting\BackgroundWorkScheduler.cs (1)

66ThreadPool.UnsafeQueueUserWorkItem(state => {

Hosting\HostingEnvironment.cs (2)

640ThreadPool.QueueUserWorkItem(this._initiateShutdownWorkItemCallback); 1540registeredWaitHandle = ThreadPool.UnsafeRegisterWaitForSingleObject(waitHandle, (_, __) => {

Hosting\ProcessHost.cs (1)

991ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object o) {

Hosting\SuspendManager.cs (3)

64ThreadPool.UnsafeQueueUserWorkItem(_ => { 76ThreadPool.UnsafeQueueUserWorkItem(_ => { 158ThreadPool.UnsafeQueueUserWorkItem(_quwiThunk, callback);

HttpApplication.cs (1)

2289ThreadPool.QueueUserWorkItem(_resumeStepsWaitCallback, error);

HttpRuntime.cs (5)

1189ThreadPool.GetMaxThreads(out workerMax, out ioMax); 1216ThreadPool.GetMaxThreads(out workerMax, out ioMax); 1227ThreadPool.GetMinThreads(out currentMinWorkerThreads, out currentMinIoThreads); 1234ThreadPool.SetMinThreads(newMinWorkerThreads, newMinIoThreads); 2298ThreadPool.QueueUserWorkItem(_theRuntime._appDomainUnloadallback);

LegacyAspNetSynchronizationContext.cs (1)

183ThreadPool.QueueUserWorkItem(callback);

RequestQueue.cs (5)

145ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxIoThreads); 152ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); 210ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads); 216ThreadPool.QueueUserWorkItem(_workItemCallback); 237ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);

UI\LegacyPageAsyncTaskManager.cs (1)

339ThreadPool.QueueUserWorkItem(_resumeTasksCallback);

UI\Page.cs (1)

5970ThreadPool.QueueUserWorkItem(_callHandlersThreadpoolCallback);

Util\CancellationTokenHelper.cs (1)

51ThreadPool.UnsafeQueueUserWorkItem(_ => {

Util\WorkItem.cs (1)

64ThreadPool.QueueUserWorkItem(_onQueueUserWorkItemCompletion, callback);

Hosting\DefaultWorkflowSchedulerService.cs (2)

156if (ThreadPool.QueueUserWorkItem(QueueWorkerProcess)) 268if (ThreadPool.QueueUserWorkItem(this.QueueWorkerProcess))

Shared\MS\Internal\SafeSecurityHelper.cs (1)

526ThreadPool.QueueUserWorkItem(callback, state);