博客园_从挨踢到IT

C#中一种通用的树的生成方式

2011-12-08T05:32:00Z

在写程序时，经常要用到树的这种结构，如果是做界面编程，那么TreeView是一个不错的选择，几个设置就能把数据绑定好，但是如果自己写类呢？相对就麻烦一点。

这里讨论一下如何快速建立自己的树型结构，即怎么把建树的方法抽离出来加以复用。

代码的复用，不外乎类，接口，泛型。

先考虑用接口来实现，定义一个ITreeNode 然后每一个要建立树型结构的结点去实现？感觉不大好，因为你要定义比如Parent Children等一系列的东西，很是很麻烦，每一个实现起来也很困难。

那抽像类？抽象类的继承到是方便，但是在实际使用中涉及各种类型转换，代码写起来不爽。

泛型呢？泛型的结构又过于笼统，但是可以折衷一下，就是用泛型定义一个结点的类

（小弟写代码方式都相对“妥协”，一位大人说的，各位将就着看哈）

1 namespace Soway.DB.Tree
2 {
3     public class  TreeNode<T>
4     {
5
6         public T Data { get; set; }
7         public TreeNode<T> Parent { get; set; }
8         public List<TreeNode<T>> Children { get; set; }
9     }
10 }

结点类定义好了以后，就要去实现一个 TreeFactory ，将建树的通用算法提出来。

namespace Soway.DB.Tree
{



    public class TreeFactory <T>
    {
public List<TreeNode<T>> CreateTreeByLevel
            (List<T> Items )
        {
            //////
        }
    }
}

这里的我的方法名已经默认为ByLevel ，即按层建立树，这样，新的问题又出现了：

1.怎么保证输入值Items是已经按层遍立建立好的结点？

2.怎么分层？即怎么区分树的父结点，子结点，同级结点之间的关系？

这些问题其实都与泛型的具体类型有关，但如果把具体类型约束了，那就违反我们本意了。

走一步算一步，先这样，把树结点之间的关系定义出来，算是一个枚举吧：

namespace Soway.DB.Tree
{
    public enum  TeeNodeCompareResult
    {
        /// <summary>
        /// 树结点
        /// </summary>
        Parent,
        /// <summary>
        /// 子结点
        /// </summary>
        Child,
        /// <summary>
        /// 下一个同级结点
        /// </summary>
        NextNode,
        /// <summary>
        /// 前一个同级结点
        /// </summary>
        PreNode,
        /// <summary>
        /// 同一个结点
        /// </summary>
        EquealNode ,
        /// <summary>
        /// 下一层的结点
        /// </summary>
        NexLevelNode

    }
}

有了这个关系以后，于是有了进一步的想法，考虑传递给TreeFactory一个委托，可以通过这个来得到两个结点之间比较关系：

namespace Soway.DB.Tree
{
public delegate TeeNodeCompareResult TeeNodeCompare<T>(T child, T parent);
}

这样，我们的TreeFactory里多了一个泛型委托的成员。。。

   private TeeNodeCompare<T> compare;

        public TreeFactory(Tree.TeeNodeCompare<T> Compare)
        {
            this.compare = Compare;

        }

现在，当这个泛型委托处理好了以后，我们下一步问题也好办了，就是将输入的Items进行按层排序，这时，只要有一个Comparison<T>（）的实现，我直接调用 List<T>.Sort(Comprarion<T>)即可了

下面给出这个Comparation<T>的实现：

private int CompareResult(T ob1, T ob2)
        {
            switch (compare(ob1, ob2))
            {
                case TeeNodeCompareResult.Child:
                case TeeNodeCompareResult.NextNode:
                case TeeNodeCompareResult.NexLevelNode:
                    return 1;
                case TeeNodeCompareResult.Parent :
                case TeeNodeCompareResult.PreNode:
                    return -1;
                default :
                    return 0;
            }


        }

