public partial class Form1 : Form
    {
 
        public Form1()
        {
            InitializeComponent();
            this.backgroundWorker1.WorkerSupportsCancellation = true;
            this.backgroundWorker1.WorkerReportsProgress = true;
 
            this.backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
            this.backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
            this.backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
 
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            if (this.textBox1.Text != "" && this.textBox2.Text != "")
            {
                ab a = new ab(int.Parse(this.textBox1.Text), int.Parse(this.textBox2.Text));
                this.backgroundWorker1.RunWorkerAsync(a);
            }
 
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            this.backgroundWorker1.CancelAsync();
        }
 
        void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.progressBar1.Value = e.ProgressPercentage;
        }
 
        void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                this.textBox3.Text = "Result :Canclled!";
                this.progressBar1.Value = 100;
            }
            else if (e.Error != null)
            {
                MessageBox.Show("Error Details : " + (e.Error as Exception).ToString());
            }
            else
            {
                    this.textBox3.Text = "Result :" + e.Result;
                    this.progressBar1.Value = 100;
             }
        }
 
        void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            //do something here backgroundly.
 
                for (int i = 0; i < this.progressBar1.Maximum; i++)
                {
                    Thread.Sleep(50);
                    this.backgroundWorker1.ReportProgress(i);
 
                    if (this.backgroundWorker1.CancellationPending)
                    {
                        e.Cancel = true;
                        return;
                    }
 
                }
                ab a = (ab)e.Argument;
                e.Result = a.C;
 
            }
 
    }
 
    class ab
    {
        private int _a;
 
        public int A
        {
            get { return _a; }
            set { _a = value; }
        }
        private int _b;
 
        public int B
        {
            get { return _b; }
            set { _b = value; }
        }
        public ab(int a,int b)
        {
            this._a = a;
            this._b = b;
        }
 
        public int C
        {
            get { return _b + _a; }
        }
    }

        public class SynDemo
        {
            public virtual bool IsSynchronized
            {
                get { return false; }
            }
 
            public virtual void doThis()
            {
                //dothis
            }
 
            public virtual void doThat()
            {
                //doThat
            }
 
            public static SynDemo SynchronizeDemo(SynDemo d)
            {
                if (!d.IsSynchronized)
                {
                    return new SynchronizedDemo(d);
                }
                return d;
            }
 
                    private class SynchronizedDemo : SynDemo
                    {
                        private SynDemo _demo;
                        private object _synRoot =new object();
 
                        public SynchronizedDemo(SynDemo d)
                        {
                            this._demo = d;
                        }
 
                        public override bool IsSynchronized
                        {
                            get
                            {
                                return true;
                            }
                        }
 
                        public override void doThat()
                        {
                            lock(_synRoot)
                            {
                                _demo.doThat();
                            }
                        }
 
                        public override void doThis()
                        {
                            lock(_synRoot)
                            {
                                _demo.doThis();
                            }
                        }
 
                    }
        }

        public static void Main()
        {
            //1.使用一个带参数的委托ParameterizedThreadStart来初始化Thread
            myData data = new myData();
            data.Message = "new Info";
            new Thread(paralizeThread).Start(data);
            //2.通过初始化一个类的字段，将该类的方法封装到线程中去
            new Thread(new myThreadClass("new info2").ThreadMethod).Start();
 
        }
        //类或结构都行
        struct myData
        {
            string message;
 
            public string Message
            {
                get { return message; }
                set { message = value; }
            }
        }
 
        static void paralizeThread(object o)
        {
            myData data = (myData)o;
            Console.WriteLine("Thread {1} received a Parameter : {0}",data.Message,Thread.CurrentThread.ManagedThreadId);
        }
 
        class myThreadClass
        {
            string _message;
            public myThreadClass(string message)
            {
                this._message = message;
            }
 
            public void ThreadMethod()
            {
                Console.WriteLine("Thread {1} received a Parameter : {0}", this._message, Thread.CurrentThread.ManagedThreadId);
            }
        }

    class Programe
    {
        private delegate void ADelegateSomewhat(int x);
 
        public static void Main()
        {
            ADelegateSomewhat aD = MathPupil;
            ////1.直接调用EndInvoke,这和直接调用MathPupil(100)的效果一样，
            ////但会等到这个方法执行完之后才去执行后面的语句
            //IAsyncResult ar= aD.BeginInvoke(100,null,null);
            //aD.EndInvoke(ar);
 
            ////2.轮询,每隔50毫秒看看孩子算完了没.
            //IAsyncResult ar = aD.BeginInvoke(200, null, null);
            //while (!ar.IsCompleted)
            //{
            //    Console.Write(".");
            //    Thread.Sleep(500);
            //}
            //aD.EndInvoke(ar);
 
            ////3.实际上和2的方法类似，只是把Sleep的时间放上来了
            ////但事实上，功能会多点,比如控制跳出的条件等
            //IAsyncResult ar = aD.BeginInvoke(300,null,null);
            //while (!ar.AsyncWaitHandle.WaitOne(500))
            //{
            //    Console.Write(".");
            //}
            //aD.EndInvoke(ar);
 
            //4.回调函数,最有意义,设置相对麻烦点
            IAsyncResult ar = aD.BeginInvoke(400, MathCallBack, aD);
            //现在干点别的事，不用关心算算术题的孩子了。
            //由delegate的回调方法自动来管理
            Console.ReadLine();
            //如果不等待委托完成其任务就结束主线程，委托线程就会停止
        }
 
        //假装自己一个小学生处理一道加法算术题，历时5秒钟
        static void MathPupil(int x)
        {
            Console.WriteLine("Now I'll pretend to be a pupil");
            int sum = 0;
            for (int i = 0; i < x; i++)
            {
                sum += i;
                Thread.Sleep(5000/x);
            }
            Console.WriteLine("After 5 secends, i've got the answer :" +sum);
        }
 
        static void MathCallBack(IAsyncResult ar)
        {
            ADelegateSomewhat aD = (ADelegateSomewhat)ar.AsyncState;
            aD.EndInvoke(ar);
        }
 
    }

