博客园_Kudy's Tech Blog

【jUploader】1.0版基于jQuery文件无刷新上传插件下载及介绍

2012-03-31T08:38:00Z

【jUploader】介绍

花了1天多写了个上传插件，功能比较简单，但是很实用。这个只是单文件上传，以后有时间再写个多文件ajax上传插件，而且还会基于这个插件写个头像剪裁的插件，喜欢它的朋友别忘了点一下推荐支持一下下，３Ｑ

【jUploader】下载

Download: jquery.jUploader-1.0.js 10.10kb

Download: jquery.jUploader-1.0.min.js 4.25kb

Download: jquery.jUploader-1.0-demo.rar 1.83mb

Supported in IE6+, FF3.6+, Chrome6+, Safari4+. More info go to www.kudystudio.com

大家也可以去看看在线的实例：http://www.kudystudio.com/jUploader/index.html

全局设置:

下面的为下面的实例写的设置。

实例（一）:

这个实例是放个预览图片，上传完后设置上传后的地址。

实例（二）:

这个实例是放个预览图片和loading图片，上传过程显示loading图片，上传完后给预览图片设置上传后的地址交显示。

实例（三）:

这个实例是放个预览图片，在上传按钮旁边放个span来提示上传信息。

实例（四）:

这个实例是放个预览图片，用jBox来显示上传提示。

参数说明：

下面是插件的可用参数说明。

本文链接

怎么设计个性化、灵活、实时更新的配置管理器？讲讲实现思路

2011-12-28T13:31:00Z

有些天没写文章了，今晚给大家分享一下我对配置管理的实现思路。这个实现主要适合中小应用程序（Web或Winform），如果你的网站需要负载均衡，那这个方案就不适用了，这时建议配置保存在数据库或分布式缓存里，如果你有更好的想法，欢迎指点。这个配置设计在09年开发SNS网站时就完成了，那时看了Discuz!的.net开源版本，觉得它的配置管理不够灵活才想到用泛型来实现自己的配置管理组件。今天要讲的实现比09初版本多了两点功能：配置路径的迟加载和自定义配置序列化。其中路径迟加载是在看到汤姆大叔一个配置管理文章想到的，其实这个小功能不需要.Net4.0的Lazy就可以轻松实现，因为，需求太简单了。

这里所说的个性化、灵活、实时更新的定义？

个性化，是指你可以随意定义自己想要的配置结构、保存格式、存放位置等等。

灵活，是指可以方便的对配置进行读、写操作，并可以很容易实现任意多个配置管理器。

实时更新，是指在配置发生改变时可以实时的更新，且不会重启Web应用程序。

IFileConfigManager<T>

下面开始讲解设计。既然是配置管理器，那还是先定义好接口吧，请看IFileConfigManager<T>：

/// <summary>
/// Interface containing all properties and methods to be implemented
/// by file configuration manager.
/// </summary>
/// <typeparam name="T">The type of config entity.</typeparam>
public interface IFileConfigManager<T> : IDisposable
where T : class, new()
{
/// <summary>
/// Gets the path of the config file.
/// </summary>
string Path { get; }

/// <summary>
/// Gets the encoding to read or write the config file.
/// </summary>
Encoding Encoding { get; }

/// <summary>
/// Gets the serializer of the config manager for loading or saving the config file.
/// </summary>
FileConfigSerializer<T> Serializer { get; }

/// <summary>
/// Gets the current config entity.
/// </summary>
/// <returns></returns>
T GetConfig();

/// <summary>
/// Saves the current config entity to file.
/// </summary>
void SaveConfig();

/// <summary>
/// Saves a specified config entity to file.
/// </summary>
/// <param name="config"></param>
void SaveConfig(T config);

/// <summary>
/// Backups the current config entity to a specified path.
/// </summary>
/// <param name="backupPath"></param>
void BackupConfig(string backupPath);

/// <summary>
/// Restores config entity from a specified path and saves to the current path.
/// </summary>
/// <param name="restorePath"></param>
void RestoreConfig(string restorePath);
}

T参数当然就是定义的配置类型了，而且必须是引用类型，有无参数构造函数。Path是配置文件的完整路径，Encoding是读取和保存配置时用的编码，Serializer是处理配置序列化和反序列化的具体实现，GetConfig()是获取当前配置，SaveConfig()是保存当前配置，SaveConfig(T config)是保存指定的配置，BackupConfig(string backupPath)备份配置到指定路径，RestoreConfig(string restorePath)从指定路径还原配置。

FileConfigSerializer<T>

接口IFileConfigManager<T>中定义的Serializer是用于支持自定义配置序列化功能的，下面看看FileConfigSerializer<T>的实现：

public abstract class FileConfigSerializer<T>
where T : class, new()
{
#region Fields

// XML格式
public static readonly FileConfigSerializer<T> Xml = new XmlFileConfigSerializer();

// 二进制格式
public static readonly FileConfigSerializer<T> Binary = new BinaryFileConfigSerializer();

#endregion

#region Methods

// 从配置文件反序列化，使用指定的编码
public abstract T DeserializeFromFile(string path, Encoding encoding);

// 序列化到配置文件，使用指定的编码
public abstract void SerializeToFile(T config, string path, Encoding encoding);

#endregion

#region XmlFileConfigSerializer

// 实现默认的Xml序列化类
private sealed class XmlFileConfigSerializer : FileConfigSerializer<T>
{
public override T DeserializeFromFile(string path, Encoding encoding)
{
return SerializationUtil.DeserializeFromXmlFile<T>(path, encoding);
}

public override void SerializeToFile(T config, string path, Encoding encoding)
{
SerializationUtil.SerializeToXmlFile(config, path, encoding);
}
}

#endregion

#region BinaryFileConfigSerializer

// 实现默认的二进制序列化类
private sealed class BinaryFileConfigSerializer : FileConfigSerializer<T>
{
public override T DeserializeFromFile(string path, Encoding encoding)
{
return SerializationUtil.DeserializeFromBinaryFile<T>(path, encoding);
}

public override void SerializeToFile(T config, string path, Encoding encoding)
{
SerializationUtil.SerializeToBinaryFile(config, path, encoding);
}
}

#endregion
}

FileConfigSerializer<T>定义为抽象类，是为了方便默认的使用和扩展，里面使用的SerializationUtil类，是本人为了方便写的一个简单的序列化助手类，相信大家对对象的序列化操作不会陌生了，无非使用了System.Xml.Serialization.XmlSerializer、System.Runtime.Serialization.Formatters.Binary.BinaryFormatter、System.Runtime.Serialization.Json.DataContractJsonSerializer和System.Runtime.Serialization.NetDataContractSerializer来处理。如果不想用它们，你还可以实现FileConfigSerializer<T>进行完全的自己定义配置的加载与保存方式。对于json序列化推荐大家使用http://www.codeplex.com/json/　。

序列化用到的四个函数实现如下：

