面向对象编程好处：提高软件可复用性、可扩展性、易维护性、灵活性
第一章：理解.NET Framework与C#

  1..NET框架由.NET Frmaework和CLR组成；

  2.CLR(公共语言运行时)由CTS(通用类型系统)和CLS(公共语言规范)组成
    CTS作用：解决不同语言的数据类型不同的问题
    CLS作用：是一种最低的语言标准，限制了由这些不同点引发的互操作性问题

  3.简单类库的使用：
   (1)ping与本机相连的IP
     using System.Net;
     using System.Net.NetworkInformation;
     private void btnPing_Click(object sender,EventArgs e)
     {
        Ping pingSender=new Ping();
       PingReply reply=pingSender.Send(txtIP.Text,200);
    if(reply.Status==IPStatus.Success)
    {
        string message=string.Formate("地址：{0}连接测试成功！",txtIP.Text);
          MessageBox.Show(message);
    }
    else
    {
        string message=string.Formate("地址：{0}连接测试失败！",txtIP.Text);
        MessageBox.Show(message);
    }
     }

  (2)下载图片到指定路径：
     using System.Net;
     using System.IO;
     private void btnDownload_Click()
     {
      try
            {
        if(!File.Exists("Bliss.jpg"))
        {
            WebClient webClient = new WebClient();
                    webClient.DownloadFile(@"E:\Bliss.jpg", "123.jpg");//123.jpg为Bliss.jpg改名后的图片的名字
                    picShow.Image = Image.FromFile("123.jpg");
        }
        else
        {
            MessageBox.Show("你要下载的图片已经存在！");
        }
                
            }
            catch (Exception mes) 
            {
                MessageBox.Show(mes.Message);
            }
     }

  4.使用正则表达式:
    using System.Text.RegularExpressions;
    private static bool ipIsPass(string ip)
    {
         Regex rx = new Regex(@"^((2[0-4]\d|25[0-5]|[1]?\d\d?)\.){3}([2][5]?[0-4]?|[2][0-4]?[0-9]?|[2-9][0-9]?|[1][0-9]?[0-9]?)$");
        if (rx.IsMatch(ip))
         {
              return true;
         }
         else
         {
             return false;
         } 
     }
     
第二章：属性和方法
   1. C#中的几种类：
      普通类：public class Student
      抽象类：public abstract class Student
      部分类：public partial class Student
      静态类：public static class Student

   2.Java和.NET访问修饰符比较：
     Java:private、protected、default、public 
        类或属性在缺省访问修饰符的情况下，默认都是default
     .NET:private、protected、internat、public
       (1)类或属性在缺省访问修饰符的情况下，默认都是internal，并且在包下面的类只能是internal或public，而类中的类可以用            任意的访问修饰符
       (2)方法或字段在缺省访问修饰符的情况下是private 

   3.ref和out的区别：
     ref在调用前一定要赋值，调用的方法不一定要赋值
     out相反

   4.方法的重载：
     与方法是否为static无关，与返回类型无关，只与参数类型和参数个数有关

   5.构造函数的使用：
     public Student():this("李四"，"s25302")//调用自身类中的构造函数
     {
    
     }     
     public Student(string name,string stuNo)
     {
    this.name=name;
        this.stuNo=stuNo;
     }
    注意：静态构造函数不能重载，不能带访问修饰符和参数

  6.命名规范：
    (1)Pascal命名法命名的法一般情况下适用于公有成员
    (2)Camel命名法命名的法一般情况下适用于私有成员
    (3)私有字段要在前面加上下划线如：private string _name;
    (4)Pascal：类名、方法名、属性、枚举、结构
    (5)Camel：字段、内联变量(传的参数) 

  7.this相当于类的实例对象，this只能在类内部的实例方法中适用，它可以访问私有的变量    

