.NET平台和C#编程的总结

第一章   简单认识.NET框架

   （1）首先我们得知道 .NET框架具有两个主要组件：公共语言进行时CLR（Common Language Runtime）和框架类库FCL（Framework Class Library）

       其中，CLR还包括通用类型系统CTS（Common Type System）和公共语言规范CLS（Common Language Specification）

       （2）

        C#语言要编程可以被CPU解析执行的代码需要两次编译：

         第一次编译：将C#语言通过C#编译器编译成MSIL中间代码

         第二次编译：将MSIL代码通过即时编译器（JIT）编译成CPU可以解析执行的代码，或者成为（平台专用代码）

       Java程序想要被CPU解析执行也需要两次编译：

         第一次编译：将后缀名为java的文件通过Java编译器编译成后缀名为.class（字节码）文件

         第二次编译：将.class文件通过Java虚拟机（jvm）编译成CPU可以解析的代码

    （3）面向对象

           面向对象三大特性：封装，继承和多态

          那些年我们学过的访问修饰符：

          public :任何位置，包括跨程序集

          internal:在当前程序集（项目）中都可以访问

          private:只能在当前类中访问（当前类的花括号中访问）

          protected:只能在当前类和子类中使用

    （4）变量，类和方法的命名

         骆驼命名法：第一个单词的首字母小写，后续有含义的单词首字母大写。   变量

         帕斯卡命名法：每一个单词的首字母大写    类和方法

     （5）new：代表的含义

           1.创建对象

           2.开辟空间

           3.自动调用构造函数

    （6）字段和属性的区别

           1.属性不能保存数据，真正保存数据的是字段。

           2.属性是可有可无的，字段是必须的。

           3.如果字段只是让类内部访问，那么设置成private，如果想找一个中间者，在Main方法中访问到类中的私有字段，那么属性可以是一种选择。

    （7）自动属性

          定义：当为我们不需要进行逻辑判断时可以使用自动属性。 定义自动属性在后台会自动帮我们生成一个对应数据类型的私有字段　

    （8）CLR的主要用途：

        CLR是所有.NET程序运行的环境，是所有.NET应用程序的编程基础，所有.NET受CLR监管和处理，这些操作包括进程内的应用程序加载，将IL转换为GG，

        异常处理，垃圾回收，加载程序集

                                                     第二章 深入C#数据类型

    （1）值类型和引用类型

        值类型：是在栈上存储真实的值    引用类型：在栈和堆上都开辟空间

        值类型：int  double float boolean  char byte long short  枚举(enum)  结构体(struct)

       引用类型：int[] class 接口(interface) string

    （2）结构

       定义：

访问修饰符  struct  结构名

{

            // 结构体
 }

例：
public struct Student
{
      //结构体
}

（2）注意点：

       1.在结构中可以有字段和方法

       2.定义结构时，结构中的字段不能被赋初值

       3.可以不用new，直接定义结构的对象即可

       4.声明结构的对象后，必须给结构的成员赋初值

       5.结构体也是一种特殊的值类型

   （3）装箱和拆箱

        将值类型转换为引用类型的过程称为装箱，反之称为拆箱

       示例:

static void Main(String[] args)
{
    int i=123;
    oject o=i;  //装箱
    i=456;   //改变i的内容
   Console.WriteLine("值类型的值：{0}",i);
   Console.WriteLine("引用类型的值：{0}",o);
}

（4）不同类型的参数传递
         值方式参数传递：传递数据类型是值类型,没有ref在方法中不会保留

                               传递数据类型是引用类型,没有ref在方法中会永久保留

         引用方式传递：不管有没有ref都会永久保留

    

例：
 class Voter
{
   public void Vote(SE se)
   {
      //人气值+1
      se.Popularity++;
    }
}

/测试相关代码

SE  zhang=new SE();
zhang.Age=25;
zhang.Name="张梅";
zhang.Gender=Gender.female;
zhang.Popularity=10;
//投票前
MessageBox.Show(zhang.SayHi());
Voter voter=new Voter();
voter.Vote(zhang);  //引用类型做参数
//投票后
MessageBox.Show(zhang.SayHi());
   