public static void SerializeToXmlFile(object obj, string path, Encoding encoding)
{
using (var sw = new StreamWriter(path, false, encoding))
{
new XmlSerializer(obj.GetType()).Serialize(sw, obj);
}
}

public static object DeserializeFromXmlFile(string path, Type type, Encoding encoding)
{
object obj = null;

using (var sr = new StreamReader(path, encoding))
{
using (var xtr = new XmlTextReader(sr))
{
xtr.Normalization = false;
obj = new XmlSerializer(type).Deserialize(xtr);
}
}

return obj;
}

public static void SerializeToBinaryFile(object obj, string path, Encoding encoding)
{
byte[] bytes = null;
using (var ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, obj);
ms.Position = 0;
bytes = new Byte[ms.Length];
ms.Read(bytes, 0, bytes.Length);

using (var fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
{
using (var bw = new BinaryWriter(fs, encoding))
{
bw.Write(bytes);
}
}
}
}

public static object DeserializeFromBinaryFile(string path, Encoding encoding)
{
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
using (var br = new BinaryReader(fs, encoding))
{
byte[] bytes = new byte[fs.Length];
br.Read(bytes, 0, (int)fs.Length);

using (var ms = new MemoryStream())
{
ms.Write(bytes, 0, bytes.Length);
ms.Position = 0;
return new BinaryFormatter().Deserialize(ms);
}
}
}
}

实时更新

好了，大家已经知道了接口的定义了，下面来讲讲实时更新配置功能有哪些方法可以实现。我们知道，如果利用Web.config来配置的话，第一：如果配置内容多而杂，那会很乱；第二：如果手动修改配置，会导致Web重启（而我们并不希望它重启），所以，如果要解决上面两点问题，我们就要思考点什么了。上面我提到了Discuz!论坛的.net开源版本里配置管理，它是使用Timer来定时查检配置是否有修改，如果有修改就重新加载的，恩，这是一个可行的方案。还有其它方法吗？必须是有的，只要你肯去思考，下面列出本人想到的几个比较容易想到的方案：

方法１：使用Timer（.net库里有三个timer，请自行选择），每隔一秒就查检一下配置文件修改时间，如果文件被修改了，正更新最后修改时间并重新加载配置内容；

方法２：使用System.IO.FileSystemWatcher，可以实时监控配置文件，一发生改变即重新加载配置内容；

方法３：使用System.Web.Caching.Cache，加上缓存依赖，文件更改后缓存会失效，同样可以实时重新加载配置内容。

这三种方法中，方法３是本人比较推荐的，因为它的开销最小，而且可以实时更新配置，实现起来也是最简单的。对于新手可能看到这还不知道实现，下面再贴出本人实现上面接口的四个类，一个是默认管理器类，没有实时更新的功能，其它三个就是实现上面三种方法的管理器类了。

internal class DefaultFileConfigManager<T> : DisposableObject, IFileConfigManager<T>
where T : class, new()
{
#region Fields

private string path = null;
private Func<string> pathCreator = null;

#endregion

#region Constructors

public DefaultFileConfigManager(Func<string> pathCreator, FileConfigSerializer<T> serializer, Encoding encoding)
{
pathCreator.ThrowsIfNull("pathCreator");
serializer.ThrowsIfNull("serializer");

this.pathCreator = pathCreator;
this.Encoding = encoding;
this.Serializer = serializer;
this.SyncRoot = new object();
this.Config = null;
}

#endregion

#region Properties

public string Path
{
get
{
if (this.path == null)
{
string path = this.pathCreator();

path.ThrowsIfNull("The path returned form pathCreator is null.");

this.path = path;
this.LazyInitialize();
}

return this.path;
}
}

public Encoding Encoding
{
get;
protected set;
}

public FileConfigSerializer<T> Serializer
{
get;
protected set;
}

protected object SyncRoot
{
get;
set;
}

protected virtual T Config
{
get;
set;
}

#endregion

#region Methods

public virtual T GetConfig()
{
if (this.Config == null)
{
lock (this.SyncRoot)
{
if (this.Config == null)
{
FileInfo file = new FileInfo(this.Path);
if (!file.Exists)
{
// make sure the existence of the config directory
if (!file.Directory.Exists)
{
file.Directory.Create();
}
// save the default config to file
this.Config = new T();
this.Serializer.SerializeToFile(this.Config, this.Path, this.Encoding);
}
else
{
// else, loads from the specified path
this.Config = this.Serializer.DeserializeFromFile(this.Path, this.Encoding);
}
}
}
}

return this.Config;
}

public void SaveConfig()
{
this.SaveConfig(this.GetConfig());
}

public virtual void SaveConfig(T config)
{
config.ThrowsIfNull("config");

lock (this.SyncRoot)
{
FileInfo file = new FileInfo(this.Path);

// make sure the existence of the config directory
if (!file.Directory.Exists)
{
file.Directory.Create();
}

this.Config = config;
this.Serializer.SerializeToFile(this.Config, this.Path, this.Encoding);
}
}

public void BackupConfig(string backupPath)
{
backupPath.ThrowsIfNull("backupPath");

T config = this.GetConfig();
this.Serializer.SerializeToFile(config, backupPath, this.Encoding);
}

public void RestoreConfig(string restorePath)
{
restorePath.ThrowsIfNull("restorePath");

T config = this.Serializer.DeserializeFromFile(restorePath, this.Encoding);
this.SaveConfig(config);
}

// this method is provided to subclasses to initialize their data
protected virtual void LazyInitialize()
{
}

#endregion
}

internal sealed class FileConfigManagerWithTimer<T> : DefaultFileConfigManager<T>
where T : class, new()
{
private Timer timer = null;
private DateTime lastWriteTime = DateTime.MinValue; // a flag to notify us of the change config

public FileConfigManagerWithTimer(Func<string> pathCreator, FileConfigSerializer<T> serializer, Encoding encoding)
: base(pathCreator, serializer, encoding)
{
}

protected override void LazyInitialize()
{
base.LazyInitialize();

// initializes the timer, with it's interval of 1000 milliseconds
this.timer = new Timer(1000);
this.timer.Enabled = true;
this.timer.AutoReset = true;
this.timer.Elapsed += new ElapsedEventHandler(Timer_Elapsed);
this.timer.Start();
}

protected override void Dispose(bool disposing)
{
if (disposing)
{
// disposes the timer
this.timer.Dispose();
this.timer = null;
}
}

private void Timer_Elapsed(object sender, ElapsedEventArgs e)
{
if (!File.Exists(this.Path))
{
// the file has been deleted
return;
}

var tempWriteTime = File.GetLastWriteTime(this.Path);

// if equals to the initial value, update it and return
if (this.lastWriteTime == DateTime.MinValue)
{
this.lastWriteTime = tempWriteTime;
return;
}

// if no equals to new write time, update it and reload config
if (this.lastWriteTime != tempWriteTime)
{
this.lastWriteTime = tempWriteTime;

lock (this.SyncRoot)
{
this.Config = this.Serializer.DeserializeFromFile(this.Path, this.Encoding);
}
}
}
}

