博客园_选择大于努力,选择前请三思,选择后请努力.

[算法]遍历文件系统

2011-10-01T03:43:00Z

 1 public void BFS(DirectoryInfo dir, ref long nfile, ref long ndir) 
 2         {
 3             try
 4             {
 5                 IEnumerable<string> ieDir = Directory.EnumerateDirectories(dir.FullName);
 6 
 7                 IEnumerator<string> iDir = ieDir.GetEnumerator();
 8 
 9                 do
10                 {
11                     if (iDir.Current != null)
12                     {
13                         Console.WriteLine(iDir.Current.ToString());
14                         ndir++;
15 
16                         try
17                         {
18                             IEnumerable<string> ieFile = Directory.EnumerateFiles(iDir.Current.ToString());
19 
20                             IEnumerator<string> iFile = ieFile.GetEnumerator();
21                             do
22                             {
23                                 if (iFile.Current != null)
24                                 {
25                                     Console.WriteLine(iFile.Current.ToString());
26                                     nfile++;
27                                 }
28 
29                             }
30                             while (iFile.MoveNext());
31                         }
32                         catch
33                         {
34 
35                         }
36 
37                         BFS(new DirectoryInfo(iDir.Current.ToString()), ref nfile, ref ndir);
38 
39                     }
40 
41 
42                 }
43                 while (iDir.MoveNext());
44             }
45             catch 
46             {
47 
48             }
49 
50         }

 1  public void BFS2(DirectoryInfo dir, ref long nFile, ref long nDir)
 2         {
 3             try
 4             {
 5                 if (dir.Exists)
 6                 {
 7                     Console.WriteLine(dir.FullName);
 8                     nDir++;
 9 
10                     try
11                     {
12                         FileInfo[] arrFile = dir.GetFiles();
13 
14                         foreach (FileInfo fiNode in arrFile)
15                         {
16                             if (fiNode.Exists)
17                             {
18                                 Console.WriteLine(fiNode.FullName);
19                                 nFile++;
20                             }
21 
22                         }
23                     }
24                     catch
25                     {
26 
27                     }
28 
29                 }
30 
31                 DirectoryInfo[] arrDir = dir.GetDirectories();
32                 foreach (DirectoryInfo node in arrDir)
33                 {
34                     BFS2(node, ref nFile, ref nDir);
35                 }
36             }
37             catch 
38             {
39 
40             }
41 
42         }

 1 /// <summary>
 2         /// 广度优先遍历 ： 用队列
 3         /// </summary>
 4         /// <param name="dir"></param>
 5         public string BFS(DirectoryInfo dir)
 6         {
 7             long nFileCount = 0;
 8             long nDirCount = 0;
 9 
10             //文件队列
11             Queue<DirectoryInfo> dirList = new Queue<DirectoryInfo>();
12             dirList.Enqueue(dir);
13 
14             //是否包含有子文件夹
15             bool bIsHasChildDir = true;
16 
17             while (bIsHasChildDir)
18             {
19 
20                 //1. 文件夹出队  
21                 //取文件信息 
22                 //取子文件夹信息 
23                 //输出出队文件夹信息
24 
25                 DirectoryInfo WriteDir = dirList.Dequeue();
26 
27                 Console.WriteLine(WriteDir.FullName);
28                 nDirCount++;
29 
30                 try
31                 {
32                     //2.当前目录文件扫描（广度遍历）
33                     FileInfo[] fiList = WriteDir.GetFiles();
34 
35                     foreach (FileInfo node in fiList)
36                     {
37                         if (node.Exists)
38                         {
39                             Console.WriteLine(node.FullName);
40                             nFileCount++;
41                         }
42                     }
43                 }
44                 catch 
45                 {
46 
47                 }
48 
49                 try
50                 {
51                     //3.子文件夹入队
52                     DirectoryInfo[] diList = WriteDir.GetDirectories();
53 
54                     foreach (DirectoryInfo node in diList)
55                     {
56                         if (node.Exists)
57                         {
58                             //入队,同时开始访问文件夹
59                             dirList.Enqueue(node);
60                         }
61                     }
62                 }
63                 catch { }
64 
65                 //队列中没有文件夹可访问
66                 if (dirList.Count == 0)
67                 {
68                     bIsHasChildDir = false;
69                 }
70 
71             }
72 
73             return string.Format("FileCount:{0}, DirCount:{1}", nFileCount, nDirCount);
74   
75         }

 1 /// <summary>
 2         /// 深度优先遍历 : 用栈 =二叉树的前序遍历  （传统深度遍历）
 3         /// </summary>
 4         /// <param name="dir"></param>
 5         public string  DFS(DirectoryInfo dir) 
 6         {
 7             long nFileCount = 0;
 8             long nDirCount = 0;
 9 
10             //1.把root 压入 栈中
11             Stack<DirectoryInfo> dirStack = new Stack<DirectoryInfo>();
12             dirStack.Push(dir);
13 
14             DirectoryInfo parent = null;
15             while (dirStack.Count != 0) 
16             {
17                 //读顶栈
18                 DirectoryInfo current = dirStack.Pop();
19 
20                 //输出当前目录
21                 Console.WriteLine(current.FullName);
22                 nDirCount++;
23                 try
24                 {
25 
26                     FileInfo[] fiList = current.GetFiles();
27 
28                     foreach (FileInfo node in fiList)
29                     {
30                         Console.WriteLine(node.FullName);
31                         nFileCount++;
32                     }
33 
34                 }
35                 catch
36                 {
37 
38                 }
39 
40 
41                 //
42                 try
43                 {
44 
45                     DirectoryInfo[] dirList = current.GetDirectories();
46 
47                     foreach (DirectoryInfo node in dirList)
48                     {
49                         dirStack.Push(node);
50                     }
51                 }
52                 catch 
53                 {
54 
55                 }
56 
57             }
58 
59             return string.Format("FileCount:{0}, DirCount:{1}", nFileCount, nDirCount);
60         }

