C#学习笔记【十四】—— 文件操作

14.1文件读写方式

下面的类用于浏览文件系统和执行操作，比如移动，复制和删除文件System.MarshalByRefObject这个是.NET类中用于远程操作的基对象类，它允许在应用程序域之间编组数据。

类	作用
FileSystemInfo	这是表示任何文件系统对象的基类
FileInfo和File	这些类表示文件系统上的文件
DirectoryInfo和Directory	表示文件系统上的文件夹
Path	包含用于处理路径名的一些静态方法
DriveInfo	它的属性和方法提供了指定驱动器的信息

我们有两个用于表示文件夹的类和两个用于表示文件的类：Directory（文件夹）和File（文件）类只包含静态方法，不能被实例化。如果只对文件夹或文件执行一个操作，使用这些类就很有效，省去了去实例化.NET类的系统开销。

DirectoryInfo类和FileInfo类实现与Directory和File有相同的公共方法，他们拥有一些公共属性和构造函数，这些类的成员都不是静态的。需要实例化这些类，之后把每个实例与特定的文件夹或者文件关联起来。如果使用同一个对象执行多个操作，使用这些类比较合适，这是因为在构造的时候他们将读取合适文件系统对象的身份验证和其他信息，无论每个对象调用了多少方法，都不需要再次读取这些信息。

14.1.1 FileInfo、DirectoryInfo读取文件和文件夹属性

对于FileInfo，或者DirectoryInfo进行构造的时候，如果传递了一个不存在的文件或者文件夹路径，这个时候不会出现异常，只有当你使用这个文件或者文件夹的时候才会出现问题。FileInfo和DirectoryInfo的对象都可以通过Exists属性判断这个文件或者文件夹是否存在。

FileInfo和DirectoryInfo的属性列表：

属性	作用
CreationTime	创建文件或文件夹的时间
DirectoryName(用于FileInfo)	包含文件夹的完整路径
Parent(用于DirectoryInfo)	指定子目录的父目录
Exists	文件或文件夹是否存在
Extension	文件的扩展名，对于文件夹，它返回空白
FullName	文件或文件夹的完整路径名
LastAccessTime	最后一次访问文件或文件夹的时间
LastWriteTime	最后一个修改文件或文件夹的时间
Name	文件或文件夹的名称
Root（仅用于DirectoryInfo）	路径的根部分
Length（仅用于FileInfo）	返回文件的大小（以字节为单位）

FileInfo和DirectoryInfo的方法列表：

方法	作用
Create()：	创建给定名称的文件夹或者空文件，对于FileInfo,该方法会返回一个流对象，以便于 写入文件。
Delete()：	删除文件或文件夹。对于文件夹有一个可以递归的Delete选项
MoveTo()：	移动或重命名文件或文件夹
CopyTo()：	(只用于FileInfo)复制文件，文件夹没有复制方法，如果想要复制完整的目录树，需 要单独复制每个文件和文件夹
GetDirectories()：	(只适用于DirectoryInfo)返回DirectoryInfo对象数组，该数组表示文件夹 中包含的所有文件夹
GetFiles() ：	(只适用于DirectoryInfo)返回FileInfo对象数组，该数组表示文件夹中所有的文 件
GetFileSystemInfos()：	(只适用于DirectoryInfo)返回FileInfo和DirectoryInfo对象，它把 文件夹中包含的所有对象表示为一个FileSystemInfo引用数组