internal sealed class FileConfigManagerWithFileWatcher<T> : DefaultFileConfigManager<T>
where T : class, new()
{
private FileWatcher watcher = null;

public FileConfigManagerWithFileWatcher(Func<string> pathCreator, FileConfigSerializer<T> serializer, Encoding encoding)
: base(pathCreator, serializer, encoding)
{
}

protected override void LazyInitialize()
{
base.LazyInitialize();

// when the path is created, the watcher should be initialize at the same time
watcher = new FileWatcher(this.Path, FileChanged);
// just start watching the file
watcher.StartWatching();
}

protected override void Dispose(bool disposing)
{
if (disposing)
{
// disposes the watcher
this.watcher.Dispose();
this.watcher = null;
}

base.Dispose(disposing);
}

private void FileChanged(object sender, FileSystemEventArgs args)
{
lock (this.SyncRoot)
{
this.watcher.StopWatching();
try
{
// note: here making the cuurent thread sleeping a litle while to avoid exception throwed by watcher
Thread.Sleep(10);
// reload the config from file
this.Config = this.Serializer.DeserializeFromFile(this.Path, this.Encoding);
}
catch (Exception)
{
// ignore it
}
finally
{
this.watcher.StartWatching();
}
}
}
}

internal sealed class FileConfigManagerWithCacheDependency<T> : DefaultFileConfigManager<T>
where T : class, new()
{
const string KeyPrefix = "FileConfig:";

public FileConfigManagerWithCacheDependency(Func<string> pathCreator, FileConfigSerializer<T> serializer, Encoding encoding)
: base(pathCreator, serializer, encoding)
{
}

protected override T Config
{
get
{
return HttpRuntime.Cache[KeyPrefix + this.Path] as T;
}
set
{
// if not null, update the cache value
if (value != null)
{
HttpRuntime.Cache.Insert(KeyPrefix + this.Path, value, new CacheDependency(this.Path), DateTime.Now.AddYears(1), Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
}
}
}
}

这里值得讲一下的是，默认管理器DefaultFileConfigManager<T>的Func<string> pathCreator参数，这个是为了实现配置文件的迟加载的，有了它，就不需要在静态构造函数或Global.asax里初始化管理器实例了，另外为了方便使用，本人还另写了个类为返回创建的管理器实例，这个就没什么好说的了，这也就是为什么上面几个类的访问范围是程序集内部的。到此，整个实现的思路和大部分的代码实现都讲完了，希望对大家有所帮助：）更多请关注： KudyStudio文章目录

有兴趣的朋友还可以下载这个例子看看各种方法下的效果： FileConfigWeb.rar

本文链接

又失恋了。程序员，你的爱情在哪里？

2011-12-20T18:24:00Z

在这个寂寞的夜晚，我们的心在繁华都市孤独游荡。爱情是如此美丽令人向往，却喜欢拿枯燥无聊的程序员开玩笑。青春转瞬即逝，上帝啊，求求你告诉我：我们的爱情什么时候会到来？生活又是如此公平，生活在问我们：你付出了什么？体会了什么？思考了什么？ ——《电脑报》资深编辑黄旭

那一天
我不得已上路
为不安分的心
为自尊的生存
为自我的证明
路上的辛酸已融进我的眼睛
心灵的困境已化作我的坚定

在路上用我心灵的呼声
在路上只为伴着我的人
在路上是我生命的远行
在路上只为温暖我的人
温暖我的人

上面是《在路上》的歌词，又一次选择了创业，每次听《在路上》都有点小冲动，因为这次更多的动力是为了我爱的人，才开始了三个月时间，今晚她却和我说要和前男友下个月结婚了...令我纠结的原因不好直接说，下面这段代码来描述了我的心情，我都不敢运行：

补充一点吧，其实还是我不够细心，只顾忙自己的工作，程序员就这样子了，女人的心思我还真不会猜，我和她的关系还是有点复杂，这里不说出来了，那baby可能成为我心中永远的迷，不管她选择的是对还是错，我还是祝福她。有女友的同志们，有时间还是多点了解一下女人吧，这样才好维持两人的爱情。

class Program
{
static void Main(string[] args)
{
Random rd = new Random();

string[] fathers = new string[2]{"kudy", "other"};

Princess.Instance.Baby = new Baby() { Father = fathers[rd.Next(0, 2)] };

Console.WriteLine(GetMood(Princess.Instance.Baby));

Console.ReadKey();
}

static Mood GetMood(Baby baby)
{
switch (baby.Father)
{
case "other":
return Mood.Sad;
case "kudy":
return Mood.Sadder;
default:
throw new InvalidOperationException();
}
}
}

public enum Mood
{
Sad,
Sadder
}

public class Baby
{
public string Father { get; set; }
}

public sealed class Princess
{
public static readonly Princess Instance = new Princess();

private Princess() { }

public Baby Baby { get; set; }
}

明天找个MM唱K去，发泄一下，生活不容易呀

本文链接

关键字过虑实现的思路及Aho–Corasick高效字符串匹配算法应用

2011-12-20T08:22:00Z

在本人昨晚发的强大灵活的脏字过虑：1万字文章过虑1万关键词用时只要1毫秒（包括扩展的高亮功能）　文章中，只是介绍过虑的功能和性能，这个文章主要讲一下实现的思路，另外给大家看一下Aho–Corasick算法的C#实现。

既然是要过虑，那就要先查找，如果是直接的一个字符一个字符的匹配，那是很耗时的，因为时间花在不需要匹配的工作，有不少人会用正则去解决过虑，我09年的时候也这样，但后来发现大量关键词下性能确实极低下，所以才会另想它法。上一文中的过虑主要思想是这样的，开始会先用一个字典保存保存所有关键词，同一个字母开头的会另放在一个子字典里，这样一来，扫描的范围就大大的缩小了，然后再考虑到脏字一般是2个字的占了很大的比例，所以再在第二个字母做判断，如果不存在就不需要再扫描下去了，至于可跳字符，就是在直接需要扫描的时候一一判断的，没技巧可讲，另外一点值得注意的是，大小写敏感的情况下，在判断时需要转换大小写，大量关键词影响不小，所以就初始化时再保存了一分小写的，所以在扫描的时候就不需要转换了，所以是否大小写的两个情况性能上不会有什么变化，基本的思路就这样了。如果说，你想要很准确的过虑，那就要用到分词了（判断可以人性化），我的方法只能处理比较简单匹配与过虑。实现过程并没有使用Aho–Corasick算法。

在查找资料的时候还了解到Aho–Corasick算法，它可以帮助我们快速的找出多个子字符串。可以到这里了解算法：http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm

５点有约会，先直接上实现代码了（从一老外的例子里小改的），本人测试过我上面的方法和使用Aho–Corasick过虑用的时候差不了多少：

/// <summary>
/// 表示一个查找结果
/// </summary>
public struct KeywordSearchResult
{
private int index;
private string keyword;
public static readonly KeywordSearchResult Empty = new KeywordSearchResult(-1, string.Empty);

public KeywordSearchResult(int index, string keyword)
{
this.index = index;
this.keyword = keyword;
}

/// <summary>
/// 位置
/// </summary>
public int Index
{
get { return index; }
}

/// <summary>
/// 关键词
/// </summary>
public string Keyword
{
get { return keyword; }
}
}

/// <summary>
/// Aho-Corasick算法实现
/// </summary>
public class KeywordSearch
{
/// <summary>
/// 构造节点
/// </summary>
private class Node
{
private Dictionary<char, Node> transDict;

public Node(char c, Node parent)
{
this.Char = c;
this.Parent = parent;
this.Transitions = new List<Node>();
this.Results = new List<string>();

this.transDict = new Dictionary<char, Node>();
}

public char Char
{
get;
private set;
}

public Node Parent
{
get;
private set;
}

public Node Failure
{
get;
set;
}

public List<Node> Transitions
{
get;
private set;
}

public List<string> Results
{
get;
private set;
}

public void AddResult(string result)
{
if (!Results.Contains(result))
{
Results.Add(result);
}
}

public void AddTransition(Node node)
{
this.transDict.Add(node.Char, node);
this.Transitions = this.transDict.Values.ToList();
}

public Node GetTransition(char c)
{
Node node;
if (this.transDict.TryGetValue(c, out node))
{
return node;
}

return null;
}

public bool ContainsTransition(char c)
{
return GetTransition(c) != null;
}
}

private Node root; // 根节点
private string[] keywords; // 所有关键词

public KeywordSearch(IEnumerable<string> keywords)
{
this.keywords = keywords.ToArray();
this.Initialize();
}

/// <summary>
/// 根据关键词来初始化所有节点
/// </summary>
private void Initialize()
{
this.root = new Node(' ', null);

// 添加模式
foreach (string k in this.keywords)
{
Node n = this.root;
foreach (char c in k)
{
Node temp = null;
foreach (Node tnode in n.Transitions)
{
if (tnode.Char == c)
{
temp = tnode; break;
}
}

if (temp == null)
{
temp = new Node(c, n);
n.AddTransition(temp);
}
n = temp;
}
n.AddResult(k);
}

// 第一层失败指向根节点
List<Node> nodes = new List<Node>();
foreach (Node node in this.root.Transitions)
{
// 失败指向root
node.Failure = this.root;
foreach (Node trans in node.Transitions)
{
nodes.Add(trans);
}
}
// 其它节点 BFS
while (nodes.Count != 0)
{
List<Node> newNodes = new List<Node>();
foreach (Node nd in nodes)
{
Node r = nd.Parent.Failure;
char c = nd.Char;

while (r != null && !r.ContainsTransition(c))
{
r = r.Failure;
}

if (r == null)
{
// 失败指向root
nd.Failure = this.root;
}
else
{
nd.Failure = r.GetTransition(c);
foreach (string result in nd.Failure.Results)
{
nd.AddResult(result);
}
}

foreach (Node child in nd.Transitions)
{
newNodes.Add(child);
}
}
nodes = newNodes;
}
// 根节点的失败指向自己
this.root.Failure = this.root;
}

/// <summary>
/// 找出所有出现过的关键词
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public List<KeywordSearchResult> FindAllKeywords(string text)
{
List<KeywordSearchResult> list = new List<KeywordSearchResult>();

Node current = this.root;
for (int index = 0; index < text.Length; ++index)
{
Node trans;
do
{
trans = current.GetTransition(text[index]);

if (current == this.root)
break;

if (trans == null)
{
current = current.Failure;
}
} while (trans == null);

if (trans != null)
{
current = trans;
}

foreach (string s in current.Results)
{
list.Add(new KeywordSearchResult(index - s.Length + 1, s));
}
}

return list;
}

/// <summary>
/// 简单地过虑关键词
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public string FilterKeywords(string text)
{
StringBuilder sb = new StringBuilder();

Node current = this.root;
for (int index = 0; index < text.Length; index++)
{
Node trans;
do
{
trans = current.GetTransition(text[index]);

if (current == this.root)
break;

if (trans == null)
{
current = current.Failure;
}

} while (trans == null);

if (trans != null)
{
current = trans;
}

// 处理字符
if (current.Results.Count > 0)
{
string first = current.Results[0];
sb.Remove(sb.Length - first.Length + 1, first.Length -1);// 把匹配到的替换为**
sb.Append(new string('*', current.Results[0].Length));

}
else
{
sb.Append(text[index]);
}
}

return sb.ToString();
}
}

测试结果：

下载源码：http://files.cnblogs.com/kudy/KeywordSearch.rar

本文链接

强大灵活的脏字过虑：1万字文章过虑1万关键词用时只要1毫秒

2011-12-19T13:12:00Z

这几天刚整理完Kudy.Net项目中关键词过虑的功能。关键词过虑在网站开发中也算是比较常见的需求了，特别是在SNS社区网站。在网上找的相关文章都达不到我的要求，所以就自己根据过虑的特点专门写了个KeywordFilter，可能满足基本的过虑要求，性能也不错。它有如下特点：

一、允许你自定义匹配到关键词时返回的结果，例如匹配到“日你”，你可以在原文中显示例如：“”、“**”、“[已过虑]”...

二、允许你按关键词或者关键词的使用频率的排序的优先顺序进行过虑。

三、允许大小写是否敏感（性能上几乎不变），可设置关键词中可跳过的字符，例如设置可跳字符为“▇☆”，关键词里有“我爱你”，那么“我▇爱☆☆你”也会被成功过虑。

备注：如果设置了可跳字符，只会过虑有关键词出现的地方，例如上面“▇我▇爱☆☆你▇”过虑后只有“▇▇”。（哈哈，发现博客园的过虑并没有这功能）

既然是简单的处理过虑，里面当然没有做分词的处理，所以有些句子可能会被误报，只要设置重要的敏感禁用词即可。

实现思路：关键字过虑实现的思路及Aho–Corasick高效字符串匹配算法应用（附算法C#实现和测试）

另在一文中看到的过虑效率也不错，请到这里看http://www.cnblogs.com/yeerh/archive/2011/10/20/2219035.html，测试了它的速度是本人的约1.5倍，但是它并没有不区分大小写、可跳字符、关键词排序和多样化自定义关键词替换的功能，我更关心的是功能上的实用和灵活性。

更多请关注： KudyStudio文章目录

功能实现的相关成员有：Keyword、KeywordOrder、KeywordFormatter、KeywordFilterResult、KeywordFilter、HighlightFormatter、Highlighter。

１.Keyword类，主要有两个属性，Text和Frequency，分别表示关键词文本与它的使用频率（这个属性是可选的），如果从文本中转换为关键词列表，那文本格式是这样的：

Keyword1

Keyword2

或

Keyword1｜Frequency1

Keyword2｜Frequency2

[Serializable]
public sealed class Keyword
{
public Keyword(string text);
public Keyword(string text, int frequency);

public static implicit operator string(Keyword keyword);
public static implicit operator Keyword(string keyword);

public string Text { get; }
public int Frequency { get; set; }

public override bool Equals(object obj);
public override int GetHashCode();
public override string ToString();
}

２.KeywordOrder枚举，表示过虑时匹配的顺序，允许你按文本或使用频率排序，定义如下：

[Serializable]
public enum KeywordOrder
{
None = 0,
Ascending = 1,
Descending = 2,
ByFrequencyAscending = 3,
ByFrequencyDescending = 4,
}

３.KeywordFormatter类，这个是抽象类，它的作用就是在匹配到关键词时怎么格式化关键词并返回，里面默认实现了常量和重复字符的Formatter，如果还需要特殊的格式化需求，只要继承KeywordFormatter并实现Format(string keyword)方法即可，下面提到的HighlightFormatter就是其中一个例子。

public abstract class KeywordFormatter
{
public static readonly KeywordFormatter ToEmpty;
public static readonly KeywordFormatter ToIterantStar;

public static KeywordFormatter CreateConstFormatter(char replacement);
public static KeywordFormatter CreateConstFormatter(string replacement);
public static KeywordFormatter CreateIterantCharFormatter(char replacement);

public abstract string Format(string keyword);
}

４.KeywordFilterResult类，它表示过虑结果，包括过虑后的字符串和被过虑的关键词列表，定义如下：

public sealed class KeywordFilterResult
{
public KeywordFilterResult(string result, IEnumerable<Keyword> keywords);

public string Result { get; }
public List<Keyword> Keywords { get; }
}

５.KeywordFilter类，这个类是重点，它是实现过虑的核心，其它类只是功能需求上的辅助成员。要注意的是，它的初始化是需要一定的开销的（关键词量大的时候），所以对于大量的关键词，建议不要使用它的静态方法来进行过虑，而是先初始化实例，再重复的调用实例的方法来过虑。里面还有个方法ContainsAny让你快速判断里面是否包括有关键词。

public sealed class KeywordFilter
{
public KeywordFilter(IEnumerable<Keyword> keywords);
public KeywordFilter(IEnumerable<string> keywords);
public KeywordFilter(IEnumerable<Keyword> keywords, IEnumerable<char> skipChars);
public KeywordFilter(IEnumerable<string> keywords, IEnumerable<char> skipChars);

public ReadOnlyCollection<Keyword> Keywords { get; }
public ReadOnlyCollection<char> SkipChars { get; }

public bool ContainsAny(string original);
public bool ContainsAny(string original, bool ignoreCase);
public bool ContainsAny(string original, KeywordOrder order);
public bool ContainsAny(string original, KeywordOrder order, bool ignoreCase);

public KeywordFilterResult Filter(string original);
public KeywordFilterResult Filter(string original, KeywordFormatter formatter);
public KeywordFilterResult Filter(string original, KeywordFormatter formatter, bool ignoreCase);
public KeywordFilterResult Filter(string original, KeywordFormatter formatter, KeywordOrder order);
public KeywordFilterResult Filter(string original, KeywordFormatter formatter, KeywordOrder order, bool ignoreCase);

public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords);
public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords, KeywordFormatter formatter);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords, KeywordFormatter formatter);
public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords, KeywordFormatter formatter, bool ignoreCase);
public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords, KeywordFormatter formatter, KeywordOrder order);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords, KeywordFormatter formatter, bool ignoreCase);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords, KeywordFormatter formatter, KeywordOrder order);
public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords, KeywordFormatter formatter, KeywordOrder order, bool ignoreCase);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords, KeywordFormatter formatter, KeywordOrder order, bool ignoreCase);
public static KeywordFilterResult Filter(string original, IEnumerable<Keyword> keywords, IEnumerable<char> skipChars, KeywordFormatter formatter, KeywordOrder order, bool ignoreCase);
public static KeywordFilterResult Filter(string original, IEnumerable<string> keywords, IEnumerable<char> skipChars, KeywordFormatter formatter, KeywordOrder order, bool ignoreCase);