实现

 1  class Program
 2     {
 3 
 4         public static string GetTimeSpanFormatText(DateTime dateStart)
 5         {
 6             string strSpan = "span:{0}d{1}h{2}m{3}s{4}ms";
 7             TimeSpan tsSpan = DateTime.Now - dateStart;
 8             string strReturn = string.Format(strSpan, tsSpan.Days, tsSpan.Hours, tsSpan.Minutes, tsSpan.Seconds, tsSpan.Milliseconds);
 9             return strReturn;
10         }
11 
12         static void Main(string[] args)
13         {
14             DirectoryInfo root = new DirectoryInfo("C:\\");
15 
16             Recursion lsFile = new Recursion();
17             DateTime start = DateTime.Now;
18             Console.WriteLine(start.ToLongTimeString());
19             long nFileCount1 = 0;
20             long nDirCount1 = 0;
21             lsFile.BFS(root, ref nFileCount1, ref nDirCount1);
22             Console.WriteLine(GetTimeSpanFormatText(start));
23             Console.WriteLine(string.Format("FileCount:{0}, DirCount:{1}", nFileCount1, nDirCount1));
24             Console.WriteLine("OK");
25             Console.ReadLine();
26 
27             Recursion lsFile2 = new Recursion();
28             DateTime start2 = DateTime.Now;
29             long nFileCount = 0;
30             long nDirCount = 0;
31             lsFile2.BFS2(root, ref nFileCount, ref nDirCount);
32             Console.WriteLine(GetTimeSpanFormatText(start2));
33             Console.WriteLine(string.Format("FileCount:{0}, DirCount:{1}", nFileCount, nDirCount));
34             Console.WriteLine("OK");
35             
36             Console.ReadLine();
37 
38             UnRecursion btree = new UnRecursion();
39             DateTime start3 = DateTime.Now;
40             string strBFS = btree.BFS(root);
41             Console.WriteLine(GetTimeSpanFormatText(start3));
42             Console.WriteLine(strBFS);
43             Console.WriteLine("OK");
44 
45             Console.ReadLine();
46 
47 
48             UnRecursion btree3 = new UnRecursion();
49             DateTime start5 = DateTime.Now;
50             string strResult = btree3.DFS(root);
51             Console.WriteLine(GetTimeSpanFormatText(start5));
52             Console.WriteLine(strResult);
53             Console.WriteLine("OK");
54 
55             Console.ReadLine();
56            
57         }
58 
59        
60     }

结果对比

0:2:41:070   C:\ 递归1   file 138917 dir 28678
0:2:52:209   C:\ 递归2   file 138919 dir 28673
0:2:53:113   C:\ BFS     file 138915 dir 28673
0:4:57:523   C:\ DFS     file 138915 dir 28673

结论

[单线程的情况下]

对于文件系统树的遍历来说使用广度优先要比深度优先要更好些，理由是：
1、DFS每次遇到目录则立即深入搜索，因此需要保存大量句柄，而BFS则避免用太多句柄；
2、同一个目录下的文件在硬盘的物理结构上更邻近些，所以BFS更快

本文链接

Wordpress template workflow map

2011-09-05T06:53:00Z

Function_Reference http://codex.wordpress.org/Function_Reference

WordPress_Coding_Standards http://codex.wordpress.org/WordPress_Coding_Standards

Stepping_Into_Template_Tags http://codex.wordpress.org/Stepping_Into_Template_Tags

Stepping_Into_Templates http://codex.wordpress.org/Stepping_Into_Templates

CSS http://codex.wordpress.org/CSS

本文链接

浅谈Python web框架

2011-06-30T09:10:00Z

说到web framework，Ruby的世界Rails一统江湖，而Python则是一个百花齐放的世界，各种micro-framework、framework不可胜数，不完全列表见：http://wiki.python.org/moin/WebFrameworks。虽然另一大脚本语言PHP也有不少框架，但远没有Python这么夸张，也正是因为Python web framework（Python web开发框架，以下简称Python框架）太多，所以在Python社区总有关于Python框架孰优孰劣的话题，讨论的时间跨度甚至长达3-5年。

Python这么多框架，能挨个玩个遍的人不多，坦白的说我也只用过其中的三个开发过项目，另外一些稍微接触过，所以这里只能浅谈一下，欢迎懂行的朋友们补充、拍砖。

Django

Python框架虽然说是百花齐放，但仍然有那么一家是最大的，它就是Django。要说Django是Python框架里最好的，有人同意也有人坚决反对，但说Django的文档最完善、市场占有率最高、招聘职位最多估计大家都没什么意见。Django为人所称道的地方主要有：

完美的文档，Django的成功，我觉得很大一部分原因要归功于Django近乎完美的官方文档（包括Django book）。
全套的解决方案，Django象Rails一样，提供全套的解决方案（full-stack framework + batteries included），基本要什么有什么（比如：cache、session、feed、orm、geo、auth），而且全部Django自己造，开发网站应手的工具Django基本都给你做好了，因此开发效率是不用说的，出了问题也算好找，不在你的代码里就在Django的源码里。
强大的URL路由配置，Django让你可以设计出非常优雅的URL，在Django里你基本可以跟丑陋的GET参数说拜拜。
自助管理后台，admin interface是Django里比较吸引眼球的一项contrib，让你几乎不用写一行代码就拥有一个完整的后台管理界面。

而Django的缺点主要源自Django坚持自己造所有的轮子，整个系统相对封闭，Django最为人诟病的地方有：

系统紧耦合，如果你觉得Django内置的某项功能不是很好，想用喜欢的第三方库来代替是很难的，比如下面将要说的ORM、Template。要在Django里用SQLAlchemy或Mako几乎是不可能，即使打了一些补丁用上了也会让你觉得非常非常别扭。
Django自带的ORM远不如SQLAlchemy强大，除了在Django这一亩三分地，SQLAlchemy是Python世界里事实上的ORM标准，其它框架都支持SQLAlchemy了，唯独Django仍然坚持自己的那一套。Django的开发人员对SQLAlchemy的支持也是有过讨论和尝试的，不过最终还是放弃了，估计是代价太高且跟Django其它的模块很难合到一块。
Template功能比较弱，不能插入Python代码，要写复杂一点的逻辑需要另外用Python实现Tag或Filter。关于模板这一点，一直以来争论比较多，最近有两篇关于Python模板的比较有意思的文章可供参考：

