个人总结深入.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框架核心类库及其功能

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

类和对象

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

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

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

封装

1.保证数据的安全性。

2.提供清晰的对外接口

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

类图

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

二.深入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("删除成功");

        }

    }

}

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

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

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

秒客网

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

相关文章