public static List<Keyword> LoadKeywords(string filePath);
public static List<Keyword> LoadKeywords(string filePath, Encoding encoding);
public static List<Keyword> ParseKeywords(string keywordsText);
public static void SaveKeywords(IEnumerable<Keyword> keywords, string filePath);
public static void SaveKeywords(IEnumerable<string> keywords, string filePath);
public static void SaveKeywords(IEnumerable<Keyword> keywords, string filePath, Encoding encoding);
public static void SaveKeywords(IEnumerable<string> keywords, string filePath, Encoding encoding);
}

到此，过虑功能成员介绍完了，下面还有两个成员是在KeywordFilter基础上实现的高亮功能HighlightFormatter和Highlighter。

public sealed class HighlightFormatter : KeywordFormatter
{
public static readonly HighlightFormatter Html;

public HighlightFormatter(string prefix, string postfix);

public string Postfix { get; }
public string Prefix { get; }

public static KeywordFormatter Create(string prefix, string postfix);

public override string Format(string keyword);
}

public static class Highlighter
{
public static string Highlight(string original, IEnumerable<Keyword> keywords, HighlightFormatter formatter);
public static string Highlight(string original, IEnumerable<string> keywords, HighlightFormatter formatter);
public static string Highlight(string original, IEnumerable<Keyword> keywords, HighlightFormatter formatter, bool ignoreCase);
public static string Highlight(string original, IEnumerable<Keyword> keywords, HighlightFormatter formatter, KeywordOrder order);
public static string Highlight(string original, IEnumerable<string> keywords, HighlightFormatter formatter, bool ignoreCase);
public static string Highlight(string original, IEnumerable<string> keywords, HighlightFormatter formatter, KeywordOrder order);
public static string Highlight(string original, IEnumerable<Keyword> keywords, HighlightFormatter formatter, KeywordOrder order, bool ignoreCase);
public static string Highlight(string original, IEnumerable<string> keywords, HighlightFormatter formatter, KeywordOrder order, bool ignoreCase);
}