http://pydanny.blogspot.com/2010/12/stupid-template-languages.html（need proxy）

http://techspot.zzzeek.org/2010/12/04/in-response-to-stupid-template-languages/

URL配置虽然强大，但全部要手写，这一点跟Rails的Convention over configuration的理念完全相左，高手和初识Django的人配出来的URL会有很大差异。
让人纠结的auth模块，Django的auth跟其它模块结合紧密，功能也挺强的，就是做的有点过了，用户的数据库schema都给你定好了，这样问题就来了，比如很多网站要求email地址唯一，可schema里这个字段的值不是唯一的，纠结是必须的了。
Python文件做配置文件，而不是更常见的ini、xml或yaml等形式。这本身不是什么问题，可是因为理论上来说settings的值是能够动态的改变的（虽然大家不会这么干），但这不是最佳实践的体现。

总的来说，Django大包大揽，用它来快速开发一些Web运用是很不错的。如果你顺着Django的设计哲学来，你会觉得Django很好用，越用越爽；相反，你如果不能融入或接受Django的设计哲学，你用Django一定会很痛苦，趁早放弃的好。所以说在有些人眼里Django无异于仙丹，但对有一些人来说它又是毒药且剧毒。

Django案例有disqus.com、bitbucket.org、海报网等。

Pylons & TurboGears & repoze.bfg

除了Django另一个大头就是Pylons了，因为TurboGears2.x是基于Pylons来做的，而repoze.bfg也已经并入Pylons project里这个大的项目里，后面不再单独讨论TurboGears和repoze.bfg了。

Pylons和Django的设计理念完全不同，Pylons本身只有两千行左右的Python代码，不过它还附带有一些几乎就是Pylons御用的第三方模块。Pylons只提供一个架子和可选方案，你可以根据自己的喜好自由的选择Template、ORM、form、auth等组件，系统高度可定制。我们常说Python是一个胶水语言(glue language)，那么我们完全可以说Pylons就是一个用胶水语言设计的胶水框架:)

选择Pylons多是选择了它的自由，选择了自由的同时也预示着你选择了噩梦：

学习噩梦，Pylons依赖于许多第三方库，它们并不是Pylons造，你学Pylons的同时还得学这些库怎么使用，关键有些时候你都不知道你要学什么。Pylons的学习曲线相对比Django要高的多，而之前Pylons的官方文档也一直是人批评的对象，好在后来出了The Definitive Guide to Pylons这本书，这一局面有所改观。因为这个原因，Pylons一度被誉为只适合高手使用的Python框架。
调试噩梦，因为牵涉到的模块多，一旦有错误发生就比较难定位问题处在哪里。可能是你写的程序的错、也可能是Pylons出错了、再或是SQLAlchemy出错了、搞不好是formencode有bug，反正很凌乱了。这个只有用的很熟了才能解决这个问题。
升级噩梦，安装Pylons大大小小共要安装近20个Python模块，各有各自的版本号，要升级Pylons的版本，哪个模块出了不兼容的问题都有可能，升级基本上很难很难。至今reddit的Pylons还停留在古董的0.9.6上，SQLAlchemy也还是0.5.3的版本，应该跟这条有关系。所以大家玩Pylons一定要结合virtualenv来玩，给自己留条后路，不然会死得很惨。

Pylons和repoze.bfg的融合可能会催生下一个能挑战Django地位的框架。

Pylons的案例有reddit.com、dropbox.com、quora.com等。

Tornado & web.py

Tornado即是一个web server（对此本文不作详述），同时又是一个类web.py的micro-framework，作为框架Tornado的思想主要来源于web.py，大家在web.py的网站首页也可以看到Tornado的大佬Bret Taylor的这么一段话（他这里说的FriendFeed用的框架跟Tornado可以看作是一个东西）：

“[web.py inspired the] web framework we use at FriendFeed [and] the webapp framework that ships with App Engine…”

因为有这层关系，后面不再单独讨论Tornado。

web.py的设计理念力求精简（Keep it simple and powerful），总共就没多少行代码，也不像Pylons那样依赖大量的第三方模块，而是只提供的一个框架所必须的一些东西，如：URL路由、Template、数据库访问，其它的就交给用户自己去做好了。

一个框架精简的好处在于你可以聚焦在业务逻辑上，而不用太多的去关心框架本身或受框架的干扰，同时缺点也很明显，许多事情你得自己操刀上。
我个人比较偏好这种精简的框架，因为你很容易通过阅读源码弄明白整个框架的工作机制，如果框架那一块不是很合意的话，我完全可以Monkey patch一下按自己的要求来。

早期的reddit是用web.py写的，Tornado的案例有friendfeed.com、bit.ly、quora.com和我的开源站点poweredsites.org等。

Bottle & Flask

Bottle和Flask作为新生一代Python框架的代表，挺有意思的是都采用了decorator的方式配置URL路由，如：

from bottle import route, run
 
@route('/:name')
def index(name='World'):
    return '&lt;b&gt;Hello %s!&lt;/b&gt;' % name
 
run(host='localhost', port=8080)

Bottle、Flask跟web.py一样，都非常精简，Bottle甚至所有的代码都在那一个两千来行的.py文件里。另外Flask和Pylons一样，可以跟Jinja2、SQLAlchemy之类结合的很好。

不过目前不管是Bottle还是Flask成功案例都还很少。

Quixote

之所以要特别说一下Quixote，是因为国内的最大的用Python开发的网站“豆瓣网”是用Quixote开发的。我只简单翻了一下源代码，没有做过研究，不发表评论，有经验的来补充下。我只是在想，如果豆瓣网交到现在来开发，应该会有更多的选择。

其它（web2py、uliweb、Karrigell、Werkzeug …）

欢迎大家补充…

最后关于框架选择的误区

在框架的选择问题上，许多人很容易就陷入了下面两个误区中而不自知：

