WadeLiu Blog On Windows

VS2008 SP1 ISO version

2009-09-19T04:16:00.000-07:00

VS2008 RTM的版本是9.0.21022, 打sp1之后为9.0.3

VS2008 SP1在线安装包vs90sp1-KB945140大小为500K多, 打补丁的过程会非常慢的, 因为下载后总共有800M多. 为了加速打补丁的过程, 可以在MS网站下载SP1 的ISO版本, 参考下面两个博客:

http://blog.miniasp.com/post/2008/08/Microsoft-Visual-Studio-2008-Service-Pack-1-Released.aspx
http://www.cnblogs.com/vainnetwork/archive/2008/08/13/1266982.html

Asynchronious call Delegate

2008-10-17T02:19:00.000-07:00

参见 http://blogs.yodersolutions.com/net/?p=17
当我们声明了Delegate 变量(比如FooDelegate), 我们可以使用下面两种方法,来触发这个Delegate,
1. FooDelegate.Invoke(), 或者直接是FooDelegate().
2. FooDelegate.BeginInvoke().
第一种调用方法是同步执行这个delegate.
而第二种方式是异步执行这个delegate, 这个delegate会在另一个线程中被执行, 当前线程将继续执行其它代码. 需要说明的是, 一定要确保这个delegate有机会调用了EndInvoke(), 否则会有资源和内存泄漏.
异步调用的一个简单示例是:
subscriber.BeginInvoke(this, new EventArgs(), Callback, subscriber);
其中第3个参数是回调函数, 它的签名是AsynCallback delegate.当subscriber被执行完后, Callback会被调用.
其中第4个参数一定要是subscriber本身,或者是subscriber本身的一个wrapper, 这样在callback函数体中, 就能访问到subscriber本身来EndInvoke.


    class Program
    {
        static void Main(string[] args)
        {
            EventPublisher eventPublisher = new EventPublisher();
            eventPublisher.FooEvent += new EventHandler(eventPublisher_FooEvent1);
            eventPublisher.FooEvent += new EventHandler(eventPublisher_FooEvent2);
            Stopwatch sw = new Stopwatch();
            sw.Start();
            eventPublisher.AsynFireFooEvent();
            Console.WriteLine(sw.ElapsedMilliseconds.ToString());
            Console.ReadKey();
        }

        static void eventPublisher_FooEvent1(object sender, EventArgs e)
        {
            Thread.Sleep(100);
        }
        static void eventPublisher_FooEvent2(object sender, EventArgs e)
        {
            Thread.Sleep(200);
        }
    }


    
    class EventPublisher
    {
        public event EventHandler FooEvent; 


        /// <summary>
        /// synchronized invoke the all the subscriber services. 
        /// The process will return until all delegates executions are over.
        /// </summary>
        public void FireFooEvent()
        {
            if (FooEvent != null)
                FooEvent(this, new EventArgs());
        }


        /// <summary> 
        /// Raising events asynchronously lets the event subscribers do their processing in another thread 
        /// and allows the thread that raised the event to continue processing.
        /// </summary>
        public void AsynFireFooEvent()
        {
            if (FooEvent != null)
            {
                Delegate[] subscribers =  FooEvent.GetInvocationList();
                foreach (EventHandler subscriber in subscribers)
                {
                    //the 3rd arg should be a AsyncCallback type delegate. When one subscriber service will completed, the AsyncCallback method will be raised. 

                    //the 4th arg should be the exact subscriber or subscriber wrapper, so that in callback function, 
                    // we can access the subcriber to call EndInvoke()
                    subscriber.BeginInvoke(this, new EventArgs(), Callback, subscriber);
                }
            }
        }



        void Callback(IAsyncResult ar)
        {
            EventHandler raisedEvent = (EventHandler)ar.AsyncState;
            raisedEvent.EndInvoke(ar);
        }
    }

Auto build script by using NAnt

2008-10-09T19:28:00.000-07:00

当我们想专门为一个C#项目架一个build服务器, 怎样对VS的solution文件进行自动build是个问题, 最简单的办法是, 编写一个bat文件, 运行这个bat文件就能完成solution的编译甚至运行单元测试 . NAnt是个很好的选择.
简单地讲, NAnt就是一个能将xml文件作为参数的命令行工具, 你可以在这个xml中按照NAnt的schema编写你想要完成的任务, 比如压缩文件, 比如删除目录, 当然NAnt最主要的作用是可以编写任务来批量编译c#的代码. 但是考虑到MS官方已经发布了msbuild, 所以一个比较好的做法是：在NAnt的参数xml文件中, 使用msbuild来编译.Net solution, 用NAnt本身的功能完成其它事情.
当然对于Nant新手来说, 编写这样的xml并不简单. 幸好我们有一些现成工具可以使用, Tree Surgeon就是这样一个开源项目(http://www.codeplex.com/treesurgeon).
TreeSurgeon不仅仅帮你编写xml的build文件(你可以根据需要做比较的修改), 而且会自动将NAnt以及NUnit等整理到一个tools目录. Treesurgeon创建的solution目录结构也很有参考价值, 比如和src目录同级别的目录, 还有bin, tools, lib, dist目录, 其中bin是存放solution的输出文件(需要在Visual studio中将这个solution的所有project的output目录制定到这个bin目录), dist目录是专门作为solution的release目录.
如果想测试这个xml文件中某些变量设置是否正确, 可以使用在project tag之下, 创建echo tag, 在用NAnt执行这个xml文件时, echo中的message信息就会被输出到屏幕上.


<echo message="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe"/>

下面的bat和xml是使用NAnt的示例(它是由TreeSurgeon生成, 并参考了Ninject源码中的NAnt build_xml文件). 使用非常方便,
cmd> build 或
cmd> build test
build.bat的内容是:


@tools\nant\NAnt.exe -buildfile:DbGear.build %*
rem pause

DbGear.build是一个xml文件, 用NAnt命令行程序执行这个xml文件(NAnt0.86版本如用msbuild tag来调用.net 3.5 的msbuild时候, 会有bug. 所以这个例子并没有使用常规的msbuild tag,而是使用 exec tag直接调用3.5版本的msbuild命令行程序)


<?xml version="1.0" ?>
<!--refer to treesurgeon on codeplex, and build file of ninject project-->
<project name="DbGear" default="compile" xmlns="http://nant.sf.net/schemas/nant.xsd">
    <!--tell NAnt try to use msbuild from .net sdk 3.5-->    
    <property name="nant.settings.currentframework" value="net-3.5" />

    <!--declare path variables-->
    <property name="path.base" value="${project::get-base-directory()}"/>
    <property name="path.src" value="${path.base}/src"/>
    <property name="path.tools" value="${path.base}/tools"/>
    <property name="path.build" value="${path.base}/bin"/>
    <property name="path.dist" value="${path.base}/dist"/>
    <property name="path.build.testresult" value="${path.build}/test-result"/>
    <property name="path.build.debug" value="${path.build}/debug"/>

    <!--define solution variables-->
    <property name="version" value="1.0.0.0" overwrite="false"/>
    <property name="file.solution" value="${path.src}/DbGear.sln"/>
    <!--choose one suitable compiling config, eg Debug, Release or other customized config schema-->
    <property name="build.configuration" value="debug"/>

    <!-- define build  targets -->
    <target name="clean" description="Delete Automated Build artifacts">
        <delete dir="${path.build}" if="${directory::exists(path.build)}"/>
        <delete dir="${path.dist}" if="${directory::exists(path.dist)}"/>
    </target>

    <target name="init" description="create assembly out path">
        <mkdir dir="${path.dist}" if="${not(directory::exists(path.dist))}"/>
        <mkdir dir="${path.build}" if="${not(directory::exists(path.build))}"/>
        <mkdir dir="${path.build.testresult}" if="${not(directory::exists(path.build.testresult))}"/>
        <mkdir dir="${path.build.debug}" if="${not(directory::exists(path.build.debug))}"/>
    </target>
    
    
    
    <echo message="Build configuration:" />
    <echo message="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe"/>

    <!--nant0.86 has a bug  with  Framework 3.5 section,  so we will use exec to call msbuild.exe of 3.5, rather than the regular msbuild  tag -->
    <!--
    <target name="compile" depends="init"  description="Compiles using the AutomatedDebug Configuration">
        <msbuild project="${file.solution}">
            <property name="Configuration" value="${build.configuration}" />
        </msbuild>
    </target>
         -->
      
     <target name="compile" depends="init" description="Compiles using the Debug Configuration">
        <exec program="${framework::get-framework-directory(framework::get-target-framework())}\msbuild.exe" > 
        <arg value="${file.solution}" />   
        <arg value="/verbosity:minimal" />
        <arg value="/property:Configuration=${build.configuration}" />
        <arg value="/property:WarningLevel=0" /> 
        </exec>
     </target>
    
    <target name="test" depends="compile, unittest"
        description="Compile and Run Tests" />

    <target name="full" depends="clean, test"
        description="Compiles, tests, and produces distributions" />

    <!-- Internal targets -->
    <target name="unittest" description="runs the unit tests">
        <!-- Test Assembly -->
        <exec program="${path.tools}/nunit/nunit-console.exe">
            <arg value="${path.build.debug}/UnitTests.dll" />
            <arg value="/xml=${path.build.testresult}/UnitTests-Results.xml" />
        </exec>
    </target>


    <target name="dist">
        <zip zipfile="${path.dist}\DbGear-${version}.zip">
            <fileset basedir="${path.build.debug}">
                <include name="**/*" />
                <exclude name="**/*.pdb" />
            </fileset>
        </zip>
    </target>


    <target name="package-source">
        <zip zipfile="${path.dist}\DbGear-${version}-source.zip" ziplevel="9">
            <fileset basedir="${path.src}">
                <include name="**/*.cs"/>
                <include name="**/*.csproj"/>
                <include name="**/*.sln"/>
                <include name="**/*.txt"/>
                <include name="**/*.build"/>
                <exclude name="**/*.pdb" />
            </fileset>
        </zip>
    </target>
</project>

Using Ninject(one DI container)

2008-09-27T19:33:00.000-07:00

在设计中, 经常会遇到这样的情况, 在一个类中要创建或使用另一个类的实例, 暂且将前一个类称为大类, 后一个类称为小类, 也许小类有很多变种, 我们会根据不同的情况, 让大类使用不同的小类变种. 可以看出这里有一个耦合关系, 一个好的办法是使用依赖注入模式(Dependency Inject), Martin Fowler 有个非常精彩的文章专门讲述DI).
DI原理其实很简单, 我们设计的大类要依赖于小类的接口或基类, 而不是一个具体的小类, 同时不要在大类中创建小类实例, 而是通过大类的构造子或property将小类的实例传进来即可.
目前.Net领域有不少DI容器框架, (这里是DI容器框架列表), 这些框架主要有两个功能, (1)帮助完成依赖的注册与依赖实例的创建, 即绑定小类接口和某个具体小类, 绑定的地方不是在大类中, 所以实现了解耦. (2)更高级的功能是, DI 容器框架可以帮助我们创建大类实例, 就像是一个Factory工厂方法一样, 当然大类所依赖的小类, 也不同我们手动创建, 容器自动按照我们定义的小类绑定关系来创建小类实例.
Ninject是一个新的DI框架, 它的特点是:
(1)不需要使用Xml来定义绑定关系, 使用一个自定义的Module类(基类为StandardModule)来定义绑定关系;
(2)不仅仅支持constructor注入, 而且支持property注册;
(3)对于constrctor注入, 构造子还可以包含其他类型参数, 不仅仅是所依赖的类型参数.
(4)对于非constructor注入, 不仅仅支持无参构造子, 而且支持带参构造子.
(5)支持基于类型的条件绑定, 可以使用Bind().To().ForMembersOf();
(6)部分支持基于variable的Context的条件绑定, 示例代码中对此有说明.(Ninject支持另一种条件绑定, 但它需要在大类的代码加上Parameter attribute或Method attribute, 增加了大类和小类的耦合度, 所以我不喜欢, 好在基于context variable的绑定基本够用了)
(7)对于利用DI容器创建的对象, 可以在定义绑定时, 指定对象的生命周期, 比如Singleton以及SingleCall的生命周期模式.

下面是一个使用Ninject的简单示例, 需要添加Ninject.core和Ninject.condition两个assembly.
主程序类和自定义的Module类:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using Ninject.Core;
using Ninject.Conditions;
using Ninject.Core.Behavior;
using Ninject.Core.Parameters;
using Ninject.Core.Activation;

namespace NinjectDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region DI: Old way
            IEditor editor = new NotePad();
            var csProgrammer = new WindowsProgrammer(editor);
            csProgrammer.WriteCode();
            #endregion

            #region DI container
            #region Initialization for using Ninject
            var module = new ProgrammerModule();
            IKernel kernel = new StandardKernel(module);
            #endregion

            #region Simple inject
            var vbProgrammer = kernel.Get<WindowsProgrammer>();
            vbProgrammer.WriteCode();

            //Get correct concrete class according to binding condition
            var linuxProgrammer = kernel.Get<LinuxProgrammer>();
            linuxProgrammer.WriteCode();
            #endregion

            #region Including other parameters rather than inject interface
            Dictionary<string, object> param = new Dictionary<string, object>();
            //there is another parameter named firstName in constructor 
            param.Add("firstName", "Harry-Mac OS"); 
            var macProgrammer = kernel.Get<MacProgrammer>(With.Parameters.ConstructorArguments(param));
            macProgrammer.WriteCode();
            #endregion

            #region  Control binding by context variable
            IParameterCollection pc = With.Parameters.ContextVariable("OS", "Mac").ConstructorArguments(param);
            var programmer = kernel.Get<Programmer>(pc);
            macProgrammer.WriteCode();
            #endregion

            #endregion DI container

            Console.WriteLine("Enter any key to exit...");
            Console.ReadKey();
        }
    }


    class ProgrammerModule : StandardModule
    { 
        /// <summary>
        /// 注册接口和对象的绑定
        /// </summary>
        public override void Load()
        {
            //This is a default bind for IEditor inteface
            Bind<IEditor>().To<NotePad>();
            //Bind<IEditor>().To<NotePad>().Always();// same to the above line

            //This is a condtional bind for IEditor injection
            Bind<IEditor>().To<Vi>().ForMembersOf<LinuxProgrammer>();
            //or the following code
            //Bind<IEditor>().To<Vi>().OnlyIf(c => c.Member.DeclaringType == typeof(LinuxProgrammer)); 
            //or the following code
            //Bind<IEditor>().To<Vi>().OnlyIf(delegate(IContext c) { return c.Member.DeclaringType == typeof(LinuxProgrammer); }); 

            Bind<IEditor>().To<Vi>().ForMembersOf<MacProgrammer>();

            //This is another kind of conditional bind. 
            //我们获取对象要用kernel.Get<T1>()方法, 绑定用Bind<T2>()方法, 
            //  这种context绑定仅仅适合于T1和T2同一类型或基于同一类型
            Bind<Programmer>().To<MacProgrammer>().Only(When.Context.Variable("OS") == "Mac");
        }

        /// <summary>
        /// Load2 方法在本项目中其实没用, 只是为了列出Ninject在绑定时可指定对象的生命周期
        /// </summary>
        public void Load2()
        {
            //每次调用kernel.Get<>(), 总是返回一个新的对象, 如果Remoting中讲的SingleCall对象
            Bind<IEditor>().To<NotePad>();
            //Bind<IEditor>().To<NotePad>().Using<TransientBehavior>(); //same as the above

            //获取的对象是Singleton对象, 即使是不同线程, 获得的对象总是同一个
            Bind<IEditor>().To<NotePad>().Using<SingletonBehavior>();
            
            //One instance of the type will be created per web request, and will be destroyed when the request ends.
            Bind<IEditor>().To<NotePad>().Using<OnePerRequestBehavior>();

            //在同一个线程中, 每次调用kernel.Get<>()获取的对象总是同一个
            Bind<IEditor>().To<NotePad>().Using<OnePerThreadBehavior>(); 
        }
    }

}

下面是IEditor接口和实现类:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NinjectDemo
{

    interface IEditor
    {
        string Code();
    }

    public class Vi : IEditor
    {
        public string Code()
        {
            return "This is Vi editor";
        }
    }

    public class NotePad : IEditor
    {
        public string Code()
        {
            return "This is NotePad editor";
        }
    }
}

下面是Programmer基类和派生类:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

#region Ninject namespace
using Ninject.Conditions;
using Ninject.Core.Behavior;
using Ninject.Core;
#endregion 

namespace NinjectDemo
{
   abstract class Programmer
    {
        IEditor m_Editor;
        public Programmer(IEditor editor)
        {
            this.m_Editor = editor;
        }

        public virtual void WriteCode()
        {
            Console.WriteLine(m_Editor.Code());
        }

    }

   class WindowsProgrammer:Programmer
   {
       public WindowsProgrammer(IEditor editor)
           : base(editor)
       {
       }
   }

   class MacProgrammer : Programmer
   {
       string m_FirstName;

       [Inject]
       public MacProgrammer(IEditor editor, string firstName)
           : base(editor)
       {
           m_FirstName = firstName;
       }

       public override void WriteCode()
       {
            Console.Write( m_FirstName+" , ");
            base.WriteCode();
       }
   }

   class LinuxProgrammer : Programmer
   { 
       [Inject]
       public LinuxProgrammer(IEditor editor)
           : base(editor)
       { 
       }
   }
}

check exchange mail by firefox

2008-08-26T21:53:00.000-07:00

管理Exchange的邮件账号, 最好是用outlook. 当你不能使用outlook(或没有outlook软件)时, 很自然会想到了通过web方式来访问邮件账户. web 访问exchange邮箱的前提是, Exchange Server开启了Outlook Web Access功能.
之后你就可以通过IE访问你的Exchange邮件账号, 方法方式非常简单, 直接输入地址https://mail.xxx.com/ , IE的地址会自动重定向到一个新的地址https://mail.xxx.com/exchweb/bin/auth/owalogon.asp?url=https://mail.xxx.com/exchange&reason=0
.
其实我不太喜欢IE, 因为它的插件比较少, 更重要的是它的Network管理功能比Firefox差多了. 但Firefox却不能通过前面的那个较简单URL地址直接访问Exchange邮箱, 要访问需要输入这个复杂的地址.

怎样设置Firefox每隔一段时间自动接受新邮件呢, 另外Firefox最好能缩小到System tray呢?
我们需要Tab Mix Plus和Minimize To Tray 两个插件, 安装这个插件之后, 默认设置情况下, firefox的contextmenu会多了几个菜单项, 其中一个是Reload Every, 也就是每隔一段时间自动加载这个tab 页.
总结一下, 需要的插件有:
Tab Mix Plus(强大的Session管理插件)
Minimize to tray(将firefox 缩小到traybar)
MR Tech Toolkit (formerly Local Install) 6.0.1—因为Minimize to tray 这个插件不兼容firefox3, 安装了这个Mr Tech插件之后, 可以跳过Minimize to tray安装时候的compatible check过程.

svn authorization

2008-08-21T22:18:00.000-07:00

预先的环境是: svn server的IP是: 11.12.13.14, OS是windows 2003 server. repository的目录是D:\source, 我们在该repository下建立了两个项目, 分别是Project1和Project2. 建立repository的过程, 见这个blog
常用的Svn访问协议有三种, 第一种是file协议, 第二是svn协议, 第三是https协议.
https协议比较适合于跨广域网的项目开发, 需要有apache的支持, 所以配置比较复杂一些, 可参考网络上的文章 .

Setting up an ASP.NET website development environment using Visual Studio .NET, Subversion, and Windows XP http://www.codeproject.com/KB/aspnet/Subversion.aspx
HOWTO: Subversion for Windows with Apache server - a beginner's guide [version 0.4] http://svn.spears.at/
Setting Up Subversion for One or Multiple Projects http://www.linuxjournal.com/article/7655

file协议最适合一个人的项目, 设置非常简单, 你在你本机开一个svn server, 同时在你本机创建一个repository. 你的svn客户端就可以用file协议访问repository了. 也可以多人一起用, 但必须将repository 的目录共享出来, 所以安全性很差, 不建议在多人项目中使用这种模式.
本机file协议访问project1的url是 file:///D:/source/project1 .
如果是局域网访问的话是, file:///\11.12.13.14/source/project1
Svn协议比较适合于局域网内部多人项目的开发, 在svn server建立了一个repository之后, 我们就可以使用svn协议了, URL是 svn://11.12.13.14/source/project1 ,这是因为缺省情况下, 这个repository已经被开启了匿名读权限了, 但写权限被关闭了. 所以任何人都可以读取这个repository的内容. 我们需要为每个人定制不同的访问权限. 需要修改这个repository目录下的三个文件, 它们都在D:\harry\source\conf下.
(1) svnserve.conf文件, 你需要处理掉4个label的注释, 分别是authz-db和password-db和anon-access和auth-access.需要注意的是, 确保每行前边没有多余的空格, 否则当你访问svn会报错. 另外最好为realm这个label设置一个有意义的名称, 因为svn client连接server时候, 会显示server的realm名称. 同时如果你想让多个repository共用同一组用户账号, 可以将这几个repository的passwd文件指向同一个文件, 可以使用相对路径来指定passwd文件(相对路径是基准是conf目录), 也可以用绝对路径来指定. 需要注意的, 路径必须使用unix风格的分隔符/, 而不能是\.

