51海派软件 - 技术文章

C#.net实现插件式架构

admin1@51haipai.com(ufo1199078) — Thu,02 Sep 2010 10:55:49 +0800

定义插件接口，将其编译为DLL

namespace PluginInterface
{
    public interface IShow
    {
        string show();
    }
}

2 .编写插件，引用上面的DLL，实现上面定义的接口，也编译为DLL

//插件A

namespace PluginInterface
{
    public class PluginA:IShow
    {
        public string show()
        {
            return "插件A";
        }

    }
}

//插件B

namespace PluginB
{
    public class PluginB:IShow
    {

        public string show()
        {
            return "插件B";
        }

    }
}

3，在程序中使用插件，需要引用定义插件接口的DLL

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

        //查找所有的插件的路径
        private List FindPlugin()
        {
            List PluginPaths = new List();
            try
            {
                //获取当前程序的启动路径
                string path = Application.StartupPath;
                //合并路径,指向插件所在的目录
                path = System.IO.Path.Combine(path, "Plugins");
                foreach (string fileName in System.IO.Directory.GetFiles(path, "*.dll"))
                {
                    PluginPaths.Add(fileName);
                }
            }
            catch (Exception exp)
            {
                MessageBox.Show(exp.Message);
            }

            return PluginPaths;
        }

        //载入对象
        //是在Assembly asm 中查找类型，原来没有这参数
        private object LoadObject(Assembly asm,string className, string interfaceName, object[] param)
        {
            try
            {
                //取得className的类型
                //Type t = Type.GetType(className); 原来是这么写的，无论如何都是返回的null
                Type t = asm.GetType(className);

                if (t == null
                 || !t.IsClass   //是否是类
                 || !t.IsPublic //是否是公共
                 || t.IsAbstract //是否为抽象类
                 || t.GetInterface(interfaceName) == null) //是否实现了指定的接口
                {
                    return null;
                }

                //创建对象
                object o = Activator.CreateInstance(t, param);
                if (o == null)
                {
                    //创建失败返回null
                    return null;
                }

                return o;
            }
            catch
            {
                //出现异常返回null
                return null;
            }
        }

        //移除无效的插件返回正确的插件路径列表 invalid :无效的
        private List DeleteInvalidPlugin(List PluginPaths)
        {
            string interfaceName = typeof(IShow).FullName;
            List RightPluginPaths = new List();
            //遍历所有的插件
            foreach (string fileName in PluginPaths)
            {
                try
                {
                    Assembly asm = Assembly.LoadFile(fileName);
                    // 遍历导出的插件类
                    foreach (Type t in asm.GetExportedTypes())
                    {
                        //查找指定接口
                        IShow plugin = LoadObject(asm
    , t.FullName, interfaceName, null) as IShow;
                        //如果找到，将插件路径添加到RightPluginPaths，并结束循环
                        if (plugin != null)
                        {
                            RightPluginPaths.Add(fileName);
                            break;
                        }
                    }
                }
                catch
                {
                    MessageBox.Show(fileName+"不是有效的插件");
                }
            }

            return RightPluginPaths;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            List PluginPaths = FindPlugin();
            PluginPaths = DeleteInvalidPlugin(PluginPaths);
            foreach (string path in PluginPaths)
            {
                try
                {
                    //获得文件名称
                    string asmFile = path;
                    string asmName = System.IO.Path.GetFileNameWithoutExtension(asmFile);
                    if (asmFile != string.Empty)
                    {

                        // 利用反射,构造DLL文件的实例
                        System.Reflection.Assembly asm = System.Reflection.Assembly.LoadFrom(asmFile);

                        //利用反射,从程序集(DLL)中,提取类,并把此类实例化

                        //原来这么写的，无法实例化
                        // PluginInterface.IShow iShow = (PluginInterface.IShow)System.Activator.CreateInstance(asm.GetType(asmName + "Namespace." + asmName + "Class"));
                        Type[] t = asm.GetExportedTypes();
                        foreach (Type type in t)
                        {
                            if (type.GetInterface(typeof(IShow).FullName) != null)
                            {
                                PluginInterface.IShow iShow = (PluginInterface.IShow)System.Activator.CreateInstance(type);
                                // 在主程序中使用这个类的实例
                                label2.Text += iShow.show();
                            }
                        }
                    }
                }

                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

            }

        }
    }
}

c# TreeView节点查找类无限子节点查找上下两方向查找

admin1@51haipai.com(ufo1199078) — Thu,27 May 2010 16:24:32 +0800

下面直接贴出代码：（转载的要厚道，请标志出转载自本站谢谢）

调用查询类的方法：
if (向上)
            {
                TreeViewLookUp.LookUpNode(你的节点树,LookUpType.UPTILT_LOOK,要查询的内容);
            }
if (向下)
            {
                TreeViewLookUp.LookUpNode(你的节点树, LookUpType.ADOWN_LOOK, 要查询的内容);
            }

Treeview查询类源码：

 程序代码


using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;

namespace Colliery3DGS
{
    public class TreeViewLookUp
    {
        /// 
        /// 查询节点
        /// 
        /// treeview控件
        /// 查询类型（向上、向下查找）
        /// 
        public static void LookUpNode(TreeView treeview, LookUpType type, string QuestName)
        {
            if (treeview.Nodes.Count == 0)
            {
                MessageBox.Show("没有可搜索的内容", "提示");
                return;
            }
            if (type == LookUpType.ADOWN_LOOK)
            {
                if (treeview.SelectedNode != null)
                {
                    treeview.SelectedNode = FindNodeDown(treeview.SelectedNode, QuestName, false);
                }
                else
                {
                    treeview.SelectedNode = FindNodeDown(treeview.Nodes[0], QuestName, true);
                }
                if (treeview.SelectedNode == null)
                {
                    MessageBox.Show(" 已经搜索到最后，系统将会从头开始搜索", "提示");
                }
            }
            if (type == LookUpType.UPTILT_LOOK)
            {
                if (treeview.SelectedNode != null)
                {
                    treeview.SelectedNode = FindNodeUP(treeview.SelectedNode, QuestName, false);
                }
                else
                {
                    treeview.SelectedNode = FindNodeUP(treeview.Nodes[treeview.Nodes.Count - 1], QuestName, true);
                }
                if (treeview.SelectedNode == null)
                {
                    MessageBox.Show(" 已经搜索到最顶，系统将会从头最后搜索", "提示");
                }
            }

        }

        /// 
        /// 向上查找
        /// 
        /// 起始节点
        /// 要查询的名称
        /// 当前选中节点如果为空
        /// 返回符合的节点，如果为空则没有可是的
        private static TreeNode FindNodeUP(TreeNode nodePare, string QuestName, bool bl)
        {
            if (nodePare.Text.Contains(QuestName) && bl)//判断是否符合条件
                return nodePare;
            if (nodePare.Nodes.Count > 0)
            {
                TreeNode nodeSelect = FindNodeUP(nodePare.Nodes[nodePare.Nodes.Count - 1], QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }
            if (nodePare.PrevNode != null)
            {
                TreeNode nodeSelect = FindNodeUP(nodePare.PrevNode, QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }
            else if (nodePare.Parent != null && nodePare.Parent.PrevNode != null)
            {
                TreeNode nodeSelect = FindNodeUP(nodePare.Parent.PrevNode, QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }

            return null;
        }


        /// 
        /// 向下查找
        /// 
        /// 起始节点
        /// 要查询的名称
        /// 当前选中节点如果为空
        /// 返回符合的节点，如果为空则没有可是的
        private static TreeNode FindNodeDown(TreeNode nodePare, string QuestName, bool bl)
        {
            if (nodePare.Text.Contains(QuestName) && bl)//判断是否符合条件
                return nodePare;
            if (nodePare.Nodes.Count > 0)
            {
                TreeNode nodeSelect = FindNodeDown(nodePare.Nodes[0], QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }
            if (nodePare.NextNode != null)
            {
                TreeNode nodeSelect = FindNodeDown(nodePare.NextNode, QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }
            else if (nodePare.Parent != null && nodePare.Parent.NextNode != null)
            {
                TreeNode nodeSelect = FindNodeDown(nodePare.Parent.NextNode, QuestName, true);
                if (nodeSelect != null)
                    return nodeSelect;
            }
            return null;
        }
    }

    /// 
    /// 查找类型
    /// 
    public enum LookUpType
    {
        /// 
        /// 向上查找
        /// 
        UPTILT_LOOK,
        /// 
        /// 向下查找
        /// 
        ADOWN_LOOK,
    }
}

c#(mobile) 绘制文字自动换行的实现

admin1@51haipai.com(ufo1199078) — Wed,17 Mar 2010 17:29:54 +0800

问题描述：写一个自定义的控件，在使用Graphics.DrawString()方法时发现.NET Compact Framework不支持自动换行。

问题解决：自己写了一个方法实现自动换行，主要实现了以下情况的换行：1.文本长度超过指定宽度2.文本中包含回车换行符。相关代码如下：

///

/// 绘制文本自动换行（超出截断）

///

        /// 绘图图面

        /// 字体

        /// 文本

        /// 绘制范围

        private void DrawStringWrap(Graphics graphic, Font font, string text, Rectangle recangle)

        {

            List textRows = GetStringRows(graphic, font, text, recangle.Width);

            int rowHeight = (int)(Math.Ceiling(graphic.MeasureString("测试", font).Height));



            int maxRowCount = recangle.Height / rowHeight;

            int drawRowCount = (maxRowCount < textRows.Count) ? maxRowCount : textRows.Count;

            int top = (recangle.Height - rowHeight * drawRowCount) / 2;

            StringFormat sf = new StringFormat();

            sf.Alignment = StringAlignment.Near;

            sf.LineAlignment = StringAlignment.Center;

            for (int i = 0; i < drawRowCount; i++)

            {

                Rectangle fontRectanle = new Rectangle(recangle.Left, top + rowHeight * i, recangle.Width, rowHeight);

                graphic.DrawString(textRows[i], font, new SolidBrush(Color.Black), fontRectanle, sf);

            }

        }

        ///

/// 将文本分行

///

        /// 绘图图面

        /// 字体

        /// 文本

        /// 行宽

        ///

        private List GetStringRows(Graphics graphic, Font font, string text, int width)

        {

            int RowBeginIndex = 0;

            int rowEndIndex = 0;

            int textLength = text.Length;

            List textRows = new List();

            for (int index = 0; index < textLength; index++)

            {

                rowEndIndex = index;

                if (index == textLength - 1)

                {

                    textRows.Add(text.Substring(RowBeginIndex));

                }

                else if (rowEndIndex + 1 < text.Length && text.Substring(rowEndIndex, 2) == "\r\n")

                {

                    textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex));

                    rowEndIndex=index += 2;

                    RowBeginIndex = rowEndIndex;

                }

                else if (graphic.MeasureString(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex + 1), font).Width > width)

                {

                    textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex));

                    RowBeginIndex = rowEndIndex;

                }

            }

