using System;
using System.Collections;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace SerializableTest
{
    [Serializable]
    public class Book
    {
        public ArrayList alBookReader;
        public Book()
        {
            alBookReader = new ArrayList();
        }

        public string strBookName;
        [NonSerialized]
        public string strBookPwd;
        public string BookID { get; set; }
        private string _bookPrice;
        public void SetBookPrice(string price)
        {
            _bookPrice = price;
        }
    }

    //自定义序列化
    [Serializable]
    public class Employee : ISerializable
    {
        public int EmpId = 100;
        public string EmpName = "xxxxx";
        [NonSerialized]
        public string NoSerialString = "NoSerialString-Test";
        //private Employee(SerializationInfo info, StreamingContext ctxt)
        //{
        //    EmpId = (int)info.GetValue("EmployeeId", typeof(int));
        //    EmpName = (String)info.GetValue("EmployeeName", typeof(string));
        //    //NoSerialString = (String)info.GetValue("EmployeeString",typeof(string));
        //}
        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            info.AddValue("EmployeeId", EmpId);
            info.AddValue("EmployeeName", EmpName);
            //info.AddValue("EmployeeString", NoSerialString);
        }
    }

    public class SerializableMethod
    {
        string strBinaryFile = @"c:\book.data";

         //一、BinaryFormatter序列化方式
         public void Serialize(Book book)
         {
             using (FileStream fs = new FileStream(strBinaryFile, FileMode.Create))
             {
                 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                 formatter.Serialize(fs, book);
             }
         }
         public Book DeSerialize()
         {
             Book book;
             using (FileStream fs = new FileStream(strBinaryFile, FileMode.Open))
             {
                 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                 book = (Book)formatter.Deserialize(fs);
             }
             return book;
         }

         //二、XML序列化方式
         string strXmlFile = @"c:\book.xml";
         public void Serialize1(Book book)
         {
             using (FileStream fs = new FileStream(strXmlFile, FileMode.Create))
             {
                 System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(typeof(Book));
                 formatter.Serialize(fs, book);
             }
         }
         public Book DeSerialize1()
         {
             Book book;
             using (FileStream fs = new FileStream(strXmlFile, FileMode.Open))
             {
                 System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(typeof(Book));
                 book = (Book)formatter.Deserialize(fs);
             }
             return book;
         }

        //自定义序列化
         public void OtherEmployeeClassTest()
         {
             Employee mp = new Employee();
             mp.EmpId = 10;
             mp.EmpName = "邱枫";
             mp.NoSerialString = "你好呀";
             Stream steam = File.Open("c:\\temp3.dat", FileMode.Create);
             BinaryFormatter bf = new BinaryFormatter();
             bf.Serialize(steam, mp);
             steam.Close();
             mp = null;
             //反序列化
             Stream steam2 = File.Open("c:\\temp3.dat", FileMode.Open);
             BinaryFormatter bf2 = new BinaryFormatter();
             Employee mp2 = (Employee)bf2.Deserialize(steam2);
             steam2.Close();
         }

    }

}

public class Singleton
{
    private static volatile Singleton instance = null;//编译器编译代码时候，会对代码作一些优化，进而对代码进行了微调，使用volatile关键字就可以避免这个微调

    private static object lockHelper = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (lockHelper)//多线程的Singleton模式
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

//使用.net特有的支持多线程的单件模式代码

public sealed class Singleton
    {
        public static readonly Singleton Instance = new Singleton();
        private Singleton() { }
    }

在批量循环删除时，如果使用foreach时，删除符合条件的第一个节点后，循环终止，达不到循环删除多个的目的；如果使用for，可以循环删除。代码如下：