好，这些基础工作做完以后，建树的就容易了：

      /// <summary>
        /// 按层建立树
        /// </summary>
        /// <param name="Items">建立树的集合</param>
        /// <returns>建立好的树结构</returns>
        public List<TreeNode<T>> CreateTreeByLevel
            (List<T> Items )
        {
            Items.Sort(new Comparison<T>(this.CompareResult));
            List<TreeNode<T>> result = new List<TreeNode<T>>();
            TreeNode<T> lastNode =null;
            Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
            TreeNode<T> currentNode=null;
            var current = result;
            if (Items.Count > 0)
            {

                  for (int i = 0; i < Items.Count ; i++)
                {


                    TreeNode<T> AddedNode = new  TreeNode<T>(){Data=Items[i],
                        Parent = null,Children = new List<TreeNode<T>>()};//生成要添加的数据

                    queue.Enqueue(AddedNode);//入队
                      //看是否到了下一层的结点
                    if (lastNode != null &&
                        (compare(AddedNode.Data, lastNode.Data) == Tree.TeeNodeCompareResult.Child
                         || compare(AddedNode.Data, lastNode.Data) == Tree.TeeNodeCompareResult.NexLevelNode)//下一层：即结点是子结点或是下一层结点
                        )
                    {
                        currentNode = queue.Dequeue();

                    }
                    //找到对应的父结点
                    while (currentNode != null
                        &&
                        compare(AddedNode.Data, currentNode.Data) != TeeNodeCompareResult.Child
                        )
                    {
                        currentNode = queue.Dequeue();
                    }
                    if (currentNode !=null && compare(AddedNode.Data, currentNode.Data) != TeeNodeCompareResult.EquealNode)
                    {
                        AddedNode.Parent = currentNode;
                        current = currentNode.Children;
                    }
                    current.Add(AddedNode);
                    lastNode = AddedNode;
                }
            }
            return result;


        }

下面是一个使用的Demo ^_^

//类：
{
    [Table(Name="Auth")]
    public class Auth
    {
        [Column(IsKey=true)]
        public string Code { get; set; }
        public string Name { get; set; }
        public String Url { get; set; }
        public string View { get; set; }
        public string Action { get; set; }
        public string Text { get; set; }
        public string Image { get; set; }

        public override string ToString()
        {
            return Code + " " + Name;
        }



    }
//比较结点的关系：
static Soway.DB.Tree.TeeNodeCompareResult compare(Auth ob1, Auth ob2)
        {

            if (ob1.Code == ob2.Code)
                return TeeNodeCompareResult.EquealNode;
            if (ob1.Code.Length > ob2.Code.Length)
                if (ob1.Code.IndexOf(ob2.Code) == 0)
                    return TeeNodeCompareResult.Child;
                else
                    return TeeNodeCompareResult.NexLevelNode;
            else if (ob1.Code.Length < ob2.Code.Length)
                return TeeNodeCompareResult.Parent;
            else if (ob1.Code.CompareTo(ob2.Code) < 0)
                return TeeNodeCompareResult.PreNode;
            else
                return TeeNodeCompareResult.NextNode;


        }

///主函数中
var c = new Soway.DB.DBContext(builder.ToString());
            var items = c.Get<Auth  >();//初始化
    var tree = new TreeFactory<Auth>(new TeeNodeCompare<Auth>(compare)).CreateTreeByLevel(items);//建立树型结构

本文链接

自己写ORM？是否有必要？

2011-11-15T13:40:00Z

一直想有一个好用的.Net 下的ORM ，linq看了，ef code first 也看了

总觉得有一些封闭，一些深层次的实现不是很清楚，一直有冲动自己写一个，慢慢完善，现在初步把一些法和各位达人说出来，看看是否有必要，如果可以，即日开工：）

嘿嘿

1..Net 2.0以上版本

2.支持SQL和Oracle

3.支持树形结构的自动生成

4.支持主从键的简单映射

5.支持自定义查询（用户级的，不是Linq)

6.支持简单的业务形式

7.再就是各种增删改查了

8.多组主键及验证条件

参考EF Hide First 形式，算是对那种形式的扩充吧。

自己现在写了一些

初步想用反射和Hash来管理SqlCommand

即，第一次请求时用类型生成对应的SqlCommand并存储在hashTable中

以后从HastTable中用类型直接查找，复制，并填充参数

不知道是否有必要

小弟斗胆发到首页了，请各位指点，是否有这种必要

PS：举一个EF及LINQ中不好处理的事情

比如往一个主表插入记录，之后会得到这个记录的自生成主ID，之后要用这个主ID生成子表的相关参数

这个如果在一个事务中处理的话，在linq 及EF中都要自己实现

附：

之前做的一些尝试性试验：

自己写反射工厂：

http://www.cnblogs.com/geyunfei/archive/2011/04/01/2001952.html

基于数据字典的通用查询：

1.SQL组成分析 http://www.cnblogs.com/geyunfei/archive/2008/12/17/1356409.html

2.数据库组成分析 http://www.cnblogs.com/geyunfei/archive/2008/12/17/1357160.html

3.数据库设计 http://www.cnblogs.com/geyunfei/archive/2008/12/18/1357895.html

4.实体设计 http://www.cnblogs.com/geyunfei/archive/2008/12/18/1357896.html

5.完结：http://www.cnblogs.com/geyunfei/archive/2008/12/21/1359141.html