namespace c_sharp_practice11_文件操作
{
    class Program
    {
        static void Main(string[] args)
        {
            //相对路径：就是找当前程序所在的路径
            FileInfo fileInfo1 = new FileInfo("TextFile1.txt");
            Console.WriteLine(fileInfo1.Exists);

            //绝对路径：文件的完整路径
            FileInfo fileInfo2 = new FileInfo
                (@"D:\_Source Files\Visual Studio 2017\c_sharp\c_sharp_practice\c_sharp_practice11_文件操作\bin\Debug\TextFile1.txt");
            Console.WriteLine(fileInfo2.Exists);//判断文件是否存在
            Console.WriteLine(fileInfo2.Name);//文件名.后缀
            Console.WriteLine(fileInfo2.Directory);//取得文件所在路径
            Console.WriteLine(fileInfo2.Length);//文件大小
            Console.WriteLine(fileInfo2.IsReadOnly);//文件是否为只读

            fileInfo2.CopyTo("copy.txt");
            fileInfo2.Delete();//删除的是输出目录下的文件，工程下的文件还是存在的
            FileInfo fileInfo3 = new FileInfo("lemon.txt");
            if (fileInfo3.Exists == false)
            {
                fileInfo3.Create();//创建文件
            }
            fileInfo3.MoveTo("ss.txt");//重命名

            //文件夹操作（目录操作）
            DirectoryInfo dirInfo = new DirectoryInfo
                (@"D:\_Source Files\Visual Studio 2017\c_sharp\c_sharp_practice\c_sharp_practice11_文件操作\bin\Debug");
            dirInfo.CreateSubdirectory("lemon");//创建子目录

            DirectoryInfo dirInfo2 = new DirectoryInfo("ss");
            if (dirInfo.Exists == false)
            {
                dirInfo.Create();//创建目录
            }

            Console.ReadKey();
        }
    }
}

14.1.2 File读写文件

在.NET 2.0扩展了File类，通过File可以读写文件。读取文件有ReadAllText() ReadAllLines()和ReadAllBytes()这几个方法。

方法	作用
File.ReadAllText(FilePath)：	根据文件路径读取文件中所有的文本
File.ReadAllText(FilePath,Encoding)：	Encoding可以指定一个编码格式Encoding.ASCII
File.ReadAllBytes()：	方法可以打开二进制文件把内容读入一个字节数组
File.ReadAllLines()：	以行的形式读取文件，一行一个字符串，返回一个字符 串的数组

对应的写入文件的方法有WriteAllText() WriteAllLines()和WriteAllBytes()

namespace c_sharp_practice11_使用File读写文件
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] strArray = File.ReadAllLines("TextFile1.txt");//读取文本文件，把每一行读取成一个字符																	串，组成一个字符串数组
            foreach(var s in strArray)
            {
                Console.WriteLine(s);
            }
            string str = File.ReadAllText("TextFile1.txt");
            Console.WriteLine(str);
            byte[] byteArray = File.ReadAllBytes("1.png");//打开二进制文件把内容读入一个字节数组
            //foreach (var b in byteArray)
            //{
            //    Console.Write(b);
            //}

            File.WriteAllText("TextFile2.txt", "傻子Lemon");
            File.WriteAllLines("TextFile3.txt", new string[] { "Lemon", "SS" });
            File.WriteAllBytes("2.jpg", byteArray);
            Console.ReadKey();
        }
    }
}

14.1.3流读写文件

1. 流：

流是一个用于传输数据的对象，数据可以向两个方向传输：如果数据从外部源传输到程序中，这就是读取流；如果数据从程序传输到外部源中，这就是写入流。外部源可能是：一个文件；网络上的数据；内存区域上；读写到命名管道上。读写内存使用System.IO.MemorySystem ；处理网络数据使用

System.Net.Sockets.NetworkStream。

FileStream(文件流) 这个类主要用于二进制文件中读写，也可以使用它读写任何文件。

StreamReader(流读取器)和StreamWriter(流写入器)专门用于读写文本文
2. FileStream读写二进制文件：

FileStream实例用于读写文件中的数据，要构造FileStream实例，需要提供下面的4种信息：
（1）要访问的文件：一般提供一个文件的完整路径名
（2）表示如何打开文件的模式：新建文件或打开一个现有文件，如果打开一个现有的文件，写入操作是覆盖文件原来的内容，还是追加到文件的末尾？
（3）表示访问文件的方式：只读、只写、读写。
（4）共享访问：表示是否独占访问文件，如果允许其他流同时访问文件，则这些流是只读 只写 还是读写文件