            return textRows;

        }

# 开发ActiveX控件及制作CAB包

admin1@51haipai.com(ufo1199078) — Wed,17 Mar 2010 17:29:00 +0800

原文地址：http://blog.bossma.cn/archives/2009/09/271

一个项目要用到ActiveX控件，参照网上众多的例子，ActiveX控件倒是很容易就搞出来了；
然后做了一个【安装项目】，倒是可以使用，只不过需要在客户端手动点击安装，下一步，下一步…觉得不是很爽；
又试了试【CAB项目】，好像没人用VS2008来做，费了点功夫，终于找到解决办法。
特将此经验与大家分享。

开发工具：Visual Studio 2008
.NET版本：2.0
开发语言：C#

一、编写ActiveX控件
1、新建一个【Windows窗体控件库项目】
Windows控件库项目

2、添加一个【用户控件】
添加用户控件

3、拖两个Label控件到界面上
拖两个Lable控件

4、为控件添加一个方法，用来设置在Label中显示当前时间

1. ///

2. /// 设置当前时间
3. ///

   4.         ///
   5.         public void SetTime(string timeStr)
   6.         {
   7.             this.label2.Text = timeStr;
   8.         }

5、新建一个接口：
据说实现该接口的目的就是提高程序的安全性，以便客户端IE在不更改设置的情况下可以预行该ActiveX控件。
关于这个有篇文章，推荐大家看看：