目前这些功能都进行了一些改进，现在在想是否有进一步结合发展的可能

如果有牛牛们觉得靠谱，大家一起搞个开源什么的也成，嘿嘿~~·

斗胆推荐到首页，轻拍

本文链接

浅析.Net 在 winform及wpf中涉及界面交互的多线程类的封装

2011-11-10T13:42:00Z

我们在开发客户端程序时，经常要用到多线程

而我们知道， .Net 中从线程安全的考虑，对控件改变的调用要通过Invoke， beginvoke 来进行，这就涉及怎么进行工作线程与界面的互操作。

本文以一个简单的应用为例，探讨多线程的封装性，我们的主要目的是让一个类能同时适wpf及winform对多线程的要求

现在假定程序里，有一个多线程的业务处理逻辑，如下：

//……初始化等
Thread work = new Thread(new ThreadStart(run));
work.Start();
//……其他代码

void run (){

//这里有一部分要改变界面显示的代码
}

在最直观的设计中，我们是这样考虑的：

1.声明一个委托(为了从简，这里不考虑有各种参数的情况:

private void foo();

2.将用户界面交互的代码装在一个单独的函数中:

private void Foo(){
//改变界面显示
}

3.在线程中（这里先以winform为例) 用Invoke或BeginInvoke调用这个函数

为了从简，我们只考虑Invoke

void run(){
//….
this.Invoke(new foo(Foo));
//….
}

现在，我们的下一步工作是要封装这个Work类，使他在其他的winform程序中也可以方便的调用。这样，我们主要有两部分工作要做：

a.工作线程的提取

b.界面逻辑的分割

最直接的方法是这样：

delegate void foo();
class Work{

private Thread work;
public Work(){
work= new Thread(new ThreadStart(run);
}
public Begin(){
work.Start();
}

public event foo Foo;

void run (){

//这里有一部分要改变界面显示的代码
if(Foo!=null)
Foo();
}

}

这样，界面上的代码变成了这个样子：

//初始化
Work = new Work(this);
Work.Foo+= new foo(FooFunction);
Work.Begin()

到此，我们已经将多线程逻辑与界面逻辑分开了，但是现在有一个问题，就是我要在FooFuction中调用Invoke

即

FooFuction(){
this.Invoke(new Foo(fooFunction));
}
fooFunction(){
//界面处理程序
}

于是，每次复用这个逻辑，我们都要反复的自己写这个Invoke ，很麻烦，于是考虑进一步的改进，即，将当前Control作为一个成员封装至Work类中，即：

delegate void foo();
class Work{
private Control Owner ;
private Thread work;
public Work(Control owner){
work= new Thread(new ThreadStart(run);
Owner=owner;
}
public Begin(){
work.Start();
}

public event foo Foo;

void run (){

//这里有一部分要改变界面显示的代码
if(Foo!=null)
    if(Ownner!=null)
        Ownner.Invoke(Foo);
    else
        Foo();
}
}

这样，界面上的代码就要整洁多了，现在我们不用在界面中调用 Invoke了：

//初始化
Work = new Work();
Work.Foo+= new foo(FooFunction);
Work.Begin()

//other code ...
FooFuction(){
//更新界面
}

现在，我们已经完成了一个多线程类的封闭，它有很好的封闭性和可读性，但是，新的问题来了，即，我要把它移植到 wpf程序中，本来很完美的工作类，现在他面临如下问题：

1.不与wpf程序兼容，我得自己在程序中写对应wpf的Invoke

2.运行时要依靠Control类，即我要正常使用他，还得在wpf程序中添加winform的DLL才可以

因此，我们要进行如下工作，以使我们的Work类看着很完美

1.脱离Control类的依赖

2.能同时完美的支持winform 和wpf用户程序；

显然，这里面最重要的就是要如何处理这段代码：

//这里有一部分要改变界面显示的代码
if(Foo!=null)
    if(Ownner!=null)
        Ownner.Invoke(Foo);
    else
        Foo();

考虑到我们对Control的引用只是为了调用它的Invoke ,于是，可以将Invoke提一个接口：

interface IWorkHost{
void Invoke (delegate method);
public object Parent;
}

这样，我们只需将Work类中的Owner 从Control变为IWorkHost，其他代码不用改变，剩下的工作就好办了：

我们可以把对windows.forms 引用从Work所在的工程移掉，然后，加一个DLL工程WinformHost ,引用 Work类所在工程

声明一个类WinformHost来实现IWorkHost

class WinformHost:IWorkHost{
private Control parent;
public object Parent{get{return parent;}}
public WinformHost(Control parent){
parent = parent;
}
public void Invoke (delegate method){
parent.Invoke(method);
}

类似的，增加用于WPF的WPFWorkHost

class WPFHost:IWorkHost{
private Dispatcher parent;
public object Parent{get{return parent;}}
public WPFHost(Control parent){
parent = parent;
}
public void Invoke (delegate method){
parent.Invoke(method);
}

这样，当在winform中使用Work类时，代码变成：

Work = new Work(new WinformHost(this));
Work.Foo+= new foo(FooFunction);
Work.Begin()

当在 wpf程序中使用 work类时，代码变成：

Work = new Work(new WPFHost(this.dispatcher));
Work.Foo+= new foo(FooFunction);
Work.Begin()

总结：

我们在这个文章里依次做了如下的工作：

1.将一个多线程的逻辑加到winform中

2.将这个多线程封装到单独的类

3.改进这个逻辑使他同时适应winform和wpf

这里用到到模式，应该是适配器模式，其实这个应用场景和很多复用封装的场景相类似，只不过多线程在 winform和wpf中是经常讨论的问题，用这个问题来解释这种封装，我觉得会好一些。

文笔不好，见谅。

本文链接

自己写Facotry-解析.Net 的反射和attribute

2011-04-01T03:56:00Z

很多人都知道工厂，知道反射，但是真正能用的好的并不多，我也是最近才真正明白了什么是反射，反射和.Net 里的一些其他特性是怎么应用的。在这里，分享一个自己写的小的数据库工厂的架构，和大家讨论。

目的的需求：

在一个系统里，需要有一个统一的数据库类实现对SQL Server的增删改查，要求有良好的扩展行和维护性。

在知道反射和属性之前的思路，是对每个实体类写相应的操作。但是现在，可以通过应用Attribute来进行自己定义

首先，要把数据库里的表和实体类对应.这样，我们简单的定义一个属性ClassesDefineSqlAttribute，用对应表和实体类。

[AttributeUsage(AttributeTargets.Class)]
    class ClassesDefineSqlAttribute :Attribute
    {
        public String SqlTableName { get; set; }
        public ClassesDefineSqlAttribute()
        {

        }

    }

第一步对应好了以后，下一步要将实体类的属性与数据库表中的列进行对应，为此，定义ClassesDefineColumnAttribute 这里，只是简单的设置了列名，列的类型（数据，主键，改之前的主键）,呵呵，一切从简，够用就好