构造函数的参数的取值：

参数	取值
FileMode( 打开模式)	Append,Create,CreateNew,Open,OpenOrCreate和Truncate
FileAccess(读取还是写入)	Read,ReadWrite和Write
FileShare(文件共享设置)	Delete,Inheritable,None,Read,ReadWrite和Write

注意：
（1）如果文件不存在 Append Open和Truncate会抛出异常
（2）如果文件存在 CreateNew会抛出异常
（3）Create 和 OpenOrCreate Create会删除现有的文件，新建一个空的文件,OpenOrCreate会判断当前是否有文件，没有的话才会创建

创建FileStream文件流：
FileStream fs1 = new FileStream(@“c:\xx\xx.doc”,FileMode.Create);
FileStream fs2 = new FileStream(@“c:\xx\xx.doc”,FileAccess.Write);
FileStream fs3 = new FileStream(@“c:\xx\xx.doc”,FileAccess.Write,FileShare.None);
通过FileInfo打开文件流：
FileInfo myfile1 = new FileInfo(@“c:\xx\xx.doc”);
FileStream fs4= myfile1.OpenRead();
FileInfo myfile2 = new FileInfo(@“c:\xx\xx.doc”);
FileStream fs5= myfile2.OpenWrite();
FileInfo myfile3 = new FileInfo(@“c:\xx\xx.doc”);
FileStream fs6= myfile3.Open(FileMode.Append,FileAccess.Write,FileShare.None);
FileInfo myfile4 = new FileInfo(@“c:\xx\xx.doc”);
FileStream fs7= myfile4.Create();

当我们使用完了一个流之后，一定要调用fs.Close();方法去关闭流，关闭流会释放与它相关联的资源，允许其他应用程序为同一个文件设置流。这个操作也会刷新缓冲区。

从文件流读取内容：
（1）int nextByte = fs.ReadByte();读取一个字节(0-255)的数据,返回结果，如果达到流的末尾，就返回-1
（2）int nBytesRead = fs.Read(ByteArray,0,nBytes);读取多个字节，第一个是存放的组，第二个参数是开始存放的索引，第三个参数是要读取多少个字节。返回的结果是读取的自己的实际个数，如果达到流的末尾返回-1

向文件流写入内容：
（1）byte NextByte = 100;fs.WriteByte(NextByte);把一个字节写入文件流中
（2）fs.Write(ByteArray,0,nBytes); 把一个字节数组写入文件流中参数同上

namespace c_sharp_practice11_使用FileStream读写文件
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1创建文件流，用来操作文件(多用来操作字节文件，不用来操作文本文件)
            FileStream stream = new FileStream("TextFile1.txt", FileMode.Open);

            // 2读取或写入文件
            byte[] data = new byte[1024];
            while (true)
            {
                int length = stream.Read(data, 0, data.Length);
                if (length == 0)
                {
                    Console.WriteLine("读取结束");
                    break;
                }
                for (int i = 0; i < length; i++)
                {
                    Console.Write(data[i] + " ");
                }
            }

            //使用FileStream完成文件复制
            FileStream readStream = new FileStream("1.png", FileMode.Open);
            FileStream writeStream = new FileStream("2.png", FileMode.Create);
            byte[] data1 = new byte[1024];
            while (true)
            {
                int length1 = readStream.Read(data, 0, data1.Length);
                if (length1 == 0)
                {
                    Console.WriteLine("读取结束");
                    break;
                }
                else
                {
                    writeStream.Write(data1, 0, length1);
                }
            }
            writeStream.Close();
            readStream.Close();
            Console.ReadKey();
        }
    }
}

3. StreamReader和StreamWriter读写文本文件

我们对文本文件的读写一般使用StreamReader和StreamWriter,因为不同的文本有不同的编码格式，这个StreamReader会帮我们自动处理，所以我们不需要关心文本文件的编码是什么。