http://blog.csdn.net/optman/archive/2007/07/18/1698070.aspx

   1. using System;
   2. using System.Collections.Generic;
   3. using System.Text;
   4. using System.Runtime.InteropServices;
   5.
   6. namespace HelloBossma
   7. {
   8.     [ComImport, GuidAttribute("CB5BDC81-93C1-11CF-8F20-00805F2CD064")]
   9.     [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
  10.     public interface IObjectSafety
  11.     {
  12.         [PreserveSig]
  13.         int GetInterfaceSafetyOptions(ref Guid riid, [MarshalAs(UnmanagedType.U4)] ref int pdwSupportedOptions, [MarshalAs(UnmanagedType.U4)] ref int pdwEnabledOptions);
  14.
  15.         [PreserveSig()]
  16.         int SetInterfaceSafetyOptions(ref Guid riid, [MarshalAs(UnmanagedType.U4)] int dwOptionSetMask, [MarshalAs(UnmanagedType.U4)] int dwEnabledOptions);
  17.     }
  18. }

6、让我们的控件实现这个接口
关于实现这个接口，篇幅较长，可以在这篇文章找到：

http://www.pinvoke.net/default.aspx/Interfaces/IObjectSafety.html

7、为我们的控件添加Guid、ProgId和ComVisible属性

   1. namespace HelloBossma
   2. {
   3.     [Guid("636B8CE1-7512-464C-B63C-FC75BDCA21DB"), ProgId("HelloBossma.HelloBossmaActiveX"), ComVisible(true)]
   4.     public partial class HelloBossmaActiveX : UserControl, IObjectSafety
   5.     {
   6. ...
   7.     }
   8. }

8、打开项目属性，在生成里边，勾选【为Com互操作注册】
Com互操作注册

9、生成项目，进入到bin\Release目录下可以看到
HelloBossma.dll
HelloBossma.tlb
这两个文件时必须的，否则生成不成功。

二、制作ActiveX Setup安装文件
1、新建一个安装项目
安装项目

2、在项目上点右键，【添加】->【项目输出】，选择上边的项目
安装项目输出

3、打开安装项目的属性页面，设置安装URL
这里设置为：http://localhost/hellobossma
这个目录必须是实际存在的，用来存放生成的安装文件，供客户端下载安装。

4、生成项目
会生成两个文件，一个exe文件和一个msi文件

5、新建一个网站，添加如下代码到网页中。
其中classid即为控件的Guid。

   1.
   2.

6、将安装项目生成的exe和msi文件拷贝到网站hellobossma目录中。
HelloBossmaSetup.msi
setup.exe

7、启动网站，确保访问setup.exe的目录与【安装项目】中的【安装URL】一致。

8、一般情况下，网页会弹出提示，是否安装ActiveX控件等，如果提示了也不能安装，需要将网站添加到信任站点，并允许下载不安全和未签名控件。关于控件的签名和认证，本文不做说明，需要的请自行搜索。
安装ActiveX控件

使用这种安装方法，会在客户端弹出安装软件的界面，对客户来说，不太友好。

三、制作ActiveX CAB安装包
尝试了VS中的【CAB项目】模板，但是不幸的是，控件怎么也安装不上，放弃。
在网上看到很多人使用CABARC.EXE，试了一下，居然成功了，特将过程记录下来。

1、下载这个程序包，可以从微软下载，地址：
http://download.microsoft.com/download/platformsdk/cab/2.0/w98nt42kmexp/en-us/cabsdk.exe
解压这个文件，里边有详细的使用说明。

2、【开始】-【运行】，输入“CMD”，在打开的命令提示符界面中，进入解压后文件的BIN目录，

这里需要加入两个文件：
HelloBossmaSetup.msi
install.inf

HelloBossmaSetup.msi 是上边的安装项目生成的安装程序。
install.inf是一个文本文件，指定运行控件所需要下载或者呈交的文件。

关于inf文件的书写规范，这里不做介绍，有需要的可以自己搜一下。
这个例子中install.inf文件的内容

   1. [version]
   2. signature="$CHICAGO$"
   3. AdvancedINF=2.0
   4.
   5. [Setup Hooks]
   6. hook1=hook1
   7.
   8. [hook1]
   9. run=msiexec.exe /i "%EXTRACT_DIR%\HelloBossmaSetup.msi" /qn

有了这两个文件，运行下边的命令，成功的话会在当前目录生成HelloBossma.cab文件。
CABARC

3、把这个文件放到控件下载目录中，然后修改网页中的调用方式。

   1.
   2.
   3.

这里还添加了一个按钮，点击时触发一个事件，调用控件的显示时间方法，点击按钮，你会发现控件上时间的变化。
23

OK，这篇文章到这里正文就结束了。

gdi+编程10个基本技巧

admin1@51haipai.com(ufo1199078) — Wed,17 Mar 2010 15:11:26 +0800

gdi+编程10个基本技巧

创建绘图表面

创建绘图表面有两种常用的方法。下面设法得到picturebox的绘图表面。

private void form1_load(object sender, system.eventargs e)

{

//得到picturebox1的绘图表面

graphics g = this.picturebox1.creategraphics();

}

private void picturebox1_paint(object sender, system.windows.forms.painteventargs e)

{

//得到picturebox1的绘图表面

graphics g = e.graphics;

}

可以利用graphics对象绘制出各种图形图案。控件的paint事件和 onpaint方法都可以绘图都是好时机。在onpaint方法里绘制图案一定从参数e里面得到graphics属性。下面是两个例子。

protected override void onpaint(painteventargs e)

{

e.graphics.clear(color.white);

float x, y, w, h;

x = this.left+2;

y = this.top+2;

w = this.width-4;

h = this.height-4;

pen pen = new pen(color.red, 2);

e.graphics.drawrectangle(pen, x, y, w, h);

base.onpaint (e);

}

private void pictureboxii_resize(object sender, eventargs e)

{

this.invalidate();

}

private void button1_click(object sender, system.eventargs e)

{

this.pictureboxii1.creategraphics().fillellipse(

brushes.blue, 10, 20, 50, 100);

}

和文本有关的三个类：

fontfamily——定义有着相似的基本设计但在形式上有某些差异的一组字样。无法继承此类。

font——定义特定的文本格式，包括字体、字号和字形属性。无法继承此类。

stringformat——封装文本布局信息（如对齐方式和行距），显示操作（如省略号插入和国家标准 (national) 数字位替换）和 opentype 功能。无法继承此类。

下面的程序显示了一段文字。

private void button2_click(object sender, system.eventargs e)

{

graphics g = this.pictureboxii1.creategraphics();

g.fillrectangle(brushes.white, this.pictureboxii1.clientrectangle);

string s = "aaaaaaaaaaaaaaaaaaaaaaaaaa";

fontfamily fm = new fontfamily("ëîìå");

font f = new font(fm, 20, fontstyle.bold, graphicsunit.point);

rectanglef rectf = new rectanglef(30, 20, 180, 205);

stringformat sf = new stringformat();

solidbrush sbrush = new solidbrush(color.fromargb(255, 0, 0, 255));

sf.linealignment = stringalignment.center;

sf.formatflags = stringformatflags.directionvertical;

g.drawstring(s, f, sbrush, rectf, sf);

}

gdi+的路径——graphicspath类

graphicspath类提供了一系列属性和方法，利用它可以获取路径上的关键点，可以添加直线段、圆等几何元素。可以获得包围矩形，进行拾取测试。这些功能都怎么用，要仔细看一下。

private void button3_click(object sender, system.eventargs e)

{

//绘图表面

graphics g = this.pictureboxii1.creategraphics();

//填充成白色

g.fillrectangle(brushes.white, this.clientrectangle);

//弄一个绘图路径¶

graphicspath gp = new graphicspath();

//添加一些集合图形

gp.addellipse(20, 20, 300, 200);

gp.addpie(50, 100, 300, 100, 45, 200);

gp.addrectangle(new rectangle(100, 30, 100, 80));

//在绘图表面上绘制绘图路径

g.drawpath(pens.blue, gp);

//平移

g.translatetransform(200, 20);

//填充绘图路径¶

g.fillpath(brushes.greenyellow, gp);

gp.dispose();

}

区域——region类

从已有的矩形和路径可以创建region。使用graphics.fillregion 方法绘制region。该类指示由矩形和由路径构成的图形形状的内部。无法继承此类。

渐变色填充

需要使用两个刷子：

线性梯度刷子(lineargradientbrush)

路径梯度刷子(pathguadientbrush)

private void button4_click(object sender, system.eventargs e)

{

//绘图表面

graphics g = this.pictureboxii1.creategraphics();

g.fillrectangle(brushes.white, this.pictureboxii1.clientrectangle);

//定义一个线性梯度刷子

lineargradientbrush lgbrush =

new lineargradientbrush(

new point(0, 10),

new point(150, 10),

color.fromargb(255, 0, 0),

color.fromargb(0, 255, 0));

pen pen = new pen(lgbrush);

//用线性笔刷梯度效果的笔绘制一条直线段并填充一个矩形

g.drawline(pen, 10, 130, 500, 130);

g.fillrectangle(lgbrush, 10, 150, 370, 30);

//定义路径并添加一个椭圆

graphicspath gp = new graphicspath();

gp.addellipse(10, 10, 200, 100);

//用该路径定义路径梯度刷子

pathgradientbrush brush =

new pathgradientbrush(gp);

//颜色数组

color[] colors = {

color.fromargb(255, 0, 0),

color.fromargb(100, 100, 100),

color.fromargb(0, 255, 0),

color.fromargb(0, 0, 255)};

//定义颜色渐变比率

float[] r = {0.0f, 0.3f, 0.6f, 1.0f};

colorblend blend = new colorblend();

blend.colors = colors;

blend.positions = r;

brush.interpolationcolors = blend;

//在椭圆外填充一个矩形

g.fillrectangle(brush, 0, 0, 210, 110);

//用添加了椭圆的路径定义第二个路径梯度刷子

graphicspath gp2 = new graphicspath();

gp2.addellipse(300, 0, 200, 100);

pathgradientbrush brush2 = new pathgradientbrush(gp2);

//设置中心点位置和颜色

brush2.centerpoint = new pointf(450, 50);

brush2.centercolor = color.fromargb(0, 255, 0);

//设置边界颜色

color[] color2 = {color.fromargb(255, 0, 0)};

brush2.surroundcolors = color2;

//用第二个梯度刷填充椭圆

g.fillellipse(brush2, 300, 0, 200, 100);

}

gdi+的坐标系统

通用坐标系——用户自定义坐标系。

页面坐标系——虚拟坐标系。

设备坐标系——屏幕坐标系。

当页面坐标系和设备坐标系的单位都是象素时，它们相同。

private void button10_click(object sender, system.eventargs e)

{

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

this.draw(g);

}

private void draw(graphics g)

{

g.drawline(pens.black, 10, 10, 100, 100);

g.drawellipse(pens.black, 50, 50, 200, 100);

g.drawarc(pens.black, 100, 10, 100, 100, 20, 160);

g.drawrectangle(pens.green, 50, 200, 150, 100);

}

private void button5_click(object sender, system.eventargs e)

{

//左移

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

g.translatetransform(-50, 0);

this.draw(g);

}

private void button6_click(object sender, system.eventargs e)

{

//右移

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

g.translatetransform(50, 0);

this.draw(g);

}

private void button7_click(object sender, system.eventargs e)

{

//旋转

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

g.rotatetransform(-30);

this.draw(g);

}

private void button8_click(object sender, system.eventargs e)

{

//放大

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

g.scaletransform(1.2f, 1.2f);

this.draw(g);

}

private void button9_click(object sender, system.eventargs e)

{

//缩小

graphics g = this.pictureboxii1.creategraphics();

g.clear(color.white);

g.scaletransform(0.8f, 0.8f);

this.draw(g);

}

全局坐标——变换对于绘图表面上的每个图元都会产生影响。通常用于设定通用坐标系。

一下程序将原定移动到控件中心，并且y轴正向朝上。

//先画一个圆

graphics g = e.graphics;

g.fillrectangle(brushes.white, this.clientrectangle);

g.drawellipse(pens.black, -100, -100, 200, 200);

//使y轴正向朝上，必须做相对于x轴镜像

//变换矩阵为[1,0,0,-1,0,0]

matrix mat = new matrix(1, 0, 0, -1, 0, 0);

g.transform = mat;

rectangle rect = this.clientrectangle;

int w = rect.width;

int h = rect.height;

g.translatetransform(w/2, -h/2);

//以原点为中心，做一个半径为100的圆

g.drawellipse(pens.red, -100, -100, 200, 200);

g.translatetransform(100, 100);

g.drawellipse(pens.green, -100, -100, 200, 200);

g.scaletransform(2, 2);

g.drawellipse(pens.blue, -100, -100, 200, 200);

局部坐标系——只对某些图形进行变换，而其它图形元素不变。

protected override void onpaint(painteventargs e)

{

graphics g = e.graphics;

//客户区设置为白色

g.fillrectangle(brushes.white, this.clientrectangle);

//y轴朝上

matrix mat = new matrix(1, 0, 0, -1, 0, 0);

g.transform = mat;

//移动坐标原点到窗体中心

rectangle rect = this.clientrectangle;

int w = rect.width;

int h = rect.height;

g.translatetransform(w/2, -h/2);

//在全局坐标下绘制椭圆

g.drawellipse(pens.red, -100, -100, 200, 200);

g.fillrectangle(brushes.black, -108, 0, 8, 8);

g.fillrectangle(brushes.black, 100, 0, 8, 8);

g.fillrectangle(brushes.black, 0, 100, 8, 8);

g.fillrectangle(brushes.black, 0, -108, 8, 8);

//创建一个椭圆然后在局部坐标系中进行变换

graphicspath gp = new graphicspath();

gp.addellipse(-100, -100, 200, 200);

matrix mat2 = new matrix();

//平移

mat2.translate(150, 150);

//旋转

mat2.rotate(30);

gp.transform(mat2);

g.drawpath(pens.blue, gp);

pointf[] p = gp.pathpoints;

g.fillrectangle(brushes.black, p[0].x-2, p[0].y+2, 4, 4);

g.fillrectangle(brushes.black, p[3].x-2, p[3].y+2, 4, 4);

g.fillrectangle(brushes.black, p[6].x-4, p[6].y-4, 4, 4);

g.fillrectangle(brushes.black, p[9].x-4, p[9].y-4, 4, 4);

gp.dispose();

//base.onpaint (e);

}

alpha混合

color.fromargb()的a就是alpha。alpha的取值范围从0到 255。0表示完全透明，255完全不透明。

当前色＝前景色×alpha/255+背景色×（255－alpha）/255

protected override void onpaint(painteventargs e)

{

graphics g = e.graphics;

//创建一个填充矩形

solidbrush brush = new solidbrush(color.blueviolet);

g.fillrectangle(brush, 180, 70, 200, 150);

//创建一个位图，其中两个位图之间有透明效果

bitmap bm1 = new bitmap(200, 100);

graphics bg1 = graphics.fromimage(bm1);

solidbrush redbrush =

new solidbrush(color.fromargb(210, 255, 0, 0));

solidbrush greenbrush =

new solidbrush(color.fromargb(210, 0, 255, 0));

bg1.fillrectangle(redbrush, 0, 0, 150, 70);

bg1.fillrectangle(greenbrush, 30, 30, 150, 70);

g.drawimage(bm1, 100, 100);

//创建一个位图，其中两个位图之间没有透明效果

bitmap bm2 = new bitmap(200, 100);

graphics bg2 = graphics.fromimage(bm2);

bg2.compositingmode = compositingmode.sourcecopy;

bg2.fillrectangle(redbrush, 0, 0, 150, 170);

bg2.fillrectangle(greenbrush, 30, 30, 150, 70);

g.compositingquality = compositingquality.gammacorrected;

g.drawimage(bm2, 300, 200);

//base.onpaint (e);

}

反走样

protected override void onpaint(painteventargs e)

{

graphics g = e.graphics;

//放大8倍

g.scaletransform(8, 8);

//没有反走样的图形和文字

draw(g);

//设置反走样

g.smoothingmode = smoothingmode.antialias;

//右移40

g.translatetransform(40, 0);

//再绘制就是反走样之后的了

draw(g);

//base.onpaint (e);

}

private void draw(graphics g)

{

//绘制图形和文字

g.drawline(pens.gray, 10, 10, 40, 20);

g.drawellipse(pens.gray, 20, 20, 30, 10);

string s = "反走样测试";

font font = new font("宋体", 5);

solidbrush brush = new solidbrush(color.gray);

g.drawstring(s, font, brush, 10, 40);

}

完了。暂时先总结那么多。以后发现必要的可以再补充。

[.NET开发]C# WinForm制作异形窗体/控件

admin1@51haipai.com(ufo1199078) — Mon,25 Jan 2010 14:28:08 +0800

制作异形窗体或控件的思路一般都是想办法生成一个region，然后设置给指定的窗口或控件。生成region的方法有很多，最常用的就是从一幅图片生成，把该图片中的透明色部分“抠”掉，剩下的部分作为一个region。设置窗口或控件的region可以用SetWindowRgn API，不过.NET framework封装了这个操作，在C#中只要对窗口或控件的Region属性赋值就可以了。下面我就把我在C#中实现异形窗体的核心代码贴出来给大家看看，有什么意见尽管提，别客气哦J

首先，是一个根据Bitmap对象生成Region的方法：

///

/// 取得一个图片中非透明色部分的区域。

///

/// 取其区域的图片。

/// 透明色。

/// 图片中非透明色部分的区域

private Region BmpRgn(Bitmap Picture, Color TransparentColor)

{

     int nWidth = Picture.Width;

     int nHeight = Picture.Height;

     Region rgn = new Region();

     rgn.MakeEmpty();

     bool isTransRgn;//前一个点是否在透明区

     Color curColor;//当前点的颜色

     Rectangle curRect = new Rectangle();

     curRect.Height = 1;

     int x = 0, y = 0;

     //逐像素扫描这个图片，找出非透明色部分区域并合并起来。

     for(y = 0; y < nHeight; ++y)

     {

         isTransRgn = true;

         for (x = 0; x < nWidth; ++x)

         {

              curColor = Picture.GetPixel(x,y);

              if(curColor == TransparentColor || x == nWidth - 1)//如果遇到透明色或行尾

                   {

                       if(isTransRgn == false)//退出有效区

                       {

                            curRect.Width = x - curRect.X;

                            rgn.Union(curRect);

                       }

                   }

                   else//非透明色

                   {

                       if(isTransRgn == true)//进入有效区

                       {

                            curRect.X = x;

                            curRect.Y = y;

                       }

                   }//if curColor

                   isTransRgn = curColor == TransparentColor;

              }//for x

         }//for y

         return rgn;

     }

原理很简单，就是对该图片逐行扫描，在每一行中把那些非透明色的矩形（只有一个像素高）合并（union）到一个Region对象中，当扫描完整个图片，得到的也就是我们想要的Region了。这种算法在很多文章里都有介绍的。

有了region，下面就简单了：

this.Region = BmpRgn(new Bitmap("d:\\a.bmp"), Color.FromArgb(0, 0, 0));

上面的代码就是把d:\a.bmp的轮廓作为主窗口的region的，假设该图片的背景黑色（Color.FromArgb(0, 0, 0）)。

其实不光是Form，任何控件都可以用这个方法设置Region，制作出异形控件。

在程序中加载解析3DS文件，显示三维模型（c# MDX），

admin1@51haipai.com(ufo1199078) — Fri,22 Jan 2010 13:23:46 +0800

在程序中加载解析3DS文件，显示三维模型（c# MDX），

把3ds转化为x文件后有很多问题（试了好多转换工具都不行，如果你有好工具别忘了告诉我），因此决心直接解析3DS文件然后用mesh显示。
解析3DS文件网上有好多代码，但我就只找到一个是C#写的，C#的太多资源仍然稀缺啊
http://www.nabble.com/3DS-File-loader-t1663534.html

它是用OpenGL显示的，我还得把它移植到MDX上来。
（C++写的解析显示3DS的代码，目前我只找到了几个opengl的，没找到directx的，如果你知道不要忘了告诉我啊）
还有许多细节上的问题…………

全部的源代码：http://bbs.gameres.com/showthread.asp?page=end&threadid=83967

代码仅Form1.cs是我写的，其他的是来自（http://www.nabble.com/3DS-File-loader-t1663534.html），仅有少许修改。

当前的显示还有一些问题，有一些三角形显示不出来，又有一些三角形是多余的，可是我的顶点和索引解析不会有问题呀，郁闷，期待大家一起帮忙完善。

源码下载地址：下载

Form1.cs

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace ThreeD
{
///

/// Summary description for Form1.
///

public class Form1 : System.Windows.Forms.Form
{
        private Device device = null;
        private Mesh mesh = null;
        private Material[] meshMaterials;
        private Texture[] meshTextures;

///

/// Required designer variable.
///

private System.ComponentModel.Container components = null;
        private float angle = 0.0f;

public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();

            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
}

        ///

/// We will initialize our graphics device here
///

        public void InitializeGraphics()
        {
            // Set our presentation parameters
            PresentParameters presentParams = new PresentParameters();

            presentParams.Windowed = true;
            presentParams.SwapEffect = SwapEffect.Discard;
            presentParams.AutoDepthStencilFormat = DepthFormat.D16;
            presentParams.EnableAutoDepthStencil = true;

            // Create our device
            device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);

            // Load our mesh
            //LoadMesh(@"..\..\tiny.x");
            //LoadD3S(@"E:\myprog\MeshFile\tpot.3ds");
            LoadD3S(@"E:\myprog\box.3ds");
        }

        private void LoadMesh(string file)
        {
            ExtendedMaterial[] mtrl;

            // Load our mesh
            mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out mtrl);

            // If we have any materials, store them
            if ((mtrl != null) && (mtrl.Length > 0))
            {
                meshMaterials = new Material[mtrl.Length];
                meshTextures = new Texture[mtrl.Length];

                // Store each material and texture
                for (int i = 0; i < mtrl.Length; i++)
                {
                    meshMaterials[i] = mtrl[i].Material3D;
                    if ((mtrl[i].TextureFilename != null) && (mtrl[i].TextureFilename != string.Empty))
                    {
                        // We have a texture, try to load it
                        meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" + mtrl[i].TextureFilename);
                    }
                }
            }
        }
        private void LoadD3S(string file)
        {

            /*
             * mesh = Mesh.FromFile(file, MeshFlags.Managed, device, out mtrl);

            // If we have any materials, store them
            if ((mtrl != null) && (mtrl.Length > 0))
            {
                meshMaterials = new Material[mtrl.Length];
                meshTextures = new Texture[mtrl.Length];

                // Store each material and texture
                for (int i = 0; i < mtrl.Length; i++)
                {
                    meshMaterials[i] = mtrl[i].Material3D;
                    if ((mtrl[i].TextureFilename != null) && (mtrl[i].TextureFilename != string.Empty))
                    {
                        // We have a texture, try to load it
                        meshTextures[i] = TextureLoader.FromFile(device, @"..\..\" + mtrl[i].TextureFilename);
                    }
                }
            }*/

            ExtendedMaterial[] mtrl;
            Model model = new ThreeDSFile(file).ThreeDSModel;

            Entity e = model.Entities[0];
            int numberVerts = e.vertices.Length;
            mesh = new Mesh(numberVerts * 3, numberVerts, MeshFlags.Managed,
                     CustomVertex.PositionNormal.Format, device);

            using (IndexBuffer ib = mesh.IndexBuffer)
            {
                ib.SetData(e.indices, 0, LockFlags.None);
            }
            using (VertexBuffer vb = mesh.VertexBuffer)
            {
                GraphicsStream data = vb.Lock(0, 0, LockFlags.None);
                //for(int i2=0;i2                for(int i2=0;i2                {
                    data.Write
                        (new CustomVertex.PositionNormal
                        (
                        (float)e.vertices[i2].X,(float)e.vertices[i2].Y, (float)e.vertices[i2].Z,
                        (float)e.normals[i2].X, (float)e.normals[i2].Y, (float)e.normals[i2].Z
                        )
                        );

                }
                vb.Unlock();
            }


            meshMaterials = new Material[1];
            meshTextures = new Texture[1];
            /*meshMaterials[0].Ambient = e.material.Ambient;
            meshMaterials[0].Diffuse = e.material.Diffuse;
            meshMaterials[0].Emissive = e.material.Shininess;
            meshMaterials[0].Specular = e.material.Specular;
             */
            meshMaterials[0].Ambient = Color.FromArgb((int)e.material.Ambient[0], (int)e.material.Ambient[1], (int)e.material.Ambient[2]);
            meshMaterials[0].Diffuse = Color.FromArgb((int)e.material.Diffuse[0], (int)e.material.Diffuse[1], (int)e.material.Diffuse[2]);
            //meshMaterials[0].Emissive = e.material.Shininess;
            meshMaterials[0].Specular = Color.FromArgb((int)e.material.Specular[0], (int)e.material.Specular[1], (int)e.material.Specular[2]);


            // Load our mesh
            /*Model model = new ThreeDSFile(file).ThreeDSModel;
            for (int i = 0; i < model.Entities.Count; i++)
            {
                Entity e = model.Entities[i];
                for(int i2=0;i2                {
                    e.indices[i2].vertex1;
                }
            };
            model.Entities.
             * */




        }

        private void SetupCamera()
        {
            device.RenderState.CullMode = Cull.None;
            device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, this.Width / this.Height, 1.0f, 10000.0f);
            device.Transform.View = Matrix.LookAtLH(new Vector3(0,0, 580.0f), new Vector3(), new Vector3(0,1,0));
            //device.RenderState.Ambient = Color.DarkBlue;
            device.Lights[0].Type = LightType.Directional;
            device.Lights[0].Diffuse = Color.White;
            device.Lights[0].Direction = new Vector3(0, -1, -1);
            //device.Lights[0].Commit();
            device.Lights[0].Enabled = true;

        }

        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue, 1.0f, 0);

            SetupCamera();

            device.BeginScene();

            // Draw our Mesh
            DrawMesh(angle / (float)Math.PI, angle / (float)Math.PI * 2.0f, angle / (float)Math.PI / 4.0f, 0.0f, 0.0f, 0.0f);

            device.EndScene();

            device.Present();

            this.Invalidate();
        }

        private void DrawMesh(float yaw, float pitch, float roll, float x, float y, float z)
        {
            angle += 0.1f;

            device.Transform.World = Matrix.RotationYawPitchRoll(yaw, pitch, roll) * Matrix.Translation(x, y, z);

            for (int i = 0; i < meshMaterials.Length; i++)
            {
                Material boxMaterial = new Material();
                boxMaterial.Ambient = Color.White;
                boxMaterial.Diffuse = Color.White;
                device.Material = boxMaterial;
                //device.Material = meshMaterials[i];
                //device.SetTexture(0, meshTextures[i]);
                mesh.DrawSubset(i);
            }
        }

        ///