//核心代码
       public string ComplieAndRun(string input,out bool hasError)
        {
            CompilerResults cResults = null;
            string returnData = null;
            hasError = false;
 
            using(Microsoft.CSharp.CSharpCodeProvider provider =new CSharpCodeProvider())
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(prefix);
                sb.Append(input);
                sb.Append(postfix);
 
                CompilerParameters option = new CompilerParameters();
                option.GenerateInMemory = true;
                cResults=provider.CompileAssemblyFromSource(option, sb.ToString());
 
            }
 
            if (cResults.Errors.HasErrors)
            {
                hasError = true;
                StringBuilder errMessage = new StringBuilder();
                foreach (CompilerError err in cResults.Errors)
                {
                    errMessage.AppendFormat("{0}:{1}", err.Line, err.ErrorText);
                }
                returnData = errMessage.ToString();
            }
            else
            {
                TextWriter temp=Console.Out;
                StringWriter sw = new StringWriter();
                Console.SetOut(sw);
 
                Type myType = cResults.CompiledAssembly.GetType("myDriver");
                myType.InvokeMember("Run", BindingFlags.InvokeMethod|BindingFlags.Public | BindingFlags.Static, null, null, null);
 
                Console.SetOut(temp);
 
                returnData = sw.ToString();
            }
 
            return returnData;
        }
    }
 
    //每次动态调用后，通过应用程序域卸载掉
    public class DynamicRunAppInDomain
    {
        public string CompileAndRun(string input,out bool hasErr)
        {
            AppDomain app = AppDomain.CreateDomain("DynamicRun");
            DynamicRun dr = (DynamicRun)app.CreateInstanceAndUnwrap("ShaoMingboDrive", "WpfApplication1.DynamicRun");
            string res = dr.ComplieAndRun(input,out hasErr);
            AppDomain.Unload(app);
            return res;
 
        }
    }

        public static void Main()
        {
            int aNum;
            Console.WriteLine("Input a number between 1 and 5:");
            string userInput = Console.ReadLine();
            try
            {
                aNum = Int32.Parse(userInput);
                if (aNum<1 || aNum> 5)
                    throw new System.IndexOutOfRangeException("You type :" + userInput);
            }
            catch (IndexOutOfRangeException e)
            {
                Console.WriteLine("Number should be between 1 and 5. But " + e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("An Exception in Managed Heap thrown by .net framework :" + e.Message);
            }
            catch
            {
                Console.WriteLine("An Exception in Unmanaged heap thrown by the .net framework!");
            }
            finally {
                Console.WriteLine("Thank you!");
            }
 
        }
    }

            try {
                    //point A
                try
                {
                    //point B
                }
                catch {
                    //point C
                }
                finally {
                    //point D
                }
 
            }
            catch {
                    //Error hanling
            }
            finally {
                    //clean up
            }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace learningLab
{
    class growUPEventArgs:EventArgs
    {
        public string Message {get;set;}
        public growUPEventArgs(string message)
        {
            this.Message=message;
        }
    }
 
    abstract class person
    {
        private string _name;
        private int _age;
 
        public string Name
        {
            get
            {
                return _name;
            }
        }
 
        public int Age
        {
            get
            {
                return _age;
            }
        }
 
        public person(string name,int age)
        {
            this._age = age;
            this._name = name;
 
        }
 
 
        //这里并没有使用委托而是使用了泛型的EventHandler，可以节约一行代码
        public event EventHandler<growUPEventArgs> GrowUPEvent;
 
        protected virtual void OnGrowUp(growUPEventArgs e)
        {
            //handler是一个临时变量，防止被一个竞争占用
            EventHandler<growUPEventArgs> handler = GrowUPEvent;
            //若handler不为空，则发行一个事件,this就是发行者person
            if (handler != null)
            {
                handler(this, e);
            }
        }
        // 定义一个方法来触发事件
       public abstract void growUp();
    }
 
    class student : person
    {
        public student(string name, int age) : base(name, age) { }
 
       protected override void OnGrowUp(growUPEventArgs e)
       {
           base.OnGrowUp(e);
       }
 
       public override void growUp()
       {
           this.OnGrowUp(new growUPEventArgs("Yeah,I'm getting older!"));
           //throw new NotImplementedException();
       }
 
    }
 
    class teacher : person
    {
        public teacher(string name, int age) : base(name, age) { }
 
        protected override void OnGrowUp(growUPEventArgs e)
        {
            base.OnGrowUp(e);
        }
 
        public override void growUp()
        {
            this.OnGrowUp(new growUPEventArgs("Oh,NO!I'm getting older!"));
            //throw new NotImplementedException();
        }      
    }
 
    class InAclassRoom
    {
        private  List<person> _PersonList;
 
        public InAclassRoom()
        { 
            _PersonList=new List<person>();
        }
 
        public void addPeople(person p)
        {
            _PersonList.Add(p);
            p.GrowUPEvent += HandlerYourGrowUp;
 
        }
 
        private void HandlerYourGrowUp(object o,growUPEventArgs e)
        {
            Console.WriteLine(e.Message);
        }
 
        public List<person> getThePersonList()
        {
            return _PersonList;
        } 
    }
 
    class Program
    {
        public static void Main()
        {
            teacher t = new teacher("MicroTeach", 40);
            student s = new student("Shaomingbo", 23);
            InAclassRoom classRoom = new InAclassRoom();
            classRoom.addPeople(t);
            classRoom.addPeople(s);
            //订阅了事件，但未触发。按回车后，方可触发;
            //此处说明了，事件发行者决定事件<何时发生>
            Console.WriteLine("You decide:<Enter>");
            Console.ReadLine();
            List<person> plist = classRoom.getThePersonList();
            foreach (person p in plist)
            {
                Console.WriteLine("Hi, My Name is " + p.Name + ",and i'm " + p.Age + " years old.");
                Console.WriteLine("Actually ,i'm a " + p.GetType());
                Console.WriteLine("When I feel getting older,i'd say :");
                p.growUp();
                Console.WriteLine();
            }
            Console.ReadLine();
        }
    }  
}
/*Output:
You decide:<Enter>
 
Hi, My Name is MicroTeach,and i'm 40 years old.
Actually ,i'm a learningLab.teacher
When I feel getting older,i'd say :
Oh,NO!I'm getting older!
 
Hi, My Name is Shaomingbo,and i'm 23 years old.
Actually ,i'm a learningLab.student
When I feel getting older,i'd say :
Yeah,I'm getting older!
*/