读取文本文件：
（1）创建文本的读取流(会检查字节码标记确定编码格式)
StreamReader sr = new StreamReader(@“c:\xx\ReadMe.txt”);
（2）指定编码格式
StreamReader str = new StreamReader(@“c:\xx\xx.txt”,Encoding.UTF8);
(可取的编码格式 ASCII Unicode UTF7 UTF8 UTF32)
（3）在文件流的基础上创建文本读取流
FileStream fs = new
FileStream(@“c:\xx\xx.txt”,FileMode.Open,FileAccess.Read,FileShare.None)
StreamReader sr = new StreamReader(fs);
（4）通过文件信息创建文本读取流-第二种方式
FileInfo myFile = new FileInfo(@“c:\xx\xx.txt”);
StreamReader sr = myFile.OpenText();
流的关闭 sr.Close();

StreamReader的方法：
（1）string nextLine = sr.ReadLine();//读取一行字符串
（2）string restOfStream = sr.ReadToEnd();//读取流中所有剩余的文本内容
（3）int nextChar = sr.Read();//只读取一个字符
（4）int nChars = 100;
char[] charArray = new char[nChars];
int nCharsRead = sr.Read(charArray,0,nChars);//读取多个字符，第一个参数是要存放的字符数组，第二个参数是从数组的哪一个索引开始放，第三个参数是读取多少个字符 返回值是实际读取的字符的个数

写入文本文件：
(1)StreamWriter sw = new StreamWriter(@“c:\xx\xx.txt”);(默认使用UTF-8编码)
(2)StreamWriter sw = new StreamWriter(@“c:\xx\xx.txt”,true,Encoding.ASCII)
第二个参数表示是否以追加的方式打开，第三个参数是编码方式
(3)通过FileStream创建StreamWriter
FileStream fs = new FileStream(@“c:\xx\xx.txt”,FileMode.CreateNew,FileAccess.Write,FileShare.Read);
StreamWriter sw = new StreamWriter(fs);
(4)通过FileInfo创建StreamWriter
FileInfo myFile = new FileInfo(@“c:\xx\xx.txt”);
StreamWriter sw = myFile.CreateText();
所有流用完之后关闭 sw.Close();

StreamWriter的方法：
(1)写入一行字符
string nextLine = "x xx x x x x ";sw.Write(nextLine);
(2)写入一个字符
char nextChar = ‘a’;
sw.Write(nextChar);
(3)写入字符数组
char[] charArray = …;
sw.Write(charArray);
(4)写入字符数组的一部分
sw.Write(charArray,StartIndex,Length);要写入的数组,开始索引 ,写入长度

namespace c_sharp_practice11_使用StreamReader与StreamWriter读写文本文件
{
    class Program
    {
        static void Main(string[] args)
        {
            //文本文件读取流
            StreamReader reader = new StreamReader("TextFile1.txt");
            while (true)
            {
                string str = reader.ReadLine();//读取一行
                if (str == null) break;
                Console.WriteLine(str);
            }//读取到了流的末尾，之后str1，c读取不到文本文件中的内容
            string str1 = reader.ReadToEnd();//读取到文本结尾
            char c = (char)reader.Read();//读取一个字符
            reader.Close();

            //文本文件写入流
            StreamWriter writer = new StreamWriter("TextFile2.txt");
            while (true)
            {
                string message = Console.ReadLine();
                if (message == "q") break;
                writer.Write(message);//写入一个字符串
                //writer.WriteLine(message);//写入一个字符串并换行
            }
            writer.Close();

            Console.ReadKey();
        }
    }
}

14.2 XML操作

14.2.1 XML

XML 指可扩展标记语言，被设计用来传输和存储数据，被设计用来结构化、存储以及传输信息。

以下是一个XML文档示例：

<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
</note>