ＯＫ，下面开始测试了。

关键词为："SB|法_轮_功（博客园过虑了）|日你|日你大爷"

可跳字符："▇☆"

原文本：....有博客园要过虑的词，不贴出来了，请看下面的测试结果，最后一组过虑变成了【关键词】，是因为用了自定义的Formatter。

上面只是功能上的测试，下面是1000词/1000字文章/300可跳字符和10000词/10000字文章/300可跳字符性能上的测试结果，可以看到，小量关键词里，KeywordFilter实例化时间很少，但是达到1万关键词时用了252ms，而过虑所用时间只是从前面的0ms变为1ms，关键词达10万时也只用了11ms（本人电脑的配置情况），可见过虑的高效。大家有兴趣的话请下载测试源码来自己看。

是否过虑成功？那是必须的，一词不漏：

高亮在KeywordFilter的基础上就简单实现了，只是实现了个HighlightFormatter，怎么高亮主要看前缀和后缀，下面是测试html高亮的结果：

至此，文章结束，大家帮忙点一下推荐哦，提供测试源码下载：KudyStudioFilteringTest.rar

更多请关注： KudyStudio文章目录

本文链接

KudyStudio文章目录

2011-12-19T11:12:00Z

关键字过虑实现的思路及Aho–Corasick高效字符串匹配算法应用（附算法C#实现和测试）