（5）结构和类的区别
         1.结构是值类型而类是引用类型

         2.结构和另外一个结构不能继承和被继承

         3.结构没有默认构造而类有

         4.结构体没有析构函数而类有

         5.结构体可以不使用new初始化，而类不可以

 第三章  使用集合组织相关数据

   （1）定义：

           集合：

         某些特定的对象集中在一起就是集合

            数组：

         可以存储相同数据类型的一堆数据的容器

    （2）集合

         集合分为泛型集合和非泛型集合

          泛型集合分为单列和双列集合  （List<T>和Dictionary<K,V>）

          非泛型集合分为单列和双列集合 （ArrayList和HashTable）

     （3）常用的方法和属性

 Add();   //添加

 Remove();  //删除

 RemobeAt(); //根据索引删除  不适用 双列集合 

 count  //集合存储元素的个数

 Contains();  //检测元素是否存在

 ContainsKey();  //

 ContainsValue();

 Capcity //集合占用空间

   注意事项：如果删除了集合中的某一个元素，那么集合的索引会自动维护

   （4）遍历方案：

ArrayList list=new ArrayLIst();
Student stu1=new Student();
 stu1.Name="jiejie";
 stu1.Age=15;
 list.Add(stu1);
Student stu2=new Student();
 stu2.Name="jiji";
 stu2.Age=18;
 list.Add(stu2);
  //foreach
foreach(Student item in list)
{
    Console.WriteLine(item.Age+"\t"+item.Name);
}
 //for
for(int i=0;i<list.Count;i++)
{
   Console.WriteLine((Student)list[i].Name);
}

HashTable 遍历三种方案
   HashTable table=new HashTable();
第一种方式：遍历所有的Keys
foreach(var item in table.Keys)
{
    //一个item代表一个key
   Console.WriteLine("key是{0}\tvalue是{1}"，item,table[item]);
}

第二种遍历方式：遍历所有的value集合
foreach(var item in table.Values)
{
       //一个item代表一个value
   Console.WriteLine("value是{0}"，item);
}

//遍历整个table
foreach(DictionaryEntry item in table)
{
    Console.WriteLine("key是{0}\tvalue是{1}"，item.Key,item.Value);
}

第四章 深入类的方法

  （1）构造函数

       方法名和类名相同，没有返回值

       注意：在C#中，当我们定义了一个类后，系统底层默认会生成一个和类名相同的无参构造，但是如果我们定义了一个带参构造，系统将不生成无参构造，但是在

              真正的开发中建议大家定义两个构造函数，一个无参构造和带参构造

    

public class SE
{
 public SE()
{

}

public SE(string id,string name,int age,Gender gender,int popularity)
{
   Id=id;
   Name=name;
   Age=age;
   Gender=gender;
   Popularity=popularity;
}
}

（2）方法的重载

        在同一个类中，如果有多个方法方法名相同，但是参数的个数，顺序，类型不同的多个方法可以构成重载和方法的返回值类型没有关系。

      

public void Say(string name,int age)
{

}

public void Say(int age,string name)
{

}

  （3）对象间的交互

//遥控器类
public class RemoteControl
{
  //开机
  public void TurnOn(Tv tv)
   {
     tv.Open();  //调用电视机对象的开机方法
   }
  //关机
  public void TurnOff(Tv tv)
  {
    tv.TrunOff();
  }
   //换台
  public void ChangeChannel(Tv tv)
   {
       Console.WriteLine("请输入频道：");
       string ChannelNo=Console.ReadLine();
       tv.Change(ChannelNo);
   }
//电视机类
public class Tv
{
  public boolean isOn=false; //是否开机
  //打开电视机
  public void Open()
  {
   if(isOn)
   {
      Console.WriteLine("电视机已打开");
   }
   else
    {
       Console.WriteLine("成功打开电视机");
        isOm=true;
     }
  }
  //关机
  public void TurnOff()
   {
     if(isOn)
      {
        Console.WrteLine("电视机正在关机");
        isOn=false;
      }
     else
     {
       Console.WriteLine("电视机已关闭");
     }
   }
  //换台
  public void Change(string channelNo)
   {
     if(isOn)
     {
       Console.WriteLine("正在切到{0}台",channelNo);
    }
    }
//测试Main()方法
 static void Main(String[] args)
 {
   RemoteControl controler=new RemoteControl();
   Tv tv=new Tv();
   //开机
   controler.TurnOn(tv);
    //切换频道
   controler.ChangChannel(tv);
   //关机
   controler.TurnOff(tv);
    Console.ReadLine();
}