这个 XML 文档仍然没有做任何事情。它仅仅是包装在 XML 标签中的纯粹的信息。我们需要编写软件或者程序，才能传送、接收和显示出这个文档。

1. XML标签：
   第一行是 XML 声明。它定义 XML 的版本 (1.0) 和所使用的编码 (ISO-8859-1 = Latin-1/西欧字符集)。

   下一行描述文档的根元素（像在说：“本文档是一个便签”）：
   接下来 4 行描述根的 4 个子元素（to, from, heading 以及 body）：

<to>George</to>
<from>John</from>
<heading>Reminder</heading>
<body>Don't forget the meeting!</body>
	最后一行定义根元素的结尾：
</note>

2. XML文档形成一种树的结构：
   XML 文档必须包含根元素。该元素是所有其他元素的父元素。
   XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。
   所有元素均可拥有子元素：

<root>
  <child>
    <subchild>.....</subchild>
  </child>
  <child>
    <subchild>.....</subchild>
  </child>
</root>

3. XML 元素：
   XML 元素指的是从（且包括）开始标签直到（且包括）结束标签的部分。

<bookstore>
<book category="CHILDREN">
  <title>Harry Potter</title> 
  <author>J K. Rowling</author> 
  <year>2005</year> 
  <price>29.99</price> 
</book>
<book category="WEB">
  <title>Learning XML</title> 
  <author>Erik T. Ray</author> 
  <year>2003</year> 
  <price>39.95</price> 
</book>
</bookstore>

$<bookstore>$ 和 $<book>$ 都拥有元素内容，因为它们包含了其他元素。$ $只有文本内容，因为它仅包含文本。 只有 $<book>$ 元素拥有属性 (category=“CHILDREN”)。

4. XML语法规则：
   所有 XML 元素都须有关闭标签

	<p>This is a paragraph</p>
XML 标签对大小写敏感,标签 <Letter> 与标签 <letter> 
	<Message>这是错误的。</message>
	<message>这是正确的。</message> 
XML 必须正确地嵌套
	<b><i>This text is bold and italic</b></i>	
	<b><i>This text is bold and italic</i></b>
XML 文档必须有根元素
<root>
  <child>
    <subchild>.....</subchild>
  </child>
</root>
XML 的属性值须加引号
	<note date=08/08/2008>
	<to>George</to>
	<from>John</from>
	</note> 
	<note date="08/08/2008">
	<to>George</to>
	<from>John</from>
	</note> 
XML 中的注释
	<!-- This is a comment --> 

5. XML 命名规则：
   XML 元素必须遵循以下命名规则：
   （1）名称可以含字母、数字以及其他的字符
   （2）名称不能以数字或者标点符号开始
   （3）名称不能以字符 “xml”（或者 XML、Xml）开始
   （4）名称不能包含空格
   可使用任何名称，没有保留的字词。

14.2.2 C# XML操作

示例1：

<skills>
  <skill>
    <id>1</id>
    <name language="cn">天下无双</name>
    <damage>123</damage>
  </skill>
  <skill>
    <id>2</id>
    <name language="cn">光翼</name>
    <damage>123</damage>
  </skill>
  <skill>
    <id>3</id>
    <name language="cn">天行九歌</name>
    <damage>123</damage>
  </skill> 
</skills>
namespace c_sharp_practice12__XML操作
{
    /// <summary>
    /// 技能类
    /// </summary>
    class Skill
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Language { get; set; }
        public int Damage { get; set; }