怎么设计个性化、灵活、实时更新的配置管理器？给大家讲讲实现思路，欢迎讨论

Jbox插件相关：

【jBox】2.3正式版多功能jQuery对话框插件下载及常见使用问题解答

　关于KudyStudio企业类库：本人为公司写的一个功能性类库（主要Web方向，轻量的，Winform程序也可以使用），它主要包括网站开发中的常用功能如常用集合类、数据缓存（包括Memcached和Membase客户端）、数据库操作、自己定义配置管理、日志处理、数据压缩、数据加密、方法扩展、关键字过虑、简单图片处理、地址重写、各种功能性小框架(例如Web表示层框架、依赖注入框架、WCF服务框架)等等等，远不止这些，目前还在整理完善中，大约在2012年底在公司项目完善时稳定初版本应该就会发布了，它可以免费提供给大家个人或商业使用。在最近一年内的开发整理中发布的关于KudyStudio的文章会或多或少提供一些源码与分析，如果你想关注和使用此类库，请关注本博客。

工作室网站：www.kudystudio.com （未完成）

本文链接

基于WebActivator的改进版本KudyStudio.Web.Activating讲解与下载

2011-12-15T12:50:00Z

前天刚发过文章介绍了KudyStudio.Web.Activating，今天再次作了修改，并提供源码给大家。

KudyStudio.Web.Activating下提供了两个属性分别是ActivationAttribute、ActivationMethodAttribute，利用它们可以灵活地随时在你的程序集中注册一个或多个Appilcation_Start()前/后触发和Appilcation_End()前触发的处理事件。 KudyStudio文章目录

下载源码KudyStudio.Web.Activating.rar（.Net4.0）

可触发的函数目标定义如下：

/// <summary>
/// Specifies the targets to use for invoking activation methods.
/// </summary>
[Serializable]
public enum ActivationMethodTarget
{
/// <summary>
/// Provides expanded support for ASP.NET application pre-start.
/// </summary>
PreApplicationStart = 0x0,

/// <summary>
/// Provides expanded support for ASP.NET application post-start.
/// </summary>
PostApplicationStart,

/// <summary>
/// Provides expanded support for before ASP.NET application shutdown.
/// </summary>
PreApplicationEnd
}

先介绍ActivationMethodAttribute，这个属性允许你以静态方法方式来向程序集注册一个或多个触发函数，并指定触发函数的目标与执行顺序，它的定义如下：

/// <summary>
/// Provides expanded support for application activation.
/// </summary>
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple=true)]
public sealed class ActivationMethodAttribute : OrderableAttribute
{
#region Constructors

/// <summary>
/// Initializes a new instance of the ActivationMethodAttribute class.
/// </summary>
/// <param name="type">An object that describes the type of the activation method.</param>
/// <param name="methodName">An empty parameter signature that has no return value.</param>
public ActivationMethodAttribute(Type type, string methodName)
:this(type, methodName, ActivationMethodTarget.PreApplicationStart)
{
}

/// <summary>
/// Initializes a new instance of the ActivationMethodAttribute class.
/// </summary>
/// <param name="type">An object that describes the type of the activation method.</param>
/// <param name="methodName">An empty parameter signature that has no return value.</param>
/// <param name="methodTarget">The method target for the associated activation method</param>
public ActivationMethodAttribute(Type type, string methodName, ActivationMethodTarget methodTarget)
{
type.ThrowsIfNull("type");
methodName.ThrowsIfNullOrEmpty("methodName");
if (!Enum.IsDefined(typeof(ActivationMethodTarget), methodTarget))
{
throw new ArgumentException("The methodTarget is undefined.");
}

this.Type = type;
this.MethodName = methodName;
this.MethodTarget = methodTarget;
}

#endregion

#region Properties

/// <summary>
/// Gets the type that is returned by the associated activation method.
/// </summary>
public Type Type
{
get;
private set;
}

/// <summary>
/// Gets the associated activation method.
/// </summary>
public string MethodName
{
get;
private set;
}

/// <summary>
/// Gets or sets the method target for the associated activation method.
/// </summary>
public ActivationMethodTarget MethodTarget
{
get;
set;
}

#endregion
}

有了ActivationMethodAttribute属性其实可以满足基本需求了，但是ActivationAttribute属性能让你的代码组织更清晰，怎么说？因为注册触发函数时不需要传入函数名称，而且方便每个程式元件建立自己的实现类（实现IPreApplicationStart、IPostApplicationStart、IPreApplicationEnd中的一个或多个接口）而不和其它程式元件的注册事务混在一起。ActivationAttribute属性这个允许你以实现接口方式来向程序集注册一个或多个触发函数，并指定触发函数的执行顺序，定义如下：

/// <summary>
/// Provides expanded support for application activation(s).
/// </summary>
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple=true)]
public sealed class ActivationAttribute : OrderableAttribute
{
#region Constructors

/// <summary>
/// Initializes a new instance of the ActivationAttribute class.
/// </summary>
/// <param name="type">
/// An object that implements any activation interface (<see cref="IPreApplicationStart"/>,
/// <see cref="IPostApplicationStart"/>, <see cref="IPreApplicationEnd"/>).
/// </param>
public ActivationAttribute(Type type)
{
type.ThrowsIfNull("type");

this.Type = type;
}

#endregion

#region Properties

/// <summary>
/// Gets the type that implements any activation interface.
/// </summary>
public Type Type
{
get;
private set;
}

#endregion
}

重点的实现就是ActivationManager类的InvokeActivationMethods方法，代码如下：

