个人总结深入.NET平台和C#编程

前言：学习C#编程应该有几个月了，作为一个菜鸟，没有资格来评论什么。只有对自己所学进行一个总结，可能有不严谨的地方，万望谅解。

         一·深入.NET框架

.NET框架（.NET Framework），他是开发.NET应用程序的核心基础。

.NET框架的体系结构

支持C#、VB、.NET、c++、等语言的开发，也就是我们所说的跨语言开发。

.NET框架具有两个主要组件：CLR和FCL。（CLR是Common Language Runtime即公共语言进行时;FCL是Framework Class Library即框架类库）

.NET框架核心类库及其功能

类和对象

类定义了一组概念模型，而对象是真实的实体。

set访问器只写；get访问器只读。

在vs中自动属性prop+双击Tab键

封装

1.保证数据的安全性。

2.提供清晰的对外接口

3.类内部可以任意修改，不影响其他类。

类图

二.深入C#数据类型

值类型应用类型

值类型包括基本数据类型，和枚举类型，结构体等。

引用类型包括string 数组，类和接口。

结构体：

可以有字段，可以有方法。

定义时字段不能被赋初值。

不用new。声明结构对象后必须给结构成员赋初值。

拆箱和装箱

示例：

int a=1;

object o=i;//装箱

int j=(int)o;//拆箱

值传递和引用传递

引用类型作为参数时：
1、在修改变量本身时，结果类似于值传递，即不会改变传递前的变量的值
2、在修改变量的属性或字段时，才是引用传递，会影响到传递前的变量的值
3、参数使用了ref后，才是真正的引用传递，不管修改变量本身还是修改变量的属性或字段，都会影响到传递前的变量的值

值传递：传的是对象的值拷贝。(即函数内参数对象是调用时传递的对象的栈中对象的拷贝。)
引用传递：传的是栈中对象的地址。(即函数内参数对象与调用时传递的对象完全是同一栈中对象。)

三.使用集合组织相关数据

System.Collections 命名空间包含接口和类，这些接口和类定义各种对象（如列表、队列、位数组、哈希表和字典）的集合。
System.Collections.Generic 命名空间包含定义泛型集合的接口和类，泛型集合允许用户创建强类型集合，它能提供比非泛型强类型集合更好的类型安全性和性能。
System.Collections.Specialized 命名空间包含专用的和强类型的集合，例如，链接的列表词典、位向量以及只包含字符串的集合。

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();

            Console.WriteLine("遍历方法一:");
            foreach (int item in list)//不要强制转换
            {
                Console.WriteLine(item);//遍历方法一
            }

            Console.WriteLine("遍历方法二:");
            for (int i = 0; i < list.Count; i++)//数组是length
            {
                int number = (int)list[i];//一定要强制转换
                Console.WriteLine(number);//遍历方法二

            }
        }
    }
}

　　1、哈希表(Hashtable)简述
     在.NET Framework中，Hashtable是System.Collections命名空间提供的一个容器，用于处理和表现类似key/value的键值对，其中key通常可用来快速查找，同时key是区分大小写；value用于存储对应于key的值。Hashtable中key/value键值对均为object类型，所以Hashtable可以支持任何类型的key/value键值对.

2、哈希表的简单操作
在哈希表中添加一个key/value键值对：HashtableObject.Add(key,value);
在哈希表中去除某个key/value键值对：HashtableObject.Remove(key);
从哈希表中移除所有元素：                HashtableObject.Clear(); 
判断哈希表是否包含特定键key：         HashtableObject.Contains(key);
遍历

foreach(DictionaryEntry item in Hashtable)

{

item.Key;

item.Values;

}

泛型最常见的用途是泛型集合，命名空间System.Collections.Generic 中包含了一些基于泛型的集合类，使用泛型集合类可以提供更高的类型安全性，还有更高的性能，避免了非泛型集合的重复的装箱和拆箱。 
    很多非泛型集合类都有对应的泛型集合类，下面是常用的非泛型集合类以及对应的泛型集合类：

非泛型集合类	泛型集合类
ArrayList	List<T>
HashTable	DIctionary<T>
Queue	Queue<T>
Stack	Stack<T>
SortedList	SortedList<T>

 单列泛型集合：

List<Object> list=new List<Oibject>();

遍历

for(int i=0;i<list.Count;i++)

{

  Console.WriteLine(list[i]);

}

foreach(Object item in list)