        public override string ToString()
        {
            return string.Format("Id:{0},Name:{1},Language:{2},Damage:{3}", Id, Name, Language, Damage);
        }
    }
}
namespace c_sharp_practice12__XML操作
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建技能信息集合，用来存储所有技能信息
            List<Skill> skillList = new List<Skill>();
            //XMLDocument专门用来解析xml文档
            XmlDocument xmlDoc = new XmlDocument();
            //选择要加载解析的xml文档
            //xmlDoc.LoadXml(File.ReadAllText("skillinfo.txt"));//传递一个xml格式的字符串
            xmlDoc.Load("skillsinfo.txt");
            //得到根节点（XmlNode用来代表一个节点）
            XmlNode rootNode = xmlDoc.FirstChild; //获取第一个节点
            //得到根节点下的子节点集合
            XmlNodeList skillNodeList = rootNode.ChildNodes;//获取当前节点下的所有子节点
            foreach(XmlNode skillNode in skillNodeList)
            {
                Skill skill = new Skill();
                XmlNodeList fieldNodeList = skillNode.ChildNodes;
                foreach(XmlNode fieldNode in fieldNodeList)
                {
                    if (fieldNode.Name == "id")
                    {
                        skill.Id = Int32.Parse(fieldNode.InnerText);//获取节点内部的文本
                    }
                    else if (fieldNode.Name == "name")
                    {
                        skill.Name = fieldNode.InnerText;
                        skill.Language = fieldNode.Attributes[0].Value;
                    }
                    else
                    {
                        skill.Damage = Int32.Parse(fieldNode.InnerText);
                    }
                }
                skillList.Add(skill);
            }
            foreach(var skill in skillList)
            {
                Console.WriteLine(skill);
            }
            Console.ReadKey();
        }
    }
}
示例2：
<SkillInfo>
    <SkillList>
        <Skill
            SkillID="20002"  
            SkillEngName="Smash" 
            TriggerType="1" 
            ImageFile="data/gfx/image/gui_icon_skill_000.dds" 
            AvailableRace="7" 
        >
        <Name>重击</Name>
		</Skill>
        <Skill
            SkillID="20003" 
            SkillEngName="Hide"
            TriggerType="2" 
            ImageFile="data/gfx/image/gui_icon_skill_001.dds"
            AvailableRace="1" 
        >
			  <Name>隐身</Name>
		</Skill>
        <Skill
            SkillID="20004" 
            SkillEngName="Ikari" 
            TriggerType="3" 
            ImageFile="data/gfx/image/gui_icon_skill_002.dds" 
            AvailableRace="1" 
        >
			  <Name>怒之翼</Name>
		</Skill>
        <Skill
            SkillID="20005" 
            SkillEngName="Revenge" 
            TriggerType="5" 
            ImageFile="data/gfx/image/gui_icon_skill_003.dds" 
            AvailableRace="2" 
        >
			  <Name>光之复仇</Name>
		</Skill>
    </SkillList>
</SkillInfo> 
namespace c_sharp_practice12__XML文档解析
{
    /// <summary>
    /// 技能信息类
    /// </summary>
    class Skill
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string EngName { get; set; }
        public int TriggerType { get; set; }
        public string ImageFile { get; set; }
        public int AvailableRace { get; set; }

        public override string ToString()
        {
            return string.Format("Id: {0}, Name: {1}, EngName: {2}, TriggerType: {3}, ImageFile: {4}, AvailableRace: {5}", Id, Name, EngName, TriggerType, ImageFile, AvailableRace);
        }
    }
} 
namespace c_sharp_practice12__XML文档解析
{
    class Program
    {
        static void Main(string[] args)
        {
             List<Skill> skillList = new List<Skill>();

            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load("xmlskill.txt");

            //XmlNode skillInfoNode = xmlDoc.FirstChild;
            //XmlNode skillListNode = skillInfoNode.FirstChild;
            XmlNode skillListNode = xmlDoc.FirstChild.FirstChild;

            XmlNodeList skillNodeList = skillListNode.ChildNodes;
            foreach (XmlNode skillNode in skillNodeList)
            {
                Skill skill = new Skill();
                XmlElement ele = skillNode["Name"];
                skill.Name = ele.InnerText;
                XmlAttributeCollection col = skillNode.Attributes;//获取该结点属性的集合
                //skill.Id = Int32.Parse(col["SkillID"].Value);
                XmlAttribute idAttribute = col["SkillID"];//通过字符串索引器 获取一个属性对象
                skill.Id = Int32.Parse(idAttribute.Value);
                skill.EngName = col["SkillEngName"].Value;
                skill.TriggerType = Int32.Parse(col["TriggerType"].Value) ;
                skill.ImageFile = col["ImageFile"].Value;
                skill.AvailableRace = Int32.Parse(col["AvailableRace"].Value);
                skillList.Add(skill);
            }
            foreach (Skill s in skillList)
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();
        }
    }
}