    public enum ColType
    {
        /// <summary>
        /// 数据列
        /// </summary>
        Data,
        /// <summary>
        /// 主键列
        /// </summary>
        ClassCode,
        /// <summary>
        /// 级别列（在树型结构中用到)
        /// </summary>
        ClassLevel,
        /// <summary>
        /// 旧键（更新时使用）
        /// </summary>
        OldCode
    }
    [AttributeUsage(AttributeTargets.Property )]
    public class ClassesDefineColumnAttribute:Attribute
    {
        //对应的数据库列名
        public string SqlColName { get; set; }
        /// <summary>
        /// 列的类型
        /// </summary>
        public ColType ColType { get; set; }

        /// <summary>
        /// 复杂类型的属性值
        /// </summary>
        public string TargetProperty { get; set; }

    }
}

用了这些准备，就可以在数据工厂中完成增删改查了

为了通用，我们把增删改的参数都设置成object ,这样，在操作时，先将object 的最终类别取到，然后得到上面的几个属性，动态的生成SQL语句

先看增操作

        public void Create(object T)
        {
            var info = T.GetType();//得到要新建的类型
            ClassesDefineSqlAttribute attribute =
                (ClassesDefineSqlAttribute)Attribute.GetCustomAttribute(info,
                typeof(ClassesDefineSqlAttribute));///得到表名

            if (attribute != null)
            {

                var Properties = info.GetProperties();///得到属性
                System.Reflection.PropertyInfo KeyProperty = null;
                String insert = "INSERT " + attribute.SqlTableName + "(";
                String values = ") Values(";
                String checksql = "";

                String GetKeySql = "WHERE 1=1";

                foreach (var infoattr in Properties)
                {

                    var ob = Attribute.GetCustomAttribute(infoattr, typeof(ClassesDefineColumnAttribute));

                    if (ob != null)
                    {
                        var attr = ob as ClassesDefineColumnAttribute;

                        if (attr is ClassesDefineColumnAttribute)
                        {

                            var a = attr as ClassesDefineColumnAttribute;
                            if (a.ColType != ColType.OldCode)
                            {

                                if (a.ColType != ColType.ClassCode
                                   ||
                                    infoattr.PropertyType == typeof(String))
                                {

                                    string valuestr = (infoattr.GetValue(T, null) ?? "").ToString();
                                    insert += a.SqlColName + ",";
                                    values += "'" + valuestr + "',";
                                    GetKeySql = GetKeySql + " And " + a.SqlColName + "='" + valuestr + "'";
                                }
                                if (a.ColType == ColType.ClassCode)
                                {

                                    KeyProperty = infoattr;
                                    if (KeyProperty.PropertyType == typeof(String))
                                    {

                                        checksql = "Select Count(*) FROM " + attribute.SqlTableName + " Where " + a.SqlColName + "='" + (infoattr.GetValue(T, null) ?? "").ToString() + "'";
                                        if (System.Convert.ToInt32(
                                            new DataConnectionFactory().GetDataTable(checksql).Rows[0][0]) > 0)
                                            throw new Exception("无法生成新数据,与现有数据编码相同!");
                                    }
                                    else
                                    {
                                        GetKeySql = "Select " + a.SqlColName + " FROM " + attribute.SqlTableName + " " + GetKeySql;
                                    }
                                }

                            }
                        }

                    }
                }

                String sql = insert.Substring(0, insert.Length - 1) + values.Substring(0, values.Length - 1) + ")";

                using (var db = new DataConnectionFactory().GetConnection())
                {
                    db.ExecuteCommand(sql);

                    //设置自增长主键的返回直

                    if (KeyProperty.PropertyType != typeof(string))
                    {
                        KeyProperty.SetValue(T,
                            new DataConnectionFactory().GetDataTable(GetKeySql).Rows[0][0], null);
                    }

                }

            }
            else
            {
                throw new Exception("类型不符合要求");
            }

        }

增操作完成，改的操作也很类似