第三章：值类型和引用类型
   1.获得当前系统时间：DateTime.Now

   2.求两个时间的差：     
     DateTime TimeStart= DateTime.Now;    
     DateTime TimeEnd = DateTime.Now;
     TimeSpan TimeStartToEnd = TimeEnd.Subtract(TimeStart);

   3.定义常量：访问修饰符 const数据类型 常量名=值
     const int Max_AGE=100;

   4.枚举：
     使用枚举好处：能够控制用户的输入，相当于sql中的约束
     应用：选择情况下使用，一般个数不超过10个
     注意：枚举是值类型，定义在命名空间下
     public enum Genders
     {
    Male=0,
    Female=1
     }
     获得枚举的整数值：
     stu.Gender=(Gender)(Enum.Parse(typeof(Genders),"Female"));
     Console.WriteLine(stu.Gender.ToString());//打印出1

   5.结构：是唯一可以new出来的值类型，在实际开发中不用结构而用类
     特征：值类型，不能带无参的构造函数，不能被继承，字段不能赋初值，构造函数必须对所有字段赋初值，不带参数的构造函数永         远不会被覆盖

   6.值类型：不能被实例化，不能等于null，值类型int、float、double、decimal、enum、struct、bool、char
     引用类型：传递的是地址，不是复制的数据或对象
   
   7.装箱和拆箱
     装箱：将值类型变成引用类型
      static void Main(string[] args)
      {
      int i=123;
          object o=i;//装箱
          i=456;
          Console.WriteLine("值类型的值为：",i);
          Console.WriteLine("引用类型的值为：",o);
      }
     拆箱：将引用类型变成值类型
    static void Main(string[] args)
    {
      int i=123;
          object o=i;
      try
      {
        int j=(int)o;
        System.Console.WriteLine("取消装箱成功！");
      }
      catch(System.InvalidCastException ex)
      { 
        System.Console.WriteLine("{0}错误：不正确的取消装箱",ex.Message);
      }
    }

   8.索引器：封装了集合或数据的操作
       特征：1.没有静态索引器 2.索引器没有名字，用关键字是this
       注意：定义一个索引器的时候，要使用this关键字
      private Student[] students;

      public Student[] Students
      {
        get{return students;}
        set{students=value;}
      }
      public Student this[int index]
      {
        get {return students[index]}
      }
      public Student this[string name]
      {
        get
        {
            int i;
            bool found=false;
            for(i=0;i<students.Length;i++)
            {
                if(students[i].Name==name)
                {
                    found=true;
                    break;    
                }    
            }
            if(found)
                return students[i]
            else 
                return null;
            
        }
      }
     
 第四章：用集合组织相关数据
   1.删除ArrayList中的元素：从尾巴开始，效率更高

   2.泛型集合:在System.Collection.Generic;中
      List<T>:T为该集合要存储的类型
       List<Student> students=new List<Student>();
       好处：List<T>比ArrayList有更大的类型安全性，因为取出元素的时候不需要类型转换

      Dictionary<k,v>:具有泛型的全部特性，编译时检查类型约束
       Dictionary<string,Student> students=new Dictionary<string,Student>();
           好处：Dictionary<k,v>比Hashtable    有更大的类型安全性，因为取出元素的时候不需要类型转换
             缺点：性能不高，很多情况下都不需要key值    

            
    集合类型        |             List<T>                   |               Dictionary<K,V>  
    ----------    --------------------------------    ---------------------------              
      方法          RemoverAt(int index),Add(T value)        Add(K key,V vlaue),Clear()
                Remove(T value),Clear()                   Remove(key),ContainsKey(key)  
    ----------    --------------------------------    ---------------------------
      属性          Count                                 Count,Keys,Values
    ----------    --------------------------------    ---------------------------
     访问元素          通过索引访问                 通过键访问

   3.ICollection<Student> 是List<Student>和Dictionary<string,Student>的父类

     static List<Student> _stus = new List<Student>();

     static Dictionary<string, Student> _stus =new Dictionary<string, Student>();
     //两种都可以用GetAllStudent();
     internal static ICollection<Student> GetAllStudent()
     {
            return _stus.Values;
     }

      foreach (Student stu in StuMage.GetAllStudent())
                this.lstStu.Items.Add(stu);

   4.Thread.Sleep(2000);//可让程序暂停2秒钟
        