哪个框架最好－世上没有最好的框架，只有最适合你自己、最适合你的团队的框架。编程语言选择也是一个道理，你的团队Python最熟就用Python好了，如果最熟悉的是Ruby那就用Ruby好了，编程语言、框架都只是工具，能多、快、好、省的干完活就是好东西，管TMD是日本鬼子还是美帝造呢！
过分关注性能－其实大部分人是没必要太关心框架的性能的，因为你开发的网站根本就是个小站，能上1万的IP的网站已经不多了，上10万的更是很少很少。在没有一定的访问量前谈性能其实是没有多大意义的，因为你的CPU和内存一直就闲着呢。而且语言和框架一般也不会是性能瓶颈，性能问题最常出现在数据库访问和文件读写上。PHP的Zend Framework是出了名的慢，但是Zend Framework一样有大站，如：digg.com；常被人说有性能问题的Ruby和Rails，不是照样可以开发出twitter吗？再者现在的硬件、带宽成本其实是很低的，特别有了云计算平台后，人力成本才是最贵的，没有上万的IP根本就不用太在意性能问题，流量上去了花点钱买点服务器空间好了，简单快速的解决性能问题。

注：前面有网友质疑我“Quora是用Pylons开发的”这样的说法不客观，特说明一下，这里所说的某个网站A是用B开发的，只是指A主要或部分是由B开发的，大家就不要再去纠结A还用C了。

本文链接

五种开源协议的比较(BSD,Apache,GPL,LGPL,MIT) – 整理

2011-06-30T08:51:00Z

当Adobe、Microsoft、Sun等一系列巨头开始表现出对”开源”的青睐时，”开源”的时代即将到来！

最初来自：sinoprise.com/read.php?tid-662-page-e-fpage-1.html（遗憾的是这个链接已经打不开了），我基本未改动，只是进行了一些排版和整理。
参考文献：http://www.fsf.org/licensing/licenses/

现今存在的开源协议很多，而经过Open Source Initiative组织通过批准的开源协议目前有58种（http://www.opensource.org/licenses/alphabetical）。我们在常见的开源协议如BSD, GPL, LGPL,MIT等都是OSI批准的协议。如果要开源自己的代码，最好也是选择这些被批准的开源协议。

这里我们来看四种最常用的开源协议及它们的适用范围，供那些准备开源或者使用开源产品的开发人员/厂家参考。

BSD开源协议（original BSD license、FreeBSD license、Original BSD license）

BSD开源协议是一个给于使用者很大自由的协议。基本上使用者可以”为所欲为”,可以自由的使用，修改源代码，也可以将修改后的代码作为开源或者专有软件再发布。

但”为所欲为”的前提当你发布使用了BSD协议的代码，或则以BSD协议代码为基础做二次开发自己的产品时，需要满足三个条件：

如果再发布的产品中包含源代码，则在源代码中必须带有原来代码中的BSD协议。
如果再发布的只是二进制类库/软件，则需要在类库/软件的文档和版权声明中包含原来代码中的BSD协议。
不可以用开源代码的作者/机构名字和原来产品的名字做市场推广。

BSD 代码鼓励代码共享，但需要尊重代码作者的著作权。BSD由于允许使用者修改和重新发布代码，也允许使用或在BSD代码上开发商业软件发布和销售，因此是对商业集成很友好的协议。而很多的公司企业在选用开源产品的时候都首选BSD协议，因为可以完全控制这些第三方的代码，在必要的时候可以修改或者二次开发。

Apache Licence 2.0（Apache License, Version 2.0、Apache License, Version 1.1、Apache License, Version 1.0）

Apache Licence是著名的非盈利开源组织Apache采用的协议。该协议和BSD类似，同样鼓励代码共享和尊重原作者的著作权，同样允许代码修改，再发布（作为开源或商业软件）。需要满足的条件也和BSD类似：

需要给代码的用户一份Apache Licence
如果你修改了代码，需要再被修改的文件中说明。
在延伸的代码中（修改和有源代码衍生的代码中）需要带有原来代码中的协议，商标，专利声明和其他原来作者规定需要包含的说明。
如果再发布的产品中包含一个Notice文件，则在Notice文件中需要带有Apache Licence。你可以在Notice中增加自己的许可，但不可以表现为对Apache Licence构成更改。

Apache Licence也是对商业应用友好的许可。使用者也可以在需要的时候修改代码来满足需要并作为开源或商业产品发布/销售。

GPL（GNU General Public License）

我们很熟悉的Linux就是采用了GPL。GPL协议和BSD, Apache Licence等鼓励代码重用的许可很不一样。GPL的出发点是代码的开源/免费使用和引用/修改/衍生代码的开源/免费使用，但不允许修改后和衍生的代码做为闭源的商业软件发布和销售。这也就是为什么我们能用免费的各种linux，包括商业公司的linux和linux上各种各样的由个人，组织，以及商业软件公司开发的免费软件了。

GPL协议的主要内容是只要在一个软件中使用(“使用”指类库引用，修改后的代码或者衍生代码)GPL 协议的产品，则该软件产品必须也采用GPL协议，既必须也是开源和免费。这就是所谓的”传染性”。GPL协议的产品作为一个单独的产品使用没有任何问题，还可以享受免费的优势。

由于GPL严格要求使用了GPL类库的软件产品必须使用GPL协议，对于使用GPL协议的开源代码，商业软件或者对代码有保密要求的部门就不适合集成/采用作为类库和二次开发的基础。

其它细节如再发布的时候需要伴随GPL协议等和BSD/Apache等类似。

LGPL（GNU Lesser General Public License）

LGPL是GPL的一个为主要为类库使用设计的开源协议。和GPL要求任何使用/修改/衍生之GPL类库的的软件必须采用GPL协议不同。LGPL允许商业软件通过类库引用(link)方式使用LGPL类库而不需要开源商业软件的代码。这使得采用LGPL协议的开源代码可以被商业软件作为类库引用并发布和销售。

但是如果修改LGPL协议的代码或者衍生，则所有修改的代码，涉及修改部分的额外代码和衍生的代码都必须采用LGPL协议。因此LGPL协议的开源代码很适合作为第三方类库被商业软件引用，但不适合希望以LGPL协议代码为基础，通过修改和衍生的方式做二次开发的商业软件采用。

GPL/LGPL都保障原作者的知识产权，避免有人利用开源代码复制并开发类似的产品

MIT（MIT）