(2) passwd文件, 在[users]section下定义用户和密码, 每个账号一行,用户名和密码用=号分隔 .
(3) authz文件, 这是最关键的配置文件. 下面是authz文件的配置:
[groups]
Prj1_Dev_Team=harry,helen
Prj2_Dev_Team=tom,peter
Test_Team=sally,mark
QA_Team=andy

[/]
*=r #所有人都能读取这个repository
harry=rw #harry具有这个repository的读写权限

[/project1]
#*=rw #取消所有人的读写权限
@Prj1_Dev_Team=rw
@SE_Team_QA=rw

[/project2]
#*=rw
@Prj2_Dev_Team=rw
@SE_Team_QA=rw
@Test_Team=rw

Registry requisite tools

2008-08-16T01:52:00.000-07:00

Regsnap -registry and windows system folder snapshot tool and analysis tool.
RegMon.exe--product from sysinternal company, it is free tool

benefits by using svn

2008-08-12T21:52:00.000-07:00

首先先讲一下subversion几个特性.
tortoisesvn安装之后, 有个help文档, 非常好, 不仅包含tortoisesvn的帮助, 而且有很多关于subversion服务器端帮助信息. 网络上有一个中文帮助chm文件, 网站为http://svndoc.iusesvn.com

Subversion 在版本控制方面做的非常好, 它用一个global revision number来标示repository的版本状态. 每次commit, 全局版本号码都增一. Subversion 一个非常好的特点是, 若一个文件在两个版本中没有任何修改, 其实它在Subversion中仅有个保存, 这里采用了类似于Unix的hard-link技术. 所以你不用担心频繁的commit会不会使repository存储快速增大.
HEAD revision指的是最新版本的revision, 但是需要注意的是, 如果你要针对HEAD revision进行某种操作时候(比如合并), 你的repository可能同时会被其他人进行commit, 这样你的合并结果可能不是你期望的那个. 所以最好的方式是, 在你合并时候, 指定版本号, 即使是合并最新版本, 也要先获取它的版本号.

Subversion为开发流程提供的新的模式
单单就subversion的合并功能, 其实对于开发模式来讲, 具有非常大的变革. 比如我们要增加一个新的feature, 这个feature的开发有一定的风险或者我们要将这个feature的开发交给另一个team. 通常我们可以将当前的trunk做一个branch, 专供new feature开发的. 由于在new feature的开发中, trunk的代码也在不断演进, 甚至是new feature依赖的基础也可能会变化的, 所以我们不能期待在new feature开发完毕之后, 再将branch和trunk合并, 这样branch的改动量会很大, 所以我们应该每个一周就将trunk的代码合并到branch中, 这样每次合并对于branch这边的冲击会小一些, 迭代几个周期, 当new feature开发完毕之后, 再将branch合并到trunk中.

routine tortoisesvn operations-2

2008-08-11T22:03:00.000-07:00

我自己写了一点关于svn的常用功能, 见http://focuswindows.blogspot.com/2008/08/routine-tortoisesvn-operations-1.html

以下内容摘自http://blog.csdn.net/iNarcissuss/archive/2007/09/16/1787411.aspx

Check-out(检出) 和 Export（导出）
+-------------------------------------------------
从服务器取得最新版本（Subversion术语--Head Revision）或某个历史版本的拷贝复制到本地的某个目录，这个本地的目录有个Subversion专门的术语---working copy(工作拷贝)，working copy的特点是自动与服务器关联，并受服务器的版本控制。
所以Subverion的CheckOut相当于VSS的设定工作路径+签出。
与CheckOut类似的一个命令是------Export（导出），它能将某个版本复制一份到本机的某个目录，与CheckOut不同的是，这个目录不是woking copy，Export（导出）
后就与服务器没有任何关系了，当然更不会受服务器的版本控制。
TortoiseSVN会在是working copy的目录上加上各种标志，而Export的目录不会有任何标志
SVN Update(SVN　更新) & Get Lock
+-------------------------------------------------
最常用的命令，你可以只CheckOut一次，但是最好经常update，特别是在你修改之前尤其特别一定用Update，以保证本地工作拷贝与服务器项目版本库一致。它的功能是
，从服务器取得最新版本跟新本机工作拷贝，相当于VSS的Get Latest Version，如果习惯VSS，并且对SVN的复制--修改--合并模型不放心的话，可以在Update之后，马上使用
“获取锁定”命令，它的作用是使的别人不可以修改你正在修改的文件，以避免冲突。
Import Export (导入导出)
+-------------------------------------------------
Import是一种快速批量向服务器添加文件的方法，如果你像把本地的文件或文件夹添加到服务器的某个目录下面，那么在本地目录中，右单击选择Import命令，然后
设定URL即可，这是从别的版本管理系统向VSS迁移的一种方法，在版本浏览器上单击某个目录，会有加入文件和加入文件夹的命令，其中加入文件一次只能加入一个文件
加入文件夹只能加入该文件夹下的所有文件，不能加入子文件夹，你可以根据实际需要使用.需要注意的是, 本机目录导入到服务器后，本机目录没有改变，和服务器也没关联，
并不是工作拷贝。Export命令请在本文其他地方找。
Switch & Relocate (切换和重定位)
+-------------------------------------------------
Switch -----在版本库内改变与当前工作拷贝关联的服务器路径URL（只限于同一个Repository内），应用情景：有时，服务器的目录会有所变化，和你当前工作拷贝
关联的服务器URL改变了，这种改变的直接结果是，你在工作拷贝中所做的修改不能提交到服务器，这时就需要Switch到正确的URL再提交。
Relocate----功能和Switch雷同，差别在于，Relocate实现的是Repository和Repository之间的切换。当服务器地址或Repository名称发生变化时，可以用它来更新
你的工作拷贝。
Create/Apply patch (创建和应用补丁)
+-------------------------------------------------
如果你对某个文件没有修改的权限，但又必须对它进行修改，这时你可以对其创建补丁，然后把补丁发给对此目录有write权限的工作人员，他进行一系列的审核，审核
通过后，他会执行应用补丁命令，可以将你所做的修改提交到服务器上。
copy to working copy...(复制到工作拷贝...)
+-------------------------------------------------
首先，注意这里是working copy ，后面在选择目录时一定不要选错！，当然，选错了tortoisesvn会提示错误的，正确的操作应该是选那些有tortoisesvn标志的目录。
执行此命令会在working copy中增加你copy的目录和文件，然后修改，再commit，repository中就做了相应的变化。
当你需要用到这样一个模块，它与已经存在的某个模块类似，然而又不完全一样，需要有一定改动时，用copy to working copy...命令较为快捷。
Resolved ...(已解决的...)
+-------------------------------------------------
当两个人同时编辑一个文件，一个人先提交后，另一个人再进行提交时就会出现冲突，TortoiseSVN会提出必须更新你的工作拷贝后才能对这个文件进行修改，
Subversion冲突的种类及解决方法
+-------------------------------------------------
--->1.当两个人同时编辑一个文件的不同部分，一个人先提交后，另一个人再进行提交时就会出现冲突
--->解决方法：在冲突的文件上调用命令SVN Update(SVN更新)，TortoiseSVN会自动从服务器上下载最新版本，并与本地工作拷贝进行合并，然后调用命令
SVN Commit(SVN 提交)，就会自动生成一个新版本传到服务器上。
--->2.当两个人同时编辑一个文件的相同部分，一个人先提交后，另一个人再进行提交时就会出现冲突
--->解决方法：这种情况下调用SVN Update时，由于是同一部分修改，TortoiseSVN不知道应该怎么办，它会自动在发生冲突的文件的目录下生成三个文件，一个
发生冲突文件的基础版本，名称为文件的全名再加上基础版本的版本号，如FileConflict.cpp.r90,另一个是你调用SVN Update时更新的版本，名称也是文件
的全名再加上基础版本的版本号，如FileConflict.cpp.r95，它是别人已经修改好提交的文件，还有一个是你的本地修改，后缀为.mine，而原文件以一种TortoriseSVN能识别的方式显示冲突的双方，而且这个文件上会出现TortoiseSVN的图标，要解决这种
冲突要求造成冲突的两个人进行沟通，确定最终的修改方案，然后进行修改，具体操作是右击有冲突图标的文件，选择“编辑冲突”命令，这时就可以对出现冲突
的文件进行编辑，TortoiseSVN会打开TortoiseMerge，里面会显示别人的修改、你的修改、最终合并的文件，在最终合并的文件中产生冲突的行上右击，根据弹出
菜单选择使用别人的修改、我的修改还是两个都用，编辑完后保存，关闭TortoiseMerge，然后右击有冲突图标的文件，选择Resolved...(已解决的...)命令后
确定即可。

关于“基础版本”及其命令 ---比较差异，检查更新，显示日志，版本分支图
+-------------------------------------------------+-------------------------------------------------
当我们从服务器上CheckOut某个版本，经过一定的修改后，右击修改的文件（注意，不是目录）会有一个“比较差异”命令，调用它会弹出TortoiseMerge，它列出了
当前修改的工作拷贝与我们CheckOut时用到的版本之间的差异，这个被我们CheckOut的版本称为当前工作拷贝的“基础版本”，注意，基础版本不一定是最新版本，最新版
本也不一定是基础版本，比如另一个人和我们CheckOut同一个版本，它在我们之前提交了一份修改会形成一个最新版本----这时，我们进行提交可能造成冲突。
刚才说过，只有文件才会有“比较差异”命令，而目录没有，有没有办法看到目录的变化呢？--肯定有，是哪个呢？先试一下第一个---“显示日志”，结果不行，它只
显示的是当前工作拷贝对应的服务器目录或文件的版本变化记录，从第一个版本到最新版本，一个也不缺。“版本分支图”也一样，它是“显示日志”命令的图形化显示，
功能和“显示日志”完全一样。答案是----“检查更新”，它比较的是当前工作拷贝相对于基础版本的更新记录，不仅能显示文件的变化，也能显示目录的增减等。
Revert (复原) 和 Update to version
+-------------------------------------------------
当你CheckOut并修改了文件后，如果在提交前发现修改不正确，可以用Revert来取消这次的修改，使文件回到基础版本的状态；如果已经提交，可以用Update to Version
(更新至版本)返回某个旧的版本，或者调用显示日志命令，在任意一处日志上单击，在下方会出现修改记录，右击某一记录，在弹出菜单中选择Save Revision to(保存版本至)
，也可以把原来版本进行存档。需要注意的是，你的本地工作拷贝可以返回到原来的版本，可是服务器上只会记录你对它进行最后一个提交的版本，所以服务器端版本不
会变化，如果你想把服务器端的文档内容也换为原来的状态，可以用旧版本文件覆盖新版本文件，然后提交，或者使用Revert changes from this revision 和 Revert to this revision命令，她们的用法在本文档中有，自己找找，调用显示日志命令，在任意一处日志上右击，在快捷菜单中会出现这两个命令。
注意，Revert命令很危险，它不向Ctrl-Z命令一样一次只撤销一次修改，它的名字是“还原”，它会把所有的修改全部撤销，直接回到基础版本的状态，如果想只撤销
一次的修改，我的方法是，使用“检查更新”和“比较差异”命令在TortoriseSVN中修改，TortoriseSVN中的"use this text block ","use other text block ","use both text block "等命令很方便，关于这两个命令在本文中也有介绍，自己找。
Revert changes from this revision 跟Revert to this revision的区别？
+-------------------------------------------------
譬如有个文件，有十个版本，假定版本号是1，2，3，4，5，6，7，8，9，10。

-->1.Revert to this revision（恢复到某个以前的版本）：如果在版本6这里点击“Revert to this revision",表示7～10的修改全部作废,历史倒退到了版本6那个年代。
如果你做了多处修改，然后决定要返回到版本 N，你就可以使用这个命令。再次说明，恢复的修改位于你的工作复本，在你提交之前，并不会影响版本库。
注意，这将会丢弃从那个版本以来的所有修改，使用选中的版本来替换文件/文件夹。

-->2.Revert changes from this revision（还原选中版本所做的修改）：如果在版本6这里点击“Revert changes from this revision",表示版本6这个历史事件被抹杀了，只剩下9个历史事件了。如果同时选择了6，7，8三个历史时期并点击“Revert changes from this revision”，表示抹杀6~8这仨历史时期。同理，如果同时选择7～10，然后点击“Revert changes from this revision”，则效果跟在版本6这里点击“Revert to this revision”是一样的。
还原的内容只在你的工作副本中，所以此操作完全不会影响版本库！要注意的是，这个操作仅仅还原该版本中的修改。不是将整个文件替换成选中的那个版本。
它对于已经做过其它无关修改的还原早期修改非常有用。如果你做了本地修改，此命令将会合并修改到工作副本。
关于“基础版本”及其命令 ---比较差异，检查更新，显示日志，版本分支图
+-------------------------------------------------+-------------------------------------------------
当我们从服务器上CheckOut某个版本，经过一定的修改后，右击修改的文件（注意，不是目录）会有一个“比较差异”命令，调用它会弹出TortoiseMerge，它列出了
当前修改的工作拷贝与我们CheckOut时用到的版本之间的差异，这个被我们CheckOut的版本称为当前工作拷贝的“基础版本”，注意，基础版本不一定是最新版本，最新版
本也不一定是基础版本，比如另一个人和我们CheckOut同一个版本，它在我们之前提交了一份修改会形成一个最新版本----这时，我们进行提交可能造成冲突。
刚才说过，只有文件才会有“比较差异”命令，而目录没有，有没有办法看到目录的变化呢？--肯定有，是哪个呢？先试一下第一个---“显示日志”，结果不行，它只
显示的是当前工作拷贝对应的服务器目录或文件的版本变化记录，从第一个版本到最新版本，一个也不缺。“版本分支图”也一样，它是“显示日志”命令的图形化显示，
功能和“显示日志”完全一样。答案是----“检查更新”，它比较的是当前工作拷贝相对于基础版本的更新记录，不仅能显示文件的变化，也能显示目录的增减等。
Branch & Tag (分支与标记)
+-------------------------------------------------
---->1.定义与理解
-->1.1 Branch and Thunk (分支和主线)
版本控制系统的一个特性是能够把各种修改分离出来放在产品的一个分割线上。这条线被称为Branch（分支）。
分支经常被用来试验新的特性，而不会对开发有编译错误的干扰。当新的特性足够稳定之后，产品的分支就可以混合回Thunk(主线)里.

-->1.2 Tag (标记/标签)
版本控制系统的另一个特性是能够标记特殊的版本(例如某个发布版本)，所以你可以在任何时候重新建立一个特定的构件和环境。这个过程被称作Tag(标记/标签)。
Subversion 没有专门的用于建立分支和标记的特殊命令，它所谓的分支其实就是一个拷贝，把原目录的内容拷到一个新的目录下面。但是这个拷贝的操作不是真正意义
上的拷贝，Subversion称之为"Lean copy"(便宜复制),它类似于Linux的硬链接，实际的操作是建立了一个内部链接，指向那个被建立分支的目录，只有当我们提交一个文件
的修改，才在分支目录下建立一个真实的文件，它的内容就是我们提交的内容，需要注意的时，这时候，除了这个文件以外，其余的文件仍然是作为被建立分支目录下文件的
链接存在的。
采用Lean copy技术的结果是分支和标记能迅速被创建，并且没有在版本库里占据任何额外的空间。
-->1.3 理解Branch
建立分支的情况举例：
a.Project发行版已经完成，正在继续开发Project贺岁版，计划在两个月后发行。不久，客户开始抱怨Project有问题，于是CheckOut（检出）Project的发行版，
找到几个错误，并进行代码更正。但是当前的版本是个不稳定的版本(现在正处于Project2贺岁版的开发中.....)，并且在下个月才能有希望稳定下来，这样就没有办法基于
最新的代码去发行一个修复错误的版本。....这种情况下就可以创建一个Branch(分支)，分支的所有文件是基于Project发行版的，可以修改这个分支而不影响到主干(即当
前正在开发的Project2贺岁版)，当Project2贺岁版完成时，你可以选定是否要把这个分支同主干（Project2贺岁版）合并或继续保留在这个分支里。
b.如果我们在维护一个项目的文档，但有一天，另一个项目也要这份文档，她们有和我们不同的需求，因此要对文档做一些修改才能适应她们的需要，这时，也可以对
这个文档建立一个分支。
c.Branch可以是项目分支，也可以是私有分支。
所谓的项目分支，是指两个项目需要并发开发，它们基于同一个原始版本的拷贝，且这两个项目又互不干扰的进行独立开发，那么这两条开发线对于原来的那个原始版
本来说，就是项目分支，而原始版本就是项目主干。
所谓的私有分支，是指如果多个人共同负责一个模块，当出现两个人同时修改一个文件的同一部分的情况时，就会不断的出现冲突，开发人员就要花大量的时间解决这
些冲突，而在分支上工作避免了频繁的解决冲突，这种分支叫做私有分支，个人可以在主干上建立一个私有分支出来，当开发到一定阶段以后，可以再对自己分支与主干进
行合并，在与主干进行合并的同时，也能关注到其他人在这一段时间内对主干做的修改。
---->2.创建分支
利用TortoiseSVN有两种方法建立分支：
-->1.从本地工作拷贝到服务器建立，在本地工作拷贝右击在弹出菜单中选择“Branch/Tag”会弹出一个对话框，在其中设定要建立分支的URL即可。
-->2.从URL到URL,在Repository Explorer(版本浏览器)中右击要建立分支的目录，在弹出菜单中选择Copy to...(“复制到...”),在弹出对话框设定要建立分支的URL.
---->3.分支的合并
创建分支后一段时间可以根据需要进行Merge(合并)操作，我们既可以将主线的改动合并到分支上，也可以将分支的改动合并到主线上：
-->1.将主线的改动合并到分支上，需要在分支的工作拷贝下进行合并,合并的范围是从主线上上次合并的版本（或建立分支时候的版本）到当前主线上的最新版本，
如果主线和分支都修改了相同的文件的相同部分，合并后会出现冲突，就要进行解决冲突，如果主线修改但是分支没有修改，则主线上合并的变更内容会增加到当前工作
拷贝中，合并的结果会保存到当前的工作拷贝中，提交后改动就会体现在分支中，如果是第一次合并，则起始版本号是上次建立分支的版本号。
-->2.将分支的改动合并到主线中，需要在主线的工作拷贝下进行合并，相关事项与上雷同。
Blame (追溯)
+-------------------------------------------------
这个命令很不错，能显示文件的所有行在哪个版本中被修改及修改的时间，还可以追溯版本库等，有兴趣可以自己研究。

routine tortoisesvn operations-1

2008-08-11T00:08:00.000-07:00

接下来, 我们讲一下tortoisesvn的常规操作. update, revert和switch的区别, 这三个命令的图标都是从服务器端到客户端的箭头, 容易搞混.

1. update是最常用的操作, 就是用来更新本地的work copy, 当然, 如果某个文档是基于svn server的最新版本做了修改,那么update并不会从svn server上download这个文档. 如果你的文档是基于svn server上的一个老版本作了修改, tortoisesvn会让启动一个向导让你解决这个conflict.

2. revert, 这个操作忽略本地work copy的任何修改, 它直接从svn server上下载被你修改了的文档.

3. switch, switch是update的一个超强版本, update是从原有的svn folder下取代码的, 而switch可以指定另一个folder的URL(但是仅限于在同一个repository之下的另一个folder), switch操作使得本地的work copy指向新的URL, 同时更新versioned file的footprint信息. 这个操作因为不需要download所有文档的内容, 所以速度很快.

4. checkout, 就是将svn上的某个directory所有文档都下载到一个本地目录,同时下载文档的footprint信息, 它要求本地目录必须是空目录. 也叫作fresh checkout.

移动和复制

当我们对源码结构进行重新组织时, 经常会对versioned file进行复制和移动操作. Tortoisesvn的move和copy命令比较隐蔽, 在tortoisesvn菜单上是找不到这些命令的, 只能是先选中要移动的folder/file, 然后按下鼠标右键, 拖拉到另一个目录, 这时候会出现一个弹出菜单, 其中就有SVN copy和SVN move.

TortoiseSVN合并和回滚操作

合并功能是Subversion最大的亮点. 它甚至是改变了我们的开发模式(和Sourcesafe的checkout-lock-checkin模式相比). 当然合并操作本身是很复杂的. 主要有3种合并模式, 需要提醒的是, 合并操作后, 结果仅仅反映到本地的work copy上了, 这时候还没有在svn server上进行merge. 如果你真的要在server上merge的话, 需要再执行commit操作.