        public void Save(object T)
        {
            var info = T.GetType();
            ClassesDefineSqlAttribute attribute = (ClassesDefineSqlAttribute)Attribute.GetCustomAttribute(info, typeof(ClassesDefineSqlAttribute));
            String oldCode = "";
            String newCode = "";

            bool HaveOldCode = false;

            System.Reflection.PropertyInfo KeyProperty = null;

            if (attribute != null)
            {

                var Properties = info.GetProperties();
                String insert = "UPDATE " + attribute.SqlTableName + " SET ";
                String wheresql = "";

                String checksql = "";

                foreach (var infoattr in Properties)
                {

                    var ob = Attribute.GetCustomAttribute(infoattr, typeof(ClassesDefineColumnAttribute));

                    if (ob != null)
                    {
                        var attr = ob as ClassesDefineColumnAttribute;
                        if (attr is ClassesDefineColumnAttribute)
                        {
                            var valueStr = infoattr.GetValue(T, null).ToString();

                            var a = attr as ClassesDefineColumnAttribute;
                            if (attr.ColType == ColType.Data
                                || (attr.ColType == ColType.ClassCode && infoattr.PropertyType == typeof(String)))
                                insert += a.SqlColName + "='" + valueStr + "',";

                            if (a.ColType == ColType.ClassCode)
                            {
                                checksql = a.SqlColName + "='" + valueStr + "'";
                                KeyProperty = infoattr;
                                newCode = valueStr;
                            }
                            if (a.ColType == ColType.OldCode)
                            {
                                HaveOldCode = true;
                                wheresql = " Where " + a.SqlColName + "='" + valueStr + "'";
                                oldCode = valueStr;

                            }
                        }

                    }
                }



                if (HaveOldCode)
                {
                    if (newCode != oldCode)
                    {

                        checksql = "Select count(*) FROM " + attribute.SqlTableName + wheresql + " OR  " + checksql;

                        if (System.Convert.ToInt32(
                            new DataConnectionFactory().GetDataTable(checksql).Rows[0][0]) >= 2)
                            throw new Exception("无法生成新数据,与现有数据编码相同!");
                    }
                }
                else
                    wheresql = "Where " + checksql;
                String sql = insert.Substring(0, insert.Length - 1) + wheresql;
                using (var db = new DataConnectionFactory().GetConnection())
                {
                    db.ExecuteCommand(sql);
                }

            }
            else
            {
                throw new Exception("类型不符合要求");
            }

        }

最后是删除的操作