private static void InvokeActivationMethods(ActivationMethodTarget target)
{
List<OrderableAttribute> allAttributes = new List<OrderableAttribute>();
// get all attributes
foreach (Assembly assembly in AppAssemblies.Concat(GetCodeAssemblies(target)))
{
allAttributes.AddRange(GetAttributes<ActivationMethodAttribute>(assembly).Cast<OrderableAttribute>());
allAttributes.AddRange(GetAttributes<ActivationAttribute>(assembly).Cast<OrderableAttribute>());
}
// handle all ordered attributes
foreach (OrderableAttribute attribute in allAttributes.OrderBy(attr => attr.Order))
{
// invokes static method activations
ActivationMethodAttribute methodAttribute = attribute as ActivationMethodAttribute;
if (methodAttribute != null && methodAttribute.MethodTarget == target)
{
MethodInfo method = methodAttribute.Type.GetMethod(methodAttribute.MethodName, StaticMethodBindingFlags);
if (method != null)
{
method.Invoke(null, null);
continue; // continue next target
}
// method not found
throw new ApplicationException(string.Format("The type {0} doesn't have a static method named {1}.", methodAttribute.Type, methodAttribute.MethodName));
}

// try next case:
// invokes activations of activation classes that implements any activation interface
ActivationAttribute classAttribute = attribute as ActivationAttribute;
if (classAttribute != null)
{
Type type = classAttribute.Type;

object activation = null;
if (IsValidActivationType(type))
{
try
{
activation = Activator.CreateInstance(type);
}
catch(Exception ex)
{
throw new ApplicationException(string.Format("Fail to create instance of type {0}.", methodAttribute.Type), ex);
}
}
else
{
// invalid activation class
throw new ApplicationException(string.Format("The type {0} is not a valid activation class.", type.FullName));
}

if (activation != null)
{
if (target == ActivationMethodTarget.PreApplicationStart && (activation is IPreApplicationStart))
{
(activation as IPreApplicationStart).PreApplicationStart();
}
else if (target == ActivationMethodTarget.PostApplicationStart && (activation is IPostApplicationStart))
{
(activation as IPostApplicationStart).PostApplicationStart();
}
else if (target == ActivationMethodTarget.PreApplicationEnd && (activation is IPreApplicationEnd))
{
(activation as IPreApplicationEnd).PreApplicationEnd();
}
}
}
}
}

.NET 4.0版本新增了一个 PreApplicationStartMethodAttribute 类只提供了一个开始的前触发支持，那怎么实现开始后触发和结束前触发呢？.Net4.0中提供了一个叫DynamicModuleUtility的类（位于Microsoft.Web.Infrastructure.dll程序集），里面只有一个方法RegisterModule(Type moduleType)，利用它可以动态的添加HttpModule。WebActivator的作者就是巧妙的利用了动态注册HttpModule。在第一个处理触发事件的HttpModule初始化时触发PostApplicationStart，最后一个HttpModule销毁时触发PreApplicationEnd，核心原理就这么两点，比较简单，KudyStudio.Web.Activating里的源码并没有作优化，因为在应用程序周期只触发一次各个事件，没必要刻意的去代码加载速度什么的。另外提醒一下，WebActivator1.5版本里的触发顺序只在每个独立程序集有效（不知道是不是作者故意的），KudyStudio.Web.Activating的触发顺序是在整个应用程序的全部程序集都有效的（有效是指排序的范围），感兴趣的朋友请下载源码分析。

下载KudyStudio.Web.Activating.rar（.Net4.0）

在此再附上测试实例说明吧，ActivatingWeb网站项目中ActivatingTest.cs里写了触发函数的实现与注册，Global.asax是用于辅助测试的。运行网站的结果如下：

所有触发函数都按指定的顺序执行了，打开Web.config后点击保存，查看网站根目录下的ActivatingTest.txt内容为：

可以看到PreApplicationEnd触发函数也正常的按顺序执行了。

文章到此结束了，如果本文对你有帮助请点击推荐表示支持，谢谢，转载时请务必写明出处。

本文链接

利用Nginx实现最简单的防盗链

2011-12-05T11:54:00Z

一、文件的防盗链：

location ~* \.(gif|jpg|png|swf|flv)$ {
valid_referers none blocked www.kudystudio.com kudystudio.com;
if ($invalid_referer) {
rewrite ^/ http://www.kudystudio.com/403.html;
#return 403;
}
}

第一行：gif|jpg|png|swf|flv 表示对gif、jpg、png、swf、flv后缀的文件实行防盗链
第二行：表示对www.kudystudio.com kudystudio.com这2个来路进行判断
if{}里面内容的意思是，如果来路不是指定来路就跳转到http://www.kudystudio.com/403.html页面，当然直接返回403也是可以的。

二、目录的防盗链：

location /images/ {
alias /data/images/;
valid_referers none blocked server_names *.kudystudio.com kudystudio.com;
if ($invalid_referer) {
return 403;
}
}

下载nginx1.0

本文链接

10分钟采集凡客最新的省、市、区、邮政编码和电话区号（附源码）

2011-12-03T12:48:00Z

最近的开发的项目需要用到省、市、区数据，因为要开发的项目也是电子商务网站，在参考凡客的用户体验时，发现它连深圳最新分离出来的光明新区都有了，拍拍网都没有更新数据，看来凡客在数据更新方面还是挺负责的，所以了解了一下它的数据格式，然后花了点时间写了个小程序来抽取最新的省、市、区、邮政编码和电话区号，邮政编码和电话区号是在用户选择数据后推荐给用户选择的，免得用户再花时间去查，如下界面：

下载程序源码

一共有三个地址是返回数据的：

private string GetCityDataUrl(string province)
{
string url = "http://my.vancl.com/DeliveryAddress/GetCityData?povinceId={0}&r={1}";

return string.Format(url, JScriptUtil.Escape(province), GetRandom());
}

private string GetDistrictDataUrl(string province, string city)
{
string url = "http://my.vancl.com/DeliveryAddress/GetAreaData?cityId={0}&povinceId={1}&r={2}";

return string.Format(url, JScriptUtil.Escape(city), JScriptUtil.Escape(province), GetRandom());
}

private string GetPostCodeUrl(string province, string city, string district)
{
string url = "http://my.vancl.com/DeliveryAddress/GetPostalCode?povince={0}&city={1}&area={2}&r={3}";

return string.Format(url, Utils.UrlEncode(province), Utils.UrlEncode(city), Utils.UrlEncode(district), GetRandom());
}

核心函数：