合并模式1-(merge a range of revisions):即同一个branch不同版本的merge, 在这个向导中, 你需要指定一个URL(因为已经有个缺省值, 所以一般情况下你不需关心这个), 然后你要指定一个要merge的版本序列, 这个不好理解, 为什么是一个版本序列呢? 在一般情况下, 你只需要指定一个版本号, 并不需要merge几个版本. 但svn仍然提供了一个让你一次性merge多个版本的功能.

合并模式2-(reintegrate a branch): 这是subserver提供的一个非常有用的功能, 它可以将我们的另一个branch代码和本地的work copy进行merge.

合并模式3-(合并两个树): 这应该是三种合并模式中, 最灵活的一种, 选项也最多, 你可以指定两个repository 的URL, 以及相应的版本号码, 然后merge.

版本回滚: TortoiseSVN的rollback功能放在Show Log的界面上了, 最方便的一个回滚方法是: Revert to this revision, 这个很好理解, 就是将版本回滚到你选定的那个版本上, 点击之后, 会将work copy回滚到刚刚指定的那个版本. 需要commit之后, 才会将这个版本真正地在svn server上了.

Continuous Integration Tool--CC.Net

2008-07-29T02:29:00.001-07:00

TeamCity is good tool, the free version is enough for most small-medium projects.
Cruise Control.Net is absolutely free and open source tool. Actually, it is more hard to configure.
Fortunately, there is a sourceforge project can help you.
cc-config: http://cc-config.sourceforge.net/

PS, CC.Net http://cruisecontrol.sourceforge.net/

Understand TeamCity Work Flow

2008-07-29T01:13:00.000-07:00

首先可以将TeamCity 看作一个专门Continuous Integration(CI)的Web Portal. TeamCity可以管理多个Build Agent, ,每个Build Agent可以认为是专门用来编译代码的机器. 当然Build Agent可以和TeamCity是同一台计算机. TeamCity为什么采用多个Build Agent这样的架构呢?

多个Build Agent的优点:

主要是考虑到Build代码的过程可能能长, 另外是我们可能又想加入Unit Test的功能, 尤其是Unit Test很多的情况下(或者commit source很频繁), 一台计算机显然不行.
我们可以将Unit Test按功能分类, 将他们分配到不同的Build Agent上.
我们也可以将Unit Test按工作量进行分配, 将他们分配到不同的Build Agent上. 这其实是Load Balance
提供Pre-Tested commit特性, 详见下文.

TeamCity的特点:

TeamCity由Java开发的, 所以是跨平台的, 支持Java和.Net. 它采用Tomcat作为Web Server.
TeamCity支持多种Build工具, Java方面, 你可以选用Ant, Maven, Idea等. .Net方面, 你可以用MSbuild, NAnt以及Visual Studio的Solution文件.
Pre-Tested Commit(Delayed commit)方式: 应该说这是TeamCity杀手级的特性(killer feature). 相信我们都遇到过这样的情况, 有的程序员嫌跑所有的单元测试太费时间, 测试了部分Unit Test就将代码提交到VCS上(或者根本没有跑Unit Test). 结果很不幸, 那些没有测试的case结果却跑不通. 你不得不将代码rollback, 其过程之痛苦不用多言. TeamCity介绍了Pre-Tested提交这个特性, 可以彻底解决这个问题. 它是为IDE提供TeamCity的插件来触发这个过程. 详细流程见下文的TeamCity的一般工作流程.

TeamCity的一般工作流程是(Workflow_Diagram):

Programmer在IDE中通过TeamCity的Pre-Tested commit将代码check in到VCS Server
TeamCity根据其Trigger设置, 定时从VCS Server取代码, 然后将代码发送到Build Agent中. 指派Agent 去执行响应的Build和Unit Test 操作.
Build Agent完成操作后, 将结果返回给TeamCity.
如果结果正确的话, 则将Code 真正提交到VCS.

Continuous Integration Tool--TeamCity

2008-07-28T22:13:00.000-07:00

TeamCity is another famous Continuous Integrating Tool. It is much easier to configure than CC.Net because TeamCity is allowed to configure through Web UI. The latter one has too many xml files to configure.

Product Site http://www.jetbrains.com/teamcity/
Free Version License Including

3 Build Agents at no additional cost
20 User Accounts
20 Build Configurations

More detail Info, View the following blogs,

Our Build Config--TeamCity(http://blog.eleutian.com/2008/03/07/OurBuildConfigurations.aspx)
CruiseControl.NET is dead. Long live Team City!(http://blog.eleutian.com/2007/12/22/CruiseControlNETIsDeadLongLiveTeamCity.aspx)
Integration of NCover into Team City for Tech Head Brothers(http://weblogs.asp.net/lkempe/archive/2008/03/30/integration-of-ncover-into-team-city-for-tech-head-brothers.aspx)
Continuous Integration Revisited(http://www.zorched.net/2006/08/10/continuous-integration-revisited/)

NDbUnit Framework

2008-07-28T22:00:00.000-07:00

NDbUnit test is a good UnitTest framework if you are familiar with C#. But this project seems not active since 2006.
Home Page: http://qualitylabs.org/projects/ndbunit/

How to increase scalability--InfoQ article

2008-07-28T00:39:00.000-07:00

http://www.infoq.com/articles/scalability-panel

WSE-enabled web service to authenticate by user/password

2008-07-24T23:15:00.000-07:00

WSE is short for web service enhancement.

WSE 1 user/password authentication
1. http://www.eggheadcafe.com/articles/20021227.asp
2.http://www.devx.com/security/Article/15634/1954
3. http://www.eggheadcafe.com/articles/20021231.asp ( X509 certification )

WSE 3
1. http://geeknotes.wordpress.com/2007/03/16/a-simple-wse-30-web-service-to-authorize-by-username-and-password/
2. http://blog.nerdbank.net/2006/03/wse3-and-aspnet-membership-provider.html

version control with TortoiseSVN without SVN Server

2008-07-24T19:48:00.000-07:00

If you only have a limited number of users, and do not need remote access, you can use Tortoise without a subversion server. This makes set-up much easier.
Steps:
1. Install TortoiseSVN software
2. Open Windows Explorer.
3. Create a empty folder as your repository, this can be local or on network drive.
4. Right click the empty folder, and then click on "Create repository here".
5. Then you can use TortoiseSVN--Repository browser to manage your repository directory. Maybe you can add such directories.
-project_a
-trunk
-branches
-tags
6. After the first 5 steps. you can do any operations just like the repository on a SVN Server.

How to arrange the svn repository layout

2008-07-24T19:22:00.000-07:00

怎样组织ｓｖｎ的目录其实非常有学问，比如我们是要将多个项目放在一个ｓｖｎ　ｒｅｐｏｓｉｔｏｒｙ下，　还是为每个项目都建立一个独立的ｓｖｎ　ｒｅｐｏｓｉｔｏｒｙ呢？　实际上，　这两种做法各有优缺点．　

使用单一ｓｖｎ　ｒｅｐｏｓｉｔｏｒｙ的优点是：只需要维护一个ｓｖｎ库，工作量自然会少了很多，　这里维护工作包括ｒｏｕｔｉｎｅｌｙ　ｂａｃｋｕｐ，ｄｕｍｐ以及升级ｓｖｎ软件．　当然缺点也很明显：　一个项目的开发人员可以访问另一个项目的文件，另外一个严重的缺点是，每个项目的ｃｏｍｍｉｔ　ｅｍａｉｌ　ｌｉｓｔ很可能不同，　但如果在一个ｒｅｐｏｓｉｔｏｒｙ下，就不能为不同的项目配置不同的ｅｍａｉｌ　ｌｉｓｔ，　这样一旦项目Ａ被ｃｏｍｍｉｔ，项目Ｂ的也会收到ｃｏｍｍｉｔ　ｅｍａｉｌ．　

下面是一个多项目的repository结构，　但项目的ｒｅｐｏｓｉｔｏｒｙ也可参照这个．

要说明的是ｔｒｕｎｋ，ｂｒａｎｃｈｅｓ和ｔａｇｓ的意义，　ｔｒｕｎｋ里面维护着是项目的主要开发版本．　ｂｒａｎｃｈｅｓ是ｔｒｕｎｋ版本的各类分支版本．ｔａｇｓ是保存着ｔｒｕｎｋ和ｂｒａｎｃｈｅｓ的某一时刻的快照．　

/
 calc/
    trunk/
    tags/
    branches/
 calendar/
    trunk/
    tags/
    branches/
 spreadsheet/
    trunk/
    tags/
    branches/

Install Subversion server on windows computer

2008-06-30T00:28:00.000-07:00

步骤1, 创建一个空目录, 比如d:/source
步骤2, 打开d:\source目录, 使用windows explorer的context menu中tortoisesvn/create a repository here菜单项, 在d:\source中创建必要的repository控制文件和数据库文件.
步骤3, 创建一个svn service服务, 并将服务的工作目录指向d:\source即可. 下面有详细的步骤.

We can register subversion service. the steps are easy. Windows system have a sc command tool to help you register.
If path of subversion contains space or other chars that must be escaped, then you must enclose the path to svnserve.exe with double-quotes, which themselves must be quoted using a backslash. Fortunately the syntax is similar to that on Unix platforms:

Create service methods:
1)On your computer if the path of svnserve.exe does not contain spaces
sc create subversion_local binpath= "c:\svn\bin\svnserve.exe --service -r d:\source" displayname= "Local Subversion Repository" depend= Tcpip
删除这个服务的命令是 sc delete subversion_local
2)On your computer if the path of svnserve.exe contains spaces
sc create subversion_local binpath= "\"c:\program files\subversion\bin\svnserve.exe\" --service -r d:\source" displayname= "Local Subversion Repository" depend= Tcpip

Access the subversion repository by tortoiseSVN, you need a repository url.
1)Browse the repository on local computer,the repository url is just like,
file:///d:/source/docs
2)Browse the repository on remote computer, 前提是computer22机器上的source/docs必须共享出来, 这样才能通过file协议来访问. 访问方式是:
file:///\computer22/source/docs
这是基于file协议的svn访问方式, 多人项目最好不用file协议(因为共享目录安全性较差, 无法做到精细化权限管理). 最好是用svn协议或https协议. 参见我的另一blog( svn authorization)
3)Browse the repository across internet, the repository url is just like,
https://xxxx.svn.sourceforge.net/svnroot/xxxx

more info : http://svn.collab.net/repos/svn/trunk/notes/windows-service.txt

Software dev environment

2008-06-23T19:50:00.000-07:00

1. Version control tool
SubVersion and TortoiseSVN
2. A bug administration tool
Mantis, hosted by sourceforge, http://www.mantisbt.org/download.php
Trac, this is a open source bug admin web system. and it provides an interface to subversion, and it has an integrated Wiki and reporting facilities. http://trac.edgewall.org/
3. Continuous Build Tool
CruiseControl.net http://www.codeproject.com/KB/architecture/ContinuousIntegration.aspx

Delphi software dev environment

2008-06-23T19:35:00.000-07:00

1. IDE Expert tools
GExpert, www.gexperts.org
DelphiSpeedUp, http://andy.jgknet.de/dspeedup/
DDevExtensions, http://andy.jgknet.de/dspeedup/index.php?page=DDevExtensions
DelforExp, Format Expert

2. Dunit and DUnitLite
http://dunit.sourceforge.net/
http://code.google.com/p/dunitlite

3. madExcept, this is an excellent exception catcher

Freesoftware and opensoftwares

2008-06-10T22:49:00.000-07:00

优秀开源和免费软件下载网站有:
http://portableapps.com/
http://nirsoft.net/
http://www.pendriveapps.com/
http://www.downloadsquad.com/
http://www.osalt.com/

24 Killer Portable Apps For Your USB Flash Drive
http://www.downloadsquad.com/2008/09/02/24-killer-portable-apps-for-your-usb-flash-drive/

Database Browser(Portable Edition,支持Oracle, SQL Server,ODBC)
http://www.dbsoftlab.com/index.php/Freeware/Database-Browser.html

NetSetManagement (portable Edition) 方便切换多个IP和网关
http://www.pendriveapps.com/2008/03/31/netsetman-portable-network-settings-manager/

WinDirStatPortable(分析磁盘文件的占用情况)
http://portableapps.com/apps/utilities/windirstat_portable

PidginPortable(MSN, QQ等IM 客户端)
http://portableapps.com/apps/internet/pidgin_portable

EraserPortable(securely Delete file/folder)
http://portableapps.com/apps/utilities/eraser_portable

MyUninstaller(非常好用的卸载工具)
http://www.nirsoft.net/utils/myuninst.html

Sumatra PDF Portable (PDF Reader)
http://portableapps.com/apps/office/sumatra_pdf_portable

Keepass--Protect your password
http://keepass.info/

italc--Local network computer projector, for team learning and team computer control.
http://italc.sourceforge.net

Desktops--Virtual Windows desktop manager, just like linux multi-desktop
http://technet.microsoft.com/en-us/sysinternals/cc817881.aspx

EyeDefender--Alert you when you have used computer for a period
http://eterlab.com/

Locate--Just the linux locate command
http://locate32.webhop.org/

WordWeb--English thesaurus and dictionary lookup
http://wordweb.info/free/

how to change file folder in subversion

2008-06-04T00:40:00.000-07:00

Subversion是一个非常好的Source版本控制软件.
TortoiseSVN是一个Windows平台上Subversion客户端. 操作非常方便, 但有一个问题是: 在TortoiseSVN的菜单中, 怎么也找不到Move file to...或者是change file folder这样的菜单项目, 不知道怎样才能移动文件.
google一搜, 才发现不仅仅是我有这样的困惑.
实际上TortoiseSVN已经考虑了这个问题, 只不过它不是将功能体现在菜单项上, 右键拖拉一个文件到一个versioned folder, 就会出现看到TortoiseSVN已经为你提供了移动功能.

http://svn.haxx.se/tsvnusers/archive-2006-02/0167.shtml

C_Sharp edition StringList Class

2008-05-26T22:08:00.002-07:00

Delphi有一个常用的类StringList, 它有一个特点是你可以一行一行加String, 如果你所加的每行String都是Name=Value格式的,它会帮你提取出Name列表和Value列表, 这个类我在用Delphi时候, 常使用它. 下面是C#版的StringList类.


namespace LiuHarry.Utils.Foundation
{
   using System;
   using System.Collections.Generic;
   using System.Runtime.InteropServices;
   using System.Text;

   public class DelphiStrList
   {
       private List<string> M_Items = new List<string>();
       private List<string> M_Keys = new List<string>();
       private string M_KeyValueEqualmark = "=";
       private List<string> M_Values = new List<string>();

       public virtual void Add(string item)
       {
           string str;
           string str2;
           this.M_Items.Add(item);
           DivideKeyValue(item, this.M_KeyValueEqualmark, out str2, out str);
           this.M_Keys.Add(str2);
           this.M_Values.Add(str);
       }

       public virtual void Clear()
       {
           this.M_Items.Clear();
           this.M_Keys.Clear();
           this.M_Values.Clear();
       }

       protected void DevideKeyValuesByItems()
       {
           this.M_Keys.Clear();
           this.M_Values.Clear();
           foreach (string str3 in this.M_Items)
           {
               string str;
               string str2;
               DivideKeyValue(str3, this.M_KeyValueEqualmark, out str2, out str);
               this.M_Keys.Add(str2);
               this.M_Values.Add(str);
           }
       }

       public static void DivideKeyValue(string entireStr, string keyValueEqualmark, out string keyStr, out string valueStr)
       {
           int index = entireStr.IndexOf(keyValueEqualmark);
           if (index > 0)
           {
               keyStr = entireStr.Substring(0, index);
               if (index < (entireStr.Length - 1))
               {
                   valueStr = entireStr.Substring(index + 1);
               }
               else
               {
                   valueStr = "";
               }
           }
           else
           {
               keyStr = entireStr;
               valueStr = "";
           }
       }

       public virtual int IndexOf(string item)
       {
           return this.M_Items.IndexOf(item);
       }

       public virtual void Insert(int index, string item)
       {
           string str;
           string str2;
           this.M_Items.Insert(index, item);
           DivideKeyValue(item, this.M_KeyValueEqualmark, out str2, out str);
           this.M_Keys.Insert(index, str2);
           this.M_Values.Insert(index, str);
       }

       public string MakeItemsToText(string ItemSeperator)
       {
           return this.MakeStrlistToText(this.M_Items, ItemSeperator);
       }

       public string MakeKeyItemsToText(string ItemSeperator)
       {
           return this.MakeStrlistToText(this.M_Keys, ItemSeperator);
       }

       private string MakeStrlistToText(List<string> items, string ItemSeperator)
       {
           StringBuilder builder = new StringBuilder();
           foreach (string str in items)
           {
               builder.Append(str);
               builder.Append(ItemSeperator);
           }
           return builder.ToString();
       }

       public string MakeValueItemsToText(string ItemSeperator)
       {
           return this.MakeStrlistToText(this.M_Keys, ItemSeperator);
       }

       public virtual bool Remove(string item)
       {
           int index = this.IndexOf(item);
           if (index >= 0)
           {
               this.M_Keys.RemoveAt(index);
               this.M_Values.RemoveAt(index);
           }
           return this.M_Items.Remove(item);
       }

       public virtual void RemoveAt(int index)
       {
           this.M_Items.RemoveAt(index);
           this.M_Keys.RemoveAt(index);
           this.M_Values.RemoveAt(index);
       }

       public virtual void Sort()
       {
           this.M_Items.Sort();
           this.DevideKeyValuesByItems();
       }

       public int Count
       {
           get
           {
               return this.M_Items.Count;
           }
       }

       public List<string> Items
       {
           get
           {
               return this.M_Items;
           }
       }

       public List<string> Keys
       {
           get
           {
               return this.M_Keys;
           }
       }

       public string KeyValueEqualmark
       {
           get
           {
               return this.M_KeyValueEqualmark;
           }
           set
           {
               this.M_KeyValueEqualmark = value;
           }
       }

       public List<string> Values
       {
           get
           {
               return this.M_Values;
           }
       }
   }
}

How to hide or show TabPage of TabControl

2008-05-26T21:48:00.000-07:00

C# 的TabControl功能严重不足, 尤其是你用它来制作Wizard界面时候, 下面代码会有所帮助的.


namespace LiuHarry.Utils.Components
{
  using System;
  using System.Windows.Forms;

  public class TabControlHelper
  {
      private TabControl m_tabControl;

      public TabControlHelper(TabControl tabCtrl)
      {
          this.m_tabControl = tabCtrl;
      }

      public void HideTabPage(TabPage tp)
      {
          if (this.m_tabControl.TabPages.Contains(tp))
          {
              this.m_tabControl.TabPages.Remove(tp);
          }
      }

      private void InsertTabPage(TabPage tabpage, int index)
      {
          if ((index < 0) || (index > this.m_tabControl.TabCount))
          {
              throw new ArgumentException("Index out of Range.");
          }
          this.m_tabControl.TabPages.Add(tabpage);
          if (index < (this.m_tabControl.TabCount - 1))
          {
              do
              {
                  this.SwapTabPages(tabpage, this.m_tabControl.TabPages[this.m_tabControl.TabPages.IndexOf(tabpage) - 1]);
              }
              while (this.m_tabControl.TabPages.IndexOf(tabpage) != index);
          }
          this.m_tabControl.SelectedTab = tabpage;
      }

      public void ShowTabPage(TabPage tp)
      {
          this.ShowTabPage(tp, this.m_tabControl.TabPages.Count);
      }

      public void ShowTabPage(TabPage tp, int index)
      {
          if (!this.m_tabControl.TabPages.Contains(tp))
          {
              this.InsertTabPage(tp, index);
          }
      }

      private void SwapTabPages(TabPage tp1, TabPage tp2)
      {
          if (!(this.m_tabControl.TabPages.Contains(tp1) && this.m_tabControl.TabPages.Contains(tp2)))
          {
              throw new ArgumentException("TabPages must be in the TabControls TabPageCollection.");
          }
          int index = this.m_tabControl.TabPages.IndexOf(tp1);
          int num2 = this.m_tabControl.TabPages.IndexOf(tp2);
          this.m_tabControl.TabPages[index] = tp2;
          this.m_tabControl.TabPages[num2] = tp1;
          this.m_tabControl.SelectedIndex = this.m_tabControl.SelectedIndex;
          string text = tp1.Text;
          string str2 = tp2.Text;
          tp1.Text = str2;
          tp2.Text = text;
      }
  }
}

DataGridViewHelper class

2008-05-26T21:42:00.001-07:00

DataGridView这个控件在开发中经常会被用到, C#的组件总觉得不如Delphi组件那么容易使用, 怎样在Grid上选择一个Row, 怎样选择一个Cell, 我就被block了好久. 下面是代码:


namespace LiuHarry.Utils.Components
{
   using System;
   using System.Collections;
   using System.Collections.Generic;
   using System.Data;
   using System.Windows.Forms;

   public class DataGridViewHelper
   {
       private DataGridView m_DataGridView;
       private SortedList<string, string> m_MapListFieldColumn = new SortedList<string, string>();
       private DataView m_ShowedDataViewInGrid;

       public DataGridViewHelper(DataGridView dataGridView, DataView showedDataViewInGrid)
       {
           this.m_DataGridView = dataGridView;
           this.m_ShowedDataViewInGrid = showedDataViewInGrid;
           this.InitFieldColumnMapList();
       }

       private string _GetGridViewColumnName(string dataFieldName)
       {
           for (int i = 0; i < this.m_DataGridView.Columns.Count; i++)
           {
               if (this.m_DataGridView.Columns[i].DataPropertyName == dataFieldName)
               {
                   return this.m_DataGridView.Columns[i].Name;
               }
           }
           return "";
       }

       private void InitFieldColumnMapList()
       {
           this.m_MapListFieldColumn.Clear();
           for (int i = 0; i < this.m_ShowedDataViewInGrid.Table.Columns.Count; i++)
           {
               string columnName = this.m_ShowedDataViewInGrid.Table.Columns[i].ColumnName;
               string str2 = this._GetGridViewColumnName(columnName);
               this.m_MapListFieldColumn.Add(columnName, str2);
           }
       }

       public string QuickFindGridViewColumnName(string dataFieldName)
       {
           int num = this.m_MapListFieldColumn.IndexOfKey(dataFieldName);
           if (num < 0)
           {
               throw new Exception("There no a column in DataGridView corresponding DataFieldName=" + dataFieldName);
           }
           return this.m_MapListFieldColumn.Values[num];
       }

       public void SelectAndScrollToCell(string fieldName, object fieldValue)
       {
           this.m_DataGridView.ClearSelection();
           if ((fieldName != null) && (fieldValue != null))
           {
               string str = this.QuickFindGridViewColumnName(fieldName);
               foreach (DataGridViewRow row in (IEnumerable) this.m_DataGridView.Rows)
               {
                   if (object.Equals(row.Cells[str].Value, fieldValue))
                   {
                       this.m_DataGridView.CurrentCell = row.Cells[str];
                       this.m_DataGridView.CurrentCell.Selected = true;
                       break;
                   }
               }
           }
       }

       public void SelectRow(object valueOfSortedField)
       {
           DataView showedDataViewInGrid = this.m_ShowedDataViewInGrid;
           this.m_DataGridView.ClearSelection();
           if ((showedDataViewInGrid != null) && (valueOfSortedField != null))
           {
               int num = showedDataViewInGrid.Find(valueOfSortedField);
               if (num >= 0)
               {
                   this.m_DataGridView.Rows[num].Selected = true;
               }
           }
       }

       public SortedList<string, string> MapListFieldColumn
       {
           get
           {
               return this.m_MapListFieldColumn;
           }
       }
   }
}

SQL Execute Trace Helper Class

2008-05-26T21:24:00.000-07:00

http://focuswindows.blogspot.com/2008/01/sql-executing-monitor-code.html
该版本可能不是最新的, 最新的代码应该是下面:


namespace LiuHarry.Utils.DB
{
   using LiuHarry.Utils.Foundation;
   using System;
   using System.Data;
   using System.Diagnostics;
   using System.IO;
   using System.Reflection;

   internal class SqlExecuteTracer : IDisposable
   {
       private bool disposed = false;
       private string m_ErrorLogFile;
       private readonly string m_ErrorLogFileSuffix = "SqlError.txt";
       private bool m_LogSqlExecute = false;
       private string m_SqlLogFile;
       private readonly string m_SqlLogFileSuffix = "SqlLog.txt";
       private TextWriterTraceListener m_SqlLogListener;

       public SqlExecuteTracer()
       {
           string assemblyFileWithoutExt = this.GetAssemblyFileWithoutExt();
           this.m_ErrorLogFile = assemblyFileWithoutExt + "_" + this.m_ErrorLogFileSuffix;
           this.m_SqlLogFile = assemblyFileWithoutExt + "_" + this.m_SqlLogFileSuffix;
       }

       public void Dispose()
       {
           this.Dispose(true);
           GC.SuppressFinalize(this);
       }

       private void Dispose(bool disposing)
       {
           if (!this.disposed && this.m_LogSqlExecute)
           {
               this.m_SqlLogListener.Close();
           }
           this.disposed = true;
       }

       private string GetAssemblyFileWithoutExt()
       {
           string location = Assembly.GetExecutingAssembly().Location;
           return (Path.GetDirectoryName(location) + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(location));
       }

       private string GetSqlFromCommand(IDbCommand cmd)
       {
           string commandText = cmd.CommandText;
           if (cmd.Parameters.Count <= 0)
           {
               return commandText;
           }
           DelphiStrList list = new DelphiStrList();
           foreach (IDbDataParameter parameter in cmd.Parameters)
           {
               if (parameter.Value != null)
               {
                   list.Add(parameter.ParameterName + "=" + parameter.Value.ToString());
               }
               else
               {
                   list.Add(parameter.ParameterName + "=NULL");
               }
           }
           return (commandText + Environment.NewLine + list.MakeItemsToText(Environment.NewLine));
       }

       public void TraceErrorSqlToLog(IDbCommand cmd, string ErrorMessage)
       {
           using (TraceListener listener = new TextWriterTraceListener(this.m_ErrorLogFile))
           {
               string sqlFromCommand = this.GetSqlFromCommand(cmd);
               this.TraceSqlToLogListener(sqlFromCommand, ErrorMessage, listener);
               listener.Close();
           }
       }

       public void TraceErrorSqlToLog(string sql, string ErrorMessage)
       {
           using (TraceListener listener = new TextWriterTraceListener(this.m_ErrorLogFile))
           {
               this.TraceSqlToLogListener(sql, ErrorMessage, listener);
               listener.Close();
           }
       }

       public void TraceSqlToLog(IDbCommand cmd)
       {
           if (this.m_LogSqlExecute)
           {
               string sqlFromCommand = this.GetSqlFromCommand(cmd);
               this.TraceSqlToLogListener(sqlFromCommand, null, this.m_SqlLogListener);
           }
       }

       public void TraceSqlToLog(string sql)
       {
           if (this.m_LogSqlExecute)
           {
               this.TraceSqlToLogListener(sql, null, this.m_SqlLogListener);
           }
       }

       private void TraceSqlToLogListener(string sql, string ErrorInfo, TraceListener listener)
       {
           listener.WriteLine("===================================");
           listener.WriteLine(DateTime.Now.ToString());
           if (!string.IsNullOrEmpty(ErrorInfo))
           {
               listener.WriteLine("Error Info:");
               listener.WriteLine(ErrorInfo);
               listener.WriteLine("SQL:");
           }
           listener.WriteLine(sql);
           listener.WriteLine("===================================");
           listener.WriteLine("");
           listener.Flush();
       }

       public bool LogSqlExecute
       {
           get
           {
               return this.m_LogSqlExecute;
           }
           set
           {
               this.m_LogSqlExecute = value;
               if (this.m_LogSqlExecute && (this.m_SqlLogListener == null))
               {
                   this.m_SqlLogListener = new TextWriterTraceListener(this.m_SqlLogFile);
               }
           }
       }
   }
}

SQLite Dataset Helper Class

2008-05-26T21:22:00.000-07:00


namespace LiuHarry.Utils.DB
{
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Data.SQLite;
    using System.Runtime.InteropServices;
    using System.Text;

    public class SqliteDataSetHelper : IDisposable
    {
        private readonly string DELETED_FLAG;
        private bool disposed;
        private readonly string INSERTED_FLAG;
        private string m_ConnectionString;
        private bool m_LogSqlExecute;
        private bool m_SelfBuildConnection;
        private SQLiteConnection m_SqlConn;
        private SqlExecuteTracer m_SqlExecuteTracer;
        private readonly string MODIFIED_FLAG;
        private readonly string PARAMETER_NAME_PREFIX;
        private readonly string PARAMETER_PREFIX;

        public SqliteDataSetHelper()
        {
            this.m_LogSqlExecute = false;
            this.m_SelfBuildConnection = true;
            this.DELETED_FLAG = "DELETED_FLAG";
            this.INSERTED_FLAG = "INSERTED_FLAG";
            this.MODIFIED_FLAG = "MODIFIED_FLAG";
            this.PARAMETER_PREFIX = "@";
            this.PARAMETER_NAME_PREFIX = "@";
            this.disposed = false;
            this.m_SqlExecuteTracer = new SqlExecuteTracer();
        }

        public SqliteDataSetHelper(SQLiteConnection conn) : this()
        {
            if (conn != null)
            {
                this.m_SelfBuildConnection = false;
                this.m_SqlConn = conn;
            }
        }

        public SqliteDataSetHelper(string connectionString) : this()
        {
            this.m_ConnectionString = connectionString;
        }

        private void ActivateConnection()
        {
            if (this.m_SqlConn == null)
            {
                this.m_SqlConn = new SQLiteConnection(this.m_ConnectionString);
                this.m_SelfBuildConnection = true;
            }
        }

        public void DeleteRows(List<DataRow> listRows, string tableName, string keyFieldName)
        {
            foreach (DataRow row in listRows)
            {
                this.SetToDeleteState(row);
                this.InnerDeleteRow(row, tableName, keyFieldName);
            }
        }

        public void DeleteRows(List<long> listRowKeyFieldValue, string tableName, string keyFieldName)
        {
            foreach (int num in listRowKeyFieldValue)
            {
                this.InnerDeleteRowByKeyField(num, tableName, keyFieldName, typeof(long));
            }
        }

        public void DeleteRows(List<string> listRowKeyFieldValue, string tableName, string keyFieldName)
        {
            foreach (string str in listRowKeyFieldValue)
            {
                this.InnerDeleteRowByKeyField(str, tableName, keyFieldName, typeof(string));
            }
        }

        public void DeleteRows(DataRow row, string tableName, string keyFieldName)
        {
            this.SetToDeleteState(row);
            this.InnerDeleteRow(row, tableName, keyFieldName);
        }

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                this.TryCloseConnection();
            }
            this.disposed = true;
        }

        public int ExecCommand(SQLiteCommand sqlcom)
        {
            int num2;
            this.ActivateConnection();
            sqlcom.Connection = this.m_SqlConn;
            try
            {
                this.TryOpenConnection();
                this.m_SqlExecuteTracer.TraceSqlToLog(sqlcom);
                num2 = sqlcom.ExecuteNonQuery();
            }
            catch (Exception exception)
            {
                this.m_SqlExecuteTracer.TraceErrorSqlToLog(sqlcom, exception.Message);
                throw exception;
            }
            finally
            {
                this.TryCloseConnection();
            }
            return num2;
        }

        public int ExecCommand(string sql)
        {
            if (sql.EndsWith(","))
            {
                sql = sql.Substring(0, sql.Length - 1);
            }
            SQLiteCommand sqlcom = new SQLiteCommand(sql);
            return this.ExecCommand(sqlcom);
        }

        public SQLiteDataReader ExecDataReader(SQLiteCommand sqlcom)
        {
            SQLiteDataReader reader;
            this.ActivateConnection();
            sqlcom.Connection = this.m_SqlConn;
            try
            {
                this.TryOpenConnection();
                this.m_SqlExecuteTracer.TraceSqlToLog(sqlcom);
                reader = sqlcom.ExecuteReader();
            }
            catch (Exception exception)
            {
                this.m_SqlExecuteTracer.TraceErrorSqlToLog(sqlcom, exception.Message);
                throw exception;
            }
            finally
            {
                this.TryCloseConnection();
            }
            return reader;
        }

        public SQLiteDataReader ExecDataReader(string sqlSelect)
        {
            if (sqlSelect.EndsWith(","))
            {
                sqlSelect = sqlSelect.Substring(0, sqlSelect.Length - 1);
            }
            SQLiteCommand sqlcom = new SQLiteCommand(sqlSelect);
            return this.ExecDataReader(sqlcom);
        }

        public DataTable ExecDataTable(SQLiteCommand sqlcom)
        {
            DataTable table2;
            DataTable dataTable = new DataTable();
            SQLiteDataAdapter adapter = new SQLiteDataAdapter(sqlcom);
            this.ActivateConnection();
            sqlcom.Connection = this.m_SqlConn;
            try
            {
                this.TryOpenConnection();
                this.m_SqlExecuteTracer.TraceSqlToLog(sqlcom);
                adapter.Fill(dataTable);
                table2 = dataTable;
            }
            catch (Exception exception)
            {
                this.m_SqlExecuteTracer.TraceErrorSqlToLog(sqlcom, exception.Message);
                throw exception;
            }
            finally
            {
                this.TryCloseConnection();
            }
            return table2;
        }

        public DataTable ExecDataTable(string sqlSelect)
        {
            if (sqlSelect.EndsWith(","))
            {
                sqlSelect = sqlSelect.Substring(0, sqlSelect.Length - 1);
            }
            SQLiteCommand sqlcom = new SQLiteCommand(sqlSelect);
            return this.ExecDataTable(sqlcom);
        }

        public object ExecScalar(SQLiteCommand sqlcom)
        {
            object obj2;
            this.ActivateConnection();
            sqlcom.Connection = this.m_SqlConn;
            try
            {
                this.TryOpenConnection();
                this.m_SqlExecuteTracer.TraceSqlToLog(sqlcom);
                obj2 = sqlcom.ExecuteScalar();
            }
            catch (Exception exception)
            {
                this.m_SqlExecuteTracer.TraceErrorSqlToLog(sqlcom, exception.Message);
                throw exception;
            }
            finally
            {
                this.TryCloseConnection();
            }
            return obj2;
        }

        public object ExecScalar(string sqlSelect)
        {
            if (sqlSelect.EndsWith(","))
            {
                sqlSelect = sqlSelect.Substring(0, sqlSelect.Length - 1);
            }
            SQLiteCommand sqlcom = new SQLiteCommand(sqlSelect);
            return this.ExecScalar(sqlcom);
        }

        ~SqliteDataSetHelper()
        {
            this.Dispose(false);
        }

        public DateTime GetDbTime()
        {
            string commandText = "select datetime('NOW')  ";
            SQLiteCommand sqlcom = new SQLiteCommand(commandText);
            return (DateTime) this.ExecScalar(sqlcom);
        }

        private DbType GetDbType(Type type)
        {
            DbType guid = DbType.String;
            if (type.Equals(typeof(int)) || type.IsEnum)
            {
                return DbType.Int32;
            }
            if (type.Equals(typeof(long)))
            {
                return DbType.Int32;
            }
            if (type.Equals(typeof(double)) || type.Equals(typeof(double)))
            {
                return DbType.Decimal;
            }
            if (type.Equals(typeof(DateTime)))
            {
                return DbType.DateTime;
            }
            if (type.Equals(typeof(bool)))
            {
                return DbType.Boolean;
            }
            if (type.Equals(typeof(string)))
            {
                return DbType.String;
            }
            if (type.Equals(typeof(decimal)))
            {
                return DbType.Decimal;
            }
            if (type.Equals(typeof(byte[])))
            {
                return DbType.Binary;
            }
            if (type.Equals(typeof(Guid)))
            {
                guid = DbType.Guid;
            }
            return guid;
        }

        public long GetMaxID(string primaryKeyField, string tableName)
        {
            SQLiteCommand sqlcom = new SQLiteCommand("Select Max(" + primaryKeyField + ") from " + tableName);
            return (long) this.ExecScalar(sqlcom);
        }

        private void InnerDeleteRow(DataRow dr, string TableName, string keyFieldName)
        {
            string format = "Delete from {0} where {1} =" + this.PARAMETER_PREFIX + "{1}";
            DataTable table = dr.Table;
            SQLiteCommand sqlcom = new SQLiteCommand(string.Format(format, TableName, keyFieldName));
            IDataParameter parameter = new SQLiteParameter();
            parameter.ParameterName = this.PARAMETER_NAME_PREFIX + keyFieldName;
            parameter.DbType = this.GetDbType(table.Columns[keyFieldName].DataType);
            parameter.Value = dr[keyFieldName];
            sqlcom.Parameters.Add(parameter);
            this.ExecCommand(sqlcom);
        }

        private void InnerDeleteRowByKeyField(object RowKeyFieldValue, string tableName, string keyFieldName, Type keyFieldType)
        {
            SQLiteCommand sqlcom = new SQLiteCommand(string.Format("Delete from {0} where {1} =" + this.PARAMETER_PREFIX + "{1}", tableName, keyFieldName));
            IDataParameter parameter = new SQLiteParameter();
            parameter.ParameterName = this.PARAMETER_NAME_PREFIX + keyFieldName;
            parameter.DbType = this.GetDbType(keyFieldType);
            parameter.Value = RowKeyFieldValue;
            sqlcom.Parameters.Add(parameter);
            this.ExecCommand(sqlcom);
        }

        private void InnerInsertRow(DataRow dr, string TableName, string primaryKeyField, bool primaryKeyValueIsAutoGenerated, out long primaryKeyValue)
        {
            string format = "Insert into {0}({1}) values ({2})";
            SQLiteCommand sqlcom = new SQLiteCommand();
            DataTable table = dr.Table;
            StringBuilder builder = new StringBuilder();
            StringBuilder builder2 = new StringBuilder();
            for (int i = 0; i < dr.Table.Columns.Count; i++)
            {
                if (!primaryKeyValueIsAutoGenerated || !(table.Columns[i].ColumnName == primaryKeyField))
                {
                    IDataParameter parameter = new SQLiteParameter();
                    parameter.ParameterName = this.PARAMETER_NAME_PREFIX + table.Columns[i].ColumnName;
                    parameter.DbType = this.GetDbType(table.Columns[i].DataType);
                    parameter.Value = dr[i];
                    sqlcom.Parameters.Add(parameter);
                    builder2.Append(table.Columns[i].ColumnName);
                    builder.Append(this.PARAMETER_PREFIX + table.Columns[i].ColumnName);
                    builder2.Append(",");
                    builder.Append(",");
                }
            }
            string str2 = builder2.ToString();
            str2 = str2.Substring(0, str2.Length - 1);
            string str3 = builder.ToString();
            str3 = str3.Substring(0, str3.Length - 1);
            string str4 = string.Format(format, TableName, str2, str3);
            sqlcom.CommandText = str4;
            this.ExecCommand(sqlcom);
            if (!primaryKeyValueIsAutoGenerated)
            {
                primaryKeyValue = 0L;
            }
            else
            {
                SQLiteCommand command2 = new SQLiteCommand("Select Max(" + primaryKeyField + ") from " + TableName);
                object obj2 = this.ExecScalar(command2);
                primaryKeyValue = (long) obj2;
            }
        }

        private void InnerModifyRow(DataRow dr, string TableName, string keyFieldName)
        {
            string format = "Update {0} set {1} {2}";
            string str2 = "{0}= " + this.PARAMETER_PREFIX + "{0}";
            string str3 = " Where {0}=" + this.PARAMETER_PREFIX + "{0}";
            StringBuilder builder = new StringBuilder();
            SQLiteCommand sqlcom = new SQLiteCommand();
            DataTable table = dr.Table;
            for (int i = 0; i < dr.Table.Columns.Count; i++)
            {
                IDataParameter parameter = new SQLiteParameter();
                parameter.ParameterName = this.PARAMETER_NAME_PREFIX + table.Columns[i].ColumnName;
                parameter.DbType = this.GetDbType(table.Columns[i].DataType);
                parameter.Value = dr[i];
                sqlcom.Parameters.Add(parameter);
                if (table.Columns[i].ColumnName == keyFieldName)
                {
                    str3 = string.Format(str3, keyFieldName);
                }
                else
                {
                    builder.Append(string.Format(str2, table.Columns[i].ColumnName));
                    builder.Append(",");
                }
            }
            string str4 = builder.ToString();
            str4 = str4.Substring(0, str4.Length - 1);
            string str5 = string.Format(format, TableName, str4, str3);
            sqlcom.CommandText = str5;
            this.ExecCommand(sqlcom);
        }

        public void InsertRows(List<DataRow> listRows, string tableName)
        {
            foreach (DataRow row in listRows)
            {
                this.InsertRows(row, tableName);
            }
        }

        public void InsertRows(DataRow row, string tableName)
        {
            long num;
            this.SetToInsertState(row);
            string primaryKeyField = "";
            bool primaryKeyValueIsAutoGenerated = false;
            this.InnerInsertRow(row, tableName, primaryKeyField, primaryKeyValueIsAutoGenerated, out num);
        }

        public void InsertRows(List<DataRow> listRows, string tableName, string primaryKeyField, bool primaryKeyValueIsAutoGenerated, out List<long> listPrimaryKeyValue)
        {
            listPrimaryKeyValue = new List<long>();
            foreach (DataRow row in listRows)
            {
                long num;
                this.SetToInsertState(row);
                this.InnerInsertRow(row, tableName, primaryKeyField, primaryKeyValueIsAutoGenerated, out num);
                listPrimaryKeyValue.Add(num);
            }
        }

        public void InsertRows(DataRow row, string tableName, string primaryKeyField, bool primaryKeyValueIsAutoGenerated, out long primaryKeyValue)
        {
            this.SetToInsertState(row);
            this.InnerInsertRow(row, tableName, primaryKeyField, primaryKeyValueIsAutoGenerated, out primaryKeyValue);
        }

        public void ModifyRows(List<DataRow> listRows, string tableName, string keyFieldName)
        {
            foreach (DataRow row in listRows)
            {
                this.SetToModifyState(row);
                this.InnerModifyRow(row, tableName, keyFieldName);
            }
        }

        public void ModifyRows(DataRow row, string tableName, string keyFieldName)
        {
            this.SetToModifyState(row);
            this.InnerModifyRow(row, tableName, keyFieldName);
        }

        public void SetToDeleteState(DataRow row)
        {
            row.RowError = this.DELETED_FLAG;
        }

        public void SetToInsertState(DataRow row)
        {
            row.RowError = this.INSERTED_FLAG;
        }

        public void SetToModifyState(DataRow row)
        {
            row.RowError = this.MODIFIED_FLAG;
        }

        private void TryCloseConnection()
        {
            if (this.m_SelfBuildConnection && (this.m_SqlConn != null))
            {
                this.m_SqlConn.Close();
            }
        }

        private void TryOpenConnection()
        {
            if (this.m_SelfBuildConnection)
            {
                this.m_SqlConn.Open();
            }
        }

        public string ConnectionString
        {
            get
            {
                return this.m_ConnectionString;
            }
            set
            {
                this.m_ConnectionString = value;
            }
        }

        public bool LogSqlExecute
        {
            get
            {
                return this.m_LogSqlExecute;
            }
            set
            {
                this.m_LogSqlExecute = value;
                this.m_SqlExecuteTracer.LogSqlExecute = this.m_LogSqlExecute;
            }
        }
    }
}