{

  Console.WriteLine(item);

}

双列泛型集合

Dictionary<object,object> dic=new Dictionary<object,object>();

遍历

foreach(KeyValuePair<object,object> item in dic)

{

Console.WriteLine(dic.Key);

Console.WriteLine(dic.Value);

}

foreach(Object item in dic.Keys)

{

 Console.WriteLine(item);

  Console.WriteLine(dic[item].Value);

}

foreach(Object item in dic.Values)

{

 Console.WriteLine(item);

}

四.深入类的方法

1.构造函数

（1.）方法名与类名相同

（2.）没有返回值

（3.）主要完成对象初始化工作

2.无参构造函数的

语法

访问修饰符 类名()

{

 //方法体

} 

3.带参构造函数

语法

访问修饰符 类名(参数列表)

{

 //方法体

} 

隐式构造函数

系统自动给类分配一个无参构造函数。

构造函数的重载

无参构造和带参构造可以看成是方法重载。

方法重载

（1.）方法名相同

（2.）方法参数类型不同或者参数个数不同

（3.）在同一个类中

对象交互

每个类都有自己的特性和功能，我们把它们封装为属性和方法。对象之间通过属性和方法进行交互。可以认为方法的参数及方法的返回值都是对象间相互传递消息。

个人理解，他为什么叫对象间交互呢。因为是对象间进行的属性方法交互。而类之间进行的继承多态接口。

 六.初识继承和多态

继承概述

1.什么是继承

（1）移除类的冗余代码

（2）集成的概念

2.base关键字和protected修饰符

public class Person
{
protected string ssn = "111-222-333-444" ;
protected string name = "张三" ;
public virtual void GetInfo() {
Console.WriteLine("姓名: {0}", name) ;
Console.WriteLine("编号: {0}", ssn) ;
}
}
class Employee: Person
{
public string id = "ABC567EFG23267" ;
public override void GetInfo() {
// 调用基类的GetInfo方法:
base.GetInfo();
Console.WriteLine("成员ID: {0}", id) ;
}
}

　　

3.子类构造函数

（1）隐式调用父类构造函数

（2）显示调用父类构造函数

 继承的使用

继承、封装和多态是面向对象编程的重要特性。
其成员被继承的类叫基类也称父类，继承其成员的类叫派生类也称子类。

派生类隐式获得基类的除构造函数和析构函数以外的所有成员。

派生类只能有一个直接基类，所以C#并不支持多重继承，但一个基类可以有多个直接派生类。
继承是可以传递的。

私有成员其实已经被继承了，但是它们却不可以被访问，因为私有成员只能被声明它们的类或结构体中才可访问，所以看上去像是没有被继承。

如果基类中是没有参数的构造函数

如果基类中是没有参数的构造函数，在派生类中可以自定义有参数的构造函数

如果基类定义了带有参数的构造函数，那么此构造函数必须被执行，且在派生类中实现该构造函数，此时我们可以使用base关键字

 

如果派生类的基类也是派生类，则每个派生类只需负责其直接基类的构造，不负责间接基类的构造，
并且其执行构造函数的顺序是从最上面的基类开始的，直到最后一个派生类结束。

is a的应用

由于SE和PM都继承Employee，即SE is a Employee,PM is a Employee.

继承的价值：

（1.）集成模拟了现实世界关系，oop中强调一切皆对象，这符合我们面向对象编程的思考方式

（2.）继承实现了代码复用

（3.）集成使程序结构更清晰

多态

解决集成带来的问题

虚方法

使用virtual关键字修饰的方法，称为虚方法。虚方法有方法体

语法

访问修饰符 virtual 返回类型 方法名（）

 {

    //方法体

 }

重写虚方法

访问修饰符 override 返回值类型 方法名()

{

//方法体

}

什么是多态

多态按字面的意思就是“多种形态”，指同一操作作用不同的对象时，可以有不同的解释，产生不同的结果。

实现多态

（1.）实现方法重写

（2.）定义父类变量

七.深入理解多态

里氏替换原则

在一个软件系统中，子类可以替换父类出现的位置，而对软件的功能没有任何影响，就称为里氏替换原则。

子类可以扩展父类的功能，但不能改变父类原有的功能。 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。 子类中可以增加自己特有的方法。

当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

看上去很不可思议，因为我们会发现在自己编程中常常会违反里氏替换原则，程序照样跑的好好的。所以大家都会产生这样的疑问，假如我非要不遵循里氏替换原则会有什么后果？