第五章：文件读写与XML
   1.文件流：FileStream ---->基础流 
     辅助流：必须借助基础流才能操作
            读写流：StreamReader
            写入流：StreamWriter
      
   2.所在命名空间：using System.IO;
    
   3.写入流：
     string path=txtFilePath.txt;
     string content=txtContent.txt;
     FileStream fs=new FileStream(path,FileMode.Create);
     StreamWriter sw=new StreamWriter(fs);
     sw.Writer(content);
     sw.Close();
     fs.Close();
  
   4.读写流：     
     string path=txtFilePath.txt;
     string content="";
     FileStream fs=new FileStream(path,FileMode.Open);
     StreamReader sw=new StreamReader(fs);     
     content=sw.ReadToEnd();
     txtContent.txt=content;
     sw.Close();
     fs.Close();

   5.文件流中FileMode的成员：
      Create                  用指定的名称新建一个文件，会覆盖原来的文件
      CreateNew               新建一个文件，如果已经存在该文件则抛异常
      Open                    打开一个文件，如果文件不存在会抛异常
      OpenOrCreate            如果不存在要打开的文件，则用指定的名称新建一个文件
      Append                  在原来的文件内容后面追加新的内容

   6.StreamReader的方法成员：
      ReadLine()              读取一行数据     
      ReadToEnd()             读取所有的内容
      Close()                 关闭阅读器
 
   7.建议用法：
     string content="";
     using (FileStream fs=new FileStream(path,FileMode.Open))
     {
         using (StreamReader sr=new StreamReader(fs,Encoding.UTF8))
       {
        content=sr.ReadToEnd();
        txtContent.txt=content;
     }
     }

   8.文件和目录操作：
    File：对文件进行操作                           
    方法：     Exists(string path)         
           Copy(string SourceFilePath,string DestinationFilePath)
               Move(string sourceFileName,string destFileName)
               Delete(string path)
     
    Directory：对文件夹进行操作
               Exists(string path)
               Move(string soureDirName,string destDirName)
           Delete(string path,bool b)   如果b为true，则删除目录中的所有内容

   9.XML:
        对象                   属性和方法                    说明  
     ----------------------------------------------------------------------------
       XmlDocument            DocumentElement              获取根节点
                              ChildNodes                   获取所有子节点
                              Load()方法                   读取整个XML的结构
     ----------------------------------------------------------------------------                      
       XmlNode                InnerText                    当前节点的值
                              Name                         当前节点的名字
                              ChildNodes                   当前节点的所有子节点
     ----------------------------------------------------------------------------  
     
    例子：         
     <Student>
    <Name stuNo="s25301">张静静</Name>
    <Age>20</Age>
    <Hobby>唱歌</Hobby>
        <Name stuNo="s25302">周杰杰</Name>
        <Age>22</Age>
        <Hobby>耍双节棍</Hobby>
     </Student>
    
    获取XML中的内容：
      XMLDocument myXml=new XMLDocument();
      myXml.Load("Student.xml");                 //读取指定的XML文档
      XMLNode student=myXml.DocumentElement;     //读取XML的根节点,Name、Age
      foreach(XmlNode node in student.ChildNodes)
      {
      switch(node.Name)
      {
        case "Name":
             Console.WriteLine("姓名：{0},学号：{1}",node.InnerText,node.Attributes["stuNo"].InnerText);       
                break;    
        case "Age":
            Console.WriteLine("年龄：{0}",node.InnerText);        
                break;    
        case "Hobby":
              Console.WriteLine("爱好：{0}",node.InnerText);    
                break;    
      }
      }

     注意：myXml.DocumentElement.FirstChild                 获取根节点的第一个子节点

   10.树形控件：
      例子：
            this.tvwStu.Nodes.Clear();

            XmlDocument doc = new XmlDocument();
            doc.Load("Exam.xml");

            //得到根节点
            XmlNode rootNode = doc.DocumentElement;

            //获取班级信息
            foreach (XmlNode classNode in rootNode.ChildNodes)
            {
                //获取班级名称
                string className = classNode.Attributes["className"].InnerText;

                TreeNode treeClassNode = new TreeNode(className);

                //获取班级学员信息
                foreach (XmlNode stuNode in classNode.ChildNodes)
                {
                    //获取姓名
                    TreeNode stuTreeNode = new TreeNode(stuNode.ChildNodes[0].InnerText);

                    treeClassNode.Nodes.Add(stuTreeNode);
                }
                
                //将节点添加到树形控件
                this.tvwStu.Nodes.Add(treeClassNode);
            }