14.3 JSON操作

1. JSON：
   JSON 是存储和交换文本信息的语法，类似 XML。

   JSON 比 XML 更小、更快，更易解析。JSON跟XML一样是一种是数据格式。

   JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，它基于ECMAScript的一个子集；JSON采用完全独立于语言的文本格式，使用 JavaScript 语法来描述数据对象，也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）但是 JSON 仍然独立于语言和平台，JSON 解析器和 JSON 库支持许多不同的编程语言；JSON 具有自我描述性，更易理解。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(网络传输速率)。

2. JSON 语法规则：
   （1）数据在键值对中
   （2）数据由逗号分隔
   （3）花括号保存对象
   （4）方括号保存数组
   JSON 名称/值对
   JSON 数据的书写格式是：名称/值对。名称/值对组合中的名称写在前面（在双引号中），值 对写在后面(同样在双引号中)，中间用冒号隔开：“firstName”:“John”
   JSON 值可以是：
   数字（整数或浮点数）
   字符串（在双引号中）
   逻辑值（true 或 false）
   数组（在方括号中）
   对象（在花括号中）
   null

3. JSON数据结构：
   json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

   （1）对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,…}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key （c# 对象[key]）获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。

   (2)数组：数组在js中是中括号“[]”括起来的内容，数据结构为 [“java”,“javascript”,“vb”,…]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。

   经过对象、数组2种结构就可以组合成复杂的数据结构了。

4. LitJson:
   JsonMapper.ToObject(string json) – 把json数据转化成JsonData对象
   JsonData data = new JsonData(); data…; data.ToJson(); --把JsonData对象转化成json数据
   JsonMapper.ToObject(T t1) – 把json数据转化成对应的类对象
   JsonMapper.ToJson(object o) --把一个对象中的数据转化成json数据
   (在unity中解析json文件)
   示例1：

[
{"id":2,"name":"天下无双","damage":123 },
{"id":3,"name":"天下无贼","damage":21 },
{"id":4,"name":"咫尺天涯","damage":900 }
]
namespace _032_json操作 {
    class Skill
    {
        public int id;
        public int damage;
        public string name;