MIT是和BSD一样宽范的许可协议,作者只想保留版权,而无任何其他了限制.也就是说,你必须在你的发行版里包含原许可协议的声明,无论你是以二进制发布的还是以源代码发布的.

本文链接

【转载】Connection strings for SQLite

2011-04-18T06:53:00Z

SQLite.NET

Type: .NET Framework Class Library
Usage: System.Data.SQLite.SQLiteConnection

Manufacturer: SQLite

Basic

Data Source=filename;Version=3;

Version 2 is not supported by this class library.

Using UTF16

Data Source=filename;Version=3;UseUTF16Encoding=True;

With password

Data Source=filename;Version=3;Password=myPassword;

Using the pre 3.3x database format

Data Source=filename;Version=3;Legacy Format=True;

With connection pooling

Connection pooling is not enabled by default. Use the following parameters to control the connection pooling mechanism.

Data Source=filename;Version=3;Pooling=False;Max Pool Size=100;

Read only connection

Data Source=filename;Version=3;Read Only=True;

Using DateTime.Ticks as datetime format

Data Source=filename;Version=3;DateTimeFormat=Ticks;

The default value is ISO8601 which activates the use of the ISO8601 datetime format

Store GUID as text

Normally, GUIDs are stored in a binary format. Use this connection string to store GUIDs as text.

Data Source=filename;Version=3;BinaryGUID=False;

Note that storing GUIDs as text uses more space in the database.

Specify cache size

Data Source=filename;Version=3;Cache Size=2000;

The Cache Size value measured in bytes

Specify page size

Data Source=filename;Version=3;Page Size=1024;

The Page Size value measured in bytes

Disable enlistment in distributed transactions

Data Source=filename;Version=3;Enlist=N;

Disable enlistment in distributed transactions

Data Source=filename;Version=3;Enlist=N;

Disable create database behaviour

If the database file doesn't exist, the default behaviour is to create a new file. Use the following parameter to raise an error instead of creating a new database file.

Data Source=filename;Version=3;FailIfMissing=True;

Limit the size of database

Data Source=filename;Version=3;Max Page Count=5000;

The Max Page Count is measured in pages. This parameter limits the maximum number of pages of the database.

Disable the Journal File

This one disables the rollback journal entirely.

Data Source=filename;Version=3;Journal Mode=Off;

Persist the Journal File

This one blanks and leaves the journal file on disk after a commit. Default behaviour is to delete the Journal File after each commit.

Data Source=filename;Version=3;Journal Mode=Persist;

Controling file flushing

Data Source=filename;Version=3;Synchronous=Full;

Full specifies a full flush to take action after each write. Normal is the default value. Off means that the underlying OS flushes I/O's.

Finisar.SQLite ADO.NET Data Provider

Type: .NET Framework Class Library
Usage:

Manufacturer: Finisar.SQLite

Standard

Data Source=mydb.db;Version=3;

The "Version" key can take value "2" for SQLite 2.x (default) or value "3" for SQLite 3.x

Create a new database

Data Source=mydb.db;Version=3;New=True;

Using compression

Data Source=mydb.db;Version=3;Compress=True;

Specifying Cache Size

The Cache Size value represents the amount of data pages that are held in memory. Try increase this value for speed improvements but don't forget to keep track of the applications memory usage.

Data Source=mydb.db;Version=3;Cache Size=3000;

SQLite3 ODBC Driver

Type: .NET Framework Class Library
Usage:

Manufacturer: SQLite

Standard

DRIVER=SQLite3 ODBC Driver;Database=mydb.db;LongNames=0;Timeout=1000;NoTXN=0;SyncPragma=NORMAL;StepAPI=0;

.NET Framework Data Provider for ODBC

Type: .NET Framework Wrapper Class Library
Usage: System.Data.Odbc.OdbcConnection

Manufacturer: Microsoft

Bridging to SQLite3 ODBC Driver

This is just one connection string sample for the wrapping OdbcConnection class that calls the underlying ODBC Driver. See respective ODBC driver for more connection strings to use with this class.

DRIVER=SQLite3 ODBC Driver;Database=mydb.db;LongNames=0;Timeout=1000;NoTXN=0;SyncPragma=NORMAL;StepAPI=0;

本文链接

【原创】无法解决 equal to 运算中 "Chinese_PRC_CI_AS" 和 "SQL_Latin1_General_CP1_CI_AS" 之间的排序规则冲突。

2011-04-12T03:08:00Z

不同数据库的表做join操作时由于不同的编码出现导致无法做equal处理

究其原因是两个数据库的默认排序规则不同，只要修改其中一个数据的默认排序规则即可

鼠标右击“数据库名称”的属性，弹出属性对话框

1.先将访问限制调整为单用户使用

2.应用后再将排序规则调整为期望的排序值

3.最后再将访问限制调整回多用户访问

本文链接

【原创】近一年来面试中遇到的算法问题

2011-03-31T02:28:00Z

1.遍历文件和文件夹

2.类似如下1 2 3 5 8 13 21....求第N项

3.求第N个素数

4.冒泡排序

5.aabbbccccddeefgggggg 统计字符串中连续相同字母的个数（bbb算一个）

6.aabbbccccddeefbbgbbggg 统计字符串某个字母连续相同字母的个数（bbb算一个）

7.字符串反转

8. 输入如下字符：

1 2 3 4

5 6 7 8

输出结果字符：

1 5

2 6

3 7

4 8

9.统计str1中出现str2出现的次数

10.(KMP)随机插入100个不重复的数字

11.判断2个链表是否有交点

12.判断2个链表是否有环

13.如果2个链表相较找到交点

14.最短路径算法

15有一个M x N的矩阵

上下左右方向相连接的算是一个block（红色部分）（斜着的不算）

统计矩阵中block的个数

本文链接

【原创】计算文本表达式

2010-09-21T01:04:00Z