后果就是：你写的代码出问题的几率将会大大增加。

例如： Father son=new Son();

C#中有两个关键字可以提现里氏替换原则：is和as操作符 is操作符用于检查对象和指定的类型是否兼容。 as操作符主要用于两个对象之间的类型转换。

父类类型做参数

示例： 先给几个类： 1.父类，交通工具类。有一堆属性。 2.汽车类，继承父类。 3.地铁类，继承父类。 4.员工类。员工乘坐交通工具回家！员工回家的方法，参数是父类对象！

然后建一个员工的集合，初始化员工. 扔到集合里。就和=可以用集合的项点出员工回家的方法传一个子类！ 总结这就是子类指向父类！也就是所谓的里氏替换原则！

抽象类和抽象方法

如果一个类不与具体的事物相联系，而只是表达一种抽象的概念，仅仅是作为其派生类的一个基类，这样的类就是抽象类，在抽象类中声明方法时，如果加上abstract时就是抽象方法

抽象类与非抽象类的主要区别：

·抽象类不能直接被实例化

·抽象类中可以包含抽象成员，但非抽象类中不可以

·抽象类不能是密封的或者静态的

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

抽象方法语法

访问修饰符 abstract 返回值类型 方法名（）；

注意：抽象方法没有闭合的大括号，而是直接跟了个“；”也就是说，它没有包括方法执行逻辑的方法体！

抽象类的定义

语法： 访问修饰符 abstract class 类名{}

注意： 抽象类提供的抽象方法，这些方法只有定义，如何实现都由抽象类的非抽象子类完成。

抽象类和抽象方法的应用

如何实现一个抽象父类派生的子类 当从一个抽象父类派生一个抽象子类时，子类将继承父类的所有特征，包括它未实现的抽象方法。抽象方法必须在子类中实现，除非他的子类也是抽象类。

抽象类和抽象方法的应用

如何实现一个抽象父类派生的子类 当从一个抽象父类派生一个抽象子类时，子类将继承父类的所有特征，包括它未实现的抽象方法。抽象方法必须在子类中实现，除非他的子类也是抽象类。

面对对象的三大特性

封装：保证对象自身数据的完整性和安全性

继承：建立类之间的关系上，实现代码复用，方便系统的扩展。

多态：相同的方法调用可实现不同的实现方式。

八.可扩展标记性语言XML

一、XML是什么？作用是什么？

l  XML ( eXtensible Markup Language )语言是一种可扩展的标记语言。其中的可扩展是相对HTML来说的。因为XML标签没有被预定义，需要用户自行定义标签。

l  XML 被设计的宗旨是：是表示数据，而非显示数据。

操作XML的方法

解析XMl文件

public static void Main（string[] args）

{

XmlDocument doc=new XmlDocument():

doc.Load("Engineer.xml");

XmlNode root=new XmlNode();

foreach(XmlNode item in doc.ChildNodes)

{

switch(node.Name)

{

case "id":

Console.WriteLine(node.InnerText);

break;

}

}

}

 用TreeView显示数据

XmlDocument doc = new XmlDocument();
            doc.Load("北京电视台.xml");
            XmlNode root = doc.DocumentElement;
            //找根节点
            foreach (XmlNode item in root.ChildNodes)//遍历子节点
            {
                if(item.Name.Equals("tvProgramTable"))//判断条件是节点的Name是否是"tvProgramTable"
                {
                    foreach (XmlNode items in item.ChildNodes)//遍历子节点的子节点
                    {
                        TvProgram Tp = new TvProgram();
                        Tp.PlayTime = Convert.ToDateTime(items["playTime"].InnerText);
                        Tp.Meridien = items["meridien"].InnerText;
                        Tp.Path = items["path"].InnerText;
                        Tp.ProgramName = items["programName"].InnerText;
                        ProgramList1.Add(Tp);//绑定到集合
                    }
                }

            }
TreeNode minenode = new TreeNode();
            minenode.Text = "我的电视台";

            //bind
            tvList.Nodes.Add(minenode);

            //根节点
            TreeNode root = new TreeNode();
            root.Text = "所有电视台";
            //bind
            tvList.Nodes.Add(root);

            ChannelManager manager = new ChannelManager();
            manager.ResolveChannels();
            List<ChannelBase> list = manager.List;
            foreach (ChannelBase item in list)
            {
                TreeNode tn = new TreeNode();
                tn.Text = item.ChannelName;
                tn.Tag = item;
                root.Nodes.Add(tn);

            }