    private void MoveFile(string fileName)
    {
        XmlDocument doc = new XmlDocument();

        doc.Load(fileName);

        //foreach (XmlNode nodeI in doc.ChildNodes[1].ChildNodes)
        //{
        //        isExists = false;
        //        foreach (XmlNode nodeJ in nodeI)
        //        {
        //            //查看IsRead属性的值
        //            if (nodeJ.Name == "IsRead" && nodeJ.InnerText == "true")
        //            {
        //                isExists = true;
        //            }
        //            table.Add(nodeJ.Name, nodeJ.InnerText);
        //        }
        //        if (isExists)
        //        {
        //            doc.ChildNodes[1].RemoveChild(nodeI);
        //            if (table.Contains("Description") && table["Description"].ToString().Length > contentSize)
        //            {
        //                list.Add(table);
        //            }
        //        }
        //    }
        //}

        for (int i = 0; i < doc.ChildNodes[1].ChildNodes.Count; i++)
        {
            XmlNode nodeI = doc.ChildNodes[1].ChildNodes[i];
            isExists = false;
            foreach (XmlNode nodeJ in nodeI)
            {
                //查看IsRead属性的值
                if (nodeJ.Name == "IsRead" && nodeJ.InnerText == "true")
                {
                    isExists = true;
                }
                table.Add(nodeJ.Name, nodeJ.InnerText);
            }
            if (isExists)
            {
                doc.ChildNodes[1].RemoveChild(nodeI);
                if (table.Contains("Description") && table["Description"].ToString().Length > contentSize)
                {
                    list.Add(table);
                }
            }
        }
    }

    public class TranFormat
    {
        //全角字符串转为半角
        //(特殊)全角空格为12288 半角空格为32
        //(规律)其他字符半角(33-126)与全角(65281-65374)的对应关系是 相差65248
        //@param str String
        //@return String
        public static String SBCtoDBC(String str)
        {
            StringBuffer sb = new StringBuffer();
            int asc = 0;
            for (int i = 0; i < str.length(); ++i)
            {
                asc = str.charAt(i);
                if (asc == 12288)
                {
                    asc = 32;
                    sb.append((char)asc);
                }
                else if (asc > 256)
                {
                    asc -= 65248;
                    if (asc >= 0)
                    {
                        sb.append((char)asc);
                    }
                    else
                    {
                        sb.append(str.charAt(i));
                    }
                }
                else
                {
                    sb.append(str.charAt(i));
                }
            }
            return sb.toString();
        }

        // 半角字符串转为全角
        //@param str String
        //@return String
        public static String DBCtoSBC(String str)
        {
            StringBuffer sb = new StringBuffer();
            int asc = 0;
            for (int i = 0; i < str.length(); ++i)
            {
                asc = str.charAt(i);
                if (asc == 32)
                {
                    asc = 12288;
                    sb.append((char)asc);
                }
                else if (asc <= 256)
                {
                    asc += 65248;
                    if (asc > 65280 && asc < 65375)
                    {
                        sb.append((char)asc);
                    }
                    else
                    {
                        sb.append(str.charAt(i));
                    }
                }
                else
                {
                    sb.append(str.charAt(i));
                }
            }
            return sb.toString();
        }

        //得到文件的编码类型(UTF Unicode big endian ANSI)
        //@param dis DataInputStream
        //@return String
        public static String getFileCodingForm(DataInputStream dis)
        {
            int coding_header = 0;
            try
            {
                //get header to analyze code-type ~~~~~~
                coding_header = (dis.read() << 8) + dis.read();
            }
            catch (IOException ex)
            {
                ex.printStackTrace();
                return null;
            }
            String code = null;
            switch (coding_header)
            {
                case 0xEFBB:
                    code = "UTF-8";
                    break;
                case 0xFFFE:
                    code = "UTF-16";
                    break;
                case 0xFEFF:
                    code = "Unicode big endian";
                    break;
                default: //no BOM or ANSI/ANSII
                    code = "ANSI";
            }
            return code;
        }

    }

    class ReadHttp
    {

        public void Method1()
        {   
             WebRequest request = WebRequest.Create("http://www.hao123.com");
             request.Credentials = CredentialCache.DefaultCredentials;
             HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            // Display the status.
             Response.Write(response.StatusDescription);
            // Get the stream containing content returned by the server.
             Stream dataStream = response.GetResponseStream();
            // Open the stream using a StreamReader for easy access.
             StreamReader reader = new StreamReader(dataStream,Encoding.Default);
            // Read the content.
            string responseFromServer = reader.ReadToEnd();
            // Display the content.
             Response.Write(responseFromServer);
            // Cleanup the streams and the response.
             reader.Close();
             dataStream.Close();
             response.Close();
        }
       