 看到这里你明白了一点了没有，回想一下上面所写的，这是一个重复的事情，一遍不行就两遍，再教你个小方法，没事的时候你就想想你学了点什么，看看自己还记得多少，忘记的就去看看自己写的，好了接下来继续吧！

   第六章 初识继承和多态

   （1）

      继承的概念是什么呢？就是一个类可以继承另一个类的属性和方法（成员）

      继承是面向对象编程中的一个非常重要的特性。

      好了，废话不多说，下面切入正题：

     1.首先我们定义一个子类，给它创建两个构造：一个无参构造和一个有参构造

 在调用子类的带参构造时，我们要想到调用子类构造的时候，没有使用base关键字调用父类的指定的构造，默认调用父类的无参构造.

   补充一下：

   01.base代表父类对象，如果base()：调用父类的构造函数

   02.base代表的是方法调用，是不需要参数类型的

  03.base(传参顺序和父类构造一致，变量名和子类构造参数一致)

（2）在这里补充一点访问修饰符

    我们所知道的：public  private  protected

    下面我画一个图来简单的描述一下（√表示可以，×表示不可以）

                  当前类     子类     其他类(Program)
   private         √          ×        ×
   protected     √          √        ×
   public           √          √        √

    总结：我们可以清晰的明白三种访问修饰符对类成员的访问限制强度：private>protected>public

 （3）new 子类底层原理用文字描述：

      1.走到子类构造，不进入构造体
      2.转向父类，进入父类构造体执行
      3.转回子类构造，执行子类构造体
      4.转到Main，内存中构建出子类对象

  （4）继承还具有两大特性这个我们也不要忘记了，就是单根性和传递性

     单根性指的就是一个子类只有一个父类

     传递性就是只要跟父类有继承关系，就可以使用父类的属性和方法

  （5）接下来我们讲一讲多态

       1.多态是什么呢？字面上的意思就是多种形态

       用专业一点的话来说就是指同一个操作作用于不同的对象时，可以有不同的解释，产生不同的执行效果。

      我们所接触的方法重载也是多态的一种方式。

      如何实现多态呢？不要急下面我来解说

 （6）实现方法的重写

      在父类中定义的方法，用virtual关键字来定义为虚方法

     在子类中定义自己的方法，用override关键字来修饰，实现对父类的方法的重写

 （7）定义父类变量，用子类变量初始化父类变量

    下面来一个小案例：

 //创建一个Person父类

 public class Person
    {
       public virtual void SayHello()
       {

            //父类特有的方法
           Console.WriteLine("父类打招呼方法");
       }
    }

//创建一个Korea子类

public class Korea:Person  //在这里要注意它继承于Person类
    {
       public override void SayHello()
       {
           Console.WriteLine("金喜善打招呼方法");
       }
    }

//创建一个Chinese类

public class Chinese:Person //在这里要注意它继承于Person类

    {
       public override void SayHello()
       {
           Console.WriteLine("你好！");
       }
    }

//创建一个American类

public class American:Person   //在这里要注意它继承于Person类
    {
        public override void SayHello()
        {
            Console.WriteLine("Hello");
        }
    }

 前面我们也学过泛型了下面我们就用泛型来存储

            List<Person> list=new List<Person>();
            Chinese chinese=new Chinese();
            American usa=new American();
            Korea korea=new Korea();

            list.Add(chinese);
            list.Add(usa);
            list.Add(korea);

下面我们可以用foreach来遍历

方式一：

           foreach (Person person in list)
            {
               person.SayHello();
            }

方式二：

           foreach (Person person in list)
            {

               //方式二：不使用统一调用
                if (person is Chinese)
                {
                   Chinese chinese= person as Chinese;
                    chinese.SayHello();
                }

               if (person is Korea)
                {
                    Korea chinese= person as  Korea;
                    korea.SayHello();
                }

               if (person is  American)
                {
                    American chinese= person as  American;
                     american.SayHello();
                }

            }

第七章   深入理解多态

   （1）里氏替换