/// Clean up any resources being used.
///

protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}

#region Windows Form Designer generated code
///

/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
///

private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.Size = new Size(800,600);
this.Text = "Form1";
}
#endregion

///

/// The main entry point for the application.
///

        static void Main()
        {
            using (Form1 frm = new Form1())
            {
                // Show our form and initialize our graphics engine
                frm.Show();
                frm.InitializeGraphics();
                Application.Run(frm);
            }
        }
}
}

AES加密解密 Web版及程序版

admin1@51haipai.com(ufo1199078) — Tue,12 Jan 2010 16:24:34 +0800

软件功能：可用来加密任何文本，只要别人不知道你的密码，基本上他是************不了的，所以呀，机器上那些想保密的东西都用来加密吧，嘎嘎

Web版地址：http://www.yongfa365.com/Tools/AES/Default.aspx

AES高级加密标准　密码学中的高级加密标准，是美国联邦政府采用的一种区块加密标准。

主要代码：

view plaincopy to clipboardprint?
using System;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace YongFa365.Security
{
    ///

    /// AES加密解密
    ///
    public class AES
    {
        public static string Encrypt(string strEncrypt, string strKey)
        {
            try
            {
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(strKey, "md5"));
                byte[] strEncryptArray = UTF8Encoding.UTF8.GetBytes(strEncrypt);
                byte[] resultArray = null;

                using (RijndaelManaged rDel = new RijndaelManaged())
                {
                    rDel.Key = keyArray;
                    rDel.Mode = CipherMode.ECB;
                    rDel.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = rDel.CreateEncryptor();

                    resultArray = cTransform.TransformFinalBlock(strEncryptArray, 0, strEncryptArray.Length);

                }
                return Convert.ToBase64String(resultArray, 0, resultArray.Length);
            }
            catch
            {
                return null;
            }
        }

        public static string Decrypt(string strDecrypt, string strKey)
        {
            try
            {
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(strKey, "md5"));
                byte[] strDecryptArray = Convert.FromBase64String(strDecrypt);
                byte[] resultArray = null;

                using (RijndaelManaged rDel = new RijndaelManaged())
                {
                    rDel.Key = keyArray;
                    rDel.Mode = CipherMode.ECB;
                    rDel.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = rDel.CreateDecryptor();
                    resultArray = cTransform.TransformFinalBlock(strDecryptArray, 0, strDecryptArray.Length);

                }

                return UTF8Encoding.UTF8.GetString(resultArray);
            }
            catch
            {

                return null;
            }
        }


    }
}