#region  数学公式自动计算表达式


    public struct MathChar
    {
        /// <summary>
        /// +
        /// </summary>
        public static readonly char Add = '+';

        /// <summary>
        /// -
        /// </summary>
        public static readonly char Sub = '-';

        /// <summary>
        /// *
        /// </summary>
        public static readonly char Mul = '*';

        /// <summary>
        /// /
        /// </summary>
        public static readonly char Div = '/';

        /// <summary>
        /// %
        /// </summary>
        public static readonly char Mold = '%';

        /// <summary>
        /// ^
        /// </summary>
        public static readonly char Power = '^';

        /// <summary>
        /// !
        /// </summary>
        public static readonly char Neg = '!';

        /// <summary>
        /// .
        /// </summary>
        public static readonly char Spot = '.';

        /// <summary>
        /// (
        /// </summary>
        public static readonly char Left = '(';

        /// <summary>
        /// )
        /// </summary>
        public static readonly char Right = ')';

        /// <summary>
        /// ' '
        /// </summary>
        public static readonly char WhiteChar = ' ';

    }

    /// <summary>
    /// Reverse Polish Notation
    /// 算术逆波兰表达式.生成.
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    private string BuildingExpression(string MathExpression)
    {
        StringBuilder ExpressionBuild = new StringBuilder(MathExpression);
        Stack ExpressionStack = new Stack();
        StringBuilder returnExpression = new StringBuilder();


        char OneChar = MathChar.WhiteChar;
        //sb.Replace(" ","");//一开始,我只去掉了空格.后来我不想不支持函数和常量能滤掉的全OUT掉.
        for (int i = 0; i < ExpressionBuild.Length; i++)
        {
            OneChar = ExpressionBuild[i];
            //保存数字
            if (char.IsDigit(OneChar))
            {
                returnExpression.Append(OneChar);
            }
            //if(char.IsWhiteSpace(c)||char.IsLetter(c))//如果是空白,那么不要.现在字母也不要.
            //如果是其它字符...列出的要,没有列出的不要.
            switch (OneChar)
            {
                case '+':
                case '-':
                case '*':
                case '/':
                case '%':
                case '^':
                case '!':
                case '(':
                case ')':
                case '.':
                    returnExpression.Append(OneChar);
                    break;
                default:
                    continue;
            }
        }
        ExpressionBuild = new StringBuilder(returnExpression.ToString());

        #region 对负号进行预转义处理.负号变单目运算符求反.
        for (int i = 0; i < ExpressionBuild.Length - 1; i++)
        {
            if (ExpressionBuild[i] == '-' && (i == 0 || ExpressionBuild[i - 1] == MathChar.Left))
            {
                //字符转义.
                ExpressionBuild[i] = '!';
            }
        }
        #endregion

        #region 将中缀表达式变为后缀表达式.
        returnExpression = new System.Text.StringBuilder();
        for (int index = 0; index < ExpressionBuild.Length; index++)
        {
            //如果是数值.
            if (char.IsDigit(ExpressionBuild[index])
             || ExpressionBuild[index] == MathChar.Spot)
            {
                //加入后缀式
                returnExpression.Append(ExpressionBuild[index]);
            }
            else if (ExpressionBuild[index] == MathChar.Add
                  || ExpressionBuild[index] == MathChar.Sub
                  || ExpressionBuild[index] == MathChar.Mul
                  || ExpressionBuild[index] == MathChar.Div
                  || ExpressionBuild[index] == MathChar.Mold
                  || ExpressionBuild[index] == MathChar.Power
                  || ExpressionBuild[index] == MathChar.Neg)
            {
                #region 运算符处理
                //栈不为空时 
                while (ExpressionStack.Count > 0)
                {
                    //将栈中的操作符弹出.
                    OneChar = (char)ExpressionStack.Pop();
                    //如果发现左括号.停.
                    if (OneChar == MathChar.Left)
                    {
                        //将弹出的左括号压回.因为还有右括号要和它匹配.
                        ExpressionStack.Push(OneChar);
                        break;
                    }
                    //如果不是左括号,那么将操作符加入后缀式中.
                    else
                    {
                        //如果优先级比上次的高,则压栈.
                        if (Priority(OneChar) < Priority(ExpressionBuild[index]))
                        {
                            ExpressionStack.Push(OneChar);
                            break;
                        }
                        else
                        {
                            returnExpression.Append(MathChar.WhiteChar);
                            returnExpression.Append(OneChar);
                        }

                    }
                }
                //把新操作符入栈.
                ExpressionStack.Push(ExpressionBuild[index]);
                returnExpression.Append(MathChar.WhiteChar);
                #endregion
            }
            //基本优先级提升
            else if (ExpressionBuild[index] == MathChar.Left)
            {
                ExpressionStack.Push(MathChar.Left);
                returnExpression.Append(MathChar.WhiteChar);
            }
            //基本优先级下调
            else if (ExpressionBuild[index] == MathChar.Right)
            {
                //栈不为空时
                while (ExpressionStack.Count > 0)
                {
                    OneChar = (char)ExpressionStack.Pop();
                    if (OneChar != MathChar.Left)
                    {
                        returnExpression.Append(MathChar.WhiteChar);
                        //加入空格主要是为了防止不相干的数据相临产生解析错误.
                        returnExpression.Append(OneChar);
                        returnExpression.Append(MathChar.WhiteChar);
                    }
                    else
                    {
                        break;
                    }

                }
            }
            else
            {
                returnExpression.Append(ExpressionBuild[index]);
            }
        }
        while (ExpressionStack.Count > 0)//这是最后一个弹栈啦.
        {
            returnExpression.Append(MathChar.WhiteChar);
            returnExpression.Append(ExpressionStack.Pop());
        }
        #endregion
        returnExpression.Append(MathChar.WhiteChar);
        return FormatSpace(returnExpression.ToString());//在这里进行一次表达式格式化.这里就是后缀式了.
    }
    /// <summary>
    /// 算术逆波兰表达式计算.
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public string ComputeExpression(string MathExpression)
    {
        string AfterExpression = BuildingExpression(MathExpression);
        string Temp = string.Empty;
        Stack ExpressionStack = new Stack();
        char OneChar = MathChar.WhiteChar;
        StringBuilder Operand = new StringBuilder();
        double x, y;
        for (int i = 0; i < AfterExpression.Length; i++)
        {
            OneChar = AfterExpression[i];
            if (char.IsDigit(OneChar)
             || OneChar == MathChar.Spot)
            {
                //数据值收集.
                Operand.Append(OneChar);
            }
            else if (OneChar == MathChar.WhiteChar
                  && Operand.Length > 0)
            {
                #region 运算数转换
                try
                {
                    Temp = Operand.ToString();
                    //负数的转换一定要小心...它不被直接支持.
                    if (Temp.StartsWith(MathChar.Sub.ToString()))
                    {
                        //现在我的算法里这个分支可能永远不会被执行.
                        ExpressionStack.Push(-((double)Convert.ToDouble(Temp.Substring(1, Temp.Length - 1))));
                    }
                    else
                    {
                        ExpressionStack.Push(Convert.ToDouble(Temp));
                    }
                }
                catch
                {
                    return "发现异常数据值.";
                }
                Operand = new StringBuilder();
                #endregion
            }
            //运算符处理.双目运算处理.
            else if (OneChar == MathChar.Add
             || OneChar == MathChar.Sub
             || OneChar == MathChar.Mul
             || OneChar == MathChar.Div
             || OneChar == MathChar.Mold
             || OneChar == MathChar.Power)
            {
                #region 双目运算
                if (ExpressionStack.Count > 0)/*如果输入的表达式根本没有包含运算符.或是根本就是空串.这里的逻辑就有意义了.*/
                {
                    y = (double)ExpressionStack.Pop();
                }
                else
                {
                    ExpressionStack.Push(0);
                    break;
                }
                if (ExpressionStack.Count > 0)
                    x = (double)ExpressionStack.Pop();
                else
                {
                    ExpressionStack.Push(y);
                    break;
                }
                switch (OneChar)
                {
                    case '+':
                        ExpressionStack.Push(x + y);
                        break;
                    case '-':
                        ExpressionStack.Push(x - y);
                        break;
                    case '*':
                        ExpressionStack.Push(x * y);
                        break;
                    case '/':
                        ExpressionStack.Push(x / y);
                        break;
                    case '%':
                        ExpressionStack.Push(x % y);
                        break;
                    case '^':
                        //       if(x>0)
                        //       {我原本还想,如果被计算的数是负数,又要开真分数次方时如何处理的问题.后来我想还是算了吧.
                        ExpressionStack.Push(System.Math.Pow(x, y));
                        //       }
                        //       else
                        //       {
                        //        double t=y;
                        //        string ts="";
                        //        t=1/(2*t);
                        //        ts=t.ToString();
                        //        if(ts.ToUpper().LastIndexOf('E')>0)
                        //        {
                        //         ;
                        //        }
                        //       }
                        break;
                }
                #endregion
            }
            else if (OneChar == MathChar.Neg)//单目取反.)
            {
                ExpressionStack.Push(-((double)ExpressionStack.Pop()));
            }
        }
        if (ExpressionStack.Count > 1)
            return "运算没有完成.";
        if (ExpressionStack.Count == 0)
            return "结果丢失..";
        return ExpressionStack.Pop().ToString();
    }
    /// <summary>
    /// 计算表达式优先级别
    /// </summary>
    /// <param name="opr"></param>
    /// <returns></returns>
    private int Priority(char opr)
    {
        switch (opr)
        {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            case '%':
            case '^':
            case '!':
                return 3;
            default:
                return 0;
        }
    }
    /// <summary>
    /// 规范化逆波兰表达式. 
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    private string FormatSpace(string str)
    {
        StringBuilder returnValue = new StringBuilder();
        for (int index = 0; index < str.Length; index++)
        {
            if (!(str.Length > index + 1 && str[index] == ' ' && str[index + 1] == ' '))
                returnValue.Append(str[index]);
            else
                returnValue.Append(str[index]);
        }
        return returnValue.ToString();
    }

    /// <summary>
    /// 过滤数字和计算公式字符
    /// </summary>
    /// <param name="Expresssion"></param>
    /// <returns></returns>
    private string[] FilterNumberAndMathChar(string Expresssion)
    {

        string TempValue = Expresssion.Trim();

        if (TempValue.Contains(MathChar.Add.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Add, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Sub.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Sub, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Mul.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Mul, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Div.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Div, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Neg.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Neg, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Mold.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Mold, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Power.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Power, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Left.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Left, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Right.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Right, MathChar.WhiteChar);
        }

        if (TempValue.Contains(MathChar.Spot.ToString()))
        {
            TempValue = TempValue.Replace(MathChar.Spot, MathChar.WhiteChar);
        }

        for (int index = 0; index < 10; index++)
        {
            if (TempValue.Contains(index.ToString()))
            {
                TempValue = TempValue.Replace(index.ToString(), MathChar.WhiteChar.ToString());
            }
        }


        string[] result = TempValue.Trim().Split(new string[] { MathChar.WhiteChar.ToString() }, StringSplitOptions.RemoveEmptyEntries);

        return result;

    }

    #endregion