       定义：在一个软件系统中，如果子类替换父类出现的位置，而对整个软件系统功能没有影响

//交通工具类
public class TrafficTool
{
     public vartual void Run()
     {
         Console.WriteLine("车在行驶");
     }
}

//地铁类
public class Tube:TrafficTool
{
    public voerride void Run()
     {
       Console.WriteLine("地铁在行驶中");
     }
}

//小汽车类
public class Car:TrafficTool
{
   public voerride void Run()
   {
     Console.WriteLine("小汽车在行驶中");
    }
}

//自行车类
public class Bicycle:TrafficTool
{
   public override void Run()
   {
     Console.WriteLine("自行车在行驶中");
    }
}

//给Employee类添加GoHome()方法：搭乘交通工具回家
public class Employee
{
   //以父类类型作为参数
   public void GoHome(TrafficTool tool)
   {
     Console.WriteLine("员工"+Name);
     tool.Run();
    }
}

//测试Main()方法
static void Main(String[] args)
{
   SE ai=new SE("123","艾边成",25,Gender.male,100);
   SE joe=new SE("103","Joe",30,Gender.female,200);
   //实例化PM对象
   PM pm=new PM("890","盖茨",50,Gender.female,30);
   //定义员工集合
   List<Employee> list=new List<Employee>();
   list.Add(ai);
   list.Add(joe);
   list.Add(pm);
  //员工选择不同的交通工具回家：传递实际创建的子类对象
  list[0].GoHome(new Bicycle());
  list[1].GoHome(new Car());
  list[2].GoHome(new Tube());
  Console.ReadLine();
}

（2）抽象类和抽象方法

    定义：抽象方法是一个没有实现的方法，通过定义方法时增加的关键字abstract可以声明抽象方法

    语法：

      访问修饰符  abstract 返回类型 方法名();

     注意：抽象方法没有闭合的大括号，而是直接跟了一个分号；，也就是说它没有方法体。

    含有抽象方法的类必然是抽象类

    语法：

     访问修饰符  abstract class 类名{}

简单示例：
  public abstract class TrafficTool
  {
     public abstract void Run();
   }

 /// <summary>
    /// 父类  工作类
    /// </summary>
   public abstract class Job
    {
        //抽象方法
        public abstract void Show();
        //工作类型
        public string Type { get; set; }
        //工作名称
        public string Name { get; set; }
        //工作描述
        public string Describe { get; set; }
        //无参构造
        public Job()
        {

        }
        //带参构造
        public Job(string type,string name,string des)
        {
            this.Type = type;
            this.Name = name;
            this.Describe = des;
        }
    }

 public class Tests : Job
    {
        /// <summary>
        /// 子类  测试类
        /// </summary>

            //测试类的方法
        public override void Show()
        {
            FrmTests tt = new FrmTests();

            tt.Show();
            this.Num = Num;
            this.BugNum = BugNum;
            this.Time = Time;

        }
        //个数
        public int Num { get; set; }
        //bug数
        public int BugNum { get; set; }
        //时间
        public string Time { get; set; }
        //无参构造
        public Tests()
        {

        }
        //带参构造
        public Tests(string type,string name,string des):base(type,name,des)
        {

        }
    }

 总结：

   1.一个类用abstract修饰，就是抽象类

   2.抽象类不能实例化

   3.抽象方法不能有方法体连{}不能有

   4.抽象方法只能在抽象类中

   5.抽象方法存在的目的就是为了约束类中方法存在的形式（返回值类型和参数列表）

   6.抽象类不能是静态类和密封类

   7.抽象类中所有的抽象方法必须被子类重写，除非子类本身也是抽象类

   8.一键重写所有抽象方法的快捷键  Ctrl+.（无输入法情况下） Shift+Alt+F10

看完这章，你是不是觉得有收获？

  第八章  可扩展标记语言XML

  （1）HTML和XML

        HTML:Hyper Text Markup Language（超文本标记语言）

        XML:Extensible Markup Language（可扩展标记语言）

   （2）HTML和XML存储和展示的角度来说

       XML：侧重数据存储

       HTML:侧重数据显示

  （3）XML的注意点

      1.XML文件严格区分大小写

      2.XML文档只能有一个根节点

      3.XML文件的标签配对出现

      4.我们可以自定义XML文档中的标签 