　　九.文件操作

如何读写文件

引入using.System.IO;

string path=txtFilePath.Text;

string content=txtContent.Text;

if(path.Equals(null)||path.Equals(""))

{

MessageBox.Show("文件的路径不为空");

return；

}

try

{

FileStream nyfs=new FileStream(path,FileMode.Create)

streamWriter mysw=new StreamWriter(myfs);

mysw.Write(content);

mysw.Close();

myfs.Close();

MessageBox.Show("写入成功");

}

catch(Exception ex)

{

MessageBox.Show(ex.Message);

}

文件流

语法

FileStream 文件流对象=new FileStream(string filePath,FileMode fileMode);

文件读写器

StreamWriter 写入器

StreamWriter mysw=new StreamWriter();

解决乱码问题

FileStream myfs=new FileStream(path,FileMode.Open)

StreamReader mySr=new StreamReader(myfs,Encoding.Default);

content=mySr.ReadToEnd();

txtContent.Text=content;

文件和目录操作

File类和Directory类

File类常用的方法

Exites(string path) 用于检查指定文件是否存在

copy()复制文件

Move()移动文件

Delete()删除文件

示例 小型资源管理器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Chap09_资源管理器
{
    class MyFile
    {
        public string FileName { get; set; }
        public long FileLength { get; set; }
        public string FileType { get; set; }
        public string FilePath { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;

namespace Chap09_资源管理器
{
    public partial class FrmMain : Form

    {
        public FrmMain()
        {
            InitializeComponent();
        }

        private void FrmMain_Load(object sender, EventArgs e)
        {
            DriveInfo[] di = DriveInfo.GetDrives();
            foreach (DriveInfo item in di)
            {
                TreeNode tn = new TreeNode(item.Name);
                tn.Tag = item.Name;
                tvList.Nodes.Add(tn);

            }

        }
        public void BindInfo(TreeNode node)
        {
            try
            {
                lvList.Items.Clear();
                DirectoryInfo dir = new DirectoryInfo(node.Tag.ToString());
                DirectoryInfo[] dirs = dir.GetDirectories();
                foreach (DirectoryInfo item in dirs)
                {
                    TreeNode tn = new TreeNode();
                    tn.Text = item.Name;
                    tn.Tag = item.FullName;
                    node.Nodes.Add(tn);
                }
                FileInfo[] fi = dir.GetFiles();
                List<MyFile> files = new List<MyFile>();
                foreach (FileInfo item in fi)
                {
                    MyFile mf = new MyFile();
                    mf.FileName = item.Name;
                    mf.FileLength = item.Length;
                    mf.FileType = item.Extension;
                    mf.FilePath = item.FullName;
                    files.Add(mf);
                }
                foreach (MyFile item in files)
                {
                    ListViewItem items = new ListViewItem(item.FileName);
                    items.SubItems.Add(item.FileLength.ToString());
                    items.SubItems.Add(item.FileType);
                    items.SubItems.Add(item.FilePath);
                    lvList.Items.Add(items);
                }

            }
            catch (Exception ex)
            {

                MessageBox.Show(""+ex.Message);
            }

        }

        private void tvList_AfterSelect(object sender, TreeViewEventArgs e)
        {

            TreeNode node = this.tvList.SelectedNode;
            this.BindInfo(node);

        }

        private void lvList_DoubleClick(object sender, EventArgs e)
        {
            Process.Start(lvList.SelectedItems[0].SubItems[3].Text);
        }

        private void 复制ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            DialogResult result = fbd.ShowDialog();
            string sourcePath = lvList.SelectedItems[0].SubItems[3].Text;
            string desPath = null;
            if(result==DialogResult.OK)
            {
                desPath = fbd.SelectedPath;
                desPath += "\\" + lvList.SelectedItems[0].SubItems[0].Text;
                File.Copy(sourcePath,desPath);
                MessageBox.Show("复制成功");
            }

        }

        private void 删除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            lvList.Items.Clear();
           string deletePath=lvList.SelectedItems[0].SubItems[3].Text;
            File.Delete(deletePath);
            MessageBox.Show("删除成功");
        }
    }
}

　　

启动后就是这样可以读出自己硬盘上的东西！

好了就写到这了。总结到这里了。