第六章:继承
   1.作用：实现软件中的代码复用、提高程序的简洁与高效
     
   2.注意：构造函数不可被继承、父类的实例不能访问子类的方法

   3.is-a关系：子类 is a 父类

   4.base关键字：base相当于父类的实例对象、但base可以访问父类中protected修饰的属性和方法,而实例对象则不能
     this关键字:不能访问父类的的私有成员

   5.密封类：用sealed关键字修饰的类。该类不能被继承

   6.如果父类有一个有参数的构造函数并且子类没有用base关键字指明调用哪一个构造函数,则父类一定要写一个无参数的构造函数
     因为子类会默认调用父类的无参构造函数     

   7.显示调用父类的构造函数
     public Student():base("张静静",20,Genders.Female){}

   8.is关键字:if(父类 is 子类){}      接口是if(子类 is 父类){}

   9.继承的传递性：如果class A:B;class B:C,则A也可以访问C的成员

第七章：多态
   1.子类重写父类的方法,父类作为参数,在运行的时候根据创建的不同的实例,去调用相应的方法

   2.派生类的访问修饰符不能高于父类

   3.抽象类：
     (1)作用：规范派生类的方法
     (2)例子：abstract public class Person{public abstract void SayHi();}
     (3)子类如果继承类抽象类,则子类应实现抽象类中定义的所有的抽象方法 public override void SayHi(){}
     (4)抽象类中可以定义非抽象方法和属性,但不能写静态的或者是sealed修饰的
     (5)抽象类中可定义虚方法

   4.
override和new的区别：
     new是覆盖,子类中的方法名和父类的方法名相同,但子类没有用override,则方法名前默认调用new关键字
     override是重写父类中的方法,在继承的时候用到

   5.is和as关键字只能针对引用类型,不能针对值类型
     is用法：if(父类 is 子类){}
     as用法：Students stu=Student[i] as Student;//相当于强转当前的对象为指定的对象,转化失败时，不会引发异常,会返回一              个null值

   6.override必须和virtual、abstract、override(三重继承的时候)一起用

第八章:接口
   1.作用：接口是一套规范和标准,实现了该接口的类必须实现接口中定义的所有方法及属性

   2.IComparable接口：类型不安全,不能实现多排序(例如：即可实现按姓名排序又可实现按年龄排序),只能按姓名排序或者按年龄排     序
     例子：class Student:Person,IComparable
           {
        public int CompareTo(object obj)
                    if(!(obj is Student))
            {
            throw new Exception("只能是Student对象的比较");
            }
            Student other=obj as Student;
            return this.Name.CompareTo(other.Name);
       }

   3.类的默认排序：(1)实现：IComparable<T>的CompareTo(T t)方法   (2)缺点:不能实现多元排序和符合排序
     一个对象的多元排序：(1)实现：IComparer(T)的Compare(T t)方法  (2)缺点:定义了很多个很简单的类,不能实现复合排序
     备注：复合排序实现：(1)通过数据库 (2)在2008c#中Linq(Linq to object)

     例子：
     public class NameComparer:IComparer<Student>
     {
    public int Compare(Student x,Student y)
              return (x.Name.CompareTo(y.Name));
     }

     public class AgeComparer:IComparer<Student>
     {
    public int Compare(Student x,Student y)
           return (y.Age.CompareTo(y.Age));
     }

     调用：
     private void TestDefaultSort()
     {
    InitStudents();
    students.Sort(new NameComparer());
    PrintStudents(students);
     }

     private void TestAgeSort()
     {    
    InitStudents();
    students.Sort(new AgeComparer());
    PrintStudents(students);
 
     }

   4.接口作为参数就是要传递一个实现了这个接口的对象。接口作为返回值就是要返回一个实现了这个接口的对象

   5.接口和抽象类的比较:
        -------------------------------------------------------------------------------------
                抽象类                    接口
        -------------------------------------------------------------------------------------
             用abstract定义                          用interface定义
        类只能继承一个抽象类                    类可一个实现多个接口
    不同点：非抽象派生类必须实现抽象方法            实现接口的类必须实现所有的成员
        需要override实现抽象方法                直接实现
        -------------------------------------------------------------------------------------
        不能实例化
        相同点：包含未实现的方法
                派生类必须实现未实现的方法
        -------------------------------------------------------------------------------------

