星期一 十二月 21, 2009 09:42

cSharp中同步类的设计

尽量的避免问题,我们最好不要在线程之间共享数据。如果要共享数据,就必须使用同步技术:确保一次只有一个线程访问和改变共享数据。其中不可避免的要用到“锁”。使用锁是需要时间的,并且,也不是总是必须的。所以对于一个类,我们可以创建一个类的2个版本,一个同步版本,一个异步版本。下面请看这个例子:

        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();
                            }
                        }
 
                    }
        }

星期天 十二月 20, 2009 11:13

cSharp中给线程传递参数

在c#中如何给线程传递参数呢?其实很简单。一般来说可以采用2种方式:

  • 使用带parameterizeThreadStart委托参数的Thread构造函数
  • 定制一个类,通过该类的构造函数初始化想要传递的参数,再将该参数应用该类的方法。把线程的方法定义为该类实例的方法即可。

下面是一个Demo :

        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);
            }
        }

星期六 十二月 19, 2009 20:13

cSharp中异步委托的笔记

异步委托,首先要搞明白,为什么要用到异步委托。

长时间以来,我个人在编写代码的时候,都认为程序应该是执行完一件事之后,然后再干接下来的。这用计算机术语来讲,叫同步执行(Synchronous Execution)。但事实上,这样的执行效果不一定人性化。举下面的一组对照:

  • 你有3份快件需要传递给远程客户。如果这件事由你本人亲自完成,那么,接下来,你将要停下手中的工作,跑3段路程,分别将这3个快件递交给3个不同的客户。然后返回公司继续执行你手上剩下的工作。现实生活中,这样的事情或许永远不会发生,因为聪明的你会打一个电话叫来快递专员来为你解决快件问题。
  • 刚入学那会,写了一个资源转换工具。那个时候还没意识到出现了这样的问题:当我执行转换的时候,UI 无法继续响应用户的操作,而只有当转换完毕之后才恢复正常。实际上,现在分析起来,就是主线程没空搭理你,它正忙,忙完之后才能执行你的更新的操作。这个处境和之前的那个跑3段路传递3个快件的境遇差不多。.net 为我们设计了这个异步委托来执行类似快递专员的工作。

搞懂异步委托,需要理解BeginInvoke() ,EndInvoke() ,IAsyncResult 以及AsyncCallback 委托:

异步委托提供以异步方式调用同步方法的能力。当同步调用一个委托时,“Invoke”方法直接对当前线程调用目标方法。如果编译器支持异步委托,则它将生成“Invoke”方法以及“BeginInvoke”和“EndInvoke”方法。如果调用“BeginInvoke”方法,则公共语言运行库 (CLR) 将对请求进行排队并立即返回到调用方。将对来自线程池的线程调用该目标方法。提交请求的原始线程自由地继续与目标方法并行执行,该目标方法是对线程池线程运行的。如果在对“BeginInvoke”方法的调用中指定了回调方法,则当目标方法返回时将调用该回调方法。在回调方法中,“EndInvoke” 方法获取返回值和所有输入/输出参数。如果在调用“BeginInvoke”时未指定任何回调方法,则可以从调用“BeginInvoke”的线程中调用“EndInvoke”。

下面,我用一个例子,谈谈可能发生的4种情况

    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);
        }
 
    }

我想,到目前为止,应该收回之前提到委托“从来不是一个重点”的言论了。

参考资料:<MSDN-magazine>:Asynchronous Method Execution Using Delegates

星期三 十二月 16, 2009 23:28

cSharp动态调用和反射的一个绝佳例子

之前看反射那一章,真把个人看郁闷了。不巧的是,看到很多业内人士的专业博客说,不会这个也搞了几年的项目开发。哎。顿时打消了学习这个知识的念头。不过,挺巧的是,今天又遇到了一个讲这个内容的章节,只不过内容更具体了。

这样一个动态调用的程序,貌似实现了一个编译器的功能。在Textbox里写上代码,能在程序下方看到编译结果。有趣的是,当代码出错的时候,能在程序中看到错误信息:

dynamic loading assemblies cSharp动态调用和反射的一个绝佳例子

//核心代码
       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;
 
        }
    }

这里是一个该程序的二进制文件:动态调用demo (31).net framework 3.5 required
如果您的机器上没有安装.net,不妨下载这个打包好的文件:动态调用Setup (32)