// 抽取凡客数据
private void DoGetVanclData()
{
string[] provinces = Util.Provinces.Split('|');
for (int i = 0; i < provinces.Length; i++)
{
string theP = provinces[i].Trim();

this.Invoke(new MethodInvoker(() =>
{
this.label1.Text = theP + "...";
}));

// 增加省份
int pid = GetNewId("Province");
this.Invoke(new MethodInvoker(() =>
{
if (pid == 1)
this.textBox1.Text += "insert into [Db_MoMoMate].[dbo].[Province]([Id],[Name])\r\nSELECT " + pid.ToString() + ", '" + theP + "'\r\n";
else
this.textBox1.Text += "union\r\nSELECT " + pid.ToString() + ", '" + theP + "'\r\n";
}));

// 获取城市数据
string[] cityData = WebRequestHelper.HttpGet(GetCityDataUrl(theP), "", Encoding.UTF8).Split('$');
Thread.Sleep(10);

foreach (string city in cityData)
{
string theC = city.Split(',')[1].Trim();

// 城市id
int cid = GetNewId("City");
string AreaCode = null;

// 获取区数据
string[] districtData = WebRequestHelper.HttpGet(GetDistrictDataUrl(theP, theC), "", Encoding.UTF8).Split('$');
Thread.Sleep(10);

foreach (string district in districtData)
{
string theD = district.Split(',')[1].Trim();

// 区id
int did = GetNewId("District");
string[] postData = WebRequestHelper.HttpGet(GetPostCodeUrl(theP, theC, theD), "", Encoding.UTF8).Split('$');

if (AreaCode == null)
{
AreaCode = postData[4];
}

string postCode = postData[3];

Thread.Sleep(10);
// 增加区
this.Invoke(new MethodInvoker(() =>
{
if (did == 1)
this.textBox3.Text += "insert into [Db_MoMoMate].[dbo].[District]([Id],[CityId],[Name],[PostCode])\r\nSELECT " + did.ToString() + ", " + cid.ToString() + ", '" + theD + "', '" + postCode + "'\r\n";
else
this.textBox3.Text += "union\r\nSELECT " + did.ToString() + ", " + cid.ToString() + ", '" + theD + "', '" + postCode + "'\r\n";
}));
}

// 增加城市
this.Invoke(new MethodInvoker(() =>
{
if (cid == 1)
this.textBox2.Text += "insert into [Db_MoMoMate].[dbo].[City]([Id],[ProvinceId],[Name],[AreaCode])\r\nSELECT " + cid.ToString() + ", " + pid.ToString() + ", '" + theC + "', '" + AreaCode + "'\r\n";
else
this.textBox2.Text += "union\r\nSELECT " + cid.ToString() + ", " + pid.ToString() + ", '" + theC + "', '" + AreaCode + "'\r\n";
}));
}

this.Invoke(new MethodInvoker(() =>
{
if (i == provinces.Length - 1)
{
this.label1.Text = "done";
this.button1.Enabled = true;
}
}));
}
}

最终运行效果如下：

本公司项目中还需要大学数据，那是09年开发大学SNS网站的老数据了，把数据都放进数据库：

需要抽取省、市、区数据的朋友可以下载程序源码来使用：点击下载

本文链接

【分享】通用强大的主数据管理系统（最终分享版本）架构分析及源码下载

2011-11-27T14:50:00Z

之前已发个文章分享刚完成的版本（http://www.cnblogs.com/kudy/archive/2011/11/07/2237802.html），这个是最近对MSH重构后的调整版本，修正了之前存在的几个小bug，也是最后分享出来给大家学习的版本。特别说明：源码分享出来主要不是让大家直接用，而是从中学习某方面值得你学习的，另一个目的是让大家对MSH进一步的了解，因为此系统使用了它提供数据访问。

主数据管理系统（Master Data Management System），本人开发它的目的是用来管理/整合公司内部所有子系统，包括用户、角色、权限（权限管理，授权与验权基础实现），同域名情况的单点登录，等等主要数据的管理。

点击下载最终分享版（VS2008/VS2010、.Net 3.5）

下载后必须要了解的：

一、数据库创建与初始化数据

在SQL server 2005/2008 下新建名为　Db_Mdms　的数据库，然后按顺序执行目录 Documents\Mdms.Documents\DB 1.0\Scripts 里的sql

1_tables.sql
2_functions.sql
3_stored-procedures.sql
4_init_data.sql

二、修改数据库连接信息
在目录 build\Mdms.Msh 里修改 Mdms.MSH.exe.config 的配置节点 Mdms.Db_ConnectionString 的值为你自己的数据库连接

三、在vs2010中运行Web项目 Mdms.Web 或右键选择 default.aspx 页面点击在浏览器中浏览，然后打开目录 build\Mdms.MSH，双击Mdms.MSH.exe运行之

这时，你可以用默认用户/密码 admin/admin888 登录系统了

在线demo: http://mdms.kudystudio.com/

用户/密码：test1/test1 test2/test2 （注：同一用户在另一浏览器登录，另一用户在session失效后会被逼下线）

demo站放在一个香港的VPS主机上，配置比较低，速度慢也是正常的，主要也放自己的个人网站。

下面对整个解决方案的项目进行简要说明。系统是多层架构+WCF服务+MTV表现层完成的；其中WCF服务使用了MSH来托管，当然你也可以自己另写程序来托管WCF服务；MTV表现层框架是本人写的一个使用习惯和MVC差不多的框架，功能比较简单，如果你想用MVC，转换也不麻烦，因为使用上都差不多。

了解MSH请看这篇文章：【MSH】一个轻量级但很实用的WCF模块服务框架+WCF模块服务托管程序MSH[开篇]

因为MTV框架还没完善，只在本人公司里使用，等功能完善了，基本扩展性也完成了会另写文章对它进行介绍。

在另一文章里还专门对此系统的权限管理进行了解说：如何给多个子系统设计一个简单通用的权限管理方案？

另外还使用了本人写的一个js窗口插件：【jBox】2.3正式版多功能jQuery对话框插件下载及常见使用问题解答

1.项目 Core/Mdms.Utility 是整个项目的公共功能库。

2.项目 Core/Mdms.Model 是整个项目要使用的数据模型类库，其中DbModels里放的是与数据库的表一一对应的数据模型，其它的是为业务层需要写的扩展性模型。

3.Msh/Db 下的三个项目相信大家都很容易理解，Mdms.Data为数据访问库，根据配置创建数据实现对象并返回接口，Mdms.IDataProvider为数据接口定义库，Mdms.SqlServerProvider为SqlServer的数据接口实现库，是提供给Msh/Modules 下的模块服务使用的，因为采用上用WCF来提供数据访问。

4.项目 Msh/Mdms.Msh 是使用MSH而写的基本功能库，方便Msh/Modules下的模块服务开发。而Mdms.BusinessBase项目是所有子系统都要使用的业务基础，里面主要实现了同域名下的单点登录，还有权限验证需要的基本功能使用。

5.Web 目录下的三个项目主要就是业务的封装和表现层的东东了。项目Mdms.Business是系统的业务封装，项目Mdms.Web是网站，项目Mdms.Web.Mtv是使用MTV框架需要的模块类与过虑器（和MVC里的控制器和过虑器相对应）。

http://files.cnblogs.com/kudy/Mdms_Shared_Final.rar

简介完毕，希望能给大家带来帮助：）

本文链接

博客园_Kudy's Tech Blog

【jUploader】1.0版 基于jQuery文件无刷新上传插件下载及介绍

怎么设计个性化、灵活、实时更新的配置管理器？讲讲实现思路

又失恋了。程序员，你的爱情在哪里？

关键字过虑实现的思路及Aho–Corasick高效字符串匹配算法应用

强大灵活的脏字过虑：1万字文章过虑1万关键词用时只要1毫秒

KudyStudio文章目录

基于WebActivator的改进版本KudyStudio.Web.Activating讲解与下载

利用Nginx实现最简单的防盗链

10分钟采集凡客最新的省、市、区、邮政编码和电话区号（附源码）

【分享】通用强大的主数据管理系统（最终分享版本）架构分析及源码下载

【jUploader】1.0版基于jQuery文件无刷新上传插件下载及介绍