using System;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace YongFa365.Security
{
    ///
    /// AES加密解密
    ///
    public class AES
    {
        public static string Encrypt(string strEncrypt, string strKey)
        {
            try
            {
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(strKey, "md5"));
                byte[] strEncryptArray = UTF8Encoding.UTF8.GetBytes(strEncrypt);
                byte[] resultArray = null;

                using (RijndaelManaged rDel = new RijndaelManaged())
                {
                    rDel.Key = keyArray;
                    rDel.Mode = CipherMode.ECB;
                    rDel.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = rDel.CreateEncryptor();

                    resultArray = cTransform.TransformFinalBlock(strEncryptArray, 0, strEncryptArray.Length);

                }
                return Convert.ToBase64String(resultArray, 0, resultArray.Length);
            }
            catch
            {
                return null;
            }
        }

        public static string Decrypt(string strDecrypt, string strKey)
        {
            try
            {
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(strKey, "md5"));
                byte[] strDecryptArray = Convert.FromBase64String(strDecrypt);
                byte[] resultArray = null;

                using (RijndaelManaged rDel = new RijndaelManaged())
                {
                    rDel.Key = keyArray;
                    rDel.Mode = CipherMode.ECB;
                    rDel.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = rDel.CreateDecryptor();
                    resultArray = cTransform.TransformFinalBlock(strDecryptArray, 0, strDecryptArray.Length);

                }

                return UTF8Encoding.UTF8.GetString(resultArray);
            }
            catch
            {

                return null;
            }
        }

    }
}
相关类及Demo下载地址：AES加密解密.rar

共享软件加密的一些误区及防破解的实用招法

admin1@51haipai.com(ufo1199078) — Tue,12 Jan 2010 15:35:51 +0800

先总结一下：

不要太相信注册表所以把注册码之类的敏感信息放在里边
不要调用系统时间看是不是试用期已过，可以调用一些系统文件的创建时间
不要将敏感信息以明文的形式写在程序中，防止直接十六进制查看
加密或验证部分与软件主体部分耦合度要高（虽然不便维护）
不要对注册码进行明文比较，防内存补丁，至少md5后比较
不要将出错提示信息紧跟在加密判断之后，防直接查找字符串，快速定位破解
检查自己的进程的父进程是否为Explorer.exe，不是就Kill掉，甚至Kill自己
.net winform程序，最好先混淆，或加密，不然被轻易破解机率为100%

--------------------------------------------------------------------------------

共享软件加密的一些误区
  本文发表于《电脑软件编程与维护》 2005年12期
  作者：星轨（oRbIt）
  E_Mail ：inte2000@163.com

　　共享软件通常是指那种采用“先使用，后付款”的方式发布的软件，这类软件通常有两个（或多个）不同的版本，公开发布的是一个功能受限制或使用时间和次数受限制的共享版本，只有当用户购买（或注册）之后才可以使用没有限制的正式版本。共享软件从出现的那一天起就深受破解者（Cracker）的“喜爱”，因为相对于防范较为严密或使用硬件加密的商业软件来说，共享软件是比较容易破解的。虽然许多共享软件的作者也采用了时间限制或注册码校验等方法保护自己的软件，但是多数共享软件的作者对软件加密与解密技术不了解，对加密方法的应用和代码编写过程中存在许多漏洞，从而使看似很可靠的加密方法形同虚设。软件破解者（甚至是一些菜鸟级的Cracker）只需要参照网络上的破解教程，按图索骥，就能够去掉一些软件的使用限制，或从内存中抓出正确的注册码，破解高手甚至能够写出注册机，这无疑是宣告了这个软件的死刑。

　　本人也发布过共享软件，经历过软件刚刚发布就被破解的尴尬，痛定思痛之后，开始研究软件加密与解密之道。思之靡多，终有所悟，其实软件加密与解密之间的斗争，道高一尺则魔高一丈，但是最终往往不是技术致胜，而是心态致胜，从软件破解者的心态考虑加密问题，常常能够兵出奇处，以奇致胜。从软件破解者的角度考虑，以下是一些软件作者常犯的一些错误，本人把它们列举出来，希望对广大软件作者能有所帮助：

过分相信Windows注册表的复杂性

　　注册表是Windows系统存储关于计算机配置信息的数据库，所有的数据都是通过一种树状结构以键和子键的方式组织起来，每个键都包含了一组特定的信息，通过键的名称和路径可以查询和修改这些信息。许多共享软件地作者都将一些比较重要的信息，比如注册信息或时间、次数限制存放在注册表中，以为注册表结构复杂，藏一些数据别人找不到。其实这是一个错误的认识，破解者利用一些注册表操作工具很容易就能获得数据在注册表中的存放位置。RegMon就是一款注册表监视软件，它能够监视系统中运行的程序对注册表的读写操作，一切诡秘在它面前都将大白于天下。还有一个名为RegSnap的软件，它的工作原理就是通过比较程序运行前后注册表的变化确定程序在注册表中的读写位置。由此可见，在注册表中存放信息是不安全的，至少要对存储的信息数据进行加密处理。

信息以明文的形式写在程序中
　　C/C++语言的编译程序对代码中出现的字符串通常不作特殊地处理，直接将其按照数据出现的顺序排放在数据段中。一些软件作者没有注意到这一点，导致程序中使用的一些敏感信息以明文的形式出现在可执行程序中，比如注册表某个键的路径、某个文件路径以及加载的外部动态库名字等等。破解者使用WinHex之类的十六进制编辑软件打开程序文件就可以看到这些信息。图（1）就是用十六进制编辑器打开某软件的截图，从中可以看到这个软件可能动态加载了RegKey.dll这个动态库，可能还操作了注册表Software\Microsoft\Windows\ArtComp\RegInfo位置下的某些键。

图（1）可执行文件中的字符串
C/C++程序的设计者稍微修改一下代码就可以避免这种简单的信息泄露，比如字符串“RegKey”，可以在程序中这样声明字符串数据：
static LPCTSTR lpszKey = _T("SfhLfz");
其实就是将每个字母向后移了一位（数值上增加1），使用前稍作处理：
TCHAR szBuffer{32};
lstrcpy(szBuffer,lpszKey);
for(int i = 0; i < lstrlen(lpszKey); i++)
  szBuffer[i]--;
//此时szBuffer中就是“RegKey”的原文

