public static bool QueueUserWorkItem(WaitCallback callBack, object state) { if (callBack == null) { throw new ArgumentNullException("callBack"); } #if MOONLIGHT callBack = MoonlightHandler(callBack); #endif if (callBack.IsTransparentProxy()) { IAsyncResult ar = callBack.BeginInvoke(state, null, null); if (ar == null) { return(false); } } else { if (!callBack.HasSingleTarget) { throw new Exception("The delegate must have only one target"); } AsyncResult ares = new AsyncResult(callBack, state, true); pool_queue(ares); } return(true); }
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state) { // no stack propagation here (that's why it's unsafe and requires extra security permissions) if (!callBack.IsTransparentProxy()) { if (!callBack.HasSingleTarget) { throw new Exception("The delegate must have only one target"); } AsyncResult ares = new AsyncResult(callBack, state, false); pool_queue(ares); return(true); } try { if (!ExecutionContext.IsFlowSuppressed()) { ExecutionContext.SuppressFlow(); // on current thread only } IAsyncResult ar = callBack.BeginInvoke(state, null, null); if (ar == null) { return(false); } } finally { if (ExecutionContext.IsFlowSuppressed()) { ExecutionContext.RestoreFlow(); } } return(true); }
public static bool QueueUserWorkItem(WaitCallback callBack, object state) { if (Microsoft.ThreadPool.UseMicrosoftThreadPool) { return(Microsoft.ThreadPool.QueueUserWorkItem(callBack, state)); } else { if (callBack == null) { throw new ArgumentNullException("callBack"); } if (callBack.IsTransparentProxy()) { IAsyncResult ar = callBack.BeginInvoke(state, null, null); if (ar == null) { return(false); } } else { AsyncResult ares = new AsyncResult(callBack, state, true); pool_queue(ares); } return(true); } }
/// <summary>Queues a method for execution, and specifies an object containing data to be used by the method. The method executes when a thread pool thread becomes available.</summary> /// <returns>true if the method is successfully queued; <see cref="T:System.NotSupportedException" /> is thrown if the work item could not be queued.</returns> /// <param name="callBack">A <see cref="T:System.Threading.WaitCallback" /> representing the method to execute. </param> /// <param name="state">An object containing data to be used by the method. </param> /// <exception cref="T:System.NotSupportedException">The common language runtime (CLR) is hosted, and the host does not support this action.</exception> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="callBack" /> is null.</exception> /// <filterpriority>1</filterpriority> public static bool QueueUserWorkItem(WaitCallback callBack, object state) { if (callBack == null) { throw new ArgumentNullException("callBack"); } return(callBack.BeginInvoke(state, null, null) != null); }
public static bool QueueUserWorkItem(WaitCallback callback, object state) { IAsyncResult ar = callback.BeginInvoke(state, null, null); if (ar == null) { return(false); } return(true); }
public static bool QueueUserWorkItem(WaitCallback callBack, object state) { if (callBack == null) { throw new ArgumentNullException("callBack"); } #if NET_2_1 && !MONOTOUCH && !MICRO_LIB callBack = MoonlightHandler(callBack); #endif IAsyncResult ar = callBack.BeginInvoke(state, null, null); if (ar == null) { return(false); } return(true); }
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state) { // no stack propagation here (that's why it's unsafe and requires extra security permissions) IAsyncResult ar = null; try { if (!ExecutionContext.IsFlowSuppressed()) { ExecutionContext.SuppressFlow(); // on current thread only } ar = callBack.BeginInvoke(state, null, null); } finally { if (ExecutionContext.IsFlowSuppressed()) { ExecutionContext.RestoreFlow(); } } return(ar != null); }
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state) { if (Microsoft.ThreadPool.UseMicrosoftThreadPool) { return(Microsoft.ThreadPool.UnsafeQueueUserWorkItem(callBack, state)); } else { if (callBack == null) { throw new ArgumentNullException("callBack"); } // no stack propagation here (that's why it's unsafe and requires extra security permissions) if (!callBack.IsTransparentProxy()) { AsyncResult ares = new AsyncResult(callBack, state, false); pool_queue(ares); return(true); } try { if (!ExecutionContext.IsFlowSuppressed()) { ExecutionContext.SuppressFlow(); // on current thread only } IAsyncResult ar = callBack.BeginInvoke(state, null, null); if (ar == null) { return(false); } } finally { if (ExecutionContext.IsFlowSuppressed()) { ExecutionContext.RestoreFlow(); } } return(true); } }
public void FireAndForget(System.Threading.WaitCallback callback, object obj) { callback.BeginInvoke(obj, EndFireAndForget, callback); }
public void FireAndForget(System.Threading.WaitCallback callback) { callback.BeginInvoke(null, EndFireAndForget, callback); }