Managed ExecuteShell API

2008-05-26T21:09:00.000-07:00


namespace LiuHarry.Utils.Foundation
{
    using System;
    using System.Diagnostics;

    public class CommandShell
    {
        public static string RunCmd(string command)
        {
            Process process = new Process();
            process.StartInfo.FileName = "cmd.exe";
            process.StartInfo.Arguments = "/c " + command;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardInput = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;
            process.StartInfo.CreateNoWindow = true;
            process.Start();
            return process.StandardOutput.ReadToEnd();
        }
        
        public static void CallWindowsApp()
        {
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.EnableRaisingEvents=false;
            //call calculator
            proc.StartInfo.FileName="calc";
            proc.Start();
        }   
        
        public static void GotoWebSite()
        {
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.EnableRaisingEvents=false;
            proc.StartInfo.FileName="iexplore";
            proc.StartInfo.Arguments=http://www.microsoft.com;
            proc.Start();
            proc.WaitForExit();
            MessageBox.Show("You have just visited www.microsoft.com");        
        }
        
        public static void OpenWordDocument()
        {
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.EnableRaisingEvents=false;
            proc.StartInfo.FileName="winword";
            proc.StartInfo.Arguments="C:\\Dotnetstuff\\TestWordDoc.doc";
            proc.Start();        
        }
        
        public static void ExecuteBatchFile()
        {
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.EnableRaisingEvents=false;
            proc.StartInfo.FileName="c:\\dotnetstuff\\netdrv.bat";
            proc.Start();
            MessageBox.Show("Map Drive Created");        
        }
        
    }
    
    
}

How to create a new XmlElement

2008-05-26T18:42:00.000-07:00

XmlNode是一个Context相关的对象, 你不能直接调用XmlNode的构造子来创建一个XmlNode. 要创建一个XmlNode有两个方法. 假设要在xmlParentNode下创建一个newNode.
方法１：　通过XmlDocument的CreateElement方法创建一个XmlNode
　　public XmlElement CreateElement(prefix,localName,namespaceURI)，如果元素带有namespace,必须加上namespaceURI，　比如：
步骤1:XmlElement newNode= docNode.CreateElement("w", "br", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");
步骤2:xmlParentNode.InsertAfter(br, rNode.FirstChild);

方法2: 不是直接创建XmlElement，而是通过修改xmlParentNode的InnerXml文本，　来增加一个节点．记住：如果新加的内容包含前缀，一定要加上namespace URI．否则会报错的．　　


xmlParentNode.InnerXml=　@"<w:r xmlns:w=""http://schemas.openxmlformats.org/wordprocessingml/2006/main""><w:rPr>
                </w:rPr>
                <w:br/>
                <w:t>Some string </w:t></w:r>";

Thread safe Singleton pattern

2008-05-21T20:16:00.000-07:00

关于Singleton模式的几个误区
网上有很多Singleton模式的样板, 多数是错误的, 下面的文档提出了很好的样板.
http://msdn.microsoft.com/en-us/library/ms998558.aspx
http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=486
http://www.yoda.arachsys.com/csharp/singleton.html
http://codebetter.com/blogs/steve.hebert/archive/2005/12/16/135697.aspx
另外特别说明的是:
1. Singleton class的Instance属性或者公开方法GetInstance()不应带参数, 也就是说无论在什么情况下获取Singleton类的对象, 都始终是那一个, 不会有不同的实例.
2. Singleton类不能是Static类, 因为Static类不能包含任何实例方法(包括实例constructor). 但Singleton类一定要包含一个static变量(比如_Instance, 其类型为Singleton)来存储Singleton类的实例, 那为什么必须是static变量呢? 因为我们在使用Singleton类的时候, 不是通过constructor类创建一个Singleton对象, 而是需要通过调用一个static方法(比如GetInstance())来创建一个实例, 而static方法只能使用static变量, 不能使用任何非static变量, 这就要求存放Singleton实例的内部变量必须是static变量.
3. Singleton类必须要使用lock, 否则就不是线程安全的, 除非_Instance这个static变量, 同时被声明为readonly.
4. 一般情况下, 不要Singleton模式, 不必使用Double check+Lock这样的代码, 因为写法复杂, 而且容易会造成线程不安全. 尤其是在多核机器上. 可以直接使用Single Check+Lock写法, 简单而又安全.

Bad Code	Good Code
// Bad code! Do not use! Not Thread safe, public sealed class Singleton { static Singleton instance=null; Singleton() { } public static Singleton Instance { get { if (instance==null) { instance = new Singleton(); } return instance; } } }	//Thread safe, 不是Lazy load, 特点:实现简单 //But performance suffers as a lock is acquired every time the instance is requested public sealed class Singleton { static Singleton instance = null; static readonly object padlock = new object(); Singleton() { } public static Singleton Instance { get { lock (padlock) { if (instance == null) { instance = new Singleton(); } return instance; } } } }
// Try to double Check, But still is not thread safe! Do not use! //Thread safe issue see: //http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html public sealed class Singleton { static Singleton instance=null; static readonly object padlock = new object(); Singleton() { } public static Singleton Instance { get { if (instance==null) { lock (padlock) { if (instance==null) { instance = new Singleton(); } } } return instance; } } }	//Thread safe,虽然不是Lazy load. 它使用了static Initilization,特点:简单 public sealed class Singleton { private static readonly Singleton instance = new Singleton(); private Singleton(){} public static Singleton Instance { get { return instance; } } }
// double Check, Thread not safe //Thread safe issue see: //http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html public sealed class Singleton { static Singleton instance=null; static readonly object padlock = new object(); Singleton() { } public static Singleton Instance { get { if (instance==null) { lock (padlock) { if (instance==null) { //线程不安全,因为编译器会进行代码优化, //临时变量tempInstance会被舍弃,这样就编程了线程不安全代码了 Singleton tempInstance=new Singleton(); instance = tempInstance; } } } return instance; } } }	// double Check, Thread safe public sealed class Singleton { volatile static Singleton instance=null; static readonly object padlock = new object(); Singleton() { } public static Singleton Instance { get { if (instance==null) { lock (padlock) { //线程安全,因为instance被标记为volatile if (instance==null) { Instance=new Singleton(); } } } return instance; } } }

thread-safe, not quite as lazy, without using locks

thread-safe, fully lazy instantiation

public sealed class Singleton
{
static readonly Singleton instance=new Singleton();

// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
static Singleton()
{
}

Singleton()
{
}

public static Singleton Instance
{
  get
  {
      return instance;
  }
}
}

public sealed class Singleton
{
Singleton()
{
}

public static Singleton Instance
{
  get
  {
      return Nested.instance;
  }
}

class Nested
{
  // Explicit static constructor to tell C# compiler
  // not to mark type as beforefieldinit
  static Nested()
  {
  }

  internal static readonly Singleton instance = new Singleton();
}
}

How to design a class which has absolute readonly List property

2008-05-06T00:36:00.000-07:00

有时候, 我们设计的类,包含一个Collection对象, 要求该类的使用者可以访问这个Collection属性, 而不能修改Collection的Item, 比如一个容器类.
如果这个属性是List<T>类型的话, 即使该Collection属性只有getter方法, 也无法阻止容器类的使用者修改的Collection的元素.

.Net的System.Collections.ObjectModel命名空间中包含一个ReadOnlyCollection<T>,
可以帮你做到对Collection的绝对只读封装. 其实ReadOnlyCollection类实现了IList<T>接口, 但它没有将Items属性设置public, 而是将它设为protected,
这样就ReadOnlyCollection对象就不能得到Items属性, 但可以通过属性索引来查的单个元素的值.ReadOnlyCollection的这种实现方法值得好好学习.


     /// <summary>
    /// CtrlContainer的使用者
    /// </summary>
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
    
        private void button1_Click(object sender, EventArgs e)
        {
            CtrlContainer cc = new CtrlContainer("file1.dfm");
            //可以通过cc.ListControl属性增加一个元素
            cc.ListControl.Add("ImageBox");

            //不能可以通过cc.ReadOnlyListControl属性增加或修改一个元素, 只能读取某个元素
            string firstControlName = cc.ReadOnlyListControl[0];
            MessageBox.Show(firstControlName);
        }
    }


    /// <summary>
    /// 一个展现ReadOnlyCollection的Demo Class, 
    /// 这个类是一个Control的容器类, 它通过分析一个dfm文件, 获取该文件包含的所有Control,
    /// 不允许CtrlContainer类的使用者修改Control的列表
    /// </summary>
    public class CtrlContainer
    {
        private List<string> m_ListControl = new List<string>();

 
        /// <summary>
        /// 这个只读属性其实并不能很好地防止CtrlContainer类的使用者修改m_ListControl的元素, 
        /// 因为他仍然可以使用ListControl.Add()等方法.
        /// </summary>
        public List<string> ListControl
        {
            get { return m_ListControl; } 
        }

        //using System.Collections.ObjectModel;
        ReadOnlyCollection<string> m_ReadOnlyListControl;


        /// <summary>
        /// 这个属性可以确保CtrlContainer类的使用者不能修改m_ListControl的元素, 只能读取m_ListControl的元素
        /// </summary>
        public ReadOnlyCollection<string> ReadOnlyListControl
        {
            get { return m_ReadOnlyListControl; } 
        }


        public CtrlContainer(string dfmFileName)
        {
            //parse the dfm file, and extract all controls 
            m_ListControl.Add("Button");

            // 因为m_ListControl是以引用的方式传给ReadOnlyCollection, 
            // 所以, 无论是在创建m_ReadOnlyListControl之前或之后, 对m_ListControl的元素进行操作, 都将反映到m_ReadOnlyListControl上
            m_ReadOnlyListControl = new ReadOnlyCollection<string>(m_ListControl);

            m_ListControl.Add("Richbox");
            m_ListControl.Add("ComboBox");
        }
    }

A simple method to parse characteristic text to enum

2008-05-05T23:57:00.001-07:00

设想下面的场景, 我们要解析一个文本文件, 在该文件中包含一些特征文本, 有richbox, 有combobox, 就像是delphi的dfm文件一样. 然后我们要针对不同的特征做不同的处理.

这时, 我们往往定义一个枚举类型, 然后读取文本, 根据特征文本, 转成一个枚举值.

我以前的做法是定义一个SortedList<string,ControlType>, 其中包含richbox和对应的枚举值. 在解析特征文本的时候, 通过这个SortedList, 就可以得到枚举值.

其实, 这个过程也可以使用Enum这个类的Parse()来完成, 前提是你定义的枚举值的名称和特征文本一摸一样(大小写可以不同). 下面是一个示例:


    public  class EnumMapping 
    {

        /// <summary>
        /// 根据枚举的名称,返回对应的枚举值
        /// </summary>
        /// <param name="enumName"></param>
        /// <returns></returns>
        public ControlType ConvertFromName(string enumName)
        {
            return (ControlType)Enum.Parse(typeof(ControlType), enumName, true);
        }
    }


    public enum ControlType
    {
        richbox,
        combobox,
        image
    }

How to handle xml namespace and xpath by using Linq Xml

2008-05-05T22:44:00.000-07:00

.Net3.5对XML的支持更进一步, 你可以彻底地抛弃Dom处理方式了. 因为XDocument和XElement以及XNode比之前的XmlDocument和XmlNode处理速度更快.

下面是一个相对较为复杂的例子, 其中展现了怎样处理Xml的Namespace以及如何使用XPath来定位一个Xml元素.


        /// <summary>
        /// 查找所有节点名为p:cNvPr的Xml元素
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_SelectElementByXPath_Click(object sender, EventArgs e)
        {
            XDocument xDoc=XDocument.Load(@"c:\\slide1.xml");
            

            //using System.Xml.XPath 
            //  XElement或XDocument之所以有能力处理XPath, 是靠System.Xml.XPath.Extensions这个扩展static类提供的功能
            //  public static IEnumerable<XElement> XPathSelectElements(this XNode node, string expression, IXmlNamespaceResolver resolver)
            //   XPathSelectElements()函数还需要一个参数作为XML Namespace的解析器, 而XmlNamespaceManager类就是一个这样的解析器, 
            //  所以还需要引入System.Xml命名空间, 来创建一个XmlNamespaceManager对象
            
            NameTable nt = new NameTable();
            XmlNamespaceManager nameMgr = new XmlNamespaceManager(nt);
            nameMgr.AddNamespace("p", "http://schemas.openxmlformats.org/presentationml/2006/main");

            //***注意参数应该是p:cNvPr, 而不是cNvPr
            var elements = from element in xDoc.XPathSelectElements("//p:cNvPr",nameMgr)
                           select element ;
            foreach (var element in elements)
            {
                System.Console.Out.Write(element);
                System.Console.Out.WriteLine("==============");
            }  
              
        }


        /// <summary>
        /// 查找所有节点名为p:cNvPr的Xml元素
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_SelectElementByDescendant_Click(object sender, EventArgs e)
        {
            XDocument xDoc = XDocument.Load(@"c:\\slide1.xml");
            XNamespace xns = XNamespace.Get("http://schemas.openxmlformats.org/presentationml/2006/main");

            //public IEnumerable<XElement> Descendants(XName name)

            //***注意参数应该是cNvPr, 而不是p:cNvPr
            var elements1 = from element in  xDoc.Descendants(xns.GetName("cNvPr")) 
                           select element ;

            //因为XNamespace类重载了加法运算符号, 
            //  所以对一个XNamespace对象和一个localName字符串相加, 返回的是一个XName对象,
            //  正是 XElement或XDocument的Descendants()函数所需要的参数类型
            
            //下面代码返回的elements1, 和elements1是完全一样的
            var elements2 = from element in  xDoc.Descendants(xns + "cNvPr")
                           select element ;
 
            foreach(var element in elements2)
            {
                System.Console.Out.Write(element) ;
                System.Console.Out.WriteLine("==============");
            }
        }

ADO.NET call oracle stored procedure

2008-04-24T01:40:00.001-07:00

http://www.c-sharpcorner.com/UploadFile/john_charles/CallingOraclestoredproceduresfromMicrosoftdotNET06222007142805PM/CallingOraclestoredproceduresfromMicrosoftdotNET.aspx

Understand Thread and Lock

2008-04-03T00:06:00.000-07:00

Keywords: C#

Very good articles about thread and synchronizition:
http://www.albahari.com/threading/
Chinese version: http://knowledge.swanky.wu.googlepages.com/threading_in_c_sharp.html

Best Practice--.Net Performance Test

2008-04-02T22:28:00.000-07:00

Production Debugging for .NET Framework Applications
http://msdn2.microsoft.com/en-us/library/ms954594.aspx

Performance and scalability checklist
http://msdn2.microsoft.com/en-us/library/ms998592.aspx

Performance Test guide
http://www.codeplex.com/PerfTesting

Performance Optimization and Test Best Practice Tools
http://www.codeplex.com/GuidanceExplorer

My offen misunderstand things of CSharp

2008-03-31T19:41:00.000-07:00

对于C#语言总有一些容易混淆的东西, 比如App Domain, lock语句块, 线程安全, deadlock和Content, 以及类的析构子和Finializer.
我总结了一个文章, http://docs.google.com/Doc?id=ddhzfwz6_1gkm272fd

Wonderful software-Task Coach

2008-03-18T19:16:00.001-07:00

Keywords: Task Management, Track Task, Schedule management

Today, I visit the famious website--http://portableapps.com/apps,

And I found one good software, Task Coach. It is more powerful than outlook, sunlight.

From now on, I make one day schedule by using TaskCoach in the morning. I track my task by it.

Before I leave office I export the calendar from TaskCoach, and import it into Mozilla ThunderBird/SunLight to publish my task into google.

OOXML resource

2008-03-11T19:26:00.001-07:00

Keywords: OOXML, Office 2007

Tutorial book: http://openxmldeveloper.org/articles/1970.aspx.

Tutorial presentation: h ttp://openxmldeveloper.org/articles/DeveloperWorkshopContent.aspx

Reference book: http://www.ecma-international.org/news/TC45_current_work/Office Open XML Part 3 - Primer_final.docx

Study Use Case

2008-03-10T21:09:00.001-07:00

Keywords: UML, Use case, 用例, Use Case Diagram, 用例图

这篇文章基本上是http://focuswindows.blogspot.com/2008/02/2-uml-tutorial.html的中文翻译, 该英文文档相当棒. 这节只关注Use Case.

1. 用例图的几个概念

Use Case Diagram是站在用户的视点去理解系统到底是什么样子的. 它关注于系统是什么, 而不关注怎样构建系统. Use Case Diagram由Actor、Use Case和Communication association(或者简称为Communication)组成. 怎样画Use Case diagram, 需要先明白Use Case和Actor概念.

Use Case是面向对象的概念, 所以我们要用面向对象的概念来理解Use Case,到底什么是UseCase呢? 我们开发的系统其实是真实世界中的一个对象, 那么这个对象对外提供的服务,可以说就是Use Case.

大家在讲Use Case的粒度问题的时候, 常犯的错误就是将该系统的服务的步骤, 当成Use Case. 步骤不是Use Case diagram关注的东西, (UML用Sequence diagram和Activity diagram来体现步骤)

Actor是目标系统的用户, 这个用户可以是人, 也可以是其他系统. 通常将用户按照角色分类, 就能确定用例图的Actor了.

2. 怎样画Use Case diagram

2.1 画Actor: Actor用一个小人表示.

2.2 画Use Case: Use Case是一个椭圆, 里面包含Use Case名.

2.3 画Communication: 用一个直线连接Actor和一个Use Case.

2.4 画System boundary: 用矩形表示, doundary圈住所有的Use Case.

2.5 理解Use case 之间的关系

2.5.1 Generalization关系, 这个关系和类的继承关系一样. 可以说derived use case就是Base use case的具体化(或者说是Base use case的一个实例). 比如刷卡付款和付款这两个用例, 就有generalization关系. 画法是:一条实线带一个实线箭头, 箭头指向Base Use Case.

2.5.2 Include关系, 包含关系很好理解, 如果多个Use case有相同的部分, 可以将相同的部分抽取出来, 这样新Use Case和原有的Use Case就有了Include关系.UML 画法是: 一条虚线带箭头, 箭头指向derived Use Case, 并且在虚线上打<<Include>>标记.

2.5.3 Extend关系, 表示一个Use Case是另一个Use Case的变种, 要注意它和Generalization的区别, Generalization关系就像基类和派生类间的关系; Extend关系就象是同一个基类的两个派生类之间的关系. UML画法是:一条虚线带箭头, 箭头指向参考的Use Case, 并且在虚线上打<<Extend>>标记.

3. 用例图的用处:

3.1. 协助我们来确定系统的feature或需求

3.2. 作为和Client沟通的材料, 因为用例图是站在用户的角度来理解系统, 所以特别适合和Client沟通.