加密或验证部分与软件主体部分耦合度太低
　　基于软件工程思想考虑，应该尽量降低软件模块之间的耦合度，但是对于软件加密来说，耦合度越高则加密强度越高，对注册码的验证最好不要封装到独立的函数或模块中。许多软件作者喜欢将加密或注册信息验证部分的代码封装到一个函数中，在程序中这样使用：
if(CheckRegCode(szRegCode) == TRUE)
{
  //注册信息正确，执行正常的功能
}
else
{
  //注册信息不正确，提示错误
}

这种封装看起来使程序代码结构良好，便于代码的组织与维护，但是也为破解者提供了良机。这样的程序通过反汇编之后通常有以下结构：
push 00406070 '字符串szRegCode参数入栈
call 00401050 '调用CheckRegCode函数
test eax,eax '判断CheckRegCode返回值
je 00401029 '跳转到出错位置
' 注册信息正确，顺序执行

从上面的汇编代码可以看到，只需将执行跳转的je指令（机器码是740B）改成两个NOP（CPU空操作指令，机器码是90）就等于忽略了对CheckRegCode函数返回值的判断，也就是说，无论这个函数返回TRUE还是FALSE，真正的功能代码都会执行，对注册码的校验就形同虚设。破解者根据指令的内存偏移地址计算出在可执行程序文件中的文件偏移位置，直接修改可执行文件就达到了破解这个功能的目的。此外，破解者还知道校验函数的位置是00401050，也就可以直接修改这个函数的代码，将函数开始部分的代码改成：
mov eax,1 ' 机器码是B801
ret ' 机器码是C3
也就是说根本不判断注册码，直接返回1（校验成功的标志），就能够使整个软件的注册码校验功能失效，软件被彻底的破解。

　　还有一些软件作者为了软件开发的便利，将注册码的计算和校验功能封装到一个单独的动态链接库中，在软件安装过程中将其安装在系统目录中，以为这样就可以神不知鬼不觉了，其实不然，破解者利用SoftICE之类的系统级调试工具在系统的LoadLibrary（根据编码的不同可能有LoadLibraryA和LoadLibraryW两个版本）API上下断点，就可以获知程序所有的动态库加载动作，对注册码进行校验的动态库也不例外。知道这些信息之后，破解就变得简单了，无需修改主程序文件，只要将这个动态库替换掉就可以破解这个软件。比如，某软件使用名为“SysSec.dll”的动态库完成注册码校验功能，这个动态库有一个导出函数，函数原型为：
BOOL WINAPI CheckRegCode(LPCTSTR lpszCode);
破解者只需编写一个同名的动态库，也实现一个同名且同类型的导出函数，函数内容仅仅是返回TRUE：
BOOL WINAPI CheckRegCode(LPCTSTR lpszCode)
{
  return TRUE;
}
然后编译这个动态库，将其复制到系统目录覆盖原来的动态库，这样软件运行过程中会调用破解者的动态库，结果可想而知。网上有很多免费或收费的加密算法库，这些库往往不提供源代码，软件作者在使用这些库的时候一定要慎重，原因很简单：首先，这种用法导致加密模块与主程序耦合度不高，很容易被破解者“切开”；其次，这些公开的库就是软件破解者的众失之的，一旦某个破解组织推出了针对这个加密算法库的破解补丁，那么所有基于这个加密算法库的软件就都被破解了。

　　可见，对于软件加密来说，应该尽量增加加密模块与主程序的耦合度，将加密或校验代码嵌入到程序代码中，虽然给代码的组织和维护带来了困难，但是提高了软件的安全性，正所谓有得即有失，鱼和熊掌不可兼得。

对注册码进行明文比较
　　现在网上流行的大部分共享软件都是采用“用户信息/注册码”方式进行加密的，它的使用过程一般是用户把自己的用户信息（用户名、机器特征码等）通过网络或其他方式发送给软件作者，软件作者根据用户信息利用预先设计好的算法计算出一个注册码，然后将此注册码发送给用户，用户得到注册码后按照软件说明的注册步骤在软件中输入用户信息和从软件供应者那里得到的注册码，如果注册码正确就取消时间或功能的限制，成为正式版本。这种保护方法实现起来简单，不需要额外的成本，用户不仅购买方便，还可以根据自己的注册信息得到售后服务。
　　“用户信息/注册码”方式的验证过程其实就是验证用户信息到注册码之间的数学映射关系，这个映射关系通常是由软件开发者制定的，而且映射关系越复杂就越不容易被破解。以用户信息做自变量，E表示映射函数，则该映射关系可被表示为以下映射函数：

  注册码＝ E（用户信息）            映射函数（1）

应该说，只要映射函数E足够复杂，这个映射就是安全的，但是问题往往出在映射函数的两端，也就是作为自变量的用户信息和作为结果的注册码，这两部分都是以明文的形式传递的，如果处理不当就会露出破绽，正所谓良玉其内，败絮其外。以下是软件作者常用的注册信息校验方式：
TCHAR szUserName[32];//存放破解者输入的用户信息（假设是Cracker）
TCHAR szRegCode[64]; //存放破解者输入的注册码（假的，假设是ababababab）
TCHAR szRealRegCode[64];
CalculateRegCode(szUserName,szRealRegCode);//szRealRegCode得到了内部计算的正确注册码
if(lstrcmp(szRegCode,szRealRegCode) == 0)
{
  //输入的注册信息正确
}
else
{
  //输入的注册信息不正确
}

这段代码的问题在于CalculateRegCode函数调用之后，内存中就存在了正确的注册码的明文，保存在内存地址szRealRegCode处，通常情况下破解者不知道这个内存位置，但是借助SoftICE之类的调试软件就很容易跟踪到这个位置。比如，程序为了验证注册信息是否正确需要从注册窗口界面得到用户信息和用户输入的注册码，这些操作最终是通过调用Windows的API GetWindowText（根据编码的不同可能有GetWindowTextA和GetWindowTextW两个版本）或GetDlgItemText（根据编码的不同可能有GetDlgItemTextA和GetDlgItemTextW两个版本）完成的，破解者利用调试软件在这些函数上下断点就可以跟踪到szRegCode（存放破解者输入的假注册码）的内存地址。当然，破解者还可以利用内存搜索得到szRegCode的内存地址，在SoftICE中可以使用以下命令得到szRegCode的内存地址：
s 30: 0 1 FFFFFFFF "ababababab"
在内存地址szRegCode处下内存断点，当有对szRegCode地址进行操作时SoftICE就会中断，以上面的程序为例，就会在lstrcmp调用的时候中断，分析lstrcmp调用前后的代码（通常有以下类似的结构）：
push 00408580 'szRealRegCode地址入栈
push 00408560 'szUserName地址入栈
call 00401080 '调用CalculateRegCode计算正确的注册码，存放在szRealRegCode地址00408580处
push 00408580 'szRealRegCode地址入栈（已经得到正确的注册码）
push 00408520 'szRegCode地址入栈（假的注册码）
call dword ptr [00405050] '调用KERNEL32.lstrcmpA比较
test eax, eax '判断结果
jne 0040104E '注册码比较不正确，跳转到出错位置
'信息正确，顺序执行正常的功能

由此可知，在调用lstrcmp中断时，CalculateRegCode已经计算出来正确的注册码，存放在内存地址00408580处，使用SoftICE的D命令查看内存就可以看到注册码，结果如图（2）所示：

图（2）内存中的注册码

“A12B-457C-120F”就是CalculateRegCode函数根据用户信息计算出来的正确的注册码，破解者绕开CalculateRegCode函数的算法，利用代码中的逻辑漏洞“兵不血刃”就得到了“Cracker”的注册码，重复这个过程就可以得到“张三”或“李四”的注册码，而且这些注册码都是CalculateRegCode函数计算出来的，可谓是“正宗”加“原创”。
  防止这种情况出现的关键是避免注册码以明文的形式出现在内存中，考察映射函数（1），其实只要修改映射函数的输入和输出设计，不返回计算出的正确注册码明文，而是返回一个注册码经过散列（hash）计算之后得到的散列值，就可以避免出现这种情况。例如：

散列值1 ＝ E1（用户信息）         映射函数（2）
散列值2 ＝ MD5（用户注册码）

　　整个注册信息校验过程首先使用映射函数E1根据用户信息在内部计算正确的注册码，但是不直接输出这个注册码，而是利用MD5或CRC32之类的不可逆散列函数计算出注册码的散列值并输出这个散列值1，然后用MD5或CRC32直接计算用户输入的注册码得到散列值2，最后通过比较散列值1和散列值2来判断注册码是否正确。整个过程中正确的注册码只是短暂存在于CalculateRegCode内部，破解者即使通过汇编代码调试跟踪到了比较散列值的地方，也无法得到正确的注册码，只能通过分析CalculateRegCode函数的内部映射方式获得注册码，只要软件设计的映射方式足够复杂就能够让大多数破解者知难而退。  共享软件中负责注册码校验的代码是软件中最关键的代码，也是软件破解者首先要找的地方。通过对校验代码的分析，破解者不仅能够利用前面介绍的方法从内存中抓取正确的注册码，还能了解软件的整个加密策略，甚至写出注册机。所以，尽量隐藏这部分代码，让破解者无法确定它们的位置也就能够极大地提高软件的安全性。