        public void Method2()
        {
            //方法二：
             WebClient client = new WebClient();

            // Add a user agent header in case the
            // requested URI contains a query.

             client.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");

             Stream data = client.OpenRead("http://www.hao123.com");
             StreamReader reader = new StreamReader(data,Encoding.Default);
            string s = reader.ReadToEnd();
             Response.Write(s);
             data.Close();
             reader.Close();
        }

        public void Method3()
        {
            //方法三：
            WebClient client = new WebClient();
            //client.DownloadFile("http://www.hao123.com","123.htm");
            string reply = client.DownloadString("http://www.hao123.com");
            Response.Write(reply);

        }
    }

        public Form1()
        {
            InitializeComponent();

            string fileName = @"2009 LNCNEB 4_v2_120.visf.pdf";
            if (File.Exists(fileName))
            {
                OpenPDF(fileName, axAcroPDF1);
            }
        }

        private void OpenPDF(string pdf, AxAcroPDF ax)
        {
            axAcroPDF1.Dock = DockStyle.Fill;
            //axAcroPDF1.OcxState = ((System.Windows.Forms.AxHost.State)(resources.Get Object("axAcroPdf.OcxState")));
            string fileName = pdf;
            ax.LoadFile(fileName);

        }

        private void Read_Click(object sender, EventArgs e)
        {
            axAcroPDF1.gotoPreviousPage();
        }

        private void button1_Click(object sender, EventArgs e)
        {

            axAcroPDF1.gotoNextPage();
        }

        private void button2_Click(object sender, EventArgs e)
        {

            axAcroPDF1.setZoom(80f);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            axAcroPDF1.setCurrentPage(3);

        }

        private void button4_Click(object sender, EventArgs e)
        {
            Point p = new Point(200,200);
            axAcroPDF1.AutoScrollOffset = p;

        }

给word文件自然行之后插入换行符号，相当于按下Shift + Enter键

1、 打开用Solid PDF输出的word文件

2、 在‘视图’菜单下的‘宏’/‘查看宏’/‘创建’，输入宏的名字，如‘LineBreak’之后弹出如下界面：

3、 双击要插入换红符号的word文件，如‘ThisDocument’，在右边的窗体中粘入下面脚本：

Sub LineBreak()
    Application.ScreenUpdating = False
    Selection.EndKey Unit:=wdStory
    Selection.MoveUp Unit:=wdLine, Count:=1
   
