导图社区 程序设计
- 531
- 20
- 2
- 举报
程序设计
NET与C#的概述，NET及C#是什么，集成开发环境的搭建，惯例第一个程序，项目文件解释。程序设计基础，C#程序的组成要素，C#数据类型，常量和变量，运算符和表达式，引用类型，常用的系统定义类
编辑于2021-04-08 23:40:53- 数据类型
- 设计基础
- 程序要素
- 系统定义
- 相似推荐
- 大纲
程序设计
第一章 .NET与C#的概述
1.1、.NET及C#是什么？
.NET
是什么？
集合平台
开发环境
标准协议
统一开发工具
编程类库
组成结构
底层操作系统
为.NET应用程序的开发提供软硬件支持
.NET企业服务器
为企业的信息化和信息集成提供帮助
XML Web服务控件
提供一些公共性的Web服务：身份认证、发送信息、密码认证
.NET框架
为运行在.NET平台上的程序提供运行和执行的环境
.NET开发工具
集成开发环境和编程语言
C#
是什么？
一门运行在.NET CLR上的计算机语言，是一款专门为使用.NET平台而创建的计算机语言
语言特点
语法简洁
可面向对象编程（窗体控件式编程）
强大的Web服务器控件
完整的安全性和错误处理
强大的灵活性
1.2、集成开发环境的搭建
Visual Studio2017的安装
程序下载网址
https://www.visualstudio.com/zh-hans/downloads/
按个人开发需求安装相对应的版本
版本对应激活码
Visual Studio 2017（VS2017） 企业版Enterprise 注册码：NJVYC-BMHX2-G77MM-4XJMR-6Q8QF
Visual Studio 2017（VS2017） 专业版Professional 激活码key：KBJFW-NXHK6-W4WJM-CRMQB-G3CDH
安装过程
按照安装提示和个人需求选择性安装功能模块
安装路径建议：不建议默认安装在C盘目录下
1.3、惯例：第一个程序
新建项目步骤：
1、启动Visaual Studio2017
2、文件
新建
项目
选择：控制台应用程序
输入该项目的项目名称
选择项目存储位置
确定
实例代码
代码：（在Main方法中输入） Console.WriteLine("Hello，World！"); //调用方法输出指定内容 //Console:控制台类，WriteLine为方法，输入后换行，Write输出不会换行 Console.ReadLine();
（直接按F5或者调试运行）运行程序
代码片段解析
namespace
命名空间，等同于该个项目的名字，可在其他地方使用using来调用该项目中的方法
Console.WriteLine()方法
实际上等同于System.Console.WriteLine()方法，因为前面已经调用System命名空间，作用：向屏幕输出信息或者从键盘获取输入
class
c#中每一个class都是一个类，项目创建的初始化会自动创建一个Main()方法为用户提供程序入口，从Main()方法开始启动
//
注释作用，处于//后面的字符串是不会被编译运行的，起到解释代码的作用
Console.ReadLine()方法
获取用户输入的方法
;
英文状态下的分号，C#规定“:”是一条语句结束的标志
注意
C#语言对大小写是特别敏感的，大写的C和小写的c表示不同的字符
注意语句结束的是有一定要以西文半角状态下的分号结尾
尽量使用缩进的方式来凸显程序的层次结构
如果程序运行报错，提示符号错误，务必检查该符号是否在西文半角状态下输入的
1.4、项目文件解释
.sln文件
为解决方案资源管理器提供该项目相关的所有文件目录支持，打开.sln文件就能快速定位改革项目的所有文件
.csproj文件
项目文件，创建项目程序所需要的引用、数据连接、文件夹和文件信息，可包含多个文件
.cs文件
C#源代码文件
.resx文件
资源文件，包括windows窗体、web窗体等文件信息
.aspx文件
web窗体文件，有HTML标记、Web服务器控件、脚本组成
.asmx文件
XML Web服务文件，连接特定的.cs文件，用作XML Web services可寻址入口点
.config文件
发布路径，找到要发布的网站
.suo文件
解决方案用户选项，记录所有将解决方案建立的关联的选项，以便在每次打开时都包含用户所做的自定义设置
第二章 程序设计基础
2.1、C#程序的组成要素
标识符
解释：（类、命名空间、变量、常量、对象、方法）进行标识的名称
命名规则：
标识符中只能包含字母（大小写）、数字和下划线“_”，不可以出现其他的字符
标识符只能以字母或者下划线开头，其他的开头都不符合命名规则
new是关键字，不能作为标识符
标识符区分大小写，name和Name不是同一个标识符
关键字
C#程序语言所保留的特定含义的字符串，不可以作为普通的标识符使用
关于保留的标识符，可自行百度
语句
语句是程序的基本单位，是执行某种操作的命令，通常以西文半角状态下的分号结束语句“;”
一条语句可以写在多行，也可以一行书写多行语句
例子：
一对花括号是一个块结构，花括号必须是一对不能单个出现
花括号可以嵌套，表示程序的不同层次
建议养成良好的代码块的层次缩进
注释
单行注释：//
多行注释：/*开始，*/结束 中间为注释部分
文档注释：/// 在程序编译的时候，会自动生成一个注释文档说明书
命名空间
命名空间，等同于该个项目的名字，可在其他地方使用using来调用该项目中的方法
格式
SpaceName
namespace为命名空间的关键字
SpaceName为命名空间的，是用户或系统定义的名字
也可以进行多层命名空间的嵌套
类和方法
C#的源代码必须放在类里面，类是C#程序的基本组成元素
一个应用程序中至少要包含一个自定义类
类使用关键字class声明
类的成员有属性、方法、事件
2.2、C#数据类型
值类型
整数类型
解释：就是没有小数部分的数值
细分整数类型
在实际的应用中，需要按照实际的出发选择相对应的整型类型，以便节省内存空间
无符号长整型：ulong
长整型：long
无符号整型：uint
整型：int
无符号短整型：ushort
短整型：short
字节型：byte
短字节型：sbyte
实数类型
解释：就是浮点型和小数型
细分实数类型
在实际的应用中，需要按照实际的出发选择相对应的整型类型，以便节省内存空间
单精度浮点型：float
双精度浮点型：double
小数类型：decimal
布尔类型
解释：表示逻辑真和逻辑假的两个概念，该数据类型只有两种取值
逻辑真：true
逻辑假：false
字符类型
解释：指的是单个字符，使用的是Unicode字符集，其中包括:
数字字符
英文字符
表达式符号
结构类型
解释：结构类型是程序员自定义的一种类型，需要先自定义结构类型后再定义该结构类型的结构类型变量
结构类型的定义与使用：
代码请查看备注
public struct Book //声明结构类型，为程序调用函数做准备，为了能够使得整个程序能够正常调用声明的数据成员，所以声明的位置需要放在程序入口的外层 { //声明结构类型的数据成员 public string Bid; //图书编号 public string Bname; //书名 public string Author; //作者 public string Publisher; //出版社 public float Price; //定价，单精度浮点型 } class Program { // #region #endregion 折叠项目的名称，起到管理代码段的作用 static void Main(string[] args) //程序入口，类下面的方法，Main只能只有一个，程序初始状态进入程序的入口，当然还可以有很多程序入口，但Main只能有一个 { Book b1; //定义一个书本1，下面为b1的相关属性赋值 b1.Bid = "1001"; b1.Bname = "C#程序设计"; b1.Author = "张"; b1.Publisher = "清华大学出版社"; b1.Price = 39.8f; //价格只能为单精度浮点型，因为在最初的结构类型声明的时候固定了的 Console.WriteLine("图书编号\t书名\t\t作者\t出版社\t\t\t单价"); //Console.WriteLine("{0}{1}{2}{3}{4}", b1.Bid, b1.Bname, b1.Author, b1.Publisher, b1.Price); //此处占位符似乎需要手动调整，不具备自动随着变量的位置变化而变化 //Console.WriteLine("{0}\t{1}\t\t{2}\t{3}\t\t\t{4}", b1.Bid, b1.Bname, b1.Author, b1.Publisher, b1.Price); //对不齐 //Console.WriteLine( b1.Bid, b1.Bname, b1.Author, b1.Publisher, b1.Price); //只能显示第一个变量 //Console.WriteLine( b1.Bid+b1.Bname+b1.Author+b1.Publisher+b1.Price); //只能只能启连接作用 Console.WriteLine(b1.Bid + "\t"+ b1.Bname + "\t\t" + b1.Author + "\t" + b1.Publisher + "\t\t" + b1.Price); //连接转义字符作用 Console.ReadLine(); } } }
public：为访问修饰符，指明结构类型及类型成员的可访问级别，访问修饰种，需要了解详细请转跳到访问修饰符知识点
struct：是声明结构类型的关键字
Book：为结构类型标识符，属于用户自定义的，用来表示这个是一个什么结构类型，定义的时候尽量能见到名字就知道这是一个什么结构类型
花括号括起来的是结构类型的成员
结构类型成员
属于结构类型的一个成员，代表一个成员对象的属性
定义形式和定义普通变量相同
可以是一个简单的数据类型，也可以是一个结构类型
命名规则同样按照标识符命名规则
枚举类型
解释：枚举类型用于声明在逻辑上存在一定关系的一组整型常数，为了方便记忆，常数往往使用一些符号来表示
枚举类型的声明与使用：
代码请查看备注
声明： public enum TimeOfDay 访问修饰符 enum 枚举类型名：基础类型 { 枚举类型成员 Moning = 0, Afternoon = 1, Evening = 2, }; 使用： public string getTimeOfDay(TimeOfDay time) { string result = string.Empty; switch (time) { case TimeOfDay.Moning: result = "上午"; break; case TimeOfDay.Afternoon: result = "下午"; break; case TimeOfDay.Evening: result = "晚上"; break; default: result = "未知"; break; } return result; }
基础类型：指明的是枚举类型成员数值的类型，可以显式的声明枚举类型的基础类型为整型类型
枚举类型成员：是枚举类型中的常数，任意两个枚举类型成员不能有相同的名称，每个成员关联一个常数，常数值的类型就是枚举类型的基础类型
枚举类型的值如果不指定，枚举类型就会默认将第一个枚举类型成员值设置为默认值，后面的排列以一次增加
2.3、常量和变量
常量
直接常量
解释：就是在程序中直接给出的数据值
类型：
整型常量
有符号整型常量
直接书写：-28、-63.5
无符号整型常量
无符号整型常量书写时需要添加后缀：不强制添加后缀
长整型符号常量
长整型常量书写时需要添加后缀：255L，不强制性添加后缀
浮点型常量
单精度浮点型
强制添加后缀f：2.33f，如果不添加后缀将会默认为双精度浮点型常量
双精度浮点型
强制添加后缀d：2.56d
小数常量
小数常量书写时必须添加后缀m：3.14m
字符型常量
普通字符常量：l、m、5、#
字符常量只能包含一个字符
区分大小写
转义字符
\' 单引号
\" 双引号
\\ 反斜杠
\0 空
\a 警告（发生蜂鸣）
\b 退格
\f 换页
\n 换行
\r 回车
\t 水平制表符
\v 垂直制表符
字符串常量
由若干字符序列组成，使用双引号标记：“abhjejs”、“你好”、“12536”
由若干字符序列组成，使用双引号标记：“abhjejs”、“你好”、“12536”
布尔类型常量
逻辑真：true
逻辑假：false
符号常量
解释：是具有某种特殊意义的固定数据和常量，如圆周率、黄金比例等，符号通常在程序的开始处定义
定义格式：
const 数据类型 常量名=常量数据
const 数据类型 常量名=常量数据 const float PI=3.14f; const int m = 18；
const ：C#中定义符号常量的关键字
PI、M 为符号常量的名字，通常用全大写来表示，同样准遵循标识符命名规则
符号常量只要定义了就不能再程序中再次赋值
符号常量命名的名字尽量做到见名知义
如果要改变这个常量，就能改动一处就能改动全部地方，因此需要注意
变量
解释：变量指的是在程序实际的运行过程其值能够不断发生改变的量，可以将变量看做成一个带有名字的盒子，在初始状态下可以有东西和没有东西（即初始赋了值和初始没有赋值）
变量三要素
变量名：指的是该个变量的名字，带有在该程序中的唯一性，同样遵循标识符命名规则
变量类型：指的是该数据的类型，尽量按实际的需求进行选择数据类型
变量的值：指的是该变量存储的值，初始状态下可以为空也可以初始的赋值
变量的定义
变量定义示例模版
类型标识符 变量名1,变量名2,变量名...； 例如： int a,b,c; //定义三个整型变量 float d,e; //定义两个浮点型变量
C#可以同时定义多个变量，变量名之间以西文半角下的逗号 , 来分隔，最后以西文半角下的分号 ; 结束
标识符与变量名之间最少隔开一个空格
变量名遵循标识符命名规则
在同一个程序中，变量不能被重复定义
变量初始化
例子： int a = 1 , b = 2; float c = 2.33f ，d = 5.22f; char j = ‘h’; bool b1 = true , b2 = false;
变量操作
例子： int c; int a = 1 , b = 2; //变量赋值操作 c = a; //变量取值操作和变量复制操作 c = 56 //赋值操作，此处是先定义后赋值
注意：
高精度类型的数据不能向低精度转换，如果强制转换会造成数据的精度丢失
如果一个数值带有小数，且没有添加注明数据类型的后缀字符，系统将会默认为double双精度浮点型
如果不带小数点的数值，则该常数会默认为int数值类型，对于属于整数类型的常量C#会按照：int、uint、long、ulong来判断该数据类型
类型的转换
隐式转换
是在多种类型数据混合运算时，编译器自动完成的，转换规则为：低精度的数据类型转换为高精度的数据类型
隐式转换一般不会失败
也不会照成精度信息的丢失
例如：double d1 = 3.14f；
隐士转换无法完成高精度数据类型转换为低精度数据类型，且隐式转换的规则为：
参与运算的时候，是先要转换成同一类型数据后再进行运算
其他数据类型不能转换为char类型
不存在float，double浮点类型与decimal小数类型之间的转换
byte字节型和short短整型进行运算时，必需转换为int型才能参与运算
显式转换
解释：又称为强制转换，需要用户明确的指明需要转换的类型
类型说明符 需要转换的表达式 例如： float f = 12; int k; k =(int)(f); //将浮点型的f转换为整型后赋值给变量k
显式转换不一定能成功，而且会有数据精度丢失的现象
显式转换的应用例子：四舍五入
float x; float y; Console.WriteLine("请输入一个实数："); x = Convert.ToSingle(Console.ReadLine()); y = (int)((x + 0.005f) * 100f) / 100.0f; Console.WriteLine("\n将实数{0}四舍五入后保留两位小数的结果是：{1}", x, y); Console.ReadLine();
使用方法进行数据类型转换
Parse方法
代码请查看备注
数值类型的名称.Parse(字符串表达式) int k = int.Parse("200"); float f = float.Parse("200.0"); 如果写成： int k = int.Parse("200.0"); 则不能通过系统的编译，会提示报错！！
原理：Parse方法使用比较简单，只要是符合需要转换的数据类型，就可以直接将字符串转换成相对的数据类型
Convert类的方法
代码请查看备注
例子： int k ; k = Convert.ToInt32("97") ; char cr1 = Convert.ToChar(k); float f = Convert.Tofloat(k);
Convert方法几乎涵盖C#中所有类型的转换
2.4、运算符和表达式
算数运算符和算数表达式
基本算数运算符
+ 取正
取正的时候可以选择性省略
- 取负
+ 加
- 减
* 乘
/ 除
% 取余
除取正外的其他运算符与数学中的用法相似
不同数值类型所运算所得到的结果是不一样的如：7 /3 = 27 /3 = 2.33333...什么数据类型运算，则获得相对应的数据类型结果
求余运算，所得到的结果只输出余数
C#中允许实数进行求余运算
算数表达式
3+5/6*99-5*(55) 属于合法的算数表达式，类似于常用的简单数学公式
自增++与自减--
++ 自增1
++x 先自增1赋值变量后再参与运算，注意运算顺序
x++ 先参加运算后再自增1赋值变量，注意运算顺序
-- 自减1
--x 先自减1后赋值变量后再参与运算，注意运算顺序
x-- 先参加运算后再自减1后赋值变量，注意运算顺序
关系运算符和关系表达式
关系运算符
大于
= 大于等于
小于
= 小于等于
== 等于
！= 不等于
关系表达式
377%2 == 0
表达式中既有算数表达式又有关系表达式，先计算算数表达式，再计算关系表达式
注意等于为： == ，切记不要用 = 赋值符号来表示等于
赋值运算符合赋值表达式
= 赋值符号
例子：x = 10；将常量10赋值给xa = b+c；//将b+c的结算结果赋值给a
赋值号左边必须是变量
赋值表达式
变量 = 表达式x = 10;
复合赋值运算符
*=
/=
%=
+=
-=
=
=
=
^=
|=
功能为：
运算
赋值
例子：a += b 等于 a = a +ba *= b 等于 a = a*b
赋值运算符的运算优先等级与赋值运算符= 相等
逻辑运算和逻辑表达式
逻辑运算符
逻辑与
操作符两边都为真则真，否则为假
|| 逻辑或
操作符只要一边为真则真
! 逻辑非
对操作数取反
逻辑表达式
实例代码请查看备注
写一段逻辑表达式来判断某年为闰年： 判断条件，当该年可被4整除且不能被100整除，或者能被400整除 表达式为： year / 4 ==0 && year /100 != 0 || year / 400 == 0 ;
逻辑运算符的优化
有时候逻辑运算并不需要执行所有的逻辑运算步骤，就能确定逻辑运算的结果，只有在必须执行下一个逻辑运算才能获得结果的时候才执行该逻辑运算符
详细运算思路请查看备注
代码： int x = 4 , y = 6 ; bool b1 ; b1 = (x > 10 ) && (++y > 10); Console.WriteLine(" x={0} , y={1} , b1={3}",x,y,b1); Console.ReadLine(); 逻辑运算过程： 当逻辑运算到x > 10 被判断为false，计算机就会停止右边的逻辑判断，因此右边 ++y 不会被计算执行，因此在最后输出的时候，结果为： x = 4，y = 6，b1 = false
位运算符：全部都在二进制下进行
按位于运算：操作数1 操作数2
0 0 = 0
0 1 = 0
1 0 =0
1 1 = 1
按位于运算：操作数1 | 操作数2
0 | 0 =0
1 | 0 = 1
0 | 1 = 1
1 | 1 = 1
异或运算符：操作数1 ^ 操作数2
1 ^ 0 = 1
0 ^ 1 =1
0 ^ 0 = 0
1 ^ 1 = 1
取补运算符：0取反后为1，1取反后为0
~00001000 —————— 11110111 取反结果为： 11110111
左移运算符：操作数1 << 操作数2
4<<1 将4转换为二进制为：00000100 左移1 左移结果为：00001000
右移运算符：操作数1 >操作数2
4>>1 将4转换为二进制为：00000100 右移1 左移结果为：00000010
其他运算符
条件运算符：?：
属于三元运算符
表达式1 ? 表达式2 : 表达式3
运算规则
先计算表达式1，如果表达式1的值为真，则计算表达式2的值，并将表达式2的值作为整个表达式的值返回，如果表达式1的值为假，则计算表达式3的值，并将表达式3的值作为表达式的值返回 例子：如求x的绝对值 x = x >= 0 ? x : -x;
typeof 运算符
typeof运算符用于返回System.Type对象并获取系统原型对象的类型
例子
实例代码： Console.WriteLine(" {0} , {1} , {2} ", typeof(int) , typeof(float) , typeof(long)); 输出结果： System.Int32 ,System.Int32 ,System.Single
sizeof 运算符
sizeof运算符用于读取类型并返回类型在内存中所占的字节数，就是显示数据类型所占的内存字节数
new 运算符
new运算符用来创建对象和调用构造函数
Form2 frm = new Form2(); 依据From2创建了一个名为frm的对象
运算符的优先等级和结合性
运算符的优先等级
①括号。学数学的时候我们就知道，要先计算括号里面的内容。C#语言也是一样，如果有多层括号，要从里向外计算。括号优先级最高。 ②一元运算符。有些运算符两边有2个操作数，比如2+3、6%5等等，这些叫做二元运算符。只有一个操作数的叫做一元运算符，它们的优先级高于二元运算符。一元运算符包括：++(自加) 、 --（自减） 、 !（逻辑非）。 ③*（乘）、/（除）、%（取余）。 ④+（加）、-（减）。 ⑤>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。 ⑥==（等于）、!=（不等于）。 ⑦&&（逻辑与）。 ⑧||（逻辑或）。 ⑨赋值运算符。包括：=、+=、-=、*=、/=、%=。 另外，还需要注意一点：优先级相同的运算符从左向右计算（赋值运算符相反）。
结合性：当操作数两侧的运算符优先等级相同时
自左向右的结合方向为左结合
自右向左的结合方向为右结合
2.5、引用类型
字符串
定义、赋值及定义初始化赋值的格式
字符串的定义： string s1 , s2 ; 字符串的定义并初始化赋值： string s1= “ 你好啊！ ”； string s1； s1 = “ 你好啊！ ”；
字符串连接运算符： +
实例
字符串连接符： + 可以连接字符串和字符类型 string s1 = “你好，” + “ 世界。”； 输出结果：你好，世界
关系运算符： == !=
实例
== 和 != 可以用于判断字符串是否相等 string s1 = “小明” ，s2 = “小张”； bool s1 == s2； 输出为：flase
Tostring()方法
可将其他类型转换成字符串类型
格式： 变量名.Tostring() 实例： int x = 123； string s1 = Tostring(x);
string类与StringBuilder类
string方法特点
string类作为变量时，如果进行重新赋值，则会重新分配新的内存空间，如果在频繁修改string的值时，则会消耗大量的系统内存
string类的常用方法
字符串检索方法：IndexOf()
IndexOf方法用于检索字符串中的特定字符或者字符串首次出现的位置 IndexOf( char value) //用于定位字符的位置 IndexOf( string value) //用于定位字符串的位置 string s1= “the world ed！”； m = IndexOF('W'); //m 等于4 d = IndexOf("orl")； //d 等于4 f = IndexOf('e',3,10) //从3到10开始，找到e的位置为9 1、字符串从第一个字符开始初始为0 2、如果字符串中不包含该字符或者字符，则返回-1
字符串截取方法：
SubString()
字符串截取方法可以获取字符串中的子串 SubString( int starIndex) starIndex从指定的位置开始截取，直到字符串末尾 SubString(int starIndex , int length ) starIndex 开始截取length长度的字符串 string s1 = “C# string”； d1 = s1.Substring(3); //截取结果为：string d2 = s1.Substring(0,2) //截取结果为：C#
字符串删除方法：
Remove()
Remove()方法可以删除字符串的一部分，并保留其他部分 Remove(int starIndex) 删除字符串中从starIndex开始直到最后的所有字符串 Remove(int starIndex , int length) 删除字符串中的starIndex开始的长度我为length的字符串 string s1, s2; string s = "the world hello"; s1 = s.Remove(3); //删除从1到3的字符串 s2 = s.Remove(3, 7); //删除3前面的和加上从3之后从1开始数，直至到位于第七位开始后面的所有字符串
插入字符串方法：
Insert()
在原字符串的任意指定位置插入字符串，使得插入的字符串加上原来的字符串组合成一个新的字符串 实例： string s = "the world", s1; s1 = s.Insert(3, " nihao"); Console.WriteLine(s1); Console.ReadLine(); 输出结果：the nihao world
替换字符串方法;
Replace()
Replace方法能够将字符串的字符或者字符串换成其他的字符或者字符串 string s = "the hello A World", s1, s2,s3; s2 = s.Replace('A', 'a'); s1 = s2.Replace("W", "w"); s3 = s2.Replace('t','T'); Console.WriteLine(s1, s2); Console.WriteLine("{0},{1}",s1,s3); Console.ReadLine(); 此处得注意一下输出的问题： Console.WriteLine(s1, s2);与Console.WriteLine("{0},{1}",s1,s3);;输出效果是不一样的，前者会刷新显示，而后者则是输出两句
转换大小写方法：
ToLower()和ToUpper()
ToLower()方法可以将字符串中的所有字母转换成大写 ToUpper()方法可以将字符串中的所有字母转换成小写 string s = "the world"; Console.WriteLine("{0},{1}",s.ToLower(),s.ToUpper()); Console.ReadLine(); 输出效果：the world,THE WORLD
将字符串转换为字符数组：
ToCharArray()
string s1 = "the"; char [] arrch = s1.ToCharArray(s1); //分解字符串s1 将会形成数组，数组arrch中有元素t，h，e
返回字符串的字符个数：
Length
string s = "the world"; int len = s.Length; Console.WriteLine("该字符串的字符个数为：" + len); Console.ReadLine(); 输出结果为：该字符串的字符个数为：9
StringBuilder方法特点
StringBuilder类则不会出现string类的情况，其可以创建可变字符串对象而不用重新消耗内存空间，用于字符串的动态修改
声明StringBuilder对象
声明一个StringBuilder对象需要用StringBuilder够着函数： StringBuilder strb1 = new StringBuilder();
追加操作
Append()
实现追加功能： strb1.Append("你好");
插入操作
Insert()
插入操作： strb1.Insert(0,"hello"); 在最前面位置插入hello
删除操作
Remove()
删除操作： strb1.Remove(0,5); Console.WriteLine(strb1); ConsoleReadLine();
类
解释：类是面向对象程序设计语言编程的基本单位，包含数据成员、数据方法、方法成员、嵌套类的数据结构，类支持继承机制，通过继承派生类可以扩含基类的数据成员和方法成员，达到代码重用的目的
关键字class
实例
public class Student { public int sno; public string sname; public int score; public void Output() { sno = 56; sname = "小明"; score = 89; Console.WriteLine("{0},{1},{2}", sno, sname, score); Console.ReadLine(); } } Student 为类的名字 sno、sname、score为类的成员 Output为类Studnt的方法
接口
解释：接口是一种特殊的数据结构，C#中的类只支持单继承，但接口可以实现多继承的功能，接口中只能声明抽象对象，没有具体的实现代码，接口有点类似于设备说明书，只能够说明该设备的功能和属性，但这些功能和属性并不能在说明书上实现，而必须在类和结构中实现，其中类和结构就相当于设备本身。实现接口的类或者结构要与接口的定义严格一致。接口声明并不包括数据成员，只能包含方法、属性、事件、索引等成员。
定义实例
修饰符 interface 接口名称:继承的接口列表 { 接口内容; }
委托
委托类似于C语言的函数指针，委托可以看作特殊的类，所以委托可以像普通的类放在同样的位置，委托必须先定义后使用，类的实例叫对象，委托的实例叫委托实例。
委托定义
delegate 返回值类型 委托名称（方法参数列表） public class Ji_suan //创建一个计算类 { public int a, b; //a和b必须在这里定义，是因为在下面的 public string sub() { int c; string str; c = a + b; str = a.ToString() + "+" + b.ToString() + "=" + c.ToString(); return str; } } delegate String mydelegate(); //委托声明 static void Main(string[] args) { //委托实例的调用 Ji_suan m = new Ji_suan(); //声明一个计算类的对象m m.a = 10; m.b = 5; mydelegate d1 = new mydelegate(m.sub); Console.WriteLine(d1()); //这里的 d1() Console.ReadLine(); }
数组
解释：数组是一系列相同类型的数据集合，数组中的数据成为数组的元素，数组中的每个元素都是相同的数据类型，所有的元素共用一个数组名字，数组中的元素坐标是从0开始计数的，具有n个元素的数组其下标范围：0~n-1
数组的声明
数组类型 [] 数组名 = new 数组类型[数组长度]; int arr1 = new int[10]; 声明一个数组arr1，其中包含10个元素，元素下标为0~9
数组类型：可以是C#中的任意定义类型
数组名：遵循标识符的命名规则
数组长度：数组中的元素个数，只能是整型常量表达式
数组类型后面的方括号是不能省略的
多维数组的声明
二维维数组：long [,] arr2 = new long[3,4];
三维数组：double [,,] arr3 = new double[3,3,3];
数组类型后面括号里面的逗号个数应该与数组的维度数相对应，是必须要保持一致的
数组的初始化
数组类型 [] 数组名 = new 数组类型[数组长度] {数组元素初始值列表}; int num_1 = new int[10] {1,2,3,4,5,6,7,8,9,10}; 值得注意的是，其初始的数组中的元素个数必须等于前面括号中的数组长度 int num_1 = new int[] {1,2,3,4,5,6,7,8,9,10}; 不会限制数组中元素个数，可以为任意的元素个数
值得注意的是，其初始的数组中的元素个数必须等于前面括号中的数组长度,否则会出现编译错误
如果不想限制数组中的元素的个数，则就不需要在数组个数的方框内填写数值
访问数组元素
数组名[数组下标] int a; int [] arr1 = new int []{1,2,3,4}; a = arr1[0]; //获取数组arr1中下标为0 的元素赋值给a Console.WriteLine(a); Console.ReadLine();
数组的常用操作
Length属性
获取目标数组的数组长度，即数组中的元素个数
方法
格式： 数组名.Length; int [] arr2 = new int [] {1,2.3,4}; int k = arr2.Length;
Sort方法
Sort方法实现对一堆数组排序，是Array类提供的静态方法
方法
格式： Array.Sort(数组名); int[] arr2 = new int[] {5,55,9,6}; Array.Sort(arr2); //数组排序 Console.WriteLine("{0},{1},{2},{3}", arr2[0], arr2[1], arr2[2], arr2[3]); Console.ReadLine();
Reverse方法
实现反转一堆数组，也是Array类提供的静态方法
方法
格式： Array.Reverse(数组名); int[] arr2 = new int[] {5,55,9,6}; Array.Reverse(arr2); //反转数组 Console.WriteLine("{0},{1},{2},{3}", arr2[0], arr2[1], arr2[2], arr2[3]); Console.ReadLine();
Clear方法
将重新初始化数组中的一系列元素，也就是将数组中的部分元素全部归0
方法
格式： Array.Clear(数组名,起始下标,需要初始化的元素个数); Array.Clear(arr2,0,3); //选择性初始化数组元素 Console.WriteLine("{0},{1},{2},{3}", arr2[0], arr2[1], arr2[2], arr2[3]); Console.ReadLine();
Copy方法
实现将一个数组中的部分（全部）复制到另外一个数组
方法
格式： Array.Copy(源数据元组,目的数组名,复制个数); int [] arr1 = new int []{1,2,3}; int[] arr3 = new int[9]; Array.Copy(arr1,arr3,3); //复制数组元素 Console.WriteLine("{0},{1},{2},{3}", arr3[0], arr3[1], arr3[2], arr3[3]); Console.ReadLine();
集合
集合是一个特殊的类，通过高度结构化的方式存储任意对象。除了基本的数据处理功能外，集合直接提供各种数据结构的实现，如队列、链表、栈等，可以使得程序员节省大量的编程时间，轻易实现复杂的数据类型的操作
动态数组
ArrayList可根据需要，灵活的对数组进行操作：数组的添加、删除、插入元素等，ArrayList是一维数组，且下标的下限始终为0
动态数组的创建
实例
格式： using System.Collections; //需要在一开始就调用Collections才能在程序中使用动态数组 ArrayList 列表对象名 = new ArrayList(); 实例： ArrayList list = new ArrayList();
注意：using System.Collections; 需要在一开始就调用System.Collections才能在后续的程序中使用动态数组
动态数组的常用方法
Add 添加方法，可以将一个元素添加到动态数组的末尾
实例： using System.Collections; //需要在一开始就调用Collections才能在程序中使用动态数组 ArrayList list = new ArrayList(); list.Add("12"); list.Add("32"); Console.WriteLine("{0},{1}", list[0],list[1]); Console.ReadLine();
AddRange 系列添加方法：将一系列的数据添加到动态数组的末尾，且保证原来一系列的数据任然按照原来的顺序存放
实例： int[] arr4 = new int[] { 1,2,3,4}; ArrayList list_1 = new ArrayList(); list_1.AddRange(arr4); Console.WriteLine("{0},{1}", list_1[0], list_1[1]); Console.ReadLine();
Remove 删除方法：可以从动态数组中移除特定的对象的第一个匹配项，第一个匹配项指的是如果在这个数组中的元素值有相同的，则删除遍历到的第一个符合匹配的元素
list.Remove("32"); //动态数组的元素匹配删除 Console.WriteLine("{0}", list[0]); //此处不可以多余输出，否则会提示报错 Console.ReadLine();
RemoveAt删除方法：可以移除动态数组中的指定索引元素
实例： ArrayList list_2 = new ArrayList() {1,9999,2,3,3}; list_2.RemoveAt(0); Console.WriteLine("{0}", list_2[0]); Console.ReadLine();
子主题
实例： ArrayList list_2 = new ArrayList() {1,9999,2,3,3}; //动态数组list_2创建 list_2.RemoveAt(0); //动态数组的指定元素删除 Console.WriteLine("{0}", list_2[0]); Console.ReadLine();
Reverse反转数组元素方法：可以将动态数组的的元素进行整体反转，类似于普通数组的数组反转
Sort排序方法：将动态数组的元素进行排序
Clone方法：复制一个动态数组赋值给另外的一个数组
队列Queue
解释：队列是一种先进先出的数据结构
队列的创建
实例
格式： Queue 队列名 = new Queue([队列长度][,增长因子]); Queue MyQ = new Queue();
队列长度默认为32，增长因子默认为2.0，就是当默认队列容量不足时，队列的长度自动增加为原来的2倍，队列长度和增长因子可以在定义的时候不用指定
建议在定义队列的时候按实际的需求定义队列的长度
队列的操作
Enqueue方法：用于入队操作，入队操作会在队尾尾部添加数据，整个队列数据+1
Queue MyQ = new Queue(); //定义一个名为MyQ的队列 MyQ.Enqueue("小明"); //向队列添加元素 MyQ.Enqueue("小红"); int MyQ_long = MyQ.Count; //统计该队列的长度，并赋值给变量MyQ_long Console.WriteLine("MyQ队列长度为：" + Convert.ToInt32(MyQ_long)); //在输出的时候，需要统一一下数值类型，将int的数值转换成字符串类型 Console.ReadLine();
count方法：获取目标队列的长度
实例： int MyQ_long = MyQ.Count; //统计该队列的长度，并赋值给变量MyQ_long
Dequeue方法：用于出队的操作，就是取出队列头部的数据后，然后删除队列的中的那个元素，整个队列-1
实例： int MyQ_out; Console.WriteLine("从MyQ队列中出队的元素为：" + MyQ.Dequeue()); //name.Dequeue() 出队操作 MyQ_out = MyQ.Count; Console.WriteLine("从MyQ队列中出队元素后，其元素个数为：" + MyQ_out); //出队后的元素个数 Console.ReadLine();
Clear方法：用于清除队列中的所有元素
实例： MyQ.Clear(); int MyQ_clean = MyQ.Count; Console.WriteLine("清除MyQ队列中的所有元素后的元素个数为：" + MyQ_clean); //清除队列中的所有元素 Console.ReadLine();
栈Stack
解释：栈是一种先进后出的数据结构，就是先进入栈的元素是最后出来的，最后进入的元素是先出来的
栈的创建
实例
格式： Stack 栈名 = new Stack(); Stack sk = new Stack(); //定义一个名为sk的栈
栈的操作
Push方法：入栈
实例： Stack sk = new Stack(); //定义一个名为sk的栈 sk.Push("小化"); //向栈压人2个元素，其中小化位于栈顶 sk.Push("小张"); Console.WriteLine("sk栈的栈顶元素为：" + sk.Peek()); //peek方法是返回栈的栈顶元素 Console.WriteLine("sk栈删除的元素为：" + sk.Pop()); //pop方法是删除并返回栈的栈顶元素 sk.Clear(); //清空栈的元素 int sk_clean = sk.Count; //统计清空栈后的栈的元素个素赋值给变量sk_clean Console.WriteLine("清空栈后的元素个数为：" + sk_clean); //输出清空后的结果 Console.ReadLine();
Pop方法：出栈
实例： Stack sk = new Stack(); //定义一个名为sk的栈 sk.Push("小化"); //向栈压人2个元素，其中小化位于栈顶 sk.Push("小张"); Console.WriteLine("sk栈的栈顶元素为：" + sk.Peek()); //peek方法是返回栈的栈顶元素 Console.WriteLine("sk栈删除的元素为：" + sk.Pop()); //pop方法是删除并返回栈的栈顶元素 sk.Clear(); //清空栈的元素 int sk_clean = sk.Count; //统计清空栈后的栈的元素个素赋值给变量sk_clean Console.WriteLine("清空栈后的元素个数为：" + sk_clean); //输出清空后的结果 Console.ReadLine();
Peek方法：返回栈顶数据
实例： Stack sk = new Stack(); //定义一个名为sk的栈 sk.Push("小化"); //向栈压人2个元素，其中小化位于栈顶 sk.Push("小张"); Console.WriteLine("sk栈的栈顶元素为：" + sk.Peek()); //peek方法是返回栈的栈顶元素 Console.WriteLine("sk栈删除的元素为：" + sk.Pop()); //pop方法是删除并返回栈的栈顶元素 sk.Clear(); //清空栈的元素 int sk_clean = sk.Count; //统计清空栈后的栈的元素个素赋值给变量sk_clean Console.WriteLine("清空栈后的元素个数为：" + sk_clean); //输出清空后的结果 Console.ReadLine();
Clear犯法：清空栈的元素
实例： Stack sk = new Stack(); //定义一个名为sk的栈 sk.Push("小化"); //向栈压人2个元素，其中小化位于栈顶 sk.Push("小张"); Console.WriteLine("sk栈的栈顶元素为：" + sk.Peek()); //peek方法是返回栈的栈顶元素 Console.WriteLine("sk栈删除的元素为：" + sk.Pop()); //pop方法是删除并返回栈的栈顶元素 sk.Clear(); //清空栈的元素 int sk_clean = sk.Count; //统计清空栈后的栈的元素个素赋值给变量sk_clean Console.WriteLine("清空栈后的元素个数为：" + sk_clean); //输出清空后的结果 Console.ReadLine();
装箱与拆箱
解释：C#中有值类型的相互转换，其中有隐式转换和显式转化，因为C#的所有数据类型都是通过System.Object继承而来的，因此值类型和引用类型也是可以通过隐式转换和显式转换来互相转换的，其中把值类型转换成对象的操作叫做装箱，将对象类型转换为与之兼容的值类型的过程叫做拆箱
装箱：需要定义一个引用类型的实例后，再将值类型变量赋值给引用类型实例
实例： int xx = 22; object obj = xx; //定义一个引用类型obj，并装箱，将xx的值复制一份放进一块独立的内存中，赋值给引用类型的obj xx += xx; Console.WriteLine("当xx发生自增22后为：" + xx); Console.WriteLine("xx转换成引用类型后的值为：" + obj + " （当前xx已完成自增22）"); Console.ReadLine();
注意：定义一个引用类型后装箱操作：object obj = x；后，其变量x值再次发生改变时，其引用类型装箱后的obj的值，是不会随着x变量的变化而变化的，它只是引用了一个x变量的副本而已
拆箱：将一个引用类型显式地转换成一个值类型
实例： int xxx = 11; object obj_1 = xxx; int xxx_1 = (int)obj_1; //拆箱，将引用类型转换为数值类型
注意事项：
只有被装过箱的对象才能进行拆箱，否则会出现错误
装箱可以隐式转换，但是拆箱必须显式转换
无论是装箱还是拆箱，都十分的耗费系统资源，因此在使用的时候，不要滥用装箱和拆箱
2.6、常用的系统定义类