出错提示信息紧跟在加密判断之后出现
　　为了方便软件的版本控制，多数共享软件都将共享版和正式版整合在一起发布，只是通过对使用时间或功能进行限制来区分是共享版还是正式版。这样的软件通常都有一个界面让用户输入注册码，通过验证注册码完成从共享版到注册版的转变。比如在软件界面上添加一个“注册”菜单或在关于对话框中添加一个“注册”按钮，通过用户的点击引导用户完成注册过程。这种策略并无不妥，破解者不大可能根据软件界面元素推测出校验代码的位置，但是许多软件作者对编译原理不了解，往往在得到注册校验结果后立即弹出消息窗口提示注册成功或注册码不正确之类的信息，这就给破解者提供了定位注册码校验代码的线索。就以下面的演示代码为例：
BOOL bCheckValid = CheckValue(注册码...);
if(bCheckValid)
{
  MessageBox(... "注册成功！"...);
}
else
{
  MessageBox(... "注册信息不正确！"...);
}
C/C++的编译器在生成这段代码时，两个提示信息字符串作为静态变量被放置在程序的数据段中，在代码段的MessageBox函数调用的地方会引用这两个地址，这两个地址就能够成为破解者的线索。本文前面已经介绍过，C/C++的编译器对代码中出现的字符串不作任何处理，按照顺序连续排放在数据段的某个位置，用16进制编辑器打开编译过的可执行文件，通常可以在数据段看到这些提示信息的明文。破解者使用字符串搜索（很多16进制编辑器都提供强大的搜索功能）功能在编译过的可执行文件中搜索MessageBox弹出的提示信息，就能定位到这些信息的偏移位置（相对地址），搜索相对地址可以进一步找到引用这些信息的位置，通常就是MessageBox函数的调用位置，这就离CheckValue函数的位置很近了，稍有经验的破解者都可以很容易找到它。将提示信息加密存放就可以避免程序在这些16进制编辑器中泄漏天机，不过最好的方法就是让注册提示信息远离关键的加密校验代码。在很多情况下不必在用户输入注册码后立刻提示成功与否，可以在某个位置设置一个标志，然后在软件的关键功能或核心功能执行之前取出这个标志判断，如果不是有效的注册用户就拒绝执行该功能。此外，对于标志存放也要妥善保护，最简单的方法就是使用定时器或辅助线程，每隔一定的时间就对注册码校验一次，重新设置一次标志的状态，以免被内存补丁程序破解。

其他常见问题
　　使用时间限制功能的共享软件，用该避免使用GetSystemTime或GetLocalTime获得时间，因为破解者通常会在这些众所周知的API上下断点来捕捉程序中的破绽，不仅如此，这两个函数还很容易被“欺骗”，用户只需要修改Windows系统的时间就可以控制这两个API函数返回在“有效期内的”时间，从而使软件永不过期。其实有很多种获取时间的方法，Windows系统的一些关键文件通常只是在安装时创建一次，获得这些文件的创建时间就是一个很好的获取时间的方法。
　　有些软件作者发布的试用版其实就是完整的正式版，只是修改资源将软件界面上的一些功能菜单或按钮禁止，这样做很省事，但是很不安全，破解者只需将被禁止的菜单或按钮重新改成可用就可以将试用版变成正式版，这样的资源修改工具有很多，很多国外软件的汉化版本就是通过修改程序资源实现的，软件作者应该避免采用这种方式加密软件。

总结
　　很多网友向我询问软件加密的问题，但是他们通常觉得我给出的方案过于复杂（换句话说就是没有必要）。有网友问我，我的软件是面向计算机初级用户的，他们连注册表是怎么回事都不知道，怎么会破解我的软件？我的回答是永远不要小看别人，就算别人是菜鸟，但是菜鸟的“朋友”呢？即使一个功能简单的软件，也需要开发者付出很多的心血，但是破解只需要几分钟到几天的时间，这对于软件作者来说是非常不公平的。软件的加密与解密技术并不是什么特别难的技术，希望共享软件的作者能够多了解一些常见的加密与解密方法，更好地保护自己的软件。好的加密方法不一定就是什么高级技术，一个简单的方法如果用的巧妙往往也能起到出其不意的效果。希望本文列举出的常见问题以及相应的对策能够对广大共享软件作者有所帮助。

参考文献
[1] 冉林仓．Win32汇编语言实用教程．北京：清华大学出版社，2004．
[2] Matt Pietrek．An In-Depth Look into the Win32 Portable Executable File Format．MSDN Magazine，2002
[3] 段刚．软件加密技术内幕．北京：电子工业出版社，2004．

--------------------------------------------------------------------------------

共享软件防破解的实用招法
1、检测主程序大小，防止破解补丁之类：

Function TForm1.GesSelfSf: integer;
var
F: file of byte;
begin
Filemode:=0;
Assignfile(F,'.\FileName.exe');
Reset(f);
Result:=Filesize(F);
Closefile(F);
end;

2、检测创建日期和时间，让破解补丁实效：

Function TForm1.FinDate:String;
var
t:TDate;
begin
ShortDateFormat:='yyyy-mm-dd';
t:=FileDateToDateTime(FileAge('FileName.exe'));
Result:=DateToStr(t);
end;

3、注册码加密函数嵌入数学函数，增加破解难度：
（略）

4、必要时自己删除自己（主程序）：

procedure TForm1.Funll;
var
hModule:THandle;
buff:array[0..255]of Char;
hKernel32:THandle;
pExitProcess,pDeleteFileA,pUnmapViewOfFile:Pointer;
begin
hModule:=GetModuleHandle(nil);
GetModuleFileName(hModule, buff, sizeof(buff));
CloseHandle(THandle(4));
hKernel32:=GetModuleHandle('KERNEL32');
pExitProcess:=GetProcAddress(hKernel32, 'ExitProcess');
pDeleteFileA:=GetProcAddress(hKernel32, 'DeleteFileA');
pUnmapViewOfFile:=GetProcAddress(hKernel32, 'UnmapViewOfFile');
asm
LEA EAX, buff
PUSH 0
PUSH 0
PUSH EAX
PUSH pExitProcess
PUSH hModule
PUSH pDeleteFileA
PUSH pUnmapViewOfFile
RET
end;
begin
Funll;
end;
end;

附：注册机破解法的原理以及应对方法

认识注册机破解法
　　顾名思义，写注册机来破解软件注册的方法，就是模仿你的注册码生成算法或者逆向注册码验证算法而写出来的和你一模一样的注册机。如果被写出注册机，你的软件只好免费了。或者你必须更换算法，但以前注过册的合法用户都得被迫更换注册码了。

　　Cracker要写注册机必须详细研究你软件的验证模块，这必须先将你的软件脱壳，再反汇编或者用调试器跟踪。市面上许多加壳和保护软件都吹嘘不可能被脱壳，但到目前为止没有一个软件兑现了自己的诺言。由于CPU最终执行的都是有效指令，所以等你的程序自解压完成后再从内存中Dump出来就可以实现脱壳。因此不要在壳上面花很多功夫，因为没有这个必要。

第一招：制造假相

　　反汇编和调试器跟踪都是不可能防止的，因为所有的Win32程序都必须通过API来调用Windows系统中的关键DLL的（如Kernel32.dll、GDI32.dll等），然而API是可以Hook的。我们只能从自己的代码着手来保护我们的劳动果实了。

　　为了自己调试和以后维护的方便，我们一般采用有意义的名字给我们的函数命名，可这给了Cracker可乘之机。例如这样的函数是什么意思大家应该一目了然吧?IsRegistered（），IsLicensed（），LicenseVerify（），CheckReg（）……这样Cracker就可以轻松地从数千个函数中找到他的目标——你的注册码校验函数!而且破解Delphi编写的软件还有一件TMG小组的破解利器——DeDe。它可以轻松地看到你软件里的Form、Unit和函数名，还可以反汇编一部分代码，更可以和Win32DASM合作反汇编更多的代码，对Delphi编出的程序威胁极大。

　　为了不给Cracker创造温馨舒适的破解环境，要故意混乱（Obfuscate）我们的代码，将软件中所有的函数名全部替换成随机生成的函数名。例如Func_3dfsa_fs32zlfv这个函数是什么意思?恐怕只有天知道了。网上有现成的代码混乱器，按你使用的编程语言的种类可以找到一些。但要注意，只有当你要发布软件时才使用它，而且一定注意备份源代码。否则，当你看不懂你自己的代码时就着急了：）

第二招：用公匙，并改名

　　另外，一定要使用公开密匙算法保护你的软件。RSA、DSA和El Gamal之类的算法都可以从网上找到。但注意：将你算法单元中所有涉及到算法名称的字符串全部改名。避免被Cracker发现你用的算法而模仿写出注册机来!你还可以张冠李戴，明明用的DSA，将名字全部替换成RSA。

　　其它算法，如对称算法和Hash算法也要注意改名，否则这样：

　　EncryptedCode = Blowfish（MD5（UserName），MD5（Key））；

　　 //你的加密算法，使用了Blowfish（对称算法）和MD5（Hash算法）

　　虽然那些Cracker不了解Blowfish和MD5算法的原理，也不会逆向推测它们，但他们了解你的校验算法的流程和算法名，便可马上从网上找到类似的Blowfish和MD5算法包，从而模拟你的软件仿造出注册机。

　　如果你用不常见的，算法如Skipjack（NASA美国航天局标准算法）、LOKI、3-WAY、Safer之类不出名但保密程度很高的算法，并且全部改名，这样就会伤透他们脑筋了。

　　当然，最好把Hash算法也全部改名，会给他们制造更多的困难。但注意，MD5和SHA之类的Hash初始值会被Cracker从内存中找到，这样他就知道你用的Hash了。所以建议同时使用MD5的变形算法Ripe-MD（RMD）128或160或其它的Hash，如Tiger、Haval等算法。

第三招：阻止别人调试

　　还有一点，调试器对我们的威胁很大，我们不会让Cracker们舒舒服服地使用SoftICE、TRW或OllyDbg来调试我们的程序。除了常用的MeItICE方法外，这里我给一个笔者写的方法：

　　 {检查自己的进程的父进程是否为Explorer.exe，否则是被调试器加载了}

　　 {不过注意，控制台程序的父进程在WinNT下是Cmd.exe!}

　　 {注意加载TlHelp32.pas单元}