本文链接

【转载】Coolite的GridPanle导出Excel

2010-09-21T00:55:00Z

public void ToExcel(Coolite.Ext.Web.GridPanel gp, string fileName, DataTable dt, HttpResponse resp)
    {

        resp.Clear();
        resp.ContentEncoding = System.Text.Encoding.GetEncoding("UTF-8");
        resp.AppendHeader("Content-Disposition", "attachment;filename=" + fileName + ".xls");
        resp.ContentType = "application nd.ms-excel";

        string colHeaders = string.Empty;
        string ls_item = string.Empty;
        int i = 0;
        int cl = gp.ColumnModel.Columns.Count;
        string columns = string.Empty;

        //输出表头
        //取得数据表各列标题，各标题之间以t分割，最后一个列标题后加回车符 
        for (i = 0; i < cl; i++)
        {
            if (i == (cl - 1))//最后一列，加n
            {
                if (!gp.ColumnModel.Columns[i].Hidden)
                {
                    colHeaders += gp.ColumnModel.Columns[i].Header;
                    columns += gp.ColumnModel.Columns[i].DataIndex + ",";
                }
                colHeaders += "\n";
            }
            else
            {
                if (!gp.ColumnModel.Columns[i].Hidden && gp.ColumnModel.Columns[i].ColumnID != "update")
                {
                    colHeaders += gp.ColumnModel.Columns[i].Header + "\t";
                    columns += gp.ColumnModel.Columns[i].DataIndex + ",";
                }
            }
        }
        resp.Write(colHeaders);

        if (columns != string.Empty) columns = columns.Substring(0, columns.LastIndexOf(","));
        string[] columnall = columns.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

        cl = columnall.Length;

        //逐行处理数据   
        for (int j = 0; j < dt.Rows.Count; j++)
        {
            ls_item += (j + 1).ToString() + "\t";//No.列
            //当前行数据写入HTTP输出流，并且置空ls_item以便下行数据     
            for (i = 0; i < cl; i++)
            {
                if (i == (cl - 1))
                {
                    ls_item += EditString(dt.Rows[j][columnall[i].ToString()].ToString()) + "\n";
                }
                else
                {
                    ls_item += EditString(dt.Rows[j][columnall[i].ToString()].ToString()) + "\t";
                }
            }
            resp.Write(ls_item);
            ls_item = string.Empty;
        }
        Response.Flush();
        resp.End();
    }

    private string EditString(string TextString)//处理字符问题
    {
        if (TextString.IndexOf('\r') != -1)
        {
            TextString = TextString.Replace('\r', ' ');
        }
        if (TextString.IndexOf('\n') != -1)
        {
            TextString = TextString.Replace('\n', ' ');
        }
        if (TextString.IndexOf('\t') != -1)
        {
            TextString = TextString.Replace('\t', ' ');
        }
        if (TextString.IndexOf("'") != -1)
        {
            TextString = TextString.Replace("'", "");
        }

        if (TextString.IndexOf(@"""") != -1)
        {
            TextString = TextString.Replace(@"""", "");
        }
        return TextString;
    }

本文链接

【原创】Coolite异步上传图片

2010-09-21T00:49:00Z

Coolite.Ext.Web.FileUploadField uploadControl = ((Coolite.Ext.Web.FileUploadField)this.tbMain.FindControl(ControlsID.imageUpload));
        //图片路径
        string strFileName = uploadControl.FileName;

        DateTime Now = DateTime.Now;

        string FileName = "Parts" + Now.ToString("yyyyMMddHHmmssffff");

        string FilePath = "~/UploadFile/ConstructImage/" + FileName + System.IO.Path.GetExtension(strFileName);
        
        try
        {
            System.Web.HttpFileCollection _files = System.Web.HttpContext.Current.Request.Files;

            for (System.Int32 _iFile = 0; _iFile < _files.Count; _iFile++)
            {
                System.Web.HttpPostedFile _postedFile = _files[_iFile];

                if (!string.IsNullOrEmpty(FilePath))
                {
                    if (System.IO.File.Exists(System.Web.HttpContext.Current.Request.MapPath(FilePath)))
                    {
                        File.Delete(System.Web.HttpContext.Current.Request.MapPath(FilePath));
                    }
                    _postedFile.SaveAs(System.Web.HttpContext.Current.Request.MapPath(FilePath));
                }
            }
        }
        catch
        {

            Coolite.Ext.Web.MessageBox.Config configError = new Coolite.Ext.Web.MessageBox.Config();
            configError.Title = "上传状态";
            configError.Message = "文件上传有错误,请检查!";
            configError.Buttons = Coolite.Ext.Web.MessageBox.Button.OK;
            configError.Icon = Coolite.Ext.Web.MessageBox.Icon.ERROR;
            Coolite.Ext.Web.Ext.Msg.Show(configError);
            return;
        }


        Coolite.Ext.Web.Image uploadImage = ((Coolite.Ext.Web.Image)this.tbMain.FindControl(ControlsID.uploadImage));
        uploadImage.ImageUrl = FilePath;

        this.ImageUrl = @"http://" + Request.Url.Host + ":" + Request.Url.Port.ToString() + Request.ApplicationPath + FilePath.Replace("~", string.Empty);

        Session.Add("imageUrl", ImageUrl.ToString());

        Coolite.Ext.Web.MessageBox.Config config = new Coolite.Ext.Web.MessageBox.Config();
        config.Title = "上传状态";
        config.Message = "上传成功";
        config.Buttons = Coolite.Ext.Web.MessageBox.Button.OK;
        config.Icon = Coolite.Ext.Web.MessageBox.Icon.INFO;

        Coolite.Ext.Web.Ext.Msg.Show(config);

本文链接

博客园_选择大于努力,选择前请三思,选择后请努力.

[算法]遍历文件系统

Wordpress template workflow map

浅谈Python web框架

五种开源协议的比较(BSD,Apache,GPL,LGPL,MIT) – 整理

【转载】Connection strings for SQLite

SQLite.NET Type: .NET Framework Class LibraryUsage: System.Data.SQLite.SQLiteConnection Manufacturer: SQLite

Finisar.SQLite ADO.NET Data Provider Type: .NET Framework Class LibraryUsage: Manufacturer: Finisar.SQLite Standard

SQLite3 ODBC Driver Type: .NET Framework Class LibraryUsage: Manufacturer: SQLite

.NET Framework Data Provider for ODBC Type: .NET Framework Wrapper Class LibraryUsage: System.Data.Odbc.OdbcConnection Manufacturer: Microsoft Bridging to SQLite3 ODBC Driver

【原创】无法解决 equal to 运算中 "Chinese_PRC_CI_AS" 和 "SQL_Latin1_General_CP1_CI_AS" 之间的排序规则冲突。

【原创】近一年来面试中遇到的算法问题

【原创】计算文本表达式

【转载】Coolite的GridPanle导出Excel

【原创】Coolite异步上传图片

SQLite.NET

Type: .NET Framework Class Library
Usage: System.Data.SQLite.SQLiteConnection

Manufacturer: SQLite

Finisar.SQLite ADO.NET Data Provider

Type: .NET Framework Class Library
Usage:

Manufacturer: Finisar.SQLite

Standard

SQLite3 ODBC Driver

Type: .NET Framework Class Library
Usage:

Manufacturer: SQLite

.NET Framework Data Provider for ODBC

Type: .NET Framework Wrapper Class Library
Usage: System.Data.Odbc.OdbcConnection

Manufacturer: Microsoft

Bridging to SQLite3 ODBC Driver