    Do
        Selection.EndKey Unit:=wdLine
        If Asc(Selection.Characters(1).Text) <> 13 Then
            Selection.InsertBreak (wdLineBreak)
           
           
            Selection.MoveUp Unit:=wdLine, Count:=1
            Selection.MoveUp Unit:=wdLine, Count:=1
        Else
            Selection.MoveUp Unit:=wdLine, Count:=1
        End If
    Loop Until (Selection.Information(wdFirstCharacterLineNumber) = 1 And Selection.Information(wdActiveEndPageNumber) = 1)
    Selection.EndKey Unit:=wdLine
    If Asc(Selection.Characters(1).Text) <> 13 Then
        Selection.InsertBreak (wdLineBreak)
    End If
    Application.ScreenUpdating = True
End Sub

删除word文件的空行

Sub DelBlank()
'
' DelBlank 宏
'
'
Dim i As Paragraph, n As Integer
Application.ScreenUpdating = False
For Each i In ActiveDocument.Paragraphs
If Len(Trim(i.Range)) = 1 Then
i.Range.Delete
n = n + 1
End If
Next
MsgBox "共删除空白段落" & n & "个"
Application.ScreenUpdating = True

End Sub

将word文件输出为txt文件
Sub ToTxt()
'
' ToTxt 宏
'
'

Dim wordapp     As Variant
      Dim worddoc     As Variant
      Dim filepath     As String
      filepath = "c:"
      Set wordapp = CreateObject("word.Application")
            Set worddoc = wordapp.Documents.Open(filepath + "\a.doc", False)
      wordapp.Visible = False
      Call worddoc.SaveAs(filepath + "\" + "attach.txt", wdFormatText)
      worddoc.Close
        wordapp.Quit

End Sub

4、 点击窗体上‘运行’按钮，即可在word文件中插入换行符

5、 第一次运行的过程如上，以后运行，打开word文件后，选择宏，如‘LineBreak’，单击运行即可。

在固定数量字符后插入回车符号
^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?
^&^p

在固定数量字符后插入换行符号
^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?^?
^&^l

清除空段
^p^p
^p

清除空行
^l^l
^l

第1章 简介 1
1.1 本书主要内容 1
1.2 解决具体的性能问题 2
1.3 性能和开发过程 3
1.3.1 性能优先级 3
1.3.2 测试环境和安全惯例 5
1.3.3 开发人员的职责 7
1.4 本章小结 7
第2章 考察性能 8
2.1 性能考察模式 8
2.2 白盒考察 10
2.2.1 反汇编器和反编译器 10
2.2.2 MSIL反汇编器 11
2.2.3 反编译器 13
2.2.4 Rotor 13
2.2.5 x86反汇编 14
2.2.6 效能评测器和系统工具：灰盒考察 15
2.3 使用基准测试工具进行黑盒考察 16
2.4 本章小结 21
第3章 类型的设计与实现 22
3.1 引用类型和值类型 22
3.2 对象的分配和填充 23
3.2.1 类构造函数 24
3.2.2 静态构造函数 25
3.2.3 静态构造函数的调用时间 25
3.2.4 规范实例 26
3.2.5 析构函数 27
3.3 类封装 28
3.4 实现接口 31
3.5 用户定义类型转换 32
3.6 方法修饰符 33
3.7 重写Equals方法 34
3.8 实现GetHashCode方法 37
3.9 装箱和拆箱 39
3.10 本章小结 40
第4章 字符串、文本和正则表达式 41
4.1 字符串的比较 42
4.2 字符串的格式化 45
4.3 枚举 47
4.4 空字符串 47
4.5 保留池 48
4.6 System.Text.StringBuilder 49
4.7 字符串反转 50
4.8 正则表达式 52
4.9 本章小结 55
第5章 集合 56
5.1 System.Array 56
5.1.1 矩形数组与交错数组 57
5.1.2 数组初始化 58
5.1.3 数组同步 58
5.1.4 非安全数组访问 59
5.2 System.Collections 61
5.3 枚举 65
5.3.1 循环终止 67
5.3.2 循环不变量 68
5.4 集合同步 68
5.5 散列码与IHashCodeProvider接口 70
5.6 堆栈分配 74
5.7 本章小结 75
第6章 编程语言的详细说明 76
6.1 Visual Basic .NET 78
6.1.1 字符串 79
6.1.2 错误处理 79
6.1.3 布尔逻辑 81
6.1.4 数组和集合 82
6.1.5 后期绑定 83
6.1.6 可选参数 84
6.1.7 低级别的执行控制 84
6.2 托管C++ 85
6.3 C# 87
6.4 J# 88
6.5 本章小结 89
第7章 垃圾回收与对象生存期管理 91
7.1 CLR垃圾回收器 91
7.2 非托管资源、清除以及终止化 94
7.2.1 终止化的开销 96
7.2.2 恰当使用垃圾回收进行资源清理 97
7.3 优化内存的使用 100
7.3.1 弱引用 102
7.3.2 对象循环利用和弱引用 102
7.4 固定 104
7.5 控制进程的内存使用量 106
7.6 内存监视工具 108
7.7 本章小结 108
第8章 异常 110
8.1 异常和异常处理 111
8.2 受保护代码块处理程序的效率 111
8.3 执行中断 112
8.4 受保护代码块 113
8.5 异常的重新抛出 114
8.6 恰当编写代码避免异常 116
8.7 异常的抛出 116
8.8 异常的监控 118
8.9 本章小结 118
第9章 安全性 119
9.1 安全性、应用程序设计和性能 119
9.2 公共语言运行库安全模型 120
9.2.1 加载过程中有效性和合法性验证 121
9.2.2 程序集 122
9.2.3 堆栈遍历和权限要求 123
9.3 密码术和加密 126
9.4 安全性能监视 128
9.5 本章小结 128
第10章 线程 129
10.1 线程同步 129
10.1.1 实现线程安全的代码 131
10.1.2 同步原语 133
10.1.3 线程调度 134
10.1.4 Thread.Sleep与Thread.SpinWait 138
10.1.5 资源争用和线程锁定 139
10.2 ReaderWriterLock 139
10.3 线程挂起 141
10.4 线程池 142
10.5 监视线程 144
10.6 本章小结 146
第11章 IO和序列化 147
11.1 IO性能背景 147
11.1.1 System.IO命名空间 148
11.1.2 读写磁盘 150
11.1.3 System.IO.FileStream 151
11.1.4 System.IO.BufferedStream类型 152
11.2 稀疏、压缩和内存映射文件 153
11.3 序列化 156
11.3.1 自定义序列化的优化技术 158
11.3.2 格式器的选择 159
11.4 本章小结 160
第12章 远程处理技术 161
12.1 跨应用程序域移动数据 161
12.2 Remoting信道选择 162
12.3 对象激活 165
12.4 调用方法 167
12.5 IIS寄宿 169
12.6 接收链 170
12.6.1 实现信道接收器 171
12.6.2 集合、等值性和序列化 173
12.6.3 使用信道接收器 174
12.7 监测Remoting 175
12.8 本章小结 176
第13章 .NET Framework与非托管代码的互操作性 177
13.1 P/Invoke调用 177
13.1.1 编组数据到托管类型 180
13.1.2 字符集 182
13.1.3 非托管DLL的加载和卸载 183
13.1.4 安全属性 183
13.2 COM 184
13.2.1 COM错误的转化 187
13.2.2 避免COM生成的异常 187
13.3 托管C++ 189
13.4 监测交互操作 191
13.5 本章小结 192
第14章 公共语言运行库 193
14.1 进程初始化 193
14.2 加载行为 194
14.2.1 重定位 195
14.2.2 强命名程序集 197
14.2.3 多模块程序集 198
14.2.4 加载器优化 200
14.2.5 卸载程序集 201
14.2.6 即时编译 202
14.3 方法和属性的内联 204
14.4 自定义属性 204
14.5 管理CLR 205
14.6 checked算术代码 208
14.7 Decimal类型 209
14.8 Debug版本和Release版本 209
14.9 托管应用程序的内存使用 210
14.10 反射 211
14.11 本章小结 212
第15章 解决性能问题 214
15.1 任务管理器 214
15.2 代码评测器 217
15.3 系统监视器 219
15.4 内存评测器 222
15.5 源代码底层 224
15.6 第三方工具 225
15.7 代码规范 226
15.8 PSS 226
15.9 企业级工具 227
15.9.1 分布式评测器 227
15.9.2 Visual Studio Analyzer 227
15.9.3 负载生成工具 228
15.10 本章小结 228
附录A .NET基准测试工具 229
A.1 性能的比较 229
A.2 实现基准测试工具 231
A.2.1 函数调用 231
A.2.2 函数顺序 233
A.2.3 安装、清除以及摒弃测试结果 234
A.2.4 委托设计 235
A.2.5 测试执行 237
A.2.6 结果分析和表示 238
A.2.7 测试工具的体系结构 240
A.3 小结 242

一、新建copy.bat文件

二、其内容为：

@echo off
set /a date=%date:~0,4%%date:~5,2%%date:~8,2%
mkdir E:\copy\%date%\
xcopy D:\copy E:\copy\%date%\ /s

echo %date%
pause.

        private void button1_Click(object sender, EventArgs e)
        {
            MoveData();
        }

        //移动数据
        void MoveData()
        {
            string[] fileNames = Directory.GetFiles(@"D:\Data\Cache");
            foreach (string fileName in fileNames)
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(fileName);

                List<Hashtable> list = new List<Hashtable>();
                Hashtable table1 = new Hashtable();
                foreach (XmlNode nodeI in doc.ChildNodes[1].ChildNodes)
                {
                    if (nodeI.Name != "Items")
                    {
                        table1.Add(nodeI.Name,nodeI.InnerText);
                    }
                    bool isExists = false;
                    Hashtable table = new Hashtable();
                    foreach (XmlNode nodeJ in nodeI)
                    {
                        table.Add(nodeJ.Name, nodeJ.InnerText);
                        if (nodeJ.Name == "IsRead" && nodeJ.InnerText == "true")
                        {
                            isExists = true;
                        }

                    }
                    if (isExists)
                    {
                        doc.ChildNodes[1].RemoveChild(nodeI);
                        list.Add(table);
                    }
                }

                //
                string file1 = fileName.Replace(@"\Cache", @"\Cache1");
                string file2 = fileName.Replace(@"\Cache", @"\Cache2");
                bool secess;
                if (!File.Exists(file2))
                {
                    secess = Create(file2, table1, list);
                }
                else
                {
                    secess = Insert(file2, list);
                }
                if (secess)
                {

                    string dir = file1.Substring(0, file1.LastIndexOf(@"\"));
                    if (!Directory.Exists(dir))
                    {
                        Directory.CreateDirectory(dir);
                    }
                    doc.Save(file1);
                }
            }
        }

        bool Create(string fileName, Hashtable table, List<Hashtable> list)
        {
            /*
<?xml version="1.0" encoding="utf-8"?>
<rss xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Description>中国最具平台.</Description>
<Items>
    <Description>北京时间6月2.</Description>
    <Guid>http://article.pchome.net/content-910571.html</Guid>
    <IsDateFromFeed>true</IsDateFromFeed>
    <Link>http://article.pchome.net/content-910571.html</Link>
    <ParseDate>2009-06-25T13:20:05.671875+08:00</ParseDate>
    <PubDate>2009-06-25T12:00:00+08:00</PubDate>
    <Subject>PChome 电脑之家 文章</Subject>
    <Title>ICANN明年增数百顶级域名 支持非英文</Title>
</Items>
<Items>
</Items>
</rss>
             *
             */
            bool secess = true;
            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                XmlDeclaration dec = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null);
                xmlDoc.AppendChild(dec);

                XmlElement root = xmlDoc.CreateElement("rss");
                xmlDoc.AppendChild(root);

                //一级
                ICollection collTable = table.Keys;
                foreach (string key in collTable)
                {
                    XmlElement element = xmlDoc.CreateElement(key);
                    element.InnerText = table[key].ToString();
                    root.AppendChild(element);
                }

                //item
                for (int i = 0; i < list.Count; i++)
                {
                    XmlNode items = xmlDoc.CreateElement("Items");
                    ICollection coll = list[i].Keys;
                    foreach (string key in coll)
                    {
                        XmlElement element = xmlDoc.CreateElement(key);
                        element.InnerText = list[i][key].ToString();
                        items.AppendChild(element);
                    }
                    root.AppendChild(items);
                }
                string dir = fileName.Substring(0, fileName.LastIndexOf(@"\"));
                if (!Directory.Exists(dir))
                {
                    Directory.CreateDirectory(dir);
                }
                xmlDoc.Save(fileName);
            }
            catch
            {
                secess = false;
            }
            return secess;
        }

        bool Insert(string fileName, List<Hashtable> list)
        {
            bool secess = true;
            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(fileName);
                XmlNode root = xmlDoc.SelectSingleNode("rss");

                for (int i = 0; i < list.Count; i++)
                {
                    XmlNode items = xmlDoc.CreateElement("Items");
                    ICollection coll = list[i].Keys;
                    foreach (string key in coll)
                    {
                        XmlElement element = xmlDoc.CreateElement(key);
                        element.InnerText = list[i][key].ToString();
                        items.AppendChild(element);
                    }
                    root.AppendChild(items);
                }
                xmlDoc.Save(fileName);
            }
            catch (Exception ex)
            {
                secess = false;
            }

            return secess;

        }

            string[] fileNames = System.IO.Directory.GetFiles(@"D:\Data\Cache");
            foreach (string fileName in fileNames)
            {
                System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
                doc.LoadXml(fileName);
            }

使用doc.LoadXml(fileName);报错，‘跟级别上的数据无效’

使用doc.Load(fileName);正确

区别：

doc.LoadXml(fileName);是装载xml字符串  
doc.Load(fileName);是装载文件

创建、查询、修改带名称空间的 XML 文件的例子

一、代码：

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace XMLs

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        private void button1_Click(object sender, EventArgs e)

        {

            string w3NameSpace = "http://www.w3.org/2000/xmlns/";

            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();

            //创建根节点

            System.Xml.XmlNode root = doc.CreateNode(System.Xml.XmlNodeType.Element,

            "w", "wordDocument", "http://schemas.microsoft.com/office/word/2003/2/wordml");

            System.Xml.XmlAttribute xa;

            xa = doc.CreateAttribute("xmlns", "v", w3NameSpace);

            xa.Value = "urn:schemas-microsoft-com:vml";

            root.Attributes.Append(xa);

            //为节点添加属性

            xa = doc.CreateAttribute("xmlns", "w10", w3NameSpace);

            xa.Value = "urn:schemas-microsoft-com:office:word";

            root.Attributes.Append(xa);

            xa = doc.CreateAttribute("xmlns", "SL", w3NameSpace);

            xa.Value = "http://schemas.microsoft.com/schemaLibrary/2003/2/core";

            root.Attributes.Append(xa);

            xa = doc.CreateAttribute("xmlns", "aml", w3NameSpace);

            xa.Value = "http://schemas.microsoft.com/aml/2001/core";

            root.Attributes.Append(xa);

            xa = doc.CreateAttribute("xmlns", "wx", w3NameSpace);

            xa.Value = "http://schemas.microsoft.com/office/word/2003/2/auxHint";

            root.Attributes.Append(xa);

            xa = doc.CreateAttribute("xmlns", "o", w3NameSpace);

            xa.Value = "urn:schemas-microsoft-com:office:office";

            root.Attributes.Append(xa);

            xa = doc.CreateAttribute("xmlns", "dt", w3NameSpace);

            xa.Value = "uuid:C2F41010-65B3-11d1-A29F-00AA00C14882";

            root.Attributes.Append(xa);

           xa = doc.CreateAttribute("xmlns", "space", w3NameSpace);

            xa.Value = "preserve";

            root.Attributes.Append(xa);

            //为节点增加值

            System.Xml.XmlNode body = doc.CreateNode(System.Xml.XmlNodeType.Element,

             "v", "body", "urn:schemas-microsoft-com:vml");

            System.Xml.XmlNode childNode = doc.CreateNode(System.Xml.XmlNodeType.Element,

             "o", "t", "urn:schemas-microsoft-com:office:office");

            childNode.InnerText = "欢迎光临【孟宪会之精彩世界】";

            //添加到内存树中

            body.AppendChild(childNode);

            root.AppendChild(body);

            doc.AppendChild(root);

            //添加节点声明

            System.Xml.XmlDeclaration xd = doc.CreateXmlDeclaration("1.0", "UTF-8", "yes");

            doc.InsertBefore(xd, doc.DocumentElement);

            //添加处理指令

            System.Xml.XmlProcessingInstruction spi = doc.CreateProcessingInstruction(

            "mso-application", "progid=\"Word.Document\"");

            doc.InsertBefore(spi, doc.DocumentElement);

            //查询节点

            System.Xml.XmlNamespaceManager nsmanager = new System.Xml.XmlNamespaceManager(doc.NameTable);

            nsmanager.AddNamespace("w", "http://schemas.microsoft.com/office/word/2003/2/wordml");

            nsmanager.AddNamespace("v", "urn:schemas-microsoft-com:vml");

            nsmanager.AddNamespace("o", "urn:schemas-microsoft-com:office:office");

            System.Xml.XmlNode node = doc.SelectSingleNode("w:wordDocument/v:body/o:t", nsmanager);

            //Response.Write(node.InnerText);

            node.InnerText = "欢迎光临【孟宪会之精彩世界】:http://dotnet.aspx.cc/";

            //创建CDATA节点

            System.Xml.XmlCDataSection xcds = doc.CreateCDataSection("<a href='http://dotnet.aspx.cc/'>【孟宪会之精彩世界】</a>");

            node.ParentNode.InsertAfter(xcds, node);

            doc.Save("test.xml");

        }

    }

}

用UltraEdit打开文本文件，查看16进制的文本，看到如下文件头声明：

ANSI：无格式定义；
Unicode： 前两个字节为FFFE；
Unicode big endian： 前两字节为FEFF；
UTF-8： 前两字节为EFBB；

字符集