3.3. 生成Test Case. 用例图会反映出系统会有哪些Scenario, 所以可以用来设计Test Case.

ScrewTurn Wiki Project(C#, Architecture Design)

2008-03-10T21:00:00.001-07:00

Keywords: Wiki, ScrewTurn Wiki

There is a wonderful our source project, ScrewTurn Wiki(http://www.screwturn.eu/MainPage.ashx). Download the source and research it. You will gain a lot from it.

1. Multiple Database supported: By using plugin architecuture.

2. MVC Pattern: Wonderful layer division

3. Asp.net: Good code

4. How to build one web application and how make it deploy easily

all about .net framework 3.0(copied article)

2008-03-10T20:18:00.001-07:00

All about .NET Framework 3.0 http://aspalliance.com/1351_All_about_NET_Framework_30.all

Published: 10 Jul 2007

Abstract

The .NET Framework 3.0 is the next generation of the .NET Framework that sits on the top of the previous version. It introduces some additional features, and in this article Hima discusses these features in detail.

Article Contents:

Introduction

What Happens when we install Framework 3.0

Features

Windows Presentation Foundation (WPF)

Windows Workflow Foundation (WF)

Windows Communication Foundation (WCF)

Microsoft Windows Card Space (WCS)

Related Downloads

References

Conclusion

Avoid using FileMode.OpenOrCreate to open stream

2008-03-06T21:33:00.001-08:00

Keywords: C#, Stream, FileMode.OpenOrCreate

C#提供多种方式来创建一个具有不同读写权限的流, 这主要是通过设置不同的FileMode和FileAccess值来实现的. 我们如果要取得一个具有读写权限的流, 最好是用FileMode.Create和FileAcess.ReadWrite来获取. 源码后说明原因.


        private void Test()
        {
            //get the main part of docx. The main part is just document.xml in docx package
            PackagePart wordMainPackagePart=GetMainPart();

            //load document.xml into wholeDocument object
            XmlDocument wholeDocument = new XmlDocument();
            using (Stream stream = wordMainPackagePart.GetStream())
            {
                wholeDocument.Load(stream);
            }


            //change the wholeDocument 
            //...

            //save wholeDocument into document.xml. It is better avoid using FileMode.OpenOrCreate,  we had better use FileMode.Create
            using (Stream stream = wordMainPackagePart.GetStream(FileMode.Create, FileAccess.ReadWrite))
            {
                wholeDocument.Save(stream);
            }
        }


FileMode有几个枚举值:


  FileMode.Append的意义是, 如果文件存在, 流定位到文件尾部, 新写的东西将追加到原文件尾; 如果文件不存在, 则新增文件. 这个FileMode只能和FileAccess.Write一起使用, 不能和其他的FileAccess同时使用.


  FileMode.Create的意义是:如果文件存在, 首先删除文件的内容, 然后重写文件; 如果文件不存在, 则新增文件


  FileMode.CreateNew的意义是: 如果文件存在, 则抛出一个异常; 如果文件不存在, 则新增文件


  FileMode.Open的意义是,如果文件存在,再根据FileAccess的取值, 来确定可不可写; 如果文件不存在, 则抛出一个异常


  FileMode.OpenOrCreate的意义是, 如果文件存在, 则重写这个文件, 重写的机制是不删除原有文件的内容, 那么从原文件头开始重写, 比如原有文件共10个字节, 新的内容只有5个字节的话, 则重写后的文件后5个字节仍是原有文件的内容.

  FileMode.Truncate的意义是, 如果文件存在的话, 首先删除 文件的内容, 然后重写文件.


为什么我们推荐使用FileMode.Create呢, 因为FileMode.Create其实同时具有FileMode.CreateNew和FileMode.Truncate的效果, 即当文件存在的时候,它使用FileMode.Truncate方式重写文件, 当文件不存在的时候, 它使用FileMode.CreateNew来新增文件.

misunderstand when using XmlNode.SelectSingleNode function

2008-03-06T19:43:00.000-08:00

Keywords: System.Xml, XmlNode, XPath

在使用System.Xml命名空间的XmlNode类, 有一个方法 XmlNode.SelectSingleNode(string xpath).

刚开始使用它时, 对它的作用理解有误. 如果XPath以"/"开始, 其意义为从根节点开始搜索Node. 原本想使用XmlNode456对象的SelectSingleNode(XPath123)方法, XPath123这个表达式所指的根节点应是XmlNode456, 但事实是, 这个函数仍以XmlNode456所在文档的根节点root作为搜索的起点.

要搜索Node456下的Child节点, 有2个方法, 最好使用方法2, 因为它更加简单.

方法1: 如果想通过SelectSingleNode()来搜索的话, 构建一个从根节点root指向Child的绝对路径的XPath, (XPath表达式应该以"./"开头)

方法2: 将Node456.OutXml赋值给一个tempXmlDocument., 然后再使用tempXmlDocument.SelectSingleNode(AbsoluteXPath), 可以定位到子节点. 这时候, 你可以用tempXmlDocument来直接提取Node456节点的内容, 如果还要修改Node456, 应该在修改tempXmlDocument之后, 再将修改后的内容保存到原有的Node456节点上.


            XmlDocument tempXmlDocument = new XmlDocument();
            //Load the xml from Node456
            tempXmlDocument.LoadXml(Node456.OutXml);

            //extract Info from tempXmlDocument
            //...


            //change the tempXmlDocument info 
            //...

            //save the result after changed into the Node456
            Node456.InnerXml = tempXmlDocument.DocumentElement.InnerXml;

2 UML tutorial

2008-02-28T23:20:00.001-08:00

Keywords: UML 2.1

网上关于UML的文章很多, 但下面2篇文章很实用.

http://dn.codegear.com/article/31863(这个文章还带测试题目)

http://www.sparxsystems.com.au/resources/uml2_tutorial/index.html

点空间http://www.dotspace.idv.tw/ 也有比较好的文章.

how to Use Subversion with TortoiseSVN

2008-02-27T19:32:00.001-08:00

Keywords: SVN, TortoiseSVN

how to Use Subversion with TortoiseSVN, visit http://www.codeproject.com/KB/books/Subversion_TortoiseSVN.aspx

SVN-How to set ignore-list

2008-02-27T19:17:00.001-08:00

Keywords: Subversion, svn, tortoiseSVN

Subversion is a powerful source code control system. We can upload the source code into svn database. In many cases, we do not want to version some types files, such as bin folder and .user file. There are 2 ways to set ignore list.

For example, In .net development, some files need always ignore to verion such as bin obj *.suo *.obj *.pdb *.exe *.dll *.csproj.user

1. For one specific directory, we can use the tortoiseSVN to achieve it.

Steps:

Select one folder in explorer and then select the property menuitem. In Property/Subversion window, click the properties button,

And then click add button, select svn:ignore in the property combobox in subsequence window, Input the file extension in the textbox

2. Set global Ignore list.

Steps:

Find the config file for subversion, which is located in "\Documents and Settings\<user>\Application Data\Subversion" and the file name is Config with no extension.

To get it to ignore these directories or files, you need to uncomment or edit the global-ignores line. In mine, I have it set to:

global-ignores = bin obj *.suo *.obj *.pdb *.exe *.dll *.csproj.user

This will causes it to ignore the bin and obj sub-directories of a typical Visual Studio projects.

ruby dev tools

2008-02-25T00:02:00.001-08:00

keywords: Ruby, JDT

One-Click Installer- Ruby interpretor and extenstion(Windows OS)

http://rubyforge.org/frs/?group_id=167

ActiveScriptRuby- Ruby interpretor and extenstion package(Windows OS)

http://arton.hp.infoseek.co.jp/indexj.html

RDE- Ruby Dev Eniviroment

http://homepage2.nifty.com/sakazuki/rde_en/index.html

RDT homepage

http://rubyeclipse.sourceforge.net/

Using the Ruby Development Tools plug-in for Eclipse

http://www.ibm.com/developerworks/opensource/library/os-rubyeclipse

obfuscator .net Assembly

2008-02-24T19:48:00.001-08:00

Keywords: Protection .net assembly

1. Aspose.Obfuscator is free, but use it at you own risk. http://www.aspose.com/Products/Aspose.Obfuscator/

2. CodeVeil is commercial software

http://www.xheo.com/products/codeveil/default.aspx

3. .NET Obfuscator community edition is free. But standard edition is not free.

http://www.preemptive.com/products/dotfuscator/index.html

open source net and security class library of c#

2008-02-20T01:03:00.001-08:00

Keywords: C#, Opensource, Net library, Security Library, Certificate library

great opensource site http://www.mentalis.org/

interconvert byte[] and string and stream

2008-02-20T00:55:00.001-08:00

keywords: C#, byte array, string, stream

stream和string和byte[]都是内存中的对象, 一般而言, string和byte[]都是轻量级的数据包装体, 在作layer间数据交换应优先使用它们, 因为它们占用更少的内存. 但它们本身的成员方法比较少, 尤其在持久化方面, 有可能需要借助Stream来完成, 那么怎样将string和byte[]转化成stream呢? 本文给出了一些代码. 有关不同类型stream相互转换, 可以参考另一篇文章(http://focuswindows.blogspot.com/2008/02/convert-filestream-fromto-memorystream.html).


        /// <summary>
        ///如果你并不需要解析转换后的String, 那么可以将byte数组转换成Base64String. 
        /// 使用这个方法你不需要关心buffer数组中每个byte的编码, 统统都可以将它们转换成Base64String.
        /// because Base64 store one char in 64 digits. 
        /// But the Base64 char is hard to recognized compared with the ASCII encode.
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public string ConvertBytesToBase64String(byte[] buffer)
        {
            return Convert.ToBase64String(buffer);
        }


        /// <summary>
        /// 将一个Base64String转换成Byte[]
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public byte[] ConvertBase64StringToBytes(string str)
        {
            return Convert.FromBase64String(str);
        }

 

        /// <summary>
        /// 将Stream转换为String
        /// </summary>
        /// <param name="ms"></param>
        /// <returns></returns>
        public string ConvertStreamIntoString(Stream ms)
        {
            //使用StreamReader应该是读取Stream最简单的方法
            System.IO.StreamReader reader = new StreamReader(ms);
            ms.Position = 0;
            return reader.ReadToEnd();
        }
        
        
        /// <summary>
        /// 将string转换成stream
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public MemoryStream ConvertStringToMemoryStream(string str)
        {
            MemoryStream ms=new MemoryStream() ;
            //使用一个StreamWriter来将str写到一个MemoryStream
            using (StreamWriter writer = new StreamWriter(ms))
            {
                writer.Write(str);
                writer.Flush();
            }
            return ms;
        }

Msn dev resources

2008-02-19T01:46:00.001-08:00

Keywords: MSN

百步穿杨 http://www.blogjava.net/coacoa2008/archive/2007/12/04/165182.html

巴士飞扬 http://www.busfly.cn/

Develop MSN Robot By C#

2008-02-19T01:37:00.001-08:00

this article is copied from http://www.busfly.cn/post/183.html

用.NET开发MSN聊天机器人 - MSN聊天机器人开发揭秘(收藏)

MSDN magazine reader--MSDNReader

2008-02-13T01:39:00.001-08:00

Keywords: MSDNReader, MSDN

download: http://code.msdn.microsoft.com/msdnreader

This is a downloadable tool to allow you to read MSDN magazine - which is a great magazine to get up-to-date information on .NET.

Please download and share with your friends too. This requires .NET 3.0 to be installed on your system.

Show all C# exceptions by using Exception_Hunter of Red Gate software

2008-02-13T01:20:00.001-08:00

Keywords: Exception, Exception Hunter, Red Gate

How to show all exceptions in you c# project before you release your product? It is important, because we will always leave some exceptions not handled. If you are in the situation, dont worry, you are not alone.

There is a tool can help you. The tool is Exception Hunter, It is a commerical software by Red Gate Software. I think the command line tool is more useful than the UI tool.

Command line usage:

"C:\Program Files\Red Gate\Exception Hunter 1\hunt.exe" /a:"D:\YourAssembly.Exe" /er:"Result_YourAssembly.html" /allpublicmethods

the powerful DebugView

2008-02-03T21:47:00.001-08:00

Keywords: capture debug output, Win32, .Net

DebugView is made by the famous Sysinternals company owned by Microsoft. 我们在程序中通常会有意用debug类(c#)输出一些调试信息, 或者我们要捕捉一些其他人开发的程序是否有异常, 都可以使用这个工具. 只要启动一个DebugView实例, 就可以监控所有程序的debug输出.

它不仅仅可以监视Windows和Console程序的debug, 而且可以监视Web程序的debug输出(需要在Web服务器上运行debugview).

How to test performance in C#

2008-02-03T21:34:00.001-08:00

Keywords: Performace test, Win32, .Net Framework

In Win32,

Low resolution: GetTickCount() Api

High resolution: QueryPerformanceCounter() and QueryPerformanceFrequency()

In .Net

Low resolution: Enviroment.TickCount, the best resolution it will give you is 10 milliseconds.

High resolution: System.Diagnostics.Stopwatch class.

Stopwatch class usage:


        private void btnPerformaceTest_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch sw = new Stopwatch();
            sw.Start();
            //Process1();
            sw.Stop();
            System.Console.WriteLine(sw.ElapsedMilliseconds);
            
            sw.Reset();
            sw.Start();
            //Process2();
            sw.Stop();
            System.Console.WriteLine(sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            //Process3();
            sw.Stop();
            System.Console.WriteLine(sw.ElapsedMilliseconds); 
        }

how to read binary file and save it into xml

2008-02-03T01:55:00.001-08:00

Keywords: CDATA node of xml, FileStream, MemoryStream, Base64String

In xml document, you can define CDATA node to store some large text string. There is a constraint in xml document, the xml document only can contain text string.

How to save image data or other binary data into xml?

We can convert the binary data into Base64String data, then we can store the Base64String data into xml document. We can use the following approach to achive.

Approach1: BinaryFile===>Byte[]===>Base64String===>CDATA

The following is pseudo code:

byte[] buffer=File.ReadAllBytes(string path);

string base64String= Convert.ToBase64String();

XmlCDATA=new XmlCDATA(base64String);

XmlDocument.AddChild(XmlCDATA);

How to restore the Base64String data into a FileStream?

It is easy to reach. The procedure is just reverse the above process.

Convert MemoryStream into FileStream

2008-02-03T01:32:00.001-08:00

Keywords: C#, FileStream, MemoryStream

Sometimes, we need to convert FileStream into MemoryStream. And in other times, you need to convert memoryStream into fileStream because filestream is able to save to disk file.

How to convert string/byte[] into stream or convert stream into string/byte[], please refer another article. (http://focuswindows.blogspot.com/2008/02/interconvert-byte-and-string-and-stream.html)

How to convert MemoryStream into FileStream?

If you can solve the problem, it is will be easy to convert FileStream into MemoryStream because they are based the same parent class. There are 3 approaches to convert.

The 1st solution is use the loop strategy. This method can be used largely. Every time you read some bytes from Source_Stream into a buffer(buffer is byte array, it's length usually is 1k or 10k), then write the buffer into Target_Stream.

The 2nd solution is use MemoryStream.WriteTo(stream anotherStream). This have the highest performance, but Only MemoryStream has this method. (Because it do not need allocate additional memory for carriage buffer. It uses the MemoryStream object buffer property.)

The 3rd solution is read the whole Source_Stream into one single byte array, and then write byte array into Target_Stream. But it is not good solution, because you have to allocate too big memory for byte array.


    public partial class Form1 : Form
    {
        public Form1()
        {
            //Add one textbox, named "textBox1"
            //Add one button, named "btnTest"
            InitializeComponent();
        }

        /// <summary>
        ///  Convert one MemoryStream object into FileStream Object.
        ///  Performance:
        ///    This method has the highest performance. 
        ///    This method can used largely. It is also suited for convert other kind Stream into FileStream.
        /// </summary>
        /// <param name="ms"></param>
        /// <param name="newFilePath"></param>
        public void ConvertMemoryStreamToFileStream_1(MemoryStream ms, String newFilePath)
        {
            using (FileStream fs = File.OpenWrite(newFilePath))
            {
                const int blockSize = 1024;
                byte[] buffer = new byte[blockSize];
                int numBytes;
                while ((numBytes = ms.Read(buffer, 0, blockSize)) > 0)
                {
                    fs.Write(buffer, 0, numBytes);
                }
            }
        }



        /// <summary>
        /// Convert one MemoryStream object into FileStream Object.
        /// The method is so simple. but only MemoryStream has method WriteTo(Stream anotherStream)
        /// Performance: 
        ///   This method performace is worse than ConvertMemoryStreamToFileStream_1()
        /// </summary>
        /// <param name="ms"></param>
        /// <param name="newFilePath"></param>
        public void ConvertMemoryStreamToFileStream_2(MemoryStream ms, String newFilePath)
        {
            using (FileStream fs = File.OpenWrite(newFilePath))
            {
                ms.WriteTo(fs);
            }
        }



        /// <summary>
        /// Convert one MemoryStream object into FileStream Object.
        /// Performace:
        ///     This method is the less effectively. 
        ///     Because it have to allocate a great deal of memory to accommodate the whole MemoryStream all at once.
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public void ConvertMemoryStreamToFileStream_3(MemoryStream ms, String newFilePath)
        {
            // Allocate a large memory at first.
            byte[] buffer = new byte[ms.Length];
            ms.Read(buffer, 0, (int)ms.Length);

            using (FileStream fs = File.OpenWrite(newFilePath))
            {
                fs.Write(buffer, 0, (int)ms.Length);
            }
        }


        /// <summary>
        /// Create one MemoryStream object. 
        /// The result is not expanable MemoryStream. 
        /// Performance: 
        ///     Create one MemoryStream object is fastest. 
        ///     But read bytes from unexpansble memoryStream will consume more time. I do not know the reason.
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public MemoryStream CreateMemoryStream_1(string filePath)
        {
            //Step1: read whole FileStream into byte array.
            byte[] buffer = System.IO.File.ReadAllBytes(filePath);


            //Step2:convert byte array into MemoryStream.  
            MemoryStream ms1 = new MemoryStream(buffer);
            return ms1;
        }



        /// <summary>
        /// Create one MemoryStream object. 
        /// The result is not expanable MemoryStream. 
        /// Performace:
        ///    Create one MemoryStream object is slower
        ///    But read bytes from expansble memoryStream will consume less time. I do not know the reason.
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public MemoryStream CreateMemoryStream_2(string filePath)
        {
            int blockSize = 1024;
            int bytesNum;
            byte[] buffer = new byte[blockSize];
            MemoryStream ms = new MemoryStream();
            using (FileStream fs = new FileStream(filePath, FileMode.Open))
            {
                while ((bytesNum = fs.Read(buffer, 0, blockSize)) > 0)
                {
                    ms.Write(buffer, 0, bytesNum);
                }
            }
            return ms;
        }


        private void btnTest_Click(object sender, EventArgs e)
        {
            const string SourceFile = @"c:\Launch.wmv";
            const string NewFile1 = @"c:\1.wmv";
            const string NewFile2 = @"c:\2.wmv";
            const string NewFile3 = @"c:\3.wmv";
            if (File.Exists(NewFile1))
                File.Delete(NewFile1);
            if (File.Exists(NewFile2))
                File.Delete(NewFile2);
            if (File.Exists(NewFile3))
                File.Delete(NewFile3);

            textBox1.Clear() ;
            Application.DoEvents();
            MemoryStream ms = null;
            try
            {

                System.Diagnostics.Stopwatch sw = new Stopwatch();
                sw.Start();
                ms = CreateMemoryStream_2(SourceFile);
                if (ms != null)
                {
                    sw.Stop();               
                    textBox1.AppendText(sw.ElapsedMilliseconds.ToString() + "--CreateMemoryStream_2"); 
                    textBox1.AppendText(Environment.NewLine);

                    sw.Reset();
                    sw.Start();
                    ConvertMemoryStreamToFileStream_1(ms, NewFile1);
                    
                    sw.Stop();
                    textBox1.AppendText( sw.ElapsedMilliseconds.ToString() + "--ConvertMemoryStreamToFileStream_1");
                    textBox1.AppendText(Environment.NewLine);

                    sw.Reset();
                    sw.Start();
                    ConvertMemoryStreamToFileStream_2(ms, NewFile2);
                    sw.Stop();
                    textBox1.AppendText( sw.ElapsedMilliseconds.ToString() + "--ConvertMemoryStreamToFileStream_2");
                    textBox1.AppendText(Environment.NewLine);

                    sw.Reset();
                    sw.Start();
                    ConvertMemoryStreamToFileStream_3(ms, NewFile3);
                    sw.Stop();
                    textBox1.AppendText( sw.ElapsedMilliseconds.ToString() + "--ConvertMemoryStreamToFileStream_3");
                    textBox1.AppendText(Environment.NewLine);
                }
            }
            finally
            {
                if (ms != null)
                    ms.Close();
            }
        }
    }

The performance test results:

In test case c:\Launch.wmv is an video file, its size is about 66M. if we use CreateMemoryStream_Method1() to create one unexpandable MemoryStream, the output result is:

212--CreateMemoryStream_1

968--ConvertMemoryStreamToFileStream_1

2016--ConvertMemoryStreamToFileStream_2

1929--ConvertMemoryStreamToFileStream_3

if we use CreateMemoryStream_Method2() to create an expandable MemoryStream, the output result is:

1011--CreateMemoryStream_2

1--ConvertMemoryStreamToFileStream_1

1619--ConvertMemoryStreamToFileStream_2

1225--ConvertMemoryStreamToFileStream_3

Using List.Sort() and Find() by delegate

2008-02-01T17:44:00.001-08:00

Keywords: C# Generic, List<T> class, Find, Sort, Comparison, Predicate

In List<T> class, Sort() method will perform to sort the list item. For List<string>, you can call Sort() method without argument. It will perform well. But if you sort List<Person> by using the same way, One error happened.

Why? Because the .Net Runtiime know how to compare toow string object, but it do not know how to compare two Person objects. In this situation, you will need define your comparison method. There is the same problem when using List.Find() method.

How to use List<T>.Sort()?

Refer to the List<T>.Sort source code. There are 4 override method, one of them is as follows,

public void Sort( Comparison <T> comparison);

And then refer to Comparison<T>, In System namespace

public delegate int Comparison <T>(T x, T y);

Ok, it is time to write code. You can define a static comparison method in PersonHelper class(one helper class for Person), it must follow the Comparison <T> delegate signature.

How to use List<T>.Find() ?

Look at the arguement of the Find(). This is also a delegate.

public T Find( Predicate <T> match);

and then refer to Predicate<T>, In System namespace

public delegate bool Predicate <T>(T obj);

We need pass one delegate object to Find() method, e.g CompareByNamePredicate. But the ComparePredicate() have only one argument, which is the enumerator of Generic List dictionary. How we specify the find condition, e.g, "TOM" for one Person name. We can encapsulate the CompareByNamePredicate method in one helper class. and we let one private variable of the helper class object to hold "TOM". Then we have Predicate method and Find condition. The subsequence is simple.

If you want use Helper class to achieve it, you can use anonymous delegate method. please refer to http://blogs.msdn.com/devdev/archive/2006/06/30/652802.aspx

The following code demo how to use helper class and anonymous delegate to approach the Find() and Sort() function.


    /// <summary>
    /// Main class, in this class we call the List.Find() and List.Sort().
    /// </summary>
    public partial class Form1 : Form
    {
        List<Person> m_ListPerson = new List<Person>();

        public Form1()
        {
            InitializeComponent();
            m_ListPerson.Add(new Person("c1"));
            m_ListPerson.Add(new Person("a1"));
            m_ListPerson.Add(new Person("TOM"));
        }


        /// <summary>
        /// Use named delegate method to approach the sort function
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonSort_Click(object sender, EventArgs e)
        {
            m_ListPerson.Sort(PersonHelper.CompareByName);
            listBox1.Items.Clear();
            foreach (Person p in m_ListPerson)
            {
                listBox1.Items.Add(p.FirstName);
            }
        }


        /// <summary>
        /// use anonymous delegate to approach the sort function 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonSortByDelegate_Click(object sender, EventArgs e)
        {
            //public delegate int Comparison<T>(T x, T y);
            m_ListPerson.Sort(delegate(Person p1, Person p2) { return string.Compare(p1.FirstName, p2.FirstName); });
            listBox1.Items.Clear();
            foreach (Person p in m_ListPerson)
            {
                listBox1.Items.Add(p.FirstName);
            }
        }


        /// <summary>
        /// Use Helper class and named method to approach the find function
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonFind_Click(object sender, EventArgs e)
        {
            PersonHelper personHelper = new PersonHelper();
            personHelper.FirstName = "TOM";
            Person person = m_ListPerson.Find(personHelper.CompareByNamePredicate);
            listBox1.Items.Clear();
            if (person != null)
            {
                listBox1.Items.Add(person.FirstName);
            }
        }

        /// <summary>
        /// use anonymous delegate to approach the find function 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonFindByDelegate_Click(object sender, EventArgs e)
        {
            ///public delegate bool Predicate<T>(T obj);
            Person person = m_ListPerson.Find(delegate(Person p) { return string.Equals(p.FirstName, "TOM"); });
            listBox1.Items.Clear();
            if (person != null)
            {
                listBox1.Items.Add(person.FirstName);
            }
        }
    }


    /// <summary>
    /// This is a simple Class
    /// </summary>
    public class Person
    {
        private string m_FirstName;

        public string FirstName
        {
            get { return m_FirstName; }
            set { m_FirstName = value; }
        }

        public Person(string firstName)
        {
            this.m_FirstName = firstName;
        }

    }


    /// <summary>
    /// This is helper class, which provides sort and find capablity for Generic Collection Class
    /// </summary>
    public class PersonHelper
    {

        /// <summary>
        /// implement the compare method, and it has the same signature with delegate Comparison
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <returns></returns>
        //public delegate int Comparison<T>(T x, T y);
        public static int CompareByName(Person p1, Person p2)
        {
            return string.Compare(p1.FirstName, p2.FirstName);
        }

        string m_FirstName;

        public string FirstName
        {
            get { return m_FirstName; }
            set { m_FirstName = value; }
        }


        /// <summary>
        /// /// implement the predicate method in order to find one person, and it has the same signature with delegate Predicate
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        ///public delegate bool Predicate<T>(T obj);
        public bool CompareByNamePredicate(Person p)
        {
            return string.Equals(p.FirstName, m_FirstName);
        }
    }

VBScript debug and execute

2008-01-31T23:41:00.001-08:00

Keywords: VBscript, debugger, execute

同事要我帮助他修改他的一个VBScript脚本, 当我收到邮件后, 我在想, 1.我该怎样运行这个脚本; 2. 我该使用什么编辑器?; 3.有没有比较好的script调试器?

首先google, 微软最新的脚本执行器为Microsoft script 5.7 版本. 需要download并install. 执行脚本的方法是: cscript yourscript.vbs [options], 详见cscript /?

用什么编辑器编辑VB script呢? 最好能有intellisense功能, Visual studio 6有一个这样的编辑器. 但可以使用Office软件的VBA editor.

Zip Rar Outlook Excel Word password remove tool

2008-01-31T17:50:00.001-08:00

Keywords: password remove

trial version: http://www.apasscracker.com/download/

It has can only recovery a few pdf pages if trial version was used.

and this company has also other password crack tools, for zip, rar, GoogleTalk, MSN, Outlook, Excel, Word, PST file.

PDF restriction remove tool

2008-01-31T17:47:00.000-08:00

Keywords: decrypt pdf, allow print permission, change permission restrication

Some ebooks are in pdf format, but they probably have some permission restrication, such as disable print or save.

There are some tools that can remove the restrications.

1. PDF password remover 3.0

http://www.verypdf.com/

its registration key maker: http://crackdb.org/get_112804_PDF.Password.Remover.v3.0_crack.html

2. Atomic PDF Password Recovery

trial version: http://www.apasscracker.com/download/

It has can only recovery a few pdf pages if trial version was used.

and this company has also other password crack tools, for zip, rar, GoogleTalk, MSN, Outlook, Excel, Word, PST file.

short introduction of c# syntax

2008-01-30T21:44:00.001-08:00

Keywords: C#, Syntax

i sometimes forget some c# basic. There are some links which can help me keep in mind.

Sharp New Language: C# Offers the Power of C++ and Simplicity of Visual Basic

http://msdn.microsoft.com/msdnmag/issues/0900/csharp/default.aspx

C++ -> C#: What You Need to Know to Move from C++ to C#

http://msdn.microsoft.com/msdnmag/issues/01/07/ctocsharp/

Nice Things About C#

http://www.cs.princeton.edu/~cdecoro/csharp.html

Download Web Content other than using WebClient class

2008-01-29T22:17:00.001-08:00

Keywords: WebClient, UTF-8, WebRequest

从一个URI上下载网页Content或Xml, 可以直接使用WebClient类(在System.Net命名空间), 非常简单. 它有很多Download方法, 比如DownloadString()和DownloadFile(). 这些都是同步方法, 当然它也有异步Download方法, 不过经常用的是它的同步方法.

但在用WebClient.DownloadString()一个以UTF-8编码格式存盘的一个Xml文件时, 得到的Xml字符串有乱码, 不管怎样设置WebClient的Encode属性都没有用处, 可能是WebClient的一个bug吧.

可以WebRequest方法来实现同步DownloadString的功能. 代码如下:


        public void DownloadAndLoadXml(string uri, XmlDocument doc)
        {
            System.Net.WebRequest request = System.Net.WebRequest.Create(uri);
            using (System.Net.WebResponse response=request.GetResponse())
            using (System.IO.Stream stream=response.GetResponseStream())
            {
                if (stream.Length > 0)
                {
                    stream.Position = 0;
                    doc.Load(stream);
                }
            }
        }


        /// <summary>
        /// download the web page from the given uri
        /// </summary>
        /// <param name="uri"></param>
        /// <returns></returns>
        public string DownloadStringFromWeb(string uri)
        {
            System.Net.WebRequest request = System.Net.WebRequest.Create(uri);
            using (System.Net.WebResponse response = request.GetResponse())
            using (System.IO.Stream stream = response.GetResponseStream())
            {
                System.IO.StreamReader reader = new StreamReader(stream);
                //save all info from stream into a string variable 
                string result=reader.ReadToEnd();
                reader.Close();
                return result;
            }
        }

XmlBeautifier tool development

2008-01-29T02:30:00.000-08:00

Keywords: Event, Class Inherit, Drag and drop supported

Preface

一直想写一个具有实际功能的C#例程, 来加深我对C# Event和Delegate的理解. 这个例程最好不要太庞大, 因为庞大的程序需要考虑的东西太多, 容易跑题. 碰巧在项目中, 经常需要查看Word2007的docx文件包中Xml文件(注: docx格式为zip格式, 里面包含很多xml文件, 但这些xml文件的element没有缩进). 我喜欢用Notepad++这个编辑器, 但用Notepad++不支持没有缩进的xml的collapse element功能, 浏览起来并不直观. 所以打算写一个小工具, 能够缩进xml的element. 这个工具我命名为XmlBeautifier.

Dev Environment:

Visual Studio 2005, .Net Framework 2.0, .Net Framework 3.0

System Design

XmlBeautifier设计初衷是能处理docx中的xml文件, 为了使它更具通用性, 它应该还能处理单个的xml文件, 最好还能批量处理一个目录下的所有xml文件. 我设计一个抽象基类SourcePackage, 它有3个子类, 分别是DirectoryPackage(负责批量处理某个目录下所有文件的美化), DocxPackage(负责处理docx文件), 以及SingleFilePackage(负责处理单一xml文件) .

SourcePackage类是整个程序的核心. CollectFileStream()是一个抽象方法, 负责获取这个包中的所有文件的流, 三个子类都要实现这个方法; 因为需要将包中文件以流的形式加载到内存, 所以SourcePackage类需要实现IDisposable接口, 来释放文件流资源; BeautifyFiles()负责执行xml文件的美化工作, 当把所有的文件以流的形式加载到一个m_ListFileStream后, BeautifyFiles()方法就很简单, 循环各个文件流, 分别美化它们.

Extra Features Design

一个好的程序应该是用户友好型的, 对于我们这样的小工具, 也要做到这样. 为此, 我为这个工具增加2个必要的feature. F1. 用户能够处理的进度; F2.工具支持文件(或目录)的拖拉处理.

F1. 为了是工具能实时显示处理的进度, 需要为SourcePackage类增加两个事件Handler, 一个是OneXmlProcessedHandler(当一个文件被处理完后, 这个Handler会被Invoke); 另一个是ProcessOverHandler(当整个文件包被处理完毕后, 这个Handler会被Invoke). 这2个Handler的类型为delegate, 分别为OneXmlProcessedEventHandler, ProcessOverEventHandler. 为了能将Package的文件总数和当前处理的文件Index传给UI类, 我定义了ProcessCountEventArgs这个类, 这样UI类的EventHandler就能获取这些信息. 有关事件的详细论述, 请看我的另一篇文章 .

F2. 拖拉的支持

C#的Form和Panel都有个bool型属性AllowDrop, 只要AllowDrop=true, 你就可以在资源管理器中将文件或目录拖到Form(或Panel)上, 只不过鼠标Cursor不对头, 在Panel的DragEnter事件中设置DragEventArgs参数的Effect就可以.

当文件 ( 或目录 )Drop 到 Panel 后 , 需要美化这些文档 , 在 Panel 的 DragDrop 事件中调用相应的代码就可 . 调用之前需判断 Drop 下的东西是否是文件或目录 .

private void panelDrop_DragDrop(object sender, DragEventArgs e)

{

if (e.Data.GetDataPresent(DataFormats.FileDrop))

{

String[] filenames = (String[])e.Data.GetData(DataFormats.FileDrop);

textBoxSourcePath.Text = filenames[0];

ProcessBeautify() ;

}

主要类的 Class Diagram 见下图 .

代码下载 (xmlBeautifier_Src.zip ), 可执行文件下载 (XmlBeautifier_Bin.zip )

disable the screensaver broadcasted on the intranet

2008-01-28T22:13:00.001-08:00

Keywords: Screen Saver

公司电脑屏保非常烦人, 3分钟不用, 就启动屏保, 退出屏保要输密码. 禁止屏保的办法是修改注册表.

Registry Entry: HKEY_CURRENT_USER\Software\Policies\Microsoft\Windows\Control Panel\Desktop

understand event of c#

2008-01-27T21:47:00.001-08:00

Keywords: Event, delegate, Publish and subscribe pattern

我打算设计一个程序, 它能一次性美化一个目录之下所有的xml文件, 在UI上, 要求能显示处理的进度(即每处理完一个xml文件, UI的ProgressBar就变化一下). 美化xml的由SourcePackage类的BeautifyFiles方法完成, 而UI是另一个类FormMain. 显然这要处理SourcePackage类和FormMain类之间的通讯问题. 怎样解决这个问题呢? 这其实这是一个如何解耦的问题.

如果你学过C语言, 你会很自然想到使用回调函数, 即在FormMain类中新增一个方法, 比如UpdateProgressBar(), 然后将UpdateProgressBar()这个函数传给SourcePackage.BeautifyFiles()方法. 这确实是一个解决方法. 即将一个被调用者传给调用者. 这种方法直接有效, 但耦合度很高.

另一个方案是, 采用Publish-Subscribe模式, 使用这个模式, 首先要定义一个通知, 即发布什么, 以及订阅什么. 就本实例来讲, 这个通知就是一个xml文件已经被处理完了, 在UI类中, 订阅这个通知, 然后再编写这个通知的一个Handler函数(即进行更新进度条).

C#就是采用Publish-Subscribe来实现Event, 因为C#Delegate支持多播, 所以非常完美地实现了Publish-subscribe; 如果你使用C++, 也可采用了Observer模式来实现Event. 我们用C#的Event来实现设计要求. 设计的详细思路是:

在Publish方(Publish方多数为一个服务的服务端), 需要完成的工作是:

(1) 如果需要的话,使用delegate来定义通知类型, (一般的EventHandler已经在Framework中定义了, 特殊的Handler需要自定义)

public delegate void OneXmlProcessedEventHandler(object sender, ProcessCountEventArgs e);

(2) 在SourcePackage类中, 使用event关键字来发布通知.

public event OneXmlProcessedEventHandler OneXmlProcessed;

(3) 在SourcePackage.BeautifyFiles()触发这个通知的Handler.

foreach (Stream fileStream in m_ListFileStream)

{

m_FileBeautifier.FileStream = fileStream;

m_FileBeautifier.Beautify();

if (OneXmlProcessed != null)

{

eventArgs.ProcessedIndex = eventArgs.ProcessedIndex+1 ;

OneXmlProcessed(this, eventArgs);

}

在Subscribe方(Subscribe方多为服务的消费端), 需要完成的工作是:

(1) 订阅这个通知

SourcePackage sourcePackage = new SourcePackage(packageFullName);

sourcePackage.OneXmlProcessed += new OneXmlProcessedEventHandler(OneXmlProcessedHandler);

(2) 编写通知Handler

void OneXmlProcessedHandler(object sender, ProcessCountEventArgs e)

{

const string progressIndicator="{0} of {1} is proceeded!" ;

toolStripStatusLabel1.Text = string.Format(progressIndicator, e.ProcessedIndex, e.FileCount);

toolStripProgressBar1.Value = e.ProcessedIndex;

Application.DoEvents();

}

how to use XmlDocument.Save and XmlWriter

2008-01-25T02:12:00.001-08:00

Keywords: XmlDocument class, XmlWriter, FileStream, StringBuilder

原本想使用XmlWriter来格式化一个文件流, 结果是: Xml是被格式化了, 但格式化后的字符串是append到原来的流中, 而不是重写到文件流中. 为什么会出现这个现象呢? 我们先分析一下原来的代码:


        public void BeautifyXml(FileStream fileStream)
        {
            XmlDocument xmlDoc = new XmlDocument(); 

            //1. 重置m_fileStream的position为0, 否则xmlDoc.Load可能会出现异常
            fileStream.Position = 0;

            //2. 加载m_FileStream的内容到xmlDoc
            xmlDoc.Load(fileStream);

            //3. 创建一个XmlWriterSettings对象, 设置它的Format
            XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
            xmlWriterSettings.Indent = true;
            xmlWriterSettings.IndentChars = "  ";

            //4.创建一个输出到fileStream的XmlWriter
            XmlWriter writer = XmlWriter.Create(fileStream, xmlWriterSettings);

            //5.保存XmlDocument的内容, 即输出到fileStream
            xmlDoc.Save(writer);
        }

在step2之后,XmlDoc对象已经完成Xml的加载, 然后在step4创建了一个输出到fileStream的XmlWriter, step5用xmlDoc.Save(writer)输出Xml到流中. 可以想象保存动作执行顺序应该是xmlDoc.Save()--->writer--->fileStream, 在保存时fileStream还保存着原来未被格式化的内容, 所以writer将xml的内容追加到fileStream. 知道问题的原因, 解决方案就简单了. 在step5之前先将fileStream的内容清空,可以用下面语句

fileStream.SetLength(0);

Hide program window by using HideWindowHotkey software

2008-01-24T23:03:00.001-08:00

Keywords: Hide program software window, Hide Window Hotkey

Hide Window Hotkey is a utility which allows you to hide the windows, and programs which are running on your screen.It will instantly hide or close all (or some) programs through mouse hotkey or keyboard hotkey.It also could resize your programs automatically,such as maximize, minimize,normal,minimize to tray.

http://www.elongsoft.com

Minimize software window to system tray

2008-01-24T23:00:00.001-08:00

Keywords: Tools, Minimize software window to TrayIcon

Trayconizer, This is a cool little software. It allows you to minimize almost applications to system tray. Using Trayconizer is simple. To start TrayConizer on Notepad, you would execute: c:\Path\to\Trayconizer.exe c:\windows\notepad.exe

http://www.whitsoftdev.com/trayconizer/

Getting Started with NUnit

2008-01-23T02:16:00.000-08:00

Getting Started with NUnit

Richard Davis, SharpLogic Software

In this article, we will take a look at unit testing, test-driven development, and the NUnit framework. If you are already familiar with these topics and are instead looking for information about how it all ties in with the Software Design Competition, feel free to skip ahead to the NUnit and the Software Design Competition section.

Prerequisite

Read and complete the steps described in the Getting Started With The Software Design Competition article. This will give you a cursory introduction to the process of using the NUnit GUI application to run test code.

Requirements and Setup

One of the great advantages of competing in the Imagine Cup Software Design Competition is that you’re able to use the best tools available, and they’re absolutely free!

Download and install a version of Visual Studio 2005 Express from http://msdn.microsoft.com/vstudio/express/. You can use any language to develop your class library, but the baseline source code and tests are provided in C# so you’ll need to have that installed if you want to use them. Install with the default settings.

Note: You may use any version of Visual Studio 2005 that you have available.

Download the “NUnit 2.2.8 for .NET 2.0 MSI” installer from http://www.nunit.org/index.php?p=download and install it with the default settings.
Download the practice Level 100 Tutorial challenge from http://imaginecup.sharplogic.com/Challenge.aspx?challenge=4265d098-52ac-4eb6-8549-e8ab652d99b8 and unzip it to a convenient location, such as “C:L100MathLib”. At this point you should have a directory structure that looks like the following:

Unzip the challenge package (C:L100MathLibL100Math.zip) to the “C:L100MathLib” directory so that its contents are placed into the “C:L100MathLibL100Math” directory. The resulting directory should look like the following:

Test-Driven Development and Unit Testing

Testing software is an integral phase of the development lifecycle. As software projects grow in size, so too does the complexity. Complexity can refer to the size of the source code base, architecture and design of components, number of code paths, and even algorithmic considerations. The decisions to be made about testing have to do with the “when” and the “how”, not the “why”.

Software testing provides a valuable means to help verify that software was build correctly, but it can also serve as a form of requirements specification up front. Consider the development of a method that computes the division of two integral numbers:

public int Divide(int dividend, int divisor)

{ }

To devise tests for this method we need to think like a tester. This process includes asking questions like the following:

What are the types of input and what is the set of values they can possess?
What is the expected return type? Are there any restrictions to be considered upon return to the caller?
If the input includes reference types, is null (C#) or nothing (VB.NET) ever passed in?

It is important to identify and test for cases where state and input lead to faulty operation. In the case of the Divide method, we can determine that the operation is invalid when the divisor input is zero. Next, we can write a test to exercise the Divide method and check for the desired response. In the case of the Divide method, we expect a System.DivideByZeroException to be thrown when the divisor input is zero.

The test method that we just devised is a type of unit test. Unit tests typically look for a very specific result from an operation. This means that there is often a many to one relationship of tests to one piece of code. Consider the Divide method once again. We already have one test designed, but we also want tests that make sure various valid inputs return the correct results.

As you can see from the Divide example, the development of unit tests can be done before the application code is implemented. This process is known as test-driven development, and it provides many benefits:

Requirements are self-documented.
Tests are automatic and repeatable.
Tests are designed to work with known bad and good input values.

The development of unit tests provides an automatic and repeatable method for verifying the correct functioning of code. Each time code is added or modified in a project, the suite of unit tests can be re-run to make sure that the changes did not break functionality that worked previously. The act of re-running a suite of unit tests is known as regression testing.

Keep in mind that unit testing does not guarantee that software will be free of bugs. Generally speaking, it is not realistic to get full code path coverage that exercises the entire set and combinations of input to all methods in a piece of software. In addition, the quality of testing relies solely on the developer of the tests. There may be cases where a unit test fails to identify problems in code. Nevertheless, test-driven development and unit testing are powerful allies to have throughout the software development lifecycle.

Developing Tests for NUnit

In this section, we will walk through the development of some simple unit tests that target the NUnit testing framework. Make sure that you have downloaded and installed the L100Math example as described in the Requirements and Setup section before continuing.

Load the L100Math solution file with Visual Studio 2005:

Double-click on the L100Math.sln file that you previously downloaded and extracted to your computer (C:L100MathLibL100MathL100Math.sln).

Double-click on the MathHelperTests.cs source file.

Examine the MathHelperTests class found within the MathHelperTests.cs source file. Notice that the test class has an attribute named TestFixture attached to it. This attribute is defined as part of the NUnit framework and is used by NUnit to determine which classes contain tests.
Examine the test methods found within the MathHelperTests.cs source file:

There are two test methods designed to test the functionality of the MathHelper.Add method, TestAdd and TestAdd2.

Each test method is marked with the Test attribute so that NUnit can locate designated tests.
Each test method is responsible for conducting tests in way that allows the NUnit framework to determine when a test is a success or failure. This is done by using the NUnit Assert class. In the TestAdd test method, we add 3 and 5 together and store the result. Next, the Assert.AreEqual method is given the expected result, the actual result, and a message to be presented to the user in case the provided values are not equal.

Add a new test method to the MathHelperTests class which tests for the raising of a DivideByZeroException when the divisor parameter is zero:

Copy and paste the following code:

[Test]

[ExpectedException(typeof(DivideByZeroException))]

public void TestDivide2()

{

int quotient = MathHelper.Divide(4, 0);

}

Here we used another NUnit framework attribute named ExpectedException to inform NUnit that the test will be considered a success if the specified DivideByZeroException exception type is thrown.
Note that we could alternatively wrap the call to the MathHelper.Divide method within a try…catch block. The test will succeed in this case because we prevent the DivideByZeroException from being propagated up the call stack to the NUnit framework.

[Test]

public void TestDivide2()

{

try

{

int quotient = MathHelper.Divide(4, 0);

Assert.Fail("MathHelper.Divide(4, 0) " +

"failed to throw a DivideByZeroException.");

}

catch (DivideByZeroException)

{

}

It is important to note the requirements for the most essential NUnit framework attributes, TestFixture and Test. TestFixture requires the following from the class that it is applied to:

Public scope.
A public, default constructor without parameters.

If a method that is marked with the TestFixture attribute does not have a default constructor with the correct signature, i.e. you marked it as private instead of public; all tests will fail to run. The reason will be listed under the Tests Not Run tab as shown below.

Note: You should just leave out the constructor unless you need to perform initialization.

The Test attribute requires the following from the method that it is applied to:

Public scope.
Void return type.
No parameters.

If a method that is marked with the Test attribute does not return void, the test will not be run by NUnit and the reason why will be listed under the Tests Not Run tab as shown below.

Assertions are another very important topic to become familiar with as you gain more experience using the NUnit platform. The Assert.AreEqual method, which we just saw in action, is categorized as an equality assertion by NUnit. Another type of equality assertion is the Assert.AreNotEqual method, which does exactly what its name implies. Other categories of assertion include identity, comparison, type, and condition. The following tables describe a number of the different assertion categories and their methods:

Equality Asserts
Method	Description
Assert.AreEqual	Tests whether the expected and actual arguments are equal, asserting when they are not equal.
Assert.AreNotEqual	Opposite of AreEqual method.
Examples
// This example shows a successful AreEqual test. int expected = 5; int actual = 5; Assert.AreEqual(expected, actual, "Expected and actual values are not equal.");

Identity Asserts
Method	Description
Assert.AreSame	Tests whether the expected and actual arguments are the same object reference, asserting when they are not the same.
Assert.AreNotSame	Opposite of AreSame method.
Assert.Contains	Tests whether an object is contained in an array or list.
Examples
// This example shows a successful AreSame test. object objA = new object(); object objB = objA; Assert.AreSame(objA, objB, "Object references are not the same."); // This example shows a successful Contains test. string[] myArray = { "a", "b", "c" }; Assert.Contains("b", myArray, "Array does not contain expected value.");

Comparison Asserts
Method	Description
Assert.Greater	Tests whether one object is greater than another.
Assert.Less	Tests whether one object is less than another.
Examples
// This example shows a successful Less test (arg1 < arg2). int arg1 = 5; int arg2 = 6; Assert.Less(arg1, arg2);

Type Asserts
Method	Description
IsInstanceOfType	Tests whether an object is of a specified type or derived from a specified type, asserting when it is not.
IsNotInstanceOfType	Opposite of IsInstanceOfType method.
IsAssignableFrom	Tests whether it is valid to assign an instance of the specified type to a given object, asserting if it is not.
IsNotAssignableFrom	Opposite of IsAssignableFrom method.
Examples
// This example shows a successful IsInstanceOfType test. Exception myException = new Exception(); Assert.IsInstanceOfType(typeof(Exception), myException); // This example shows a successful IsAssignableFrom test. object myObject = new object(); Assert.IsAssignableFrom(typeof(Exception), myObject); Exception myException = new Exception(); // Assertion guarantees that myObject can be assigned myException (or // any other object that is typeof(Exception)). myObject = myException;

Condition Asserts
Method	Description
Assert.IsTrue	Tests whether a boolean condition is true, asserting when it is not.
Assert.IsFalse	Tests whether a boolean condition is false, asserting when it is.
Assert.IsNull	Tests whether an object is null, asserting when it is not.
Assert.IsNotNull	Opposite of IsNull method.
Assert.IsNaN	Tests whether a double is not a number (NaN), asserting when it is not.
Assert.IsEmpty	One overload tests whether a string is empty (string.Empty or “”), asserting when it is not. Another overload tests whether a collection or array is empty, asserting when it is not.
Assert.IsNotEmpty	Opposite of IsEmpty method.
Examples
// This example shows an unsuccessful IsNotEmpty test. List<int> myList = new List<int>(); Assert.IsNotEmpty(myList, "List is empty.");

Utility Asserts
Method	Description
Assert.Fail	Throws an AssertionException with specified failure message.
Assert.Ignore	Causes the current test to be ignored.
Examples
// This example shows a custom assertion that fails when the // myDouble variable does not fit within the specified value range. double myDouble = 0.94; if (myDouble < 0.95 \|\| myDouble > 1.05) { Assert.Fail("Value is not within the specified range."); }

String Asserts
Method	Description
StringAssert.Contains	Tests whether a string contains an expected substring, asserting when it does not.
StringAssert.StartsWith	Tests whether a string starts with an expected substring, asserting when it does not.
StringAssert.EndsWith	Tests whether a string ends with an expected substring, asserting when it does not.
StringAssert.AreEqualIgnoringCase	Tests whether an expected string is equal to an actual string ignoring case, asserting when they are not.
Examples
// This example shows a successful AreEqualIgnoringCase test. string actual = "test"; StringAssert.AreEqualIgnoringCase("tEsT", actual);

Running Tests Using NUnit

Assuming that you satisfied the prerequisite listed at the beginning of this article, loading and running tests using the NUnit GUI should be a familiar process at this point. In this section, we will take a more detailed look at two ways in which tests can be run and results generated.

NUnit GUI Application

The NUnit GUI application provides a complete, easy to use interface with which you can load, select, and view the results for unit tests. As you are already aware, loading a test assembly is as simple as selecting File | Open. Once an assembly is loaded, the nunit-gui.exe application will continue to monitor the file for changes. If you make changes in Visual Studio and re-compile, the NUnit application will re-load the assembly automatically so that it remains in sync with your development.

Build the solution by selecting Build | Build Solution from the main menu.

The NUnit GUI application works with .nunit project files, so any configuration options can be tied to an assembly and saved for future use. If you take a look at the L100MathTests project again, you will notice a file named L100MathTests.nunit. This file stores NUnit project configuration data in an XML format and it is added to the project as a matter of convenience.

Follow these steps to have Visual Studio open the NUnit project file using the NUnit-Gui.exe application by default:

Right-click on L100MathTests.nunit and select Open With.
Select the NUnit-Gui (NUnit) program followed by the Set as Default button.
Select the OK button.

Now you can load the unit tests by simply double-clicking on the .nunit project file from Solution Explorer. If NUnit fails to launch, you may need to repeat steps 2-4, but this time add a new program to the list and navigate to the nunit-gui.exe application explicitly.

You can run all tests by selecting the root node and then selecting the Run button. If tests fail to meet the assertion criteria, informative messages will be placed in the Errors and Failures tab. A red node means that not all tests passed at that node or at its descendent nodes. Green indicates that all tests passed at a node and at its descendent nodes. It is also possible to run individual test classes or even individual tests within test classes. To do so, simply select the test node that you want to run and then select Run.

NUnit test results can be saved for future use by selecting Tools | Save Results as XML from the main menu. If you select the TestAdd method and run the test, the resulting XML document will include the following information:

<test-case name="L100MathTests.MathHelperTests.TestAdd" executed="True" success="False" time="0.047" asserts="0">

<message><![CDATA[Tested: MathHelper.Add(3, 5)

expected: <8>

but was: <0>]]></message>

<stack-trace><![CDATA[ at L100MathTests.MathHelperTests.TestAdd() in C:L100MathLibL100MathL100MathTestsMathHelperTests.cs:line 20

]]></stack-trace>

</failure>

</test-case>

This XML tells us that the TestAdd method was executed successfully but failed to meet the conditions of an assertion. A stack trace is also provided to let us know exactly where the assertion that failed is located.

NUnit Console Application

The NUnit console application is an alternative to the GUI application that is capable of performing tests and producing XML test results. As a quick demonstration, let’s use the NUnit console application to test the L100Math library we have been working with.

Load a command prompt window by selecting Start | All Programs | Accessories | Command Prompt.
Change the current directory to the location where the test DLL is created by Visual Studio when built as shown below.

Temporarily modify the Path environment variable to include the path to the nunit-console.exe application. Use the following command:

path=%path%;”c:Program FilesNUnit-Net-2.0 2.2.8bin”

Use the NUnit console application to test all test methods contained within the L100MathTests.dll assembly:

nunit-console L100MathTests.dll

Once the NUnit console application has finished running tests, failure messages are output to the console window. If you see errors here, it is an indication that you should check the results XML file for more details. By default, NUnit will create the results XML file in the same directory where you performed the tests and name it TestResult.xml.

Open the TestResult.xml file generated from the last test run. You can do this from an Explorer window or by issuing the command:

notepad TestResult.xml

The NUnit console application can also use Visual Studio project files and NUnit project files to run tests, as show in the examples below:

Nunit-console L100MathTests.csproj

Nunit-console L100MathTests.nunit

Many other options are available for use with the NUnit console application. Please refer to the official NUnit documentation for more information.

NUnit and the Software Design Competition

Now that you understand how to write unit tests for the NUnit framework and use the associated tools, let’s take a moment to discuss how the Software Design Competition affects the testing environment and strategy. In this section, we will highlight important points that competitors will need to keep in mind as they develop, test, submit, and debug their entries.

The design and nature of the Software Design Competition has a number of effects upon user-submitted challenge entries:

Entries must be optimized enough so that they can complete the tests performed on the backend before a set timeout.
Entries must only use code that can run under the “Execution” permission set.

For some challenges, it may be difficult to know how much optimization is necessary because the backend tests are not available to you. One solution to this problem is to simply not worry about optimization unless you get a timeout message back from the testing server. A timeout message would be something like, “Test has exceeded timeout. 3000 ms.” If you get a timeout message, you will need to examine your solution for areas that need to be optimized.

User-submitted entries will only be given the ability to execute code as defined by the .NET code access security policy. This means that you can not use file I/O, sockets, networking, or other tasks that require more privileges. One way that you can ensure your code meets this requirement during testing is to add an appropriate PermissionSet attribute to the top of your classes. The L100Math library test class, MathHelperTests, shows this in action:

[TestFixture]

[PermissionSet(SecurityAction.PermitOnly, Name = "Execution")]

public class MathHelperTests

Note that you will need to create a unit test in order to exercise all of your code for this attribute to have any affect. A security exception will not be thrown until code is executed that tries to do something that it does not have permission to do.

The design and nature of the Software Design Competition also has a number of effects upon the test suite used on the backend, as well as the test results seen by competitors:

Backend tests may be more complicated than basic unit tests and use multiple objects containing multiple asserts.
Backend test results are returned and presented to the competitor with failure messages only – stack traces are not made available.

An ideal unit test is designed to be as simple as possible to help eliminate the possible causes for failure when the test is run. However, the Software Design Competition has a need for a consistent number of unit tests to be performed at each difficulty level. Because of this, unit tests may be more complicated than is ideal. It is important to keep in mind that if a unit test has multiple assertions in it, only the first one will be reported. As a result, a unit test may continue to fail, even as you fix individual bugs.

Competitors will only have access to the failure messages retuned from the testing backend. This will be the only diagnostic information available to you as you develop your solution to challenges. As the challenges become more difficult, the failure messages will become less helpful. For example, Level 100 tests will likely explain the exact method call and parameters that failed, whereas Level 500 tests may only mention what the test was trying to accomplish.

You may run into the following types of failure messages as you progress further into the competition:

Failure message that indicates a specific method failed to return the expected results.
Failure message that indicates a method failed with specified input values.
Failure message that indicates an exception occurred in a specific method.
Failure message that only indicates an exception occurred (no other helpful information provided).
Failure message due to incorrect object inheritance.
Failure message due to missing interface implementation.

If you are having difficulty deciphering a failure message and know which method is causing the problem, try developing your own unit tests for it to see if you can determine the root cause for the problem. You may also want to re-consult the specification provided for the challenge to see if you missed any details pertinent to the problem at hand. Remember, there is no penalty for revising your entries and re-submitting them for scoring. However, only your most recent submission counts, so regression bugs can hurt you if you’re not careful.

Debugging NUnit Tests

Once you begin to develop unit tests you may wonder, “How do I test to make sure the tests are correct?” One tool that you have available is the Visual Studio Debugger. Being able to debug the unit tests is useful since it is one of the easiest ways to exercise our library code. In this section, we will demonstrate how you can take advantage of the debugger to test your unit code.

Let’s return to the L100Math library that we were working with earlier. Make sure that you have the L100Math solution file open in Visual Studio and the MathHelperTests.cs source file open for viewing.

There are some differences between the Visual Studio Express products and the other versions of Visual Studio that necessitate two different sets of steps to demonstrate debugging. Please choose the subsection below that applies to you.

Visual Studio Express

Minimize all open programs so that your desktop is visible.
Right-click on the desktop and select New | Shortcut.
For the location of the shortcut, use the following:

"C:Program FilesMicrosoft Visual Studio 8SDKv2.0GuiDebugdbgclr.exe"

Select Next.
Use the default name for the shortcut and select Finish.

At this point, you should have a shortcut on the desktop that launches the Microsoft CLR Debugger.

Ensure that the current solution is built by selecting Build | Build Solution from the main menu in Visual Studio.
Double-click on the L100MathTests.nunit file in Solution Explorer to launch the NUnit GUI application.
Launch the debugger from the desktop shortcut.

Select File | Open | File from the main menu of the debugger. This will open the Open File dialog box.

Navigate to and open the MathHelperTests.cs source file.
Place a breakpoint at the first line of the TestAdd method.

Select Tools | Attach To Process from the main menu of the debugger.
Locate and select the nunit-gui.exe process from the list of available processes.

Select Attach to attach to the NUnit GUI process. At this point, the assembly containing the TestAdd method has not been called yet, so you will see a symbol where the breakpoint was set.
Switch back to the NUnit GUI application and double-click on the TestAdd method. The breakpoint that you set should be hit and the CLR Debugger application brought back to the foreground.

Select Debug | Step Into from the debugger main menu to enter the MathHelper.Add method.

Now that you know how to attach to the NUnit process, the full power of the Microsoft CLR Debugger is at your fingertips.

Visual Studio Standard or higher

Place a breakpoint at the first line of the TestAdd method.

Right-click on the L100MathTests project in Solution Explorer and select Properties.
Select the Debug tab and fill in the following options:

Start External Program text box: C:Program FilesNUnit-Net-2.0 2.2.8binnunit-gui.exe

Command Line Arguments text box: L100MathTests.dll

Working Directory text box: C:L100MathLibL100MathL100MathTestsbinDebug

Select Debug | Start Debugging from the main menu or use the F5 shortcut.
Switch to the NUnit GUI application and double-click on the TestAdd method. The breakpoint that you previously set should be hit and a yellow cursor and line will be shown.

Select Debug | Step Into from the debugger main menu to enter the MathHelper.Add method.

Now that you know how to attach to the NUnit process, the full power of the Microsoft Visual Studio Debugger is at your fingertips.

Resources & References

Here are some addition resources that you may find helpful:

NUnit project - http://nunit.org/index.php?p=documentation

Wikipedia TDD - http://en.wikipedia.org/wiki/Test-driven_development

Wikipedia unit testing - http://en.wikipedia.org/wiki/Unit_test

MSDN unit testing article - http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnvs05/html/utfwvs05tmsys.asp

How to debug dll by using NUnit

2008-01-23T02:09:00.001-08:00

Keywords: NUnit, Unit Test, Visual Studio

这里是一个精简版使用NUnit来测试一个Class Library的步骤. 这个方法比通过NUnit GUI的菜单File/Open Project方便, 因为后者在调试程序时候, 不得不在Visual Studio的Tools/Attach to Process中为Debuger绑定一个Host程序(Attach NUnit.exe). 然后才能设置断点.

或者是为VS安装UnitRun -(Resharper tool) 或TestDriven.NET 插件, 也可以很方便地在VS中直接使用NUnit进行测试.

另有一个blog更详细地说明了怎样使用NUnit.

下面的方法, 不需要任何VS插件, 却可以很方便地调试dll:(适用于 Visual Studio Standard or higher, 不适用于Express版)

1.Place a breakpoint at the first line of the TestAdd method.

2.Right-click on the L100MathTests project in Solution Explorer and select Properties.

Select the Debug tab and fill in the following options:

Start External Program text box : C:\Program Files\NUnit-Net-2.0 2.2.8\bin\nunit-gui.exe 或者 nunit.exe

Command Line Arguments text box: L100MathTests.dll

Working Directory text box: C:\L100MathLib\L100Math\L100MathTests\bin\Debug\

3. Select Debug | Start Debugging from the main menu or use the F5 shortcut.

4. Switch to the NUnit GUI application and double-click on the TestAdd method. The breakpoint that you previously set should be hit and a yellow cursor and line will be shown.

5.Select Debug | Step Into from the debugger main menu to enter the MathHelper.Add method.

Windows shell script programming

2008-01-22T20:00:00.001-08:00

Keywords: Windows, shell script, bat file

There are 2 web sites, they are useful for batch program.

http://www.student.oulu.fi/~vtatila/batch_tutorial.html

http://www.computerhope.com/msdos.htm