     public void Delete(object T)
        {
            var info = T.GetType();
            ClassesDefineSqlAttribute attribute = (ClassesDefineSqlAttribute)Attribute.GetCustomAttribute(info, typeof(ClassesDefineSqlAttribute));
            TreeNodeAttribute treedef = (TreeNodeAttribute)Attribute.GetCustomAttribute(info, typeof(TreeNodeAttribute));


            if (attribute != null)
            {

                var Properties = info.GetProperties();
                String insert = "Delete " + attribute.SqlTableName + " ";


                foreach (var infoattr in Properties)
                {                     var ob = Attribute.GetCustomAttribute(infoattr, typeof(ClassesDefineColumnAttribute));

                    if (ob != null)
                    {
                        var attr = ob as ClassesDefineColumnAttribute;
                        if (attr is ClassesDefineColumnAttribute)
                        {
                            var valueStr = infoattr.GetValue(T, null).ToString();

                            var a = attr as ClassesDefineColumnAttribute;

                            if (a.ColType == ColType.OldCode)
                            {

                                insert  += " Where " + a.SqlColName + "='" + valueStr + "'";

                                break;

                            }
                            else if (a.ColType == ColType.ClassCode)
                            {
                                insert += " Where " + a.SqlColName + "='" + valueStr + "'";

                                break;
                            }
                        }

                    }
                }
                String sql = insert;


                using (var db = new DataConnectionFactory().GetConnection())
                {
                    db.ExecuteCommand(sql);
                }

            }
            else
            {
                throw new Exception("类型不符合要求");
            }

        }

这样，再有类型，只要做好相应的标记，便可直接应用这个类了

如我的表示档案盒的类型FileBox

    [ClassesDefineSql(SqlTableName = "DA_FileBox")]
    public class FileBox
    {
        /// <summary>
        /// 档案盒
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.ClassCode, SqlColName = "BoxNo")]
        public String BoxNo
        {
            get;
            set;
        }

        /// <summary>
        /// 标签ID
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "TagNo")]
        public string TagID
        {
            get;
            set;
        }

        /// <summary>
        /// 类别信息
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "ClassNo")]
        public string ClassNo
        {
            get;
            set;
        }

        /// <summary>
        /// 类别名称
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "ClassName")]
        public string ClassName
        {
            get;
            set;
        }

        /// <summary>
        /// 位置编号
        /// </summary>

        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "LocationNo")]
        public string LocationNo
        {
            get;
            set;
        }

        /// <summary>
        /// 位置说明
        /// </summary>

        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "LocationName")]
        public string LocationName
        {
            get;
            set;
        }

        /// <summary>
        /// 备用一
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "Note1")]
        public string Note1
        {
            get;
            set;
        }

        /// <summary>
        /// 备用二
        /// </summary>
        [ClassesDefineColumn(ColType = ColType.Data, SqlColName = "Note2")]
        public string Note2
        {
            get;
            set;
        }
    }

本文链接

无聊，写个小程序刷iPhone4

2010-12-07T02:38:00Z

官网上的iPhone4，便宜，但不好得

本人不是果粉，但也幻想弄上一个两个倒手赚点小钱

总刷网页太麻烦

自己写个App吧

很简单的应用

思路，官网上正常情况下有两个 iPhone4的“暂无供应”，只要查到有两个这种字符串，就是没放出，否则呢，嘿嘿。。。

窗体设计部分：