　　procedure CheckParentProc；
　　 var //检查自己的进程的父进程
　　 Pn: TProcesseNtry32；
　　 sHandle:THandle；
　　 H，ExplProc，ParentProc:Hwnd；
　　 Found:Boolean；
　　 Buffer:array[0..1023]of Char；
　　　 Path:string；
　　 begin
　　 H:= 0；
　　 ExplProc:= 0；
　　 ParentProc:= 0；
　　 //得到Windows的目录
　　 SetString（Path，Buffer）
　　 GetWindowsDirectory（Buffer，Sizeof（Buffer）- 1））；
　　 Path:= UpperCase（Path）+ '\EX PLORER.EXE'；//得到Explorer的路径
　　 //得到所有进程的列表快照
　　 sHandle:= CreateToolHelp32Snap Shot（TH32CS_SNAPALL，0）；
　　 Found:= Process32First（sHandle，Pn）；//查找进程
　　 while Found do //遍历所有进程
　　 begin
　　 if Pn.szExeFile = ParamStr（0）then //自己的进程
　　 begin
　　 ParentProc:= Pn.th32ParentProcessID://得到父进程的进程ID
　　 //父进程的句柄
　　 H:= OpenProcess（PRO CESS_ALL_ACCESS，True，Pn.th32Parent ProcessID）；
　　 end
　　 else if UpperCase（Pn.szExeFile）= Path then
　　 ExplProc:= Pn.th32ProcessID；//Ex plorer的PID
　　 Found:= Process32Next（sHandle，Pn）；//查找下一个
　　 end；
　　 //父进程不是Explorer，是调试器……
　　 if ParentProc <> ExplProc then
　　 begin
　　 TerminateProcess（H，0）；//杀之!除之而后快也! :）
　　 //你还可以加上其它什么死机代码来消遣消遣这位可爱的Cracker:）
　　　 end
　　 end


　　你可以在Delphi或者VC中试试，这样可以把Delphi和VC杀掉了，因为你现在用的是Delphi和VC的内置调试器来运行你的程序。调试的时候你还是把它的注释删掉吧，发布时别忘记激活哟!

第四招：保护字符串

　　最后一个问题，这也是一个非常重要的问题：保护你的字符串!字符串在注册模块中非常重要!当一个富有经验的Cracker破解你的软件时，首先做的就是窃取你的字符串。比如他会输入错误的注册码，得到你关于错误注册码的提示，通常是“无效的注册码，请重新输入!”或者“Invalid key（please input again）”等等，然后用OllyDbg进行断点调试或者用WinDASM、IDA Pro等静态分析工具在被他脱壳后的程序中查找那个字符串，找到后进行分析。因此，请一定加密你的字符串! 使用时再临时解密出来，而且要尽量少使用消息提示框，避免被Cracker找到漏洞。加密字符串不需要太复杂的算法，随便找一个快速的对称算法就可以了。

　　最后提醒大家一句，不要在加密上花太多的功夫!你应该把更多的时间和精力都用来完善你的软件，这样会更合算。借用一位前辈的话来忠告大家吧：花点时间考虑你自己的软件，看看它是否值得保护?如果没人用你的软件，保护也就没有意义了，不要过高估计你的软件“对世界的重要性”!

TreeView序列化，TreeView串行化，TreeView反序列化 c# winform

admin1@51haipai.com(ufo1199078) — Tue,12 Jan 2010 14:59:17 +0800

-

前些天看到“序列化”这个概念，大意就是把对象保存为一个文件，下次再使用时，反序列化一下就OK了，第二天一大早到公司立马做了个Demo,哇，不错，非常之不错，使用此方法后，根本没有延迟的现象。今天终于应用到这个项目中了，同志们再也不用等那10秒了。

特记录于此，供后人瞻仰

view plaincopy to clipboardprint?
using System;
using System.IO;
using System.Windows.Forms;
using System.Runtime.Serialization.Formatters.Binary;
using System.Data;

//from:http://www.ecjtu.org/forum/read.php?tid-12933.html
//反序列化：SerializeTree.TreeViewDataAccess.LoadTreeViewData(treeView1,"C:\\treeview.txt");
//序列化：  SerializeTree.TreeViewDataAccess.SaveTreeViewData(treeView1,"C:\\treeview.txt");


namespace SerializeTree
{
    ///

    /// TreeView串行化类
    ///

    public class TreeViewDataAccess
    {
        public TreeViewDataAccess() { }

        ///

        /// TreeViewData
        ///

        [Serializable()]
        public struct TreeViewData
        {
            public TreeNodeData[] Nodes;

            ///

            /// 递归初始化TreeView数据
            ///

            ///
            public TreeViewData(TreeView treeview)
            {
                Nodes = new TreeNodeData[treeview.Nodes.Count];
                if (treeview.Nodes.Count == 0)
                {
                    return;
                }
                for (int i = 0; i <= treeview.Nodes.Count - 1; i++)
                {
                    Nodes[i] = new TreeNodeData(treeview.Nodes[i]);
                }
            }

            ///

            /// 通过TreeViewData弹出TreeView
            ///

            ///
            public void PopulateTree(TreeView treeview)
            {
                if (this.Nodes == null || this.Nodes.Length == 0)
                {
                    return;
                }
                treeview.BeginUpdate();
                for (int i = 0; i <= this.Nodes.Length - 1; i++)
                {
                    treeview.Nodes.Add(this.Nodes[i].ToTreeNode());
                }
                treeview.EndUpdate();
            }
        }

        ///

        /// TreeNodeData
        ///

        [Serializable()]
        public struct TreeNodeData
        {
            public string Text;
            public int ImageIndex;
            public int SelectedImageIndex;
            public bool Checked;
            public bool Expanded;
            public object Tag;
            public TreeNodeData[] Nodes;

            ///

            /// TreeNode构造函数
            ///

            ///
            public TreeNodeData(TreeNode node)
            {
                this.Text = node.Text;
                this.ImageIndex = node.ImageIndex;
                this.SelectedImageIndex = node.SelectedImageIndex;
                this.Checked = node.Checked;
                this.Expanded = node.IsExpanded;
                this.Nodes = new TreeNodeData[node.Nodes.Count];

                if ((!(node.Tag == null)) && node.Tag.GetType().IsSerializable)
                {
                    this.Tag = node.Tag;
                }
                else
                {
                    this.Tag = null;
                }
                if (node.Nodes.Count == 0)
                {
                    return;
                }
                for (int i = 0; i <= node.Nodes.Count - 1; i++)
                {
                    Nodes[i] = new TreeNodeData(node.Nodes[i]);
                }
            }

            ///

            /// TreeNodeData返回TreeNode
            ///

            ///
            public TreeNode ToTreeNode()
            {
                TreeNode ToTreeNode = new TreeNode(this.Text, this.ImageIndex, this.SelectedImageIndex);
                ToTreeNode.Checked = this.Checked;
                ToTreeNode.Tag = this.Tag;
                if (this.Expanded)
                {
                    ToTreeNode.Expand();
                }
                if (this.Nodes == null && this.Nodes.Length == 0)
                {
                    return null;
                }
                if (ToTreeNode != null && this.Nodes.Length == 0)
                {
                    return ToTreeNode;
                }
                for (int i = 0; i <= this.Nodes.Length - 1; i++)
                {
                    ToTreeNode.Nodes.Add(this.Nodes[i].ToTreeNode());
                }
                return ToTreeNode;
            }
        }
        ///

        /// 加载TreeView
        ///

        ///
        ///
        public static void LoadTreeViewData(TreeView treeView, string path)
        {

            BinaryFormatter ser = new BinaryFormatter();
            Stream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            TreeViewData treeData = ((TreeViewData)(ser.Deserialize(file)));
            treeData.PopulateTree(treeView);
            file.Close();

        }

        ///

        /// 保存TreeView到文件
        ///

        ///
        ///
        public static void SaveTreeViewData(TreeView treeView, string path)
        {
            BinaryFormatter ser = new BinaryFormatter();
            Stream file = new FileStream(path, FileMode.Create);
            ser.Serialize(file, new TreeViewData(treeView));
            file.Close();

        }
    }

    //柳永法加的，序列化，及反序列化DataTable
    class SerializeDataTable
    {
        public static DataTable LoadDataTable(string path)
        {

            BinaryFormatter ser = new BinaryFormatter();
            Stream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            DataTable dt = (DataTable)ser.Deserialize(file);
            file.Close();
            return dt;
        }

        public static void SaveDataTable(DataTable dt, string path)
        {
            BinaryFormatter ser = new BinaryFormatter();
            Stream file = new FileStream(path, FileMode.Create);
            ser.Serialize(file, dt);
            file.Close();

        }
    }

}

using System;
using System.IO;
using System.Windows.Forms;
using System.Runtime.Serialization.Formatters.Binary;
using System.Data;

//from:http://www.ecjtu.org/forum/read.php?tid-12933.html
//反序列化：SerializeTree.TreeViewDataAccess.LoadTreeViewData(treeView1,"C:\\treeview.txt");
//序列化：  SerializeTree.TreeViewDataAccess.SaveTreeViewData(treeView1,"C:\\treeview.txt");

namespace SerializeTree
{
    ///

/// TreeView串行化类
///

    public class TreeViewDataAccess
    {
        public TreeViewDataAccess() { }

        ///

/// TreeViewData
///

        [Serializable()]
        public struct TreeViewData
        {
            public TreeNodeData[] Nodes;

            ///

/// 递归初始化TreeView数据
///

/// 通过TreeViewData弹出TreeView
///

/// TreeNodeData
///

/// TreeNode构造函数
///

/// TreeNodeData返回TreeNode
///

/// 加载TreeView
///

/// 保存TreeView到文件
///