        public override string ToString()
        {
            return string.Format("Id: {0}, Damage: {1}, Name: {2}", id, damage, name);
        }
    }
}
namespace _032_json操作 {
    class Program {
        static void Main(string[] args) {
            //使用litjson解析json文本
            //两种引入litjson的方法
            //在litjson官网下载litjson.dll，并在工程中引用
            //在工程引用打开管理NuGet程序包搜索litjson

            List<Skill> skillList = new List<Skill>();
            //我们使用jsonMapper去解析json文本
            //jsondata代表一个数组或者一个对象
            //在这里jsonData代表数组
            JsonData jsonData = JsonMapper.ToObject(File.ReadAllText("json技能信息.txt"));
            foreach (JsonData temp in jsonData)//在这里temp代表一个对象
            {
                Skill skill = new Skill();
                JsonData idValue = temp["id"]; //通过字符串索引器可以取得键值对的值
                JsonData nameValue = temp["name"];
                JsonData damageValue = temp["damage"];
                int id = Int32.Parse(idValue.ToString());
                int damage = Int32.Parse(damageValue.ToString());
                //Console.WriteLine(id+":"+nameValue.ToString()+":"+damage);
                skill.id = id;
                skill.damage = damage;
                skill.name = nameValue.ToString();
                skillList.Add(skill);
            }
            foreach (var temp in skillList)
            {
                Console.WriteLine(temp);
            }
            Console.ReadKey();
        }
    }
}
namespace _032_json操作 {
    class Program {
        static void Main(string[] args) {
            //使用litjson解析json文本
            //两种引入litjson的方法
            //在litjson官网下载litjson.dll，并在工程中引用
            //在工程引用打开管理NuGet程序包搜索litjson

            //使用泛型去解析json
            //json里面对象的键必须跟定义的类里面的字段或者属性保持一致
            Skill[] skillArray = JsonMapper.ToObject<Skill[]>(File.ReadAllText("json技能信息.txt"));
            foreach (var temp in skillArray)
            {
                Console.WriteLine(temp);
            }
            List<Skill> skillList = JsonMapper.ToObject<List<Skill>>(File.ReadAllText("json技能信息.txt"));
            foreach (var temp in skillList)
            {
                Console.WriteLine(temp);
            }
            Console.ReadKey();
        }
    }
}
示例2：
{
	"Name":"siki",
	"Level":99,
	"Age":18,
	"SkillList":[
		{"id":2,"name":"天下无双","damage":123 },
		{"id":3,"name":"天下无贼","damage":21 },
		{"id":4,"name":"咫尺天涯","damage":900 }
	]
}
namespace _032_json操作 {
    class Player
    {
    //    public string name;//字段或者属性名 要跟json里面的对应
    //    public int level;
        public string Name { get; set; }
        public int Level { get; set; }
        public int Age { get; set; }
        public List<Skill> SkillList { get; set; }

        public override string ToString()
        {
            return string.Format("Name: {0}, Level: {1}, Age: {2}, SkillList: {3}", Name, Level, Age, SkillList);
        }
    }
}
namespace _032_json操作 {
    class Program {
        static void Main(string[] args) {
            Player p = JsonMapper.ToObject<Player>(File.ReadAllText("主角信息.txt"));
            Console.WriteLine(p);
            foreach (var temp in p.SkillList)
            {
                Console.WriteLine(temp);
            }

            Player p = new Player();
            p.Name = "花千骨";
            p.Level = 100;
            p.Age = 16;
            string json =JsonMapper.ToJson(p);
            Console.WriteLine(json);
            Console.ReadKey();
        }
    }
}
14.4 Excle操作
namespace c_sharp_practice14_Excle操作
{
    class Program
    {
        static void Main(string[] args)
        {
            string fileName = "装备信息.xls";
            string connectionString= "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + fileName + ";" 
                + ";Extended Properties=\"Excel 8.0;HDR=YES;IMEX=1\"";//连接字符串xls
                //"Provider=Microsoft.ACE.OLEDB.12.0;" + "Data Source=" + fileName + ";" 
                //    + ";Extended Properties=\"Excel 12.0;HDR=YES;IMEX=1\"";//连接字符串xlsx

            //创建连接到数据源的对象
            OleDbConnection connection = new OleDbConnection(connectionString);

            //打开连接
            connection.Open();
            string sql = "select*from[Sheet1$]";//查询命令
            OleDbDataAdapter adapter = new OleDbDataAdapter(sql,connection);
            DataSet dataSet = new DataSet();//存放数据（存放DataTable）
            adapter.Fill(dataSet);//把查询结果（DataTable）填入dataSet
            connection.Close();

            //取得数据
            DataTableCollection tableCollection = dataSet.Tables;//获取当前集合中所有的表格
            DataTable table = tableCollection[0];//当前在dataSet里只放置了一张表

            //取得dataTable中的所有行
            DataRowCollection rowCollection = table.Rows;
            //遍历table取得每行额DataRow对象
            foreach(DataRow row in rowCollection)
            {
                //取得row中前八列数据
                for(int i = 0; i < 8; i++)
                {
                    Console.Write(row[i] + " ");
                }
                Console.WriteLine();
            }

            Console.ReadKey();
        }
    }
}