namespace IP4Killer
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
            this.linkLabel1 = new System.Windows.Forms.LinkLabel();
            this.label1 = new System.Windows.Forms.Label();
            this.linkLabel2 = new System.Windows.Forms.LinkLabel();
            this.label2 = new System.Windows.Forms.Label();
            this.linkLabel3 = new System.Windows.Forms.LinkLabel();
            this.label3 = new System.Windows.Forms.Label();
            this.linkLabel4 = new System.Windows.Forms.LinkLabel();
            this.notifyIcon1 = new System.Windows.Forms.NotifyIcon(this.components);
            this.SuspendLayout();
            //
            // linkLabel1
            //
            this.linkLabel1.AutoSize = true;
            this.linkLabel1.Location = new System.Drawing.Point(12, 9);
            this.linkLabel1.Name = "linkLabel1";
            this.linkLabel1.Size = new System.Drawing.Size(77, 12);
            this.linkLabel1.TabIndex = 0;
            this.linkLabel1.TabStop = true;
            this.linkLabel1.Text = "Printf@Soway";
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(42, 82);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(59, 12);
            this.label1.TabIndex = 1;
            this.label1.Text = "开始时间:";
            //
            // linkLabel2
            //
            this.linkLabel2.AutoSize = true;
            this.linkLabel2.Location = new System.Drawing.Point(108, 82);
            this.linkLabel2.Name = "linkLabel2";
            this.linkLabel2.Size = new System.Drawing.Size(65, 12);
            this.linkLabel2.TabIndex = 2;
            this.linkLabel2.TabStop = true;
            this.linkLabel2.Text = "linkLabel2";
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(44, 118);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(59, 12);
            this.label2.TabIndex = 3;
            this.label2.Text = "刷新次数:";
            //
            // linkLabel3
            //
            this.linkLabel3.AutoSize = true;
            this.linkLabel3.Location = new System.Drawing.Point(108, 118);
            this.linkLabel3.Name = "linkLabel3";
            this.linkLabel3.Size = new System.Drawing.Size(65, 12);
            this.linkLabel3.TabIndex = 4;
            this.linkLabel3.TabStop = true;
            this.linkLabel3.Text = "linkLabel3";
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(42, 153);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(59, 12);
            this.label3.TabIndex = 5;
            this.label3.Text = "秒杀次数:";
            //
            // linkLabel4
            //
            this.linkLabel4.AutoSize = true;
            this.linkLabel4.Location = new System.Drawing.Point(108, 153);
            this.linkLabel4.Name = "linkLabel4";
            this.linkLabel4.Size = new System.Drawing.Size(65, 12);
            this.linkLabel4.TabIndex = 6;
            this.linkLabel4.TabStop = true;
            this.linkLabel4.Text = "linkLabel4";
            //
            // notifyIcon1
            //
            this.notifyIcon1.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon1.Icon")));
            this.notifyIcon1.Text = "iPhone4 秒杀器";
            this.notifyIcon1.Visible = true;
            this.notifyIcon1.MouseClick += new System.Windows.Forms.MouseEventHandler(this.notifyIcon1_MouseClick);
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.Controls.Add(this.linkLabel4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.linkLabel3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.linkLabel2);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.linkLabel1);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.Name = "Form1";
            this.Text = "iPhone4秒杀器";
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Form1_FormClosing);
            this.Load += new System.EventHandler(this.Form1_Load);
            this.SizeChanged += new System.EventHandler(this.Form1_SizeChanged);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.LinkLabel linkLabel1;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.LinkLabel linkLabel2;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.LinkLabel linkLabel3;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.LinkLabel linkLabel4;
        private System.Windows.Forms.NotifyIcon notifyIcon1;

    }
}

逻辑部分：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Text.RegularExpressions;

namespace IP4Killer
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {


        }

        bool Run = false;

        int FreshTimes = 0;
        int OKTimes = 0;

        private  Encoding GetEncoding(string html)
{
string pattern = @"(?i)\bcharset=(?<charset>[-a-zA-Z_0-9]+)";
string charset = Regex.Match(html, pattern).Groups["charset"].Value;
try { return Encoding.GetEncoding(charset); }
catch (ArgumentException) { return null; }
}

        private System.Text.Encoding GetPageEncoding(string url)
        {
            System.Text.Encoding encod = System.Text.Encoding.UTF8;
            try
            {
                System.Net.WebRequest request = System.Net.WebRequest.Create(url);
                System.Net.WebResponse response = request.GetResponse();
                var i = response.Headers.AllKeys;
                System.IO.Stream stream = response.GetResponseStream();
                byte[] header = new byte[1024];
                stream.Read(header, 0, header.Length);
                string head = Encoding.Default.GetString(header);
                stream.Close(); stream.Dispose();
                string patternEncode = @"(?i)\bcharset=(?<charset>[-a-zA-Z_0-9]+)";
                Regex regEncode = new Regex(patternEncode, RegexOptions.IgnoreCase);
                Match match = regEncode.Match(head);
                if (match.Success) {
                    encod = System.Text.Encoding.GetEncoding(match.Groups["charset"].Value);
                }
            }
            catch { } return encod;

        }

        private void Work()
        {
            Run = true;
             String url = "http://store.apple.com/cn/browse/home/shop_iphone/family/iphone";

            System.Net.WebClient aWebClient = new System.Net.WebClient();
            aWebClient.Encoding = GetPageEncoding(url);


            String Current = "";
            String Last = "";
            int Times = 1;


            int temp = 0;
            while (Run)
            {
                Current  = aWebClient.DownloadString("http://store.apple.com/cn/browse/home/shop_iphone/family/iphone");
               // Match match = regEncode.Match(Current);


                String[] strs = Current.Split(new String[] { "暂无供应" }, StringSplitOptions.RemoveEmptyEntries);
                //var current = strs.Length;
                if(strs.Length != temp )

                {

                    if (temp != 0)
                    {

                        OKTimes++;
                        try
                        {

                            System.Diagnostics.Process.Start(url);
                            System.IO.File.WriteAllLines(System.DateTime.Now.ToString("yyyy年MM月dd日HHmmss_") + OKTimes.ToString() + ".html", new String[] { Current });
                        }
                        catch { }
                    }
                    temp  = strs.Length;

                }


                FreshTimes ++;

                if(Run)

                this.Invoke(new doo(this.updateTimes));

            }

        }

        private void Form1_Load(object sender, EventArgs e)
        {
            this.linkLabel2.Text = System.DateTime.Now.ToString("yyyy年MM月dd日 HH:mm:ss");
            updateTimes();

            new System.Threading.Thread(new System.Threading.ThreadStart(Work)).Start();
        }

        private delegate void  doo ();
        private void updateTimes()
        {
            try
            {
                linkLabel3.Text = FreshTimes.ToString();
                linkLabel4.Text = OKTimes.ToString();
                this.notifyIcon1.Text = "刷新:" + FreshTimes.ToString() + "次,秒杀:" + OKTimes.ToString();
            }
            catch { }

        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            Run = false;
        }

        private void Form1_SizeChanged(object sender, EventArgs e)
        {
            switch (this.WindowState)
            {
                case FormWindowState.Normal:
                    this.notifyIcon1.Visible = false;
                    this.ShowInTaskbar = true;
                    break;
                case FormWindowState.Minimized:
                    this.notifyIcon1.Visible = true;
                    this.ShowInTaskbar = false;
                    break;
                case FormWindowState.Maximized:
                    this.notifyIcon1.Visible = false;
                    this.ShowInTaskbar = true;
                    break;
            }
        }

        private void notifyIcon1_MouseClick(object sender, MouseEventArgs e)
        {
            this.WindowState = FormWindowState.Normal;
        }
    }
}