第九章：序列化和反序列化
    1.作用:(1)不容易出错，操作简单 (2)通过序列化一个对象从一个应用程序发送到另一个应用程序中 (3)在远程通信中使用广泛

    2.二进制序列化--------->同一套应用程序中使用
      命名空间：using System.RunTime.Serialization..Formatters.Binary;
      条    件：(1)要有[Serializable]修饰类   (2)与被序列化相关的类也应有[Serializable]修饰
      实    例：pulbic void Save()
                {
             using (FileStream fs=new FileStream("profile.bin",FileMode.Create))
             {
              BinaryFormatter bf=new BinaryFormatter();
              bf.Serialize(fs,Profile);
             }
        }

        public void Load()
        {
             using (FileStream fs=new FileStream("profile.bin",FileMode.Create))
             {
              BinaryFormatter bf=new BinaryFormatter();
              Profile=(Profile)bf.Deserialize(fs);
             }
        }

    3.Xml序列化   --------->跨应用程序使用(应用更广)
      命名空间：using System.Xml.Serialiable;
      条    件：(1)不需要[Serializable]修饰  (2)类必须是public的  (3)相关的类必须要有默认的构造函数 (4)Xml只能序列化                 共有成员
      实   例：
    //1: xml基本操作和序列化
    //2: DTD
    //3: Schame
    //4: xlst
    //5: dso
    class Program
    {
        static void Main(string[] args)
        {
            ExamInfo exam = new ExamInfo(2);

            using (FileStream fs = new FileStream("exam2.xml", FileMode.Create))
            {
                XmlSerializer seri = new XmlSerializer(typeof(ExamInfo));
                seri.Serialize(fs, exam);
            }
        }

        /// <summary>
        /// 创建xml
        /// </summary>
        static void CreateXml()
        {
            XmlDocument doc = new XmlDocument();
            //xml指令信息
            StringBuilder str=new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
            //创建根节点,只能有一个
            str.Append(
                string.Format("<examInfo examDate=\"{0}\"></examInfo>",
                System.DateTime.Now.ToString("d")));

            doc.LoadXml(str.ToString());

            doc.Save("Exam.xml");
        }

        static void CreateClassDate()
        {
            XmlDocument doc = new XmlDocument();
            //加载xml文件
            doc.Load("Exam.xml");

            //获取根节点
            XmlNode root = doc.DocumentElement;

            //创建classInfo节点
            XmlNode classNode = doc.CreateElement("classInfo");

            //创建className属性
            XmlAttribute className = doc.CreateAttribute("className");
            //属性赋值
            className.Value = "P0703Y2";
            //属性添加到classNode
            classNode.Attributes.Append(className);

            className = doc.CreateAttribute("description");
            //属性赋值
            className.Value = "晚班";
            //属性添加到classNode
            classNode.Attributes.Append(className);

            //把classInfo加到根节点
            root.AppendChild(classNode);

            CreateStudent(classNode, doc);

            doc.Save("Exam.xml");
        }

        static void CreateStudent(XmlNode classNode, XmlDocument doc)
        {
            for (int i = 1; i <= 9; i++)
            {
                XmlNode Student = doc.CreateElement("student");

                XmlAttribute attr = doc.CreateAttribute("stuID");
                attr.InnerText = "P07030" + i;
                Student.Attributes.Append(attr);

                attr = doc.CreateAttribute("status");
                attr.InnerText = "应届";
                Student.Attributes.Append(attr);

                attr = doc.CreateAttribute("examID");
                attr.InnerText = "P0703080" + i;
                Student.Attributes.Append(attr);

                XmlNode node = doc.CreateElement("name");
                node.InnerText = "张三" + i;
                Student.AppendChild(node);

                node = doc.CreateElement("age");
                node.InnerText = (23 + i).ToString();
                Student.AppendChild(node);

                node = doc.CreateElement("sex");
                node.InnerText = i % 2 == 0 ? "true" : "false";
                Student.AppendChild(node);

                node = doc.CreateElement("idCard");
                node.InnerText = "12345678998765432 
                       
                    
                    
 
                      




鲜花




握手




雷人




路过




鸡蛋