  下面一个简单的示例就可以帮你巩固一下：

   

效果展示

该项目主要练习xml文件解析和面向对象思维；

1.电视台和节目信息都要从xml文件中解析，并绑定；

2.实现点击电视频道节点显示该频道的电视节目信息；

3.当时间到达用户设置的节目提醒时间后弹出窗口提醒用户节目即将开始；

Xml文件：

频道

<?xml version="1.0" encoding="utf-8" ?>
<TVChannels>
    <Channel>
        <channelType>TypeA</channelType> <!--频道类型-->
        <tvChannel>北京电视台</tvChannel> <!--频道名称-->
        <path>files/北京电视台.xml</path>           <!--频道对应XML文件的本地路径-->
    </Channel>
    <Channel>
        <channelType>TypeB</channelType>
        <tvChannel>凤凰卫视</tvChannel>
        <path>files/凤凰卫视.xml</path>
    </Channel>
</TVChannels>

北京电视台

<?xml version="1.0" encoding="utf-8" ?>
<typeA version =" 1.0">
    <channelName>北京电视台</channelName>
    <tvProgramTable>
        <tvProgram>
            <playTime>2016-9-5 16:21</playTime> <!--节目播出时间-->
            <meridien>早间档</meridien> <!--时段-->

            <programName>重播：国际双行线</programName> <!--节目名称-->
            <path>c:\a.wma</path>         <!--视频路径-->
        </tvProgram>
<tvProgram>
            <playTime>2016-9-5 16:22</playTime> <!--节目播出时间-->
            <meridien>早间档</meridien> <!--时段-->

            <programName>北京您早</programName> <!--节目名称-->
            <path>C:\New Stories (Highway Blues).wma</path>         <!--视频路径-->
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 09:02</playTime> <!--节目播出时间-->
            <meridien>早间档</meridien> <!--时段-->

            <programName>重播《红星剧场》32集剧：勇者无敌（31）</programName> <!--节目名称-->
            <path>**</path>         <!--视频路径-->
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 09:58</playTime>

            <meridien>早间档</meridien>
            <programName>重播《红星剧场》32集剧：勇者无敌（32）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 11:15</playTime>

            <meridien>午间档</meridien>
            <programName>重播：专题片：我爱你，中国（14）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 11:58</playTime>

            <meridien>午间档</meridien>
            <programName>身边</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 12:30</playTime>

            <meridien>午间档</meridien>
            <programName>特别关注</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 13:05</playTime>

            <meridien>午间激情档</meridien>
            <programName>网络电视精灵</programName>
            <path>H:\video\01网络电视精灵.avi</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 13:40</playTime>

            <meridien>午间档</meridien>
            <programName>《玫瑰剧场》55集剧：闯关东中篇（21）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 14:32</playTime>

            <meridien>午间档</meridien>
            <programName>《玫瑰剧场》55集剧：闯关东中篇（22）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 15:27</playTime>

            <meridien>下午档</meridien>
            <programName>《玫瑰剧场》55集剧：闯关东中篇（23）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 16:19</playTime>

            <meridien>下午档</meridien>
            <programName>《玫瑰剧场》55集剧：闯关东中篇（24）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 17:31</playTime>

            <meridien>下午档</meridien>
            <programName>法治进行时</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 18:00</playTime>

            <meridien>晚间档</meridien>
            <programName>新闻晚高峰</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 18:30</playTime>

            <meridien>晚间档</meridien>
            <programName>北京新闻</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 18:56</playTime>

            <meridien>晚间档</meridien>
            <programName>天气预报</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 19:00</playTime>

            <meridien>晚间档</meridien>
            <programName>转播CCTV新闻联播</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 19:31</playTime>

            <meridien>晚间档</meridien>
            <programName>看气象</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 19:40</playTime>

            <meridien>晚间档</meridien>
            <programName>专题片：我爱你，中国（15）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 20:22</playTime>

            <meridien>晚间档</meridien>
            <programName>《爸妈都是老党员》首播庆典</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 21:21</playTime>

            <meridien>晚间档</meridien>
            <programName>《红星剧场》38集剧：咱爸咱妈六十年（1）</programName>
            <path>**</path>
        </tvProgram>
        <tvProgram>
            <playTime>2009-9-29 23:25</playTime>