本文链接

周末无聊，发篇蛋疼：聊聊程序员的知识面以“搜商”（两篇）

2010-05-22T06:04:00Z

1.关于新技术怎么对待及程序员的知识面现在真是一个信息爆炸，终身学习的年代，尤其对程序员，对我们这种以代码混温泡的人来说，每天都有新的技术发布，微软的SL，几年内从SL1一直到SL4，.Net 1.0,1.1,2.0,3.0,3.5,4.0想一下，才用了几年，升级了这么多版本。那对于我们，该怎么办？很多朋友一见新技术发布，便一直在学习，从技术预览版到beta1,beta2再到RC，再到正式发布，...

分享一下我的.Net Winform公共库(含程序入口，数据库设置，窗体工厂）加入Demo

2010-05-20T02:24:00Z

做Winform开发有三年了自己也封装了不少控件下面把我现在每一个程序都要用的自己的封闭的公共运行库分享出来与大家交流功能简单，确是很实用这个库主要由三个部分组成1.配置文件管理，主要思想是二进制的序列化，由于当时没用想到用XML，各位达人见笑。2.窗体工厂，就是一个反射工厂，简单的封装了几个函数，由于当时对反射不了解，有几个参数弄的很可笑，大家也笑纳吧，嘿嘿3.应用程序入口，主要实现了运行时保证...

用SMO（sql server management object)生成创建表的脚本

2010-05-13T03:52:00Z

我本人是做C# winform 开发的。最近接触一个任务。要根据SQL里一个现有的表生成创建这个表的脚本。先是想从存储过程的角度解决问题在网上看了一些资料，发现MSSQL本身没有这个功能，要自己去写。而其他的数据库对象（视图，存储过程，触发器）则可以通过 SPHelp_Text来解决。查一些资料无果后，决定自己研究一下。看了一下SQL的联机文档，发现有SMO开发的方式。如果要生成脚本，需要的引用...

关于设计，复用，学习的杂感

2009-11-14T16:38:00Z

首先声明，本人是搞.net 下winform的，一些说法可能不大适用于BS ，如果和各位看官的winform的经验有冲突，欢迎探讨。1.关于设计如果你是一个真正的开发人员，在接到一个任务时，一定要从最基本的抽像做起，去分清业务，分清数据，你可以先画一两个界面来表达一下自己的想法，但是业务逻辑的设计，一定要做到。因为国内的软件公司，大部分都是中下层的小公司，分工时大部分都是一个人一个模块的。一...

从winform转入wcf的初步思考

2009-11-01T13:01:00Z

对于从winform转移到wcf过程中的一些思考

博客园_从挨踢到IT

C#中一种通用的树的生成方式

自己写ORM？是否有必要？

浅析.Net 在 winform及wpf中涉及界面交互的多线程类的封装

自己写Facotry-解析.Net 的反射和attribute

无聊，写个小程序刷iPhone4

周末无聊，发篇蛋疼： 聊聊程序员的知识面以“搜商”（两篇）

分享一下我的.Net Winform公共库(含程序入口，数据库设置，窗体工厂）加入Demo

用SMO（sql server management object)生成创建表的脚本

关于设计，复用，学习的杂感

从winform转入wcf的初步思考

周末无聊，发篇蛋疼：聊聊程序员的知识面以“搜商”（两篇）