这个类库是在codeproject上发现的，主要是用于在.net 2.0,3.5的框架下，不可以在非创建线程下雨控件进行交互的限制，类库封装得比较好，使用了匿名方法。
Code 
// Copyright (c) 2008 CodeToast.com and Nicholas Brookins//This code is free to use in any application for any use if this notice is left intact.//Just don't sue me if it gets you fired. Enjoy!using System;using System.Collections.Generic;using System.Reflection;using System.Text;using System.Runtime.Remoting.Messaging;using System.Threading;using System.Windows.Forms;namespace CodeToast 
{ 
public static class Async { 
static Dictionary<string, object> methodLocks = new Dictionary<string, object>(); Async 'Do' overloads, for ease of use#region Async 'Do' overloads, for ease of use /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// This overload always tries the ThreadPool and DOES NOT check for reentrance. /// </summary> /// <param name="d">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return: Async.Do((DlgR)MyMethod);</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param>
/// <returns>AsyncRes with all kind o' goodies for waiting, etc.</returns> public static AsyncRes Do(DlgR d, bool getRetVal) { return Do(d, getRetVal, ReenteranceMode.Allow); } /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// This overload always tries the ThreadPool and DOES NOT check for reentrance. /// </summary> /// <param name="d">A void delegate - can be cast to (Dlg) from an anonymous delgate or method: Async.Do((Dlg)MyVoidMethod)</param> /// <returns>AsyncRes with all kind o' goodies for waiting, etc.</returns> public static AsyncRes Do(Dlg d) { return Do(d, ReenteranceMode.Allow); } /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return: Async.Do((DlgR)MyMethod);</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <returns>AsyncRes with all kind o' goodies for waiting, resturn and result values, etc.</returns> public static AsyncRes Do(DlgR d, bool getRetVal, ReenteranceMode rMode) { return Do(d, null, getRetVal, null, true, rMode, null, true); } /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A void delegate - can be cast to (Dlg) from an anonymous delgate or method: Async.Do((Dlg)MyVoidMethod);</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> public static AsyncRes Do(Dlg d, ReenteranceMode rMode) { return Do(null, d, false, null, true, rMode, null, true); } /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return: Async.Do((DlgR)MyMethod);</param> /// <param name="state">A user object that can be tracked through the returned result</param> /// <param name="tryThreadPool">True to use the TP, otherwise just go to a ful lthread - good for long running tasks.</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <returns>AsyncRes with all kind o' goodies for waiting, resturn and result values, etc.</returns> public static AsyncRes Do(DlgR d, bool getRetVal, object state, bool tryThreadPool, ReenteranceMode rMode) { return Do(d, null, getRetVal, state, tryThreadPool, rMode, null, true); } /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A void delegate - can be cast to (Dlg) from an anonymous delgate or method: Async.Do((Dlg)MyVoidMethod);</param> /// <param name="state">A user object that can be tracked through the returned result</param> /// <param name="tryThreadPool">True to use the TP, otherwise just go to a ful lthread - good for long running tasks.</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> public static AsyncRes Do(Dlg d, object state, bool tryThreadPool, ReenteranceMode rMode) { return Do(null, d, false, state, tryThreadPool, rMode, null, true); } #endregion The Big Main private 'Do' method - called by all overloads.#region The Big Main private 'Do' method - called by all overloads. /**//// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A void delegate - can be cast to (Dlg) from an anonymous delgate.</param> /// <param name="dr">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return.</param> /// <param name="state">A user object that can be tracked through the returned result</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <param name="tryThreadPool">True to use the TP, otherwise just go to a ful lthread - good for long running tasks.</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> private static AsyncRes Do(DlgR dr, Dlg d, bool getRetVal, object state, bool tryThreadPool, ReenteranceMode rMode, Control control, bool async) { //get a generic MethodInfo for checks.. MethodInfo mi = ((dr != null) ? dr.Method : d.Method); //make a unique key for output usage string key = string.Format("{0}{1}{2}{3}", ((getRetVal) ? "<-" : ""), mi.DeclaringType, ((mi.IsStatic) ? ":" : "."), mi.Name); //our custom return value, holds our delegate, state, key, etc. AsyncRes res = new AsyncRes(state, ((dr != null) ? (Delegate)dr : (Delegate)d), key, rMode); //Create a delegate wrapper for what we will actually invoke.. Dlg dlg = (Dlg)delegate { if (!BeforeInvoke(res)) return; //checks for reentrance issues and sets us up try { if (res.IsCompleted) return; if (dr != null) { res.retVal = dr();//use this one if theres a return } else { d();//otherwise the simpler dlg } } catch (Exception ex) { //we never want a rogue exception on a random thread, it can't bubble up anywhere Console.WriteLine("Async Exception:" + ex); } finally { FinishInvoke(res);//this will fire our callback if they used it, and clean up } }; if (control != null) { res.control = control; res.result = AsyncAction.ControlInvoked; if (!async) { if (!control.InvokeRequired) { res.completedSynchronously = true; dlg(); } else { control.Invoke(dlg); } } else { control.BeginInvoke(dlg); } return res; } //don't catch these errors - if this fails, we shouldn't try a real thread or threadpool! if (tryThreadPool) { //we are going to use the .NET threadpool try { //get some stats - much better than trying and silently failing or throwing an expensive exception int minThreads, minIO, threads, ioThreads, totalThreads, totalIO; ThreadPool.GetMinThreads(out minThreads, out minIO); ThreadPool.GetAvailableThreads(out threads, out ioThreads); ThreadPool.GetMaxThreads(out totalThreads, out totalIO); //check for at least our thread plus one more in ThreadPool if (threads > minThreads) { //this is what actually fires this task off.. bool result = ThreadPool.QueueUserWorkItem((WaitCallback)delegate { dlg(); }); if (result) { res.result = AsyncAction.ThreadPool; //this means success in queueing and running the item return res; } else { //according to docs, this "won't ever happen" - exception instead, but just for kicks. Console.WriteLine( "Failed to queue in threadpool.", "Method: " + key); } } else { Console.WriteLine(String.Format("Insufficient idle threadpool threads: {0} of {1} - min {2}, Method: {3}", threads, totalThreads, minThreads, key)); } } catch (Exception ex) { Console.WriteLine("Failed to queue in threadpool: " + ex.Message, "Method: " + key); } } //if we got this far, then something up there failed, or they wanted a dedicated thread Thread t = new Thread((ThreadStart)delegate { dlg(); }); t.IsBackground = true; //this or threadpriority are candidates for additional settings t.Name = "Async_" + key; res.result = AsyncAction.Thread; t.Start(); return res; } #endregion Before and after - helper methods#region Before and after - helper methods private static bool BeforeInvoke(AsyncRes res) { //if marked as completed then we abort. if (res.IsCompleted) return false; //if mode is 'allow' there is nothing to check. Otherwise if (res.RMode != ReenteranceMode.Allow) { //be threadsafe with our one and only member field lock (methodLocks) { if (!methodLocks.ContainsKey(res.Method)) { //make sure we have a generic locking object in the collection, it will already be there if we are reentering methodLocks.Add(res.Method, new object()); } //if bypass mode and we can't get or lock, we dump out. if (res.RMode == ReenteranceMode.Bypass) { if (!Monitor.TryEnter(methodLocks[res.Method])) { res.result = AsyncAction.Reenterant; return false; } } else { //Otherwise in 'stack' mode, we just wait until someone else releases it Monitor.Enter(methodLocks[res.Method]); } //if we are here, all is good. //Set some properties on the result class to show when we started, and what thread we are on res.isStarted = true; res.startTime = DateTime.Now; res.thread = Thread.CurrentThread; } } return true; } private static void FinishInvoke(AsyncRes res) { if (res == null) return; try { //finish a few more properties res.isCompleted = true; res.completeTime = DateTime.Now; //set the resetevent, in case someone is using the waithandle to know when we have completed. res.mre.Set(); } catch (Exception ex) { Console.WriteLine("Error setting wait handle on " + (res.Method ?? "NULL") + ex); } if (res.RMode != ReenteranceMode.Allow) { //if mode is bypass or stack, then we must have a lock that needs releasing try { if (methodLocks.ContainsKey(res.Method)) { Monitor.Exit(methodLocks[res.Method]); } } catch (Exception ex) { Console.WriteLine("Error releasing reentrant lock on " + (res.Method ?? "NULL")+ ex); } } } #endregion UI Overloads#region UI Overloads /**//// <summary> /// Fires off your delegate, carefully using the correct UI thread /// </summary> /// <param name="d">A void delegate - can be cast to (Dlg) from an anonymous delgate or method: Async.Do((Dlg)MyVoidMethod);</param> /// <param name="async">Whether to run async, or try on current thread if invoke is not required.</param> /// <param name="c">A control to Invoke upon GUI thread of, if needed. Null if unused.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> public static AsyncRes UI(Dlg d, Control c, bool async) { return Do(null, d, false, null, false, ReenteranceMode.Allow, c, async); } /**//// <summary> /// Fires off your delegate, carefully using the correct UI thread /// </summary> /// <param name="d">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return: Async.Do((DlgR)MyMethod);</param> /// <param name="async">Whether to run async, or try on current thread if invoke is not required.</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <param name="c">A control to Invoke upon GUI thread of, if needed. Null if unused.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> public static AsyncRes UI(DlgR d, bool getRetVal, Control c, bool async) { return Do(d, null, getRetVal, null, false, ReenteranceMode.Allow, c, async); } /**//// <summary> /// Fires off your delegate, carefully using the correct UI thread /// </summary> /// <param name="d">A delegate with a return value of some sort - can be cast to (DlgR) from an anonymous delgate with a return: Async.Do((DlgR)MyMethod);</param> /// <param name="state">A user object that can be tracked through the returned result</param> /// <param name="async">Whether to run async, or try on current thread if invoke is not required.</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <param name="c">A control to Invoke upon GUI thread of, if needed. Null if unused.</param> /// <returns>AsyncRes with all kind o' goodies for waiting, result values, etc.</returns> public static AsyncRes UI(DlgR d, bool getRetVal, Control c, object state, bool async, ReenteranceMode rMode) { return Do(d, null, getRetVal, state, false, rMode, c, async); } #endregion } AsyncRes class#region AsyncRes class /**//// <summary> /// Used with the Async helper class, This class is mostly a holder for a lot of tracking fields and properties, with a few things mandated by the IAsyncResult interface. /// </summary> public class AsyncRes : IAsyncResult { internal AsyncRes(object state, Delegate d, string key, ReenteranceMode rMode) { this.state = state; this.asyncDelegate = d; this.key = key; this.RMode = rMode; } internal ReenteranceMode RMode = ReenteranceMode.Allow; internal Thread thread = null; private string key = null; public string Method { get { return key; } } private Delegate asyncDelegate = null; public Delegate AsyncDelegate { get { return asyncDelegate; } } internal AsyncAction result = AsyncAction.Unknown; public AsyncAction Result { get { return result; } } internal Control control = null; public Control Control { get { return control; } } internal DateTime createTime = DateTime.Now; public DateTime TimeCreated { get { return createTime; } } internal DateTime completeTime = DateTime.MinValue; public DateTime TimeCompleted { get { return completeTime; } } internal DateTime startTime = DateTime.Now; public DateTime TimeStarted { get { return startTime; } } public TimeSpan TimeElapsed { get { return ((completeTime > DateTime.MinValue) ? completeTime : DateTime.Now) - createTime; } } public TimeSpan TimeRunning { get { return (startTime == DateTime.MinValue) ? TimeSpan.Zero : ((completeTime > DateTime.MinValue) ? completeTime : DateTime.Now) - startTime;} } internal object retVal = null; public object ReturnValue { get { return retVal; } } internal bool isStarted = false; public bool IsStarted { get { return isStarted; } } private object state = null; public object AsyncState { get { return state; } } /**//// <summary> /// Aborts a running associated thread. If possible it will cancel if not yet started /// </summary> /// <returns>True if the thread could be cancelled before it started.</returns> public bool CancelOrAbort() { isCompleted = true; if (!isStarted) return true;//cancelled if (thread != null && thread.IsAlive) { thread.Abort(); } return false; } internal ManualResetEvent mre = new ManualResetEvent(false); public WaitHandle AsyncWaitHandle { get { return mre; } } internal bool completedSynchronously = false; public bool CompletedSynchronously { get { return completedSynchronously; } } internal bool isCompleted = false; public bool IsCompleted { get { return isCompleted; } } } #endregion Definitions of enums and delegates#region Definitions of enums and delegates /**//// <summary> /// Abreviated Empty Delegate for use in anonymous casting /// </summary> public delegate void Dlg(); /**//// <summary> /// Abreviated Empty Delegate for use in anonymous methods when a return is needed /// </summary> /// <returns>Umm, anything you want.</returns> public delegate object DlgR(); public enum AsyncAction { Unknown = 0, ThreadPool = 1, Thread = 2, Failed = 4, Reenterant = 8, ControlInvoked = 16 } public enum ReenteranceMode { Allow = 1, Bypass = 2, Stack = 4, } #endregion
} 异步获取控件值：
Code AsyncRes result = Async.UI( //make sure the delegate/method returns a value: delegate { return textBox1.Text; }, true, //yes, we want to get the return value myForm, //the control to invoke on null, //the state object, we don't need to track anything. true, //invoke asynchronously? ReenteranceMode.Allow); //don't worry about thread safety in this case.// . do other things //// now make sure the task above has completed.. result.AsyncWaitHandle.WaitOne();//and use the valueConsole.WriteLine("The textbox says: " + result.ReturnValue);
同步设置控件值：
Code Async.UI(delegate { textBox1.Text = "This is way easier!"; }, textBox1, true);