private void VerifyDelegateNotNull(SendOrPostCallback d)
 {
     if (d == null)
     {
         throw new ArgumentNullException(SR.GetString("Async_NullDelegate"), "d");
     }
 }

 public override void Post(SendOrPostCallback d, object state)
 {
     lock (_postedCallbacks)
     {
         _postedCallbacks.Add(Tuple.Create(d, state));
     }
 }

 private AsyncSendData(AsyncDataHandler handler, Uri uriToUse, AtomEntry entry, AtomFeed feed,
     SendOrPostCallback callback, object userData, bool parseFeed)
     : base(uriToUse, null, userData, callback, parseFeed) {
     this.DataHandler = handler;
     this.entry = entry;
     this.Feed = feed;
 }

        public void Post(SendOrPostCallback callback, object state)
        {
            #region Contracts

            if (callback == null) throw new ArgumentNullException();

            #endregion

            // Create
            Action action = delegate()
            {
                try
                {
                    callback(state);
                }
                catch (Exception ex)
                {
                    Debug.Fail(string.Format("Delegate:{0}, State:{1}, Message:{2}", callback.GetType(), "Exception", ex.Message));
                }
            };

            // Set
            lock (_syncRoot)
            {
                // Require
                if (_operateState != OperateState.Started) throw new InvalidOperationException();
                if (_executeThreadState != OperateState.Started) throw new InvalidOperationException();

                // Attach
                _executeActionQueue.Enqueue(action);
            }
        }

 public Functions()
 {
     #region Initialize Delegates for Database Commands
     onGetProfileCompletedDelegate = new SendOrPostCallback(GetProfileCompleted);
     onGetServersCompletedDelegate = new SendOrPostCallback(GetServersCompleted);
     #endregion
 }

        public virtual void Post(SendOrPostCallback d, object state) {
#if (dotNET10 || dotNET11 || dotNETCF10)
            ThreadPool.QueueUserWorkItem(new WaitCallback(d), state);
#else
            ThreadPool.QueueUserWorkItem(d.Invoke, state);
#endif
        }

 public CallbackItem(SendOrPostCallback item, object state)
 {
     this.Id = Guid.NewGuid();
     this.executionCompleted = new ManualResetEvent(false);
     this.callback = item;
     this.state = state;
 }

 /// <summary>
 /// Post a call to the specified method on the creator thread
 /// </summary>
 /// <param name="callback">Method that is to be called</param>
 /// <param name="state">Method parameter/state</param>
 public void AsyncPost(SendOrPostCallback callback, object state)
 {
     if (IsAsyncCreatorThread)
         callback(state); // Call the method directly
     else
         AsynchronizationContext.Post(callback, state);  // Post on creator thread
 }

        public override async void Post(SendOrPostCallback d, object state)
        {
            // The call to Post() may be the state machine signaling that an exception is
            // about to be thrown, so we make sure the operation count gets incremented
            // before the Task.Run, and then decrement the count when the operation is done.
            OperationStarted();

            try
            {
                // await and eat exceptions that come from this post
                // We could get a thread abort, so we need to handle that
                await Task.Run(() =>
                {
                    try
                    {
                        Send(d, state);
                    }
                    finally
                    {
                        OperationCompleted();
                    }
                }).ConfigureAwait(false);
            }
            catch { }
        }

 void Invoke(SendOrPostCallback d, object state, bool sync)
 {
     if (sync)
         sc.Send(d,state);
     else
         sc.Post(d, state);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SynchronizedCall"/> class.
        /// </summary>
        /// <param name="callback">The call to marshal.</param>
        /// <param name="state">The state to provide to the call. <see langword="null"/> is fine if you don't need to include any state.</param>
        public SynchronizedCall(SendOrPostCallback callback, object state)
        {
            Throw.If.Null(callback, "callback");

            this.callback = callback;
            this.state = state;
        }

        public void Post(string resource, Dictionary<string, string> parameters, SendOrPostCallback onComplete) {
            var uriPath = resource;
            var uri = new Uri(uriPath, UriKind.Absolute);
            var httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
            httpWebRequest.Method = "POST";

            var writeRequest = new AsyncCallback(e => {
                httpWebRequest.ContentType = "application/x-www-form-urlencoded";

                var stream = httpWebRequest.EndGetRequestStream(e);
                var postData = string.Empty;

                foreach (var key in parameters.Keys) {
                    postData += key + "=" + parameters[key] + "&";
                }

                var streamWriter = new StreamWriter(stream);
                streamWriter.Write(postData);
                streamWriter.Close();
                stream.Close();

                httpWebRequest.BeginGetResponse(x => synchronizationContext.Post(onComplete, x), null);
            });

            httpWebRequest.BeginGetRequestStream(writeRequest, null);
        }

        public override void Post(SendOrPostCallback d, object state)
        {
            if (mQueue.IsAddingCompleted)
                throw new SynchronizationContextCompletedException();

            mQueue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
        }

 public static void Post(SendOrPostCallback callback, object state = null)
 {
     lock (s_posts)
     {
         s_posts.Add(Tuple.Create(callback, state));
     }
 }

		public override void Post(SendOrPostCallback d, object state)
		{
			lock (list)
			{
				list.Add(() => d(state));
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ImageListViewCacheThumbnail"/> class.
        /// </summary>
        /// <param name="owner">The owner control.</param>
        public ImageListViewCacheThumbnail(ImageListView owner)
        {
            context = null;
            bw = new QueuedBackgroundWorker();
            bw.ProcessingMode = ProcessingMode.LIFO;
            bw.IsBackground = true;
            bw.DoWork += bw_DoWork;
            bw.RunWorkerCompleted += bw_RunWorkerCompleted;

            checkProcessingCallback = new SendOrPostCallback(CanContinueProcessing);

            mImageListView = owner;
            CacheMode = CacheMode.OnDemand;
            CacheLimitAsItemCount = 0;
            CacheLimitAsMemory = 20 * 1024 * 1024;
            RetryOnError = false;

            thumbCache = new Dictionary<Guid, CacheItem>();
            editCache = new Dictionary<Guid, bool>();
            processing = new Dictionary<Guid, bool>();
            processingRendererItem = Guid.Empty;
            processingGalleryItem = Guid.Empty;

            rendererItem = null;
            galleryItem = null;

            MemoryUsed = 0;
            MemoryUsedByRemoved = 0;
            removedItems = new List<Guid>();

            disposed = false;
        }

        public override void Post(SendOrPostCallback d, object state)
        {
            if (isSingleThread) Queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            else
                base.Post(chainedState => CallWithOperationContext(d, state), state);

        }

 /// <inheritdoc/>
 public override void Send(SendOrPostCallback d, object state)
 {
     if (Dispatcher.UIThread.CheckAccess())
         d(state);
     else
         Dispatcher.UIThread.InvokeTaskAsync(() => d(state)).Wait();
 }

		public override void Send(SendOrPostCallback d, object state)
		{
			if (System.Threading.Thread.CurrentThread.ManagedThreadId == ApplicationHandler.MainThreadID)
			{
				d(state);
			}
			else
			{
				var evt = new ManualResetEvent(false);
				Exception exception = null;

				Idle.Add(() =>
				{
					try
					{
						d(state);
					}
					catch (Exception ex)
					{
						exception = ex;
					}
					finally
					{
						evt.Set();
					}
					return false;
				});

				evt.WaitOne();

				if (exception != null)
					throw exception;
			}
		}

        public override void Send(SendOrPostCallback d, object state) {
#if !dotNETCF10
            contextControl.Invoke(d, new object[] { state });
#else
            contextControl.Invoke(new EventHandler(new EventHandleCreate(d, state).EventHandler));
#endif
        }