            <meridien>晚间档</meridien>
            <programName>重播文艺：花样年华歌舞大赛（5）</programName>
            <path>**</path>
        </tvProgram>
    </tvProgramTable>
</typeA>

凤凰卫视

<?xml version="1.0" encoding="utf-8" ?>
<typeB version =" 1.0">
    <ProgramList>
        <Program>
            <playTime>2009-9-29 01:30</playTime>  <!--播出时间-->

            <name>简单工厂模式</name>          <!--节目名称-->
            <path>D:\简单工厂模式.wmv</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 02:10</playTime>  <!--播出时间-->

            <name>非凡人物论成功(713)</name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 02:15</playTime>  <!--播出时间-->

            <name>有报天天读(28/09/09) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 02:40</playTime>  <!--播出时间-->

            <name>娱乐大风暴(682) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 03:15</playTime>  <!--播出时间-->

            <name>上海新长宁集团特约之2009中华小姐环球大赛-美丽前奏(41) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 03:20</playTime>  <!--播出时间-->

            <name>完全时尚手册:天桥云裳(632)  </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 03:40</playTime>  <!--播出时间-->

            <name>东风康明斯凤凰冲击播:天力士特约之今日看世界(39)  </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 04:25</playTime>  <!--播出时间-->

            <name>音乐中国风(442)  </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 04:35</playTime>  <!--播出时间-->

            <name>维维健康新概念(193) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 04:40</playTime>  <!--播出时间-->

            <name>红牛凤凰全球连线(28/09/09) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 05:05</playTime>  <!--播出时间-->

            <name>红云红河时事开讲(28/09/09)  </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
        <Program>
            <playTime>2009-9-29 05:30</playTime>  <!--播出时间-->

            <name>别巡检调查队(34)(R) </name>          <!--节目名称-->
            <path>**</path>          <!--节目视频的本地路径-->
        </Program>
    </ProgramList>
</typeB>

需要的类：

频道父类：

namespace Chap08
{
    /// <summary>
    /// 电视频道的父类
    /// </summary>
  public abstract class ChannelBase
    {
        //频道名称
        public string Name { get; set; }
        //频道的路径
        public string Path { get; set; }
        //节目列表，该频道内的所有节目列表
        public List<TvProgram> TvList { get; set; }
        //加载所有的节目列表的方法
        public abstract void Fetch();
    }
}

Tv类：

namespace Chap08
{
    /// <summary>
    /// 节目单类
    /// </summary>
  public  class TvProgram
    {
        //开播时间
        public DateTime Time { get; set; }
        //时间档
        public string Timelots { get; set; }
        //节目名称
        public string Name { get; set; }
        //路径
        public string Path { get; set; }
    }
}

Load事件加载：

   private void FrmMain_Load(object sender, EventArgs e)
        {
            //初始化根节点
            TreeNode tn = new TreeNode("我的电视台");
           // tn.ImageIndex = 0;
            tv01.Nodes.Add(tn);
            //初始化根节点
            tn = new TreeNode("所有电台");
            tn.ImageIndex = 0;
            tv01.Nodes.Add(tn);
            //MessageBox.Show(a.ToString());
            doc = new XmlDocument();
            doc.Load("FullChannels.xml");
            root = doc.DocumentElement;
            //加载电视频道
            foreach (XmlNode item in root.ChildNodes)
            {
               tn.ImageIndex = 1;

            tv01.Nodes[1].Nodes.Add(item["tvChannel"].InnerText);
            }

        }

方法和类：

namespace Chap08
{
    //类型A 的电视频道 子类
    public class TypeAChannel : ChannelBase
    {

        public override void Fetch()
        {

        }
    }
}

TypeA:

 //加载北京电视台的方法
        List<TvProgram> AList = new List<TvProgram>();
       public void AFun()
        {
            XmlDocument doc = new XmlDocument();
            doc.Load("北京电视台.xml");
            XmlNode root = doc.DocumentElement;
            if (AList == null)
            {
                AList = new List<TvProgram>();
            }
            foreach (XmlNode item in root.ChildNodes)
            {
                if (item.Name == "tvProgramTable")
                {
                    foreach (XmlNode child in item.ChildNodes)
                    {
                        TvProgram tv = new TvProgram();
                        tv.Time = DateTime.Parse(child["playTime"].InnerText);
                        tv.Timelots = child["meridien"].InnerText;
                        tv.Name = child["programName"].InnerText;
                        tv.Path = child["path"].InnerText;
                        AList.Add(tv);
                    }
                    dgvList.DataSource = AList;
                }

            }
        }

TypeB:

namespace Chap08
{
    //类型B 的电视频道 子类
    public class TypeBChannel : ChannelBase
    {
        public override void Fetch()
        {

        }
    }
}

        //加载凤凰卫视节目的方法
        List<TvProgram> BList = new List<TvProgram>();
        public void BFun()
        {

            XmlDocument doc = new XmlDocument();
            doc.Load("凤凰卫视.xml");
            XmlNode root = doc.DocumentElement;
            if (BList == null)
            {
                BList = new List<TvProgram>();
            }
            foreach (XmlNode item in root.ChildNodes)
            {
                if (item.Name == "ProgramList")
                {
                    foreach (XmlNode child in item.ChildNodes)
                    {
                        TvProgram tv = new TvProgram();
                        tv.Time = DateTime.Parse(child["playTime"].InnerText);
                        tv.Name = child["name"].InnerText;
                        tv.Path = child["path"].InnerText;
                        BList.Add(tv);
                    }

                }

                dgvList.DataSource = BList;
            }
        }

TreeView选择：

  private void tv01_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (tv01.SelectedNode.Text == "北京电视台")
            {
                AFun();
            }
            else if (tv01.SelectedNode.Text == "凤凰卫视")
            {
                BFun();
            }
            else
            {
                List<TvProgram> list = new List<TvProgram>();
                dgvList.DataSource = list;
            }

            if (tv01.SelectedNode.Level == 0)
            {
                cms01.Items[0].Visible = false;
                cms01.Items[1].Visible = false;
            }
            else if (tv01.SelectedNode.Parent.Text == "我的电视台")
            {
                cms01.Items[0].Visible = false;
                cms01.Items[1].Visible = true;
            }
            else if (tv01.SelectedNode.Parent.Text == "所有电台")
            {
                cms01.Items[1].Visible = false;
                cms01.Items[0].Visible = true;
            }

        }

加入我的电台：

 private void toolStripMenuItem3_Click(object sender, EventArgs e)
        {

            foreach (XmlNode item in root.ChildNodes)
            {
                if (item["tvChannel"].InnerText == tv01.SelectedNode.Text)
                {
                    tv01.Nodes[0].Nodes.Add(item["tvChannel"].InnerText);
                    break;
                }
            }
        }

删除：

 private void 删除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            foreach (XmlNode item in root.ChildNodes)
            {
                if (item["tvChannel"].InnerText == tv01.SelectedNode.Text)
                {
                    tv01.SelectedNode.Remove();
                    break;
                }
            }
        }

播放：

 private void 播放ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            FrmPlay play = new FrmPlay();
            play.Path =dgvList.SelectedRows[0].Cells[3].ToString();
            play.Show();
        }

第九章 文件操作

  （1）文件的读写

 private void btn01_Click(object sender, EventArgs e)
        {
            string path = txt01.Text;///路径地址
            string content = txt02.Text;//保存的文本
            if(path.Equals(null)|| path.Equals(""))
            {
                MessageBox.Show("文件地址不能为空");
                return;
            }
            try
            {
                FileStream stream = new FileStream(path,FileMode.Create);
                StreamWriter writer = new StreamWriter(stream);
                writer.Write(content);
                writer.Close();//后开的先关
                stream.Close();
                MessageBox.Show("写入成功");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                throw;
            }
        }

 private void btn02_Click(object sender, EventArgs e)
        {
            string path = txt01.Text;
            if(path.Equals(null)||path.Equals(""))
            {
                MessageBox.Show("文件地址不能为空");
                return;
            }
            try
            {
                FileStream stream = new FileStream(path, FileMode.Open);
                StreamReader reader = new StreamReader(stream);
                string content = reader.ReadLine();
                txt02.Text = content;
                reader.Close();
                stream.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                throw;
            }

        }

/// <summary>
    /// 文件类
    /// </summary>
  public class MyFile
    {
        //文件长度
        public float  Length { get; set; }
        //文件名称
        public string Name { get; set; }
        //文件路径
        public string Path { get; set; }
        //文件类型
        public string Type { get; set; }
    }

   private void FrmMain_Load(object sender, EventArgs e)
        {

            TreeNode tn = new TreeNode("C:\\");
            tn.Tag = "C:\\";
            tvList.Nodes.Add(tn);

            tn = new TreeNode("D:\\");
            tn.Tag = "D:\\";
            tvList.Nodes.Add(tn);

            tn = new TreeNode("E:\\");
            tn.Tag = "E:\\";
            tvList.Nodes.Add(tn);
        }
        //绑定treeview的方法
        private void BindInfo(TreeNode node)
        {
            try
            {
                //清空选中文本的节点集合
                tvList.SelectedNode.Nodes.Clear();
                //初始化一个directory对象
                DirectoryInfo dir = new DirectoryInfo(node.Tag.ToString());
                //返回当前目录的子目录
                DirectoryInfo[] info = dir.GetDirectories();
                foreach (DirectoryInfo item in info)
                {
                    //一个item代表一个子节点
                    TreeNode tn = new TreeNode();
                    tn.Text = item.Name;
                    tn.Tag = item.FullName;
                    node.Nodes.Add(tn);
                }
                //清空ListView的数据
                lvList.Items.Clear();
                //FileInfo 初始化 FileInfo 类的新实例，它作为文件路径的包装。
                //GetFiles() 返回当前目录的文件列表
                FileInfo[] files = dir.GetFiles();
                foreach (FileInfo file in files)
                {
                    //把数据绑定到ListView
                    ListViewItem item = new ListViewItem(file.Name);//文件名称
                    item.SubItems.Add((file.Length / 1024).ToString()); //文件大小
                    item.SubItems.Add(file.Extension);//文件类型
                    item.SubItems.Add(file.FullName);//文件路径
                    lvList.Items.Add(item);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);

            }

        }

        private void tvList_AfterSelect(object sender, TreeViewEventArgs e)
        {
            //选中的节点的文本值传到BindInfo()方法中
            TreeNode tn = tvList.SelectedNode;
            BindInfo(tn);

        }

        private void lvList_DoubleClick(object sender, EventArgs e)
        {
            //双击打开选中的文件
            string path = lvList.SelectedItems[0].SubItems[3].Text;
            Process.Start(path);
        }

        private void 复制ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //提示用户选择文件夹。
            FolderBrowserDialog fold = new FolderBrowserDialog();
            DialogResult result = fold.ShowDialog();
            //选中的路径
            string path = lvList.SelectedItems[0].SubItems[3].Text;
            //声明一个新路径 赋值为null
            string paths = null;
            //当点击确定的时候复制新的路径
            if (result == DialogResult.OK)
            {
                paths = fold.SelectedPath;
                paths += "\\" + lvList.SelectedItems[0].SubItems[0].Text;
                File.Copy(path, paths);
                MessageBox.Show("复制成功");
            }
        }

        private void 删除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //选中要删除的文件的路径
            File.Delete(lvList.SelectedItems[0].SubItems[3].Text);
            BindInfo(tvList.SelectedNode);
            MessageBox.Show("删除成功");
        }

private void btnRead_Click(object sender, EventArgs e)
        {
            string path = "E:\\Hi.txt";
            FileStream fs = new FileStream(path,FileMode.Create);
            byte[] bt = new byte[1024];
            int count = fs.Read(bt,0,bt.Length);
            string result = Encoding.Default.GetString(bt,0,count);
            txt1.Text = result;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string fromPath = "D:\\ISO\\cn_windows_7_ultimate_with_sp1_x86_dvd_u_677486.iso";

            string ToPath = "E:\\18岁以下禁止观看.iso";

            FileStream fromFs = new FileStream(fromPath, FileMode.Open);
            FileStream toFs = new FileStream(ToPath, FileMode.Create);
            byte[] bytes = new byte[1048576];
            int count = fromFs.Read(bytes, 0, bytes.Length);
            int i = 0;
            while (count != 0)
            {
                toFs.Write(bytes, 0, count);
                count = fromFs.Read(bytes, 0, bytes.Length);
                txt1.Text=i.ToString();
                i++;
            }
            toFs.Close();
            fromFs.Close();

            MessageBox.Show("Copy Success!");
        }