河北对口计算机高考C#笔记(2026高考适用)---完结版~~~~
C#笔记
C#发展史
- 1998年，C#发布第一个版本。
- 2002年，visual studio开发环境推出
C#的特点
1.语法简洁，不允许直接操作内存，去掉了指针操作
2.彻底面向对象设计。
3.与Web紧密结合。
4.强大的安全机制，语法错误提示，引入垃圾回收器机制。
5.兼容性。
6.完善的错误，异常处理机制。
.NET(平台)
面向网络支持各种用户终端的开发环境
- 公共语言运行时（CLR）： 中间语言代码，负责将不同的编程语言的编译结果统一。
- 类库：系统封装好的工具包，可以直接拿来使用。
.NET发展
- 2000 比尔盖茨提出构想
- 2002 微软发布了.NET Framework1.0
- 2003 微软发布了.NET Framework1.1
- 2005 微软发布了.NET Framework2.0
- 2006 微软发布了.NET Framework3.0
- 2010 微软发布了.NET Framework4.0
- 2020 .Net5.0发布
Visual Studio项目管理
1.解决方案：包含多个不同类型的项目，是一个项目集合，大的文件夹。
.Net中常见的文件类型
.sln:解决方案文件
.csproj:项目文件
.cs:C#源码文件
.resx:资源文件
.aspx:网页文件
.asmx:XML Web文件
.config:配置文件
.suo:解决方案用户选项
命名空间（namespace）:命名控件在C#中起到组成程序的作用，也可以作为外部程序调用的凭证。
类：class为类的关键字，每个对象都属于一个类，类是对象的模板。
关键字：系统提前赋予特定意义的一些单词。
标识符
开发过程中，需要自定义命名的，如变量名，常量名，对象名，方法名，函数名等都属于标识符。
命名规则：由字母、下划线、数字组成，且数字不能开头，不能使用关键字。
Main方法（程序入口）
C#程序中的Main方法必须声明为static,并且区分大小写
static void Main(string[] args){//程序代码} /*static:静态修饰符 void:表示无返回值 string[] args:表示参数为数组*/
注释语句
功能：注释起解释代码的作用，不会参与代码的编译工作
- 行注释：以“//”开头，将一整行代码注释掉
- 块注释：以“/* ”开头，中间包含注释内容，以“ */”结尾
输入方法和输出方法
输入方法：Console.Readline() ------从键盘获取一行字符串
Console.Read() -------从键盘获取一个字符
输出方法：Console.WriteLine() -----将数据输出至屏幕并且加上一个换行符
Console.Write() -----将数据输出至屏幕
注意：
1.同一行代码可以书写多条语句。
int a; int b; int c;2.将一条语句拆分成多行书写。
Console.WriteLine ("你好");
数据类型
值类型
简单类型
整数类型
类型标识符 说明 占用位数 取值范围 sbyte 带符号字节型 8 -27~27-1 byte 无符号字节型 8 0~2^8-1 short 带符号的短整型 16 -215~215-1 ushort 无符号的短整型 16 0~2^16-1 int 带符号的整型 32 -231~231-1 uint 无符号整型 32 0~2^32-1 long 带符号的长整型 64 -263~263-1 ulong 无符号的长整型 64 0~2^64-1 实数类型
类型标识符 说明 占用位数 精度 float 单精度浮点数 32 6~7位 double 双精度浮点数（取值范围最大） 64 15~16位 decimal 固定精度浮点数（精度最高） 128 28~29位 注意：
1.包含小数点的数值会被默认位double类型。
2.在数值后边加F或f可以强制指定为float类型。
3.在数值后边加M或m可以强制指定为decimal类型。
Double double1 = 3.14; float float1 = 3.14f; decimal decimal1 = 3.1415926m;字符类型
采用Unicode编码格式，每个字符占用两个字节。
定义字符类型使用char关键字，值使用单引号（‘’）括起来。
char chr1 = 'a'; char chr2 = '你';注意：
1.如果使用双引号，即使包含一个字符也会认定为字符串类型，字符类型是基本数据类型，字符串类型为用引用类型。
布尔类型
Boolean flag1 = true; Boolean flag2 = false;注意：
布尔类型不能直接转换为int类型。
复杂类型
结构类型
将分散简单变量整合为一体，体现数据之间的内在联系。
//定义语法 struct 结构名称 {数据类型 字段名1;数据类型 字段名2;...}//定义一个具有姓名和年龄的结构类型Student struct Student {public string name;public int age;public char sex; }枚举类型
指程序中某个变量具有一组确定的值，通过枚举可以将其值一一列出来。
//定义枚举 enum 枚举名{枚举成员1,枚举成员2,... }enum season {spring,summer,autumn,winter }
引用类型
object类型
object类型是所有类型（值类型和引用类型）的基类，C#中所有的类型都是直接或者间接继承object,一个 object类型的变量可以赋任何类型的值。
int x = 100; object obj; obj=x; Object obj2 = "你好"; Console.WriteLine(obj); Console.WriteLine(obj2);string类型
字符串对象，表示一个Unicode字符序列。String和string都能定义字符串变量
String str = "Hello World"; string str2 = "你好"; Console.WriteLine("{0},{1}",str,str2);
值类型与引用类型的区别
值类型：栈
引用类型：堆
类型转换
隐式转换
不需要加以声明就可以进行的转换，原类型取值范围包含在目标类型中，就可以实现隐式转换。
小--------->大
int a = 12345; long b = a;显示转换（强制转换）
//(类型标识符)表达式 float a = 123.45f; Console.WriteLine((int)a); //实数类型转换为整数类型通常辉出现精度丢失问题使用方法进行数据类型转换
1.Parse方法：可以将字符串转换为数值型。
//语法：数值类型名称.Parse(字符串表达式) int a = int.Parse("123456"); Console.WriteLine(a);int pwd = int.Parse(Console.ReadLine()); Console.WriteLine(pwd);2.Convert类的方法：将一种基本数据类型转换为另一种基本数据类型
//语法：Convert.转换方法(值) int a; a = Convert.ToInt32("123"); Console.WriteLine(a);int pwd; pwd = Convert.ToInt32(Console.ReadLine()); Console.WriteLine(pwd);
装箱与拆箱
实现值类型与引用类型的相互转换。
装箱转换（将一个值类型的数据转换为对象类型的数据）
int i = 10; object obj = i;拆箱转换（将一个引用类型的数据转换为值类型数据）
int i = 10; object obj = i; int j = (int)obj;
变量与常量
常量
概念：在程序运行过程中，其值不会改变的量。
分类：
直接常量(一个固定值)
1.整型常量:16,28L 2.浮点常量:3.14，4.25f,8.997m 3.字符常量:'a','0' 4.字符串常量:"abc","HelloWorld" 5.布尔常量:true,false符号常量
//定义语法:常量名全大写 //const 数据类型 常量名 = 常量值 const float PI = 3.14;/*注意： 1.const是定义常量的关键字 2.常量名推荐全部大写 3.常量一旦赋值，不可修改 4.常量的赋值只能适用常量和常数，不能使用变量 */变量
概念：在程序运行过程中其值可以不断改变的量。
变量名：
- 只能使用数字、字母、下划线组成，且数字不能开头
- 不能使用关键字
- 严格区分大小写
- 如果使用关键字作为变量名，开头需加@
变量的定义
//语法： //数据类型 变量名[ = 值]; //可以再定义变量时直接赋值，也可以后期赋值。 int a = 13; int b; b = 3+5;变量的作用域（定义变量的适用范围）
- 成员变量：在类体中定义的变量称为成员变量,在整个类体中都能用。
- 局部变量：在类的方法中定义的变量,只能在方法内部使用。
运算符与表达式
算数运算符
符号 意义 示例 结果 + 加法运算 12+34 46 - 减法运算 88-23 65 * 乘法运算 3*2 6 / 除法运算
(运算符左右都为整型，做整除运算)10/3.0 3.33333 % 取余 10%3 1 自增与自减运算符
自增运算(++)使操作数的值加1
自减运算(–)使操作数的值减1
int i = 1; i++; Console.Writeline(i); //i=2 i-- Console.Writeline(i); //i=1位置规则：
前置形式：先进行自增或自减再进行运算
后置形式：先进行运算再进行自增或自减
int a = 5, b, c;b = a++;Console.WriteLine(a); //a=6 b=5c = ++a; //c=7Console.WriteLine(a); //a=7Console.WriteLine(b); //b=5Console.WriteLine(c); //c=7字符串运算符
+：拼接字符串，合并成新字符串。
String a = "123";int b = 465;Console.WriteLine(a + b); //123456赋值运算符
/*变量名 = 值/表达式 =:赋值运算符，将等号右边的值赋值给等号左边的变量或者常量*/string a; a = "Hello World"; int i; i = (int)12.3;**赋值复合运算符**| 符号 | 意义 | 示例 | | ------ | ------------ | ----------------------------- | | **+=** | **加赋值** | **a+=b 等同于 a=a+b** | | **-=** | **减赋值** | **a-=b 等同于 a=a-b** | | ***=** | **乘赋值** | **a'**='b 等同于 a=a*'*'b** | | **/=** | **除赋值** | **a/=b 等同于 a=a/b** | | **%=** | **取模赋值** | **a%=b 等同于 a=a%b** | | <<= | 左移赋值 | a<<=b 等同于 a=a<<b | | >>= | 右移赋值 | a>>=b 等同于 a=a>>b | | &= | 与赋值 | a&=b 等同于 a=a&b | | ^= | 异或赋值 | a^=b 等同于 a=a^b | | \|= | 或赋值 | a\|=b 等同于 a=a\|b |关系运算符
概念：比较两个运算数的关系，结果为true和false
符号 意义 < 小于 <= 小于等于 > 大于 >= 大于等于 == 等于 != 不等于 逻辑运算符
符号 意义 示例 ！ 逻辑非（取反） !(2<3)------>false && 逻辑与（同时为真结果为真，否则为假） 3>2 && 5<7 ------->true || 逻辑或（有一个为真最终结果即为真） 8<9 || 9=10 ------->true //闰年的判断：闰年年份可以被4整除并且不能被100整除，或者能被400整除 year%4==0 //能被4整除 year%100!=0 //不能被100整除 year%400==0 //能被400整除 year%4==0 && year%100!=0 || year%400==0条件运算符|三目运算符|三元表达式|行状判断语句
格式：表达式1?表达式2:表达式3
逻辑：表达式结果为真，执行表达式2，为假执行表达式3.
int a,b,c; a = 16; b = 19; a>b?c=a?c=b;运算符优先级
运算符类别 运算符 优先级 单目运算 ++、–、! 1 算数运算符 *、/、% 2 +、- 3 关系运算符 >、>=、<、<= 4 ==、!= 5 逻辑运算符 && 6 || 7 条件运算符 ?： 8 赋值运算 = 9
控制结构
顺序结构
输入语句：
Console.Read(); //返回用户从控制台上输入数据的首字符的ASCII码 Console.ReadLine(); //将用户输入的一行信息用string类型的字符串返回输出语句：
Console.WriteLine(); //输出后自动换行 Console.Write(); //输出后不换行分支结构
单分支
/*语法：if(判断表达式){代码块 }*///输入一个年龄，判断是否成年Console.Write("请输入年龄：");int age = int.Parse(Console.ReadLine());if (age >= 18) {Console.WriteLine("成年");}Console.ReadKey();双分支
/*语法： if(判断表达式){代码块1 }else{代码块2 } *///输入一个年龄，判断是否成年 Console.Write("请输入年龄："); int age = int.Parse(Console.ReadLine()); if (age >= 18) {Console.WriteLine("成年"); } else {Console.WriteLine("未成年"); }Console.ReadKey();多分支1
/* if(判断表达式1){代码块1 }else if(判断表达式2){代码块2 }...else{代码块N } */ //输入一个年龄，如果年龄在0~18岁为儿童,19~60成年人，60以上为老人Console.Write("请输入年龄：");int age = int.Parse(Console.ReadLine());if (age >= 0 && age <= 18){Console.WriteLine("儿童");}else if (age > 18 && age <= 60){Console.WriteLine("成人");}else if (age > 60){Console.WriteLine("老人");}else {Console.WriteLine("输入有误");}Console.ReadKey();多分支结构2
/* 语法：switch(表达式){case 常量表达式1:语句1;break;case 常量表达式2:语句2;break;...default:语句n;break; } *///输入学生成绩，判断改成绩处于哪个阶段，100以上为满分，90以上为优，80分以上为良好，60以上为及格，否则为不及格。Console.Write("请输入成绩：");int score = int.Parse(Console.ReadLine());switch (score/10) {case 10:Console.WriteLine("满分");break;case 9:Console.WriteLine("优秀");break;case 8:Console.WriteLine("良好");break;case 7: //case 7中没有break语句，程序不会跳出 结构，直接转入下一个分支case 6:Console.WriteLine("及格"); break;default:Console.WriteLine("不及格");break;}Console.ReadKey(); }总结：
- if判断后的表达式结果为布尔类型，switch判断后的表达式为整型。
- 分支结构只会执行一个分支
- switch…case语句中不加break,程序不会跳出判断结构。、
- 多分支结构中注意判断条件的顺序。
循环结构
for循环
/*语法： for(循环变量初始化;判断语句;循环变量的更新){循环体 } 执行顺序： 1.初始化循环变量 2.判断循环条件是否满足 3.满足 不满足 4.执行循环体 跳出循环 5.更新循环变量 6.判断循环条件是否满足 .... */ for(int i=0;i<=10;i++){Console.WriteLine(i); }/*注意： 1.for循环中三个表达式都可以省略，分号不可以省略 2.如果在循环结构中省略变量初始化，那么需要将变量初始化放在循环结构前边，否则报错 3.如果在循环结构中省略判断条件，那么会陷入死循环，无法自动中止。 4.如果在循环结构中省略变量更新，也会陷入死循环。 5.如果循环结构中的所有表达式都省略，也会陷入死循环。 */ //打印1~100之间所有的奇数//1~100所有数字找到for (int i = 1; i <= 100; i++){//判断当前的数字是否为奇数？if (i % 2 == 0){Console.WriteLine(i);}}//计算10的阶乘 1*2*3*4*5*6*7*8*9*10 //计算1~100之间所有的奇数之和？ 1+3+5+7+9...while循环
/*语法： while(循环条件){循环体 } 执行逻辑：循环条件为真执行循环体，循环条件为假不执行循环体（先判断后执行） */ //使用while实现登录系统，重新输入账户密码操作//登陆系统string user="root";string pwd="123456";string user2, pwd2;Boolean flag = true; //true:输入有无 false：输入正确while (flag) {Console.Write("账号：");user2 = Console.ReadLine();Console.Write("密码：");pwd2 = Console.ReadLine();if (user2 == user && pwd2 == pwd){flag = false;Console.WriteLine("登陆成功");}else{Console.WriteLine("账户或密码输入有误~");}}Console.ReadKey();do…while循环
/* 语法： do{循环体 }while(判断条件); 执行逻辑：先执行一次循环体，然后在判断循环条件，为真继续执行，为假不执行。（先执行后判断） */ //登陆系统改造do..while结构 //登陆系统 string user = "root"; string pwd = "123456"; string user2, pwd2; Boolean flag = true; //true:输入有无 false：输入正确do {Console.Write("账号：");user2 = Console.ReadLine();Console.Write("密码：");pwd2 = Console.ReadLine();if (user2 == user && pwd2 == pwd){flag = false;Console.WriteLine("登陆成功");}else{Console.WriteLine("账户或密码输入有误~");}} while (flag); Console.ReadKey();不同循环结构的特点：
- for循环适用于固定次数的循环
- while和do…while循环适用于非固定次数循环
- do…while循环至少会执行一次循环体，其他循环结构最少执行0次!
跳转语句
break:当循环体执行过程中遇到break语句，无论循环是否执行完毕都会立即结束循环。
//循环打印1~100的整数，当输出7个奇数时结束循环。//计数器int count = 0;for (int i= 1; i <= 100; i++){//判断是否为奇数if (i%2!=0) {count++;Console.WriteLine(i);//判断奇数的个数是否够7个if (count == 7) {break;}}}Console.WriteLine("结束循环");Console.ReadKey();continue:当循环体执行过程中遇到continue时，会立刻结束本次循环，直接进入下一次循环。
//输出打印1~100的所有整数，能被7整除的整数不打印。for (int i = 1; i <= 100; i++) {if (i % 7 == 0) {continue;}Console.WriteLine(i);}Console.WriteLine("结束循环");Console.ReadKey();经典例题
//1. 控制台输入一个数值，判断其是否为回文数（正反都相同的数字）//判断的数值int num = int.Parse(Console.ReadLine());int num2 = 0;//倒叙后的数值int num3 = num; //原数字的备份，后期左比较使用if (num < 0){Console.WriteLine("不是回文数");}else {//将数值倒序，然后与原数字进行比较while (num>0) { //123num2=num2 * 10 + num % 10; //3 32 321num /= 10; //12 1}if (num2 == num3){Console.WriteLine("是回文数");}else {Console.WriteLine("不是回文数");}}Console.ReadKey();//2.求100~999之间的所有的水仙花数 //水仙花数：各个位置上的数字的三次方相加，和等于原数字。for (int i = 100; i <= 999; i++) { //789//拆分数字int gewei = i % 10;int shiwei = i / 10 % 10;//int shiwei = i % 100 / 10;int baiwei = i / 100;//Console.WriteLine("{0},{1},{2}",baiwei,shiwei,gewei);if ((baiwei*baiwei*baiwei)+(shiwei*shiwei*shiwei)+(gewei*gewei*gewei)==i) {Console.WriteLine("{0}是水仙花数",i);}}Console.ReadKey();//3.输入一个整数，判断是否为素数 //素数：只能被1和本身整除的数字//方法1：暴力破解法int num = int.Parse(Console.ReadLine());Boolean flag = false; //true:素数 false:非素数for (int i=2;i<num;i++) { if (num % i == 0){flag = false;break;}else {flag = true;}}if (flag){Console.WriteLine("素数");}else {Console.WriteLine("非素数");}Console.ReadKey();//方法2：平方法优化法int num = int.Parse(Console.ReadLine());Boolean flag = false; //true:素数 false:非素数for (int i = 2; i <= Math.Sqrt(num); i++) {if (num % i == 0){flag = false;break;}else {flag = true;}} if (flag) {Console.WriteLine("素数"); } else {Console.WriteLine("非素数"); } Console.ReadKey();循环嵌套
说明：循环体中包含另一个完整的循环结构。
特点：外层循环执行一次，内层循环执行一遍。
/*打印输出******/for (int i = 1; i <= 5; i++){Console.Write("*");}/*打印输出*****/for (int i = 1; i <= 5; i++){Console.WriteLine("*");}/*打印输出**************************///执行一次//外层控制行数，内层控制列数for (int i = 1; i <= 5; i++){//for (int j = 1; j <= 5; j++){Console.Write("*");}Console.WriteLine();}/*打印输出****************/for (int i = 1; i <= 5; i++){for (int j = 1; j <= i; j++){Console.Write("*");}Console.WriteLine();}//九九乘法表--for循环实现for (int i = 1; i <= 9; i++){for (int j = 1; j <= i; j++){Console.Write("{0}*{1}={2} ", j, i, j * i);}Console.WriteLine();}//使用do...while实现九九乘法表int i = 1;do{int j = 1;do{Console.Write("{0}*{1}={2} ", j, i, j * i);j++;} while (j <= i);Console.WriteLine();i++;} while (i <= 9);//while实现九九乘法表 int i = 1; while (i <= 9) {int j = 1;while (j <= i){Console.Write("{0}*{1}={2} ", j, i, j * i);j++;}Console.WriteLine();i++; }/*打印实现****************/for (int i = 5; i >= 1; i--){for (int j = 1; j <= i; j++){Console.Write("*");}Console.WriteLine();}/****************行数 列数 空格数1 1 42 2 33 3 24 4 15 5 0*/for (int i = 1; i <= 5; i++){//打印空格for (int j = 1; j <= 5 - i; j++){Console.Write(" ");}//打印*for (int z = 1; z <= i; z++){Console.Write("*");}Console.WriteLine();}/**************************行数 列数(当前行数*2-1) 空格数(总行数-当前行数)1 1 42 3 33 5 24 7 15 9 0*/int count = int.Parse(Console.ReadLine());for (int i = 1; i <= count; i++){for (int j = 1; j <= count - i; j++){Console.Write(" ");}for (int z = 1; z <= i * 2 - 1; z++){Console.Write("*");}Console.WriteLine();}/***************************/for (int i = 5; i >= 1; i--){for (int j = 1; j <= 5 - i; j++){Console.Write(" ");}for (int z = 1; z <= i * 2 - 1; z++){Console.Write("*");}Console.WriteLine();}/****************************************************/for (int i = 1; i <= 5; i++){for (int j = 1; j <= 5 - i; j++){Console.Write(" ");}for (int z = 1; z <= i * 2 - 1; z++){Console.Write("*");}Console.WriteLine();}Console.WriteLine();for (int i = 5; i >= 1; i--){for (int j = 1; j <= 5 - i; j++){Console.Write(" ");}for (int z = 1; z <= i * 2 - 1; z++){Console.Write("*");}Console.WriteLine();}
窗体应用
开发步骤
- 创建项目
- 界面设计
- 属性设置
- 编写代码
- 运行调试
- 保存发布
-
创建项目
- Windows窗体应用（C#）
-
添加控件
- 从工具箱中选择要添加的控件
- 双击控件，在默认位置添加对应的控件。
-
设置属性
1.窗体设置
2.代码设置
-
代码编辑
- 双击控件可以切换至对应的控件事件中。(默认事件)
- 使用属性床空中事件标志（⚡），双击需要编写代码的事件名。
-
运行程序
- 调试菜单-----------启动调试
- 快捷键F5
- 点击
-
保存文件
1.文件-------全部保存
2.点击
窗体的结构
标题栏：显示该窗体的标题，标题的内容由窗体的Text属性指定
控制按钮：提供窗体最大化、最小化、关闭的按钮
边界：用于限制窗体的大小和边界样式
窗口区：窗体的主要部分，可以放置其他对象
![image-20241127152632959]()
窗体的属性
| 属性 | 说明 |
|---|---|
| name | 窗体名称，方便后期多窗口应用中调用指定窗口 |
| location | 获取或者设置窗体左上角在桌面上的坐标，包含两个参数，为坐标值X,Y,默认单位为像素 |
| size | 获取或设置窗体的大小，包含两个参数，分别为height和width,表示高度和宽度 |
| startposition | 获取或者设置执行时窗体的起始位置； 1.Manual：窗体的位置由location决定 2.centerScreen：窗体居中显示 3.windowsdefaultlocation:窗体定位在Windows的默认位置。 4.windowsdefaultbounds:窗体定位在Windows的默认位置，边界由windows决定 5.CenterParent:窗体在其父窗体中 |
| windowState | 获取或者设置窗体的窗口状态 Normal:默认大小的窗口（默认值） minimized:最小化窗口 maximized：最大化窗口 |
| dock | 获取或设置子窗体在父窗体中停靠的位置和方式 none:未停靠，默认值 top:上边缘停靠在其父级窗体顶端 bottom:下边缘停靠在父级窗体底端 left:左边缘停靠在父级窗体的左边 right:右边缘停靠 在父级窗体的右边 fill:各个边缘停靠在父级窗体的各个边缘 |
| ControlBox | 设置窗体标题栏中是否显示控制按钮 |
| HelpButton | 是否设置帮助按钮 |
| icon | 设置窗体标题栏中的图标 |
| MaximizeBox | 是否显示最大化按钮 |
| MinimizeBox | 是否显示最小化按钮 |
| ShowIcon | 设置是否在窗体的 标题栏中显示图标 |
| BackColor | 设置窗体的背景颜色 |
| Font | 设置窗体中显示文字的字体相关属性 name:字体名称 size:字体大小 Unit:度量单位 bold:是否设置为粗体 Italic:是否设置为斜体 strikeout:是否有删除线 Underline:是否由下划线 |
| ForeColor | 设置窗体的前景色 |
| FormBorderStyle | 设置窗体边框样式 None:无边框 FixedSingle:固定单行边框 Fixed3D：固定的三维边框 FixedDialog:固定的对话框样式的粗边框 sizable:可调整大小的边框（默认） FixedToolWindow:不可调整大小的工具窗口边框 sizableToolWindow:可调整大小的工具窗口边框 |
| text | 设置窗体的标题内容 |
| enabled | 设置窗体可用性 |
| visible | 设置窗体可见性 |
窗体方法(具备的功能)
- Activate
- 功能：将窗口置于前台并激活它。
- 语法：窗体名.activate()
- show
- 功能：显示窗体
- hide
- 功能：隐藏窗体
- close
- 功能：关闭窗口
- refresh
- 功能：刷新窗口
窗体的事件(触发的条件)
- Click事件：鼠标单击事件
- DoubleClick事件：鼠标双击事件
- FormClosing事件：窗体关闭事件
- KeyDown、KeyPress、KeyUp事件
- load:窗体加载事件
- MouseClick(鼠标单击)、MouseDoubleClick(鼠标双击)、MouseDown(鼠标按下)、MouseMove(鼠标移动)、MouseUp(鼠标释放)。
- Resize事件:窗体尺寸发生改变时触发。
多窗口调用
-
添加窗体
解决方案-------添加---------新建项--------窗体
-
设置启动窗口
打开program.cs
-
调用窗体
窗体名.Show()
窗体名.ShowDialog() 以模式对话框方式显示该窗体，新窗体仙逝后，必须操作完毕并关闭子 窗体后才可以操作主窗体
Form frm2=new Form2() frm2.show()
常用控件
控件的基本操作
- 添加控件
- 绘制控件：尺寸位置自定义
- 拖拽或双击控件：尺寸固定，位置随鼠标焦点而定
- 编程方式：通过new关键字实例化控件并添加到窗体中
- 控件布局调整：选择一个主导控件，其后所有控件根据主导控件的位置进行调整。
- 左对齐
- 居中对齐
- 右对齐
- 顶端对齐
- 中间对齐
- 底部对齐
- 删除控件：选择要删除的控件，按下delete键
- 控件锁定：完成窗体设计后，为了避免误操作改变控件的位置设置。将控件的Locked属性设置为true即可锁定该控件。
控件的公共属性
| 属性 | 功能 |
|---|---|
| name | 指定控件名称 |
| text | 设置控件显示的文本信息 |
| size | 设置控件的尺寸 |
| height | 设置控件的高度 |
| width | 设置控件的宽度 |
| location | 获取或者设置一个控件相对于它所在的容器控件左上角的坐标 |
| top | 获取或者设置控件相对于容器上边界的距离 |
| left | 获取或者设置控件相对于容器左边界的距离 |
| font | 设置字体 |
| backcolor | 设置控件的背景颜色 |
| forecolor | 设置控件显示文字或图形的颜色 |
| visible | 设置控件可见性 |
| enabled | 设置控件是否可用 |
| backgroundimage | 设置控件背景图片 |
| dock | 获取或设置控件停靠的位置和方式。指示控件的哪边停靠父容器，并确定控件如何随父容器一起调整大小。 1.None:控件未停靠，默认值 2.top 3.bottom 4.left 5.right 6.fill |
| tableindex | 获取或设置控件在容器中的tab键顺序 |
| tabstop | 获取或者设置一个值，指示用户能否通过tab键切换至该控件 |
控件的常用事件
| 事件 | 触发条件 |
|---|---|
| Click | 鼠标单击控件时触发 |
| DoubleClick | 鼠标双击时触发 |
| KeyDown | 当控件获得焦点时，摁下键盘时触发 |
| KeyUp | 当控件获得焦点时，释放一个按键时触发 |
| KeyPress | 当控件获得焦点时，按下一个键时触发 |
| MouseDown | 当鼠标指针在控件上，按下鼠标键时触发 |
| MouseUp | 当鼠标指针在控件上，释放鼠标键时触发 |
| MouseMove | 鼠标滑过控件时引发。 |
控件
标签（Label）
作用：用于在窗体中显示文本信息，label控件中的文本是只读文本，用户不能编辑。
属性：
属性 说明 text 设置标签内容 font 设置文本格式 autosize 设置标签是否根据文本大小调整尺寸。 textAlign 设置文本对齐方式，默认为Top,Left（使用前需将autosize属性关闭） borderStyle 设置边框样式（参考窗体边框样式）。 image 设置在标签上的图像 anchor 定位控件与其父窗口间的相对位置，并随父窗口的变化而变化，默认值为topleft canfocus 设置控件是否可以接受焦点
文本框标签（TextBox）
作用：用于获取用户输入的数据或显示文本，可以编辑其中的文本，也可以设置为只读控件，文本框可以多行显示，也可以用于设置密码。
属性 说明 text 获取或者设置文本框显示内容 textlength 获取或者设置文本框中文本的长度 maxlength 获取或设置可在文本框中手动输入的最大字符数 multiline 设置文本框是否支持多行输入 passwordchar 用来指定文本框中显示的字符，加密作用 UseSystemPasswordChar 设置文本框中文本是否以系统黑点显示 SelectedText 表示文本框中被选中的文本内容 ReadOnly 设置文本框为只读 事件：TextChanged,文本内容发生变化时触发该事件。
练习：将文本框中的内容实时更新至标签中
![image-20241209153752586]()
private void textBox1_TextChanged(object sender, EventArgs e){label4.Text = textBox1.Text;}
按钮控件（button）
属性 说明 text 设置按钮显示的文本。可以使用“&”符号为按钮绑定指定快捷键。 Enabled 设置按钮是否可用 image 获取或者设置显示在按钮控件上的图像 事件：
- Click：单击事件（默认事件）
- DoubleClick:双击事件
练习：制作登录界面
![image-20241211151017168]()
String user; String pwd; private void button2_Click_1(object sender, EventArgs e){//注册逻辑//点击注册按钮，将用户名和密码保存至系统，方便后期登录user = textBox1.Text;pwd = textBox2.Text;label4.Text = "注册成功！";textBox1.Text = "";textBox2.Text = "";}private void button1_Click_3(object sender, EventArgs e){//登录逻辑//输入的账户密码与注册时一致，登录成功，否则提示重新输入String user2 = textBox1.Text;String pwd2 = textBox2.Text;if (user == user2 && pwd == pwd2){label4.Text = "登录成功！";Form frm2 = new Form();frm2.Show();}else {label4.Text = "账号或密码输入有误，请重新输入";textBox1.Text = "";textBox2.Text = "";}}
选择类控件及分组
分组框控件(groupbox)
功能：用来针对窗体上的控件进行分组的，并为同一组控件添加边框和标题。是一个容器控件。
属性：
属性 说明 text 分组的名称 visible 设置分组可见性 单选按钮控件
功能：为用户提供两个或多个互斥选项组成的选项集。
属性：
属性 说明 text 设置按钮显示的文本 Checked 获取或者设置按钮的选中状态 事件：Click、CheckedChanged
复选框
功能：复选框为用户提供了两个或多个互不排斥的选项组成的选项集。
属性 说明 text 控件的显示文本 checked 获取或者设置是否选中该控件，默认值false checkstate 获取或设置CheckBox的状态，其值为：
Checked--------选中
Unchecked-------未选中
Indeterminate-------不确定练习：
private void Form1_Load(object sender, EventArgs e){label1.Visible = false;}private void radioButton1_CheckedChanged(object sender, EventArgs e){label2.Text = "错误，正确答案是C";label2.ForeColor = Color.Red;label2.Visible = true;}private void radioButton3_CheckedChanged(object sender, EventArgs e){label2.Text = "错误，正确答案是C";label2.ForeColor = Color.Red;label2.Visible = true;}private void radioButton2_CheckedChanged(object sender, EventArgs e){label2.Text = "正确";label2.ForeColor = Color.Blue;label2.Visible = true;} private void radioButton4_CheckedChanged(object sender, EventArgs e) {label2.Text = "错误，正确答案是C";label2.ForeColor = Color.Red;label2.Visible = true; }
private void Form1_Load(object sender, EventArgs e){label3.Visible = false;}private void checkBox1_CheckedChanged(object sender, EventArgs e){if (checkBox1.Checked && checkBox2.Checked && checkBox4.Checked && !checkBox3.Checked){label3.Text = "正确";label3.ForeColor = Color.Blue;label3.Visible = true;}else{label3.Text = "错误，正确答案是ABD";label3.ForeColor = Color.Red;label3.Visible = true;}}private void checkBox3_CheckedChanged(object sender, EventArgs e){if (checkBox1.Checked && checkBox2.Checked && checkBox4.Checked && !checkBox3.Checked){label3.Text = "正确";label3.ForeColor = Color.Blue;label3.Visible = true;}else{label3.Text = "错误，正确答案是ABD";label3.ForeColor = Color.Red;label3.Visible = true;}}private void checkBox2_CheckedChanged(object sender, EventArgs e) {if (checkBox1.Checked && checkBox2.Checked && checkBox4.Checked && !checkBox3.Checked){label3.Text = "正确";label3.ForeColor = Color.Blue;label3.Visible = true;}else{label3.Text = "错误，正确答案是ABD";label3.ForeColor = Color.Red;label3.Visible = true;} }private void checkBox4_CheckedChanged(object sender, EventArgs e){if (checkBox1.Checked && checkBox2.Checked && checkBox4.Checked&&!checkBox3.Checked){label3.Text = "正确";label3.ForeColor = Color.Blue;label3.Visible = true;}else{label3.Text = "错误，正确答案是ABD";label3.ForeColor = Color.Red;label3.Visible = true;}}
列表类控件
列表框控件(ListBox)
功能：为用户提供选择列表，用户可以选择一个或多个所需选项。
属性 说明 Text 当前选中的第一个选项的文本 Items 获取或着设置列表框控件选项的集合。下标从0开始。Listbox1.item[0]表示列表框中的第一个元素。 SelectedItem 获取或者设置列表框控件中的当前选定项。 SelectedItems 获取一个集合，包含所有当前的选定项。 SeletcedIndex 获取或这只列表框控件中当前选定项的索引 SelectedIndices 获取一个集合，包含所有选中项的索引 SelectionMode 获取或者设置列表框控件的选择模式
1.one:只能选择一个
2.none:表示无法选中
3.MulitSimple:表示可以选择多项
4.MulitExtended：表示可以选择多个列表项，选择方法同Windows系统相同sorted 设置列表框中的项是否按照字母顺序排序。 常用方法：
添加列表项Add()
listbox1.items.add("添加项");添加一组列表项AddRange()
String[] s = new String[]{"张三","李四"} listBox1.Items.AddRange(s)向指定位置插入列表项insert()
listBox1.Items.insert(索引位置,"插入内容") 实例：listBox1.Items.Insert(int.Parse(textBox1.Text)-1,textBox2.Text); //列表框数据索引起始值为0，所以插入位置要减1删除指定的列表项RemoveAt()
listBox1.Items.RemoveAt(索引) 示例1：listBox1.Items.RemoveAt(int.Parse(textBox1.Text)-1); //输入要删除记录的序号示例2：listBox1.Items.RemoveAt(listBox1.SelectedIndex); //鼠标选中要删除的记录删除列表框中的所有列表项Clear()
listBox1.Items.Clear()获取列表框中列表项的个数Count
listBox1.Items.Count()判断指定项是否在列表项集合中Contains()
listBox1.Items.Contains("张三");练习：
![image-20250407112909848]()
//向指定位置添加列表项 private void button1_Click(object sender, EventArgs e){listBox1.Items.Insert(int.Parse(textBox2.Text) - 1, textBox1.Text);} //删除指定列表项private void button2_Click(object sender, EventArgs e){listBox1.Items.RemoveAt(listBox1.SelectedIndex);} //清空列表项private void button3_Click(object sender, EventArgs e){listBox1.Items.Clear();} //统计列表记录数private void button4_Click(object sender, EventArgs e){label3.Text = "共有" + listBox1.Items.Count + "条记录";} //查询列表项是否包含对应的记录private void button5_Click(object sender, EventArgs e){if (listBox1.Items.Contains(textBox1.Text)){label4.Text = "该列表中包含要查询的记录";}else {label4.Text = "该列表中未查询到该记录";label4.ForeColor = Color.Red;}}
组合框ComboBox
功能：将列表框与文本框的功能组合在一起，使用户既可以从列表框中选择数据，也可以输入文本。
属性 说明 Text 当前选中的第一个选项的文本 Items 获取或着设置列表框控件选项的集合。下标从0开始。Listbox1.item[0]表示列表框中的第一个元素。 SelectedItem 获取或者设置列表框控件中的当前选定项。 SelectedItems 获取一个集合，包含所有当前的选定项。 SeletcedIndex 获取或这只列表框控件中当前选定项的索引 SelectedIndices 获取一个集合，包含所有选中项的索引 SelectedText 获取或者设置当前组合框中选定项的文本 DropDownStyle 组合框的样式
1.simple:简单下拉列表，文本可编辑
2.DropDown：下拉列表框，文本可编辑，必须单击下拉按钮才能显示列表中的内容
3.DropDownList:下拉列表框，文本不可编辑，单击下拉按钮显示列表数据sorted 设置列表框中的项是否按照字母顺序排序。 方法：droppedDown:如果组合框当前被下拉
日期/时间控件(DateTimePicker)
功能：选择日期和时间
属性 说明 MaxDate 获取或设置可选择的最大日期 MinDate 获取或设置可选择的最小日期 Text 获取当前控件选择的日期 Value 获取当前控件选择的日期，时间。
滚动条控件（ScrollBar）
属性 说明 Maximum 表示滚动条的最大值 Minimum 表示滚动条的最小值 Value 表示滚动条当前所在位置的取值 LargeChange 设置滚动条的最大变动值 SmallChange 设置滚动条的最小变动值 事件：Scroll:当滑块的值发生改变时触发该事件。
valueChange:value值发生变化时触发该事件
进度条控件(ProgressBar)
功能：通过水平放置的方框中显示适当的矩形，指示工作的进度，工作完成时进度条被填满。
属性 说明 Maximum 设置进度条的最大值 Minumun 设置进度条的最小值 value 表示操作过程中已完成的进度 step 用于指定value值递增的步长，使用PeoformStep()方法来实现递增
时钟控件/定时器(Timer)
功能：定时自动执行事件，控件不可见。
属性 说明 Interval 毫秒为单位，1000ms=1s Enabled 设置定时器是否可用，默认为false 练习：
![image-20250409145916596]()
//点击按钮启用定时器 private void button1_Click(object sender, EventArgs e){timer1.Enabled = true;}//设置进度条自动递增，递增至最大值关闭定时器 private void timer1_Tick(object sender, EventArgs e) {if (progressBar1.Value < 100){progressBar1.PerformStep();label1.Text = progressBar1.Value + "%";}else {timer1.Enabled = false;}}
选项卡控件(TabControl)
功能：可以将窗体设计成多页，使窗体功能划分为多个部分。
属性 说明 TabPages 获取控件中选项卡的集合，使用这个集合可以添加或删除TabPage对象 Multiline 获取或者设置是否可以显示一行以上的选项卡 SelectedTab 获取或设置当前选定的选项卡
对话框
消息框
功能：向用户显示应用程序一些消息提示，如程序运行结果，报错信息等。
MessageBox.show(string text,[string title,MessageBoxButton.button,MessageBoxIcon.Icon])text:设置消息框中显示的提示信息title:设置消息框标题栏中的文本button:设置消息框中显示的按钮icon:设置消息框中显示的图标
按钮参数 说明 OK 只包含“确定”按钮 OKCancel 包含“确定”和“取消”按钮 AbortRetryIgnore “中止”、“重试”、“忽略” YesNoCancel “是”,“否”,“取消” YesNo ”是”、“否” RetryCancel “重试”、“取消”
图标参数 说明 None Hand Question Exclamation Asterisk Stop Error Warning Information
返回值 说明 None 没点任何按钮 OK 点击确认 Cancel 点击取消 Abort 点击中止 Retry 点击重试 Ignore 点击忽略 Yes 点击是 No 点击否
提示框(ToolTip)
功能：为已存在窗体中的控件提供提示信息
使用：1.为窗体中添加tooltip控件，tooltip控件在窗体中是隐藏的
2.添加tooltip控件之后，所有已存在的其他可见控件都增加一个tooltip属性,该属性用来设置控件的提示词
模式对话框
分类：
- 模式窗体：当该窗体显示时，其他窗体不可用，只有将模式窗体关闭，其他窗体才可使用。
- 非模式窗体：非模式窗体在显示时，如果有多个窗体，用户可以单击任意一个窗体，被单击窗体称为当前窗体。
使用：
模式窗体
Form frm = new Form(); //新建窗体frm.ShowDialog(); //以模式窗体显示frm窗体非模式窗体
Form frm = new Form(); //新建窗体frm.Show(); //以非模式窗体显示frm窗体 通用对话框
通用对话框
功能：.Net平台提供了一套标准的Windows对话框，主要包括打开文件，保存文件，颜色管理器，字体管理器窗口，以上控件都需要是使用ShowDiaLog方法显示对话框。
分类：
打开对话框(OpenFileDialog)
属性 说明 filter 设置文件过滤规则
“jpg图片(* jpg)|*jpg”InitalDirectory 设置默认打开路径 MultiSelete 设置是否可以选择多个文件 openFileDialog1.InitialDirectory = "C:\\Users\\Administrator\\Downloads"; openFileDialog1.ShowDialog();
保存文件对话框(SaveFileDialog)
saveFileDialog1.ShowDialog();
颜色对话框(ColorDialog)
colorDialog1.ShowDialog();
字体对话框
fontDialog1.ShowDialog();
菜单设计
分类：下拉式菜单和弹出式菜单(快捷菜单)
结构：
- 菜单项右边包含…时，单击菜单项可以打开一个子对话框，进行相应的操作。
- 菜单项右侧有黑色三角形▶时，表示该菜单项包含子菜单，最多可以设计六级子菜单。
- 热键：打开菜单的情况下，用户可以直接按下对应的字母来执行命令。
- 快捷键：在任何时候用户按下快捷键都可以执行相应的命令
菜单项ToolStripMenuItem
属性 说明 Checked 获取或者设置选中编辑是否出现在菜单项文本旁边，默认值为false Name 获取或者设置菜单项的名称 Enabled 设置菜单项是否可用，如果为false则菜单项置灰 ShortcutKeys 设置快捷键 ShowShortcutKeys 设置快捷键是否显示在菜单项旁边 text 菜单项显示内容 image 设置菜单项图标 Visible 设置菜单项是否可见 ToolTipText 设置菜单项提示信息
单文档界面(SDI)
一次打开一个窗口，显示一个文档,之前创建的都是单文档界面。
多文档界面(MDI)
属性 说明 IsmidContianer 指定窗体是否为MDI父窗体 IsMdiChild 返回当前窗体师傅为MDI子窗体 MdiParent 给子窗体指定父级窗体的 // 创建子窗体并设置为MDI子窗体Form childForm1 = new Form();childForm1.MdiParent = this; // 设置父窗体为MDIFormchildForm1.Show();Form childForm2 = new Form();childForm2.MdiParent = this; // 设置父窗体为MDIFormchildForm2.Show();
章节练习
1.点击交换按钮实现前后文本内容交换
//交换按钮 private void button1_Click(object sender, EventArgs e){string str = textBox1.Text;textBox1.Text = textBox2.Text;textBox2.Text = str;} //退出按钮private void button2_Click(object sender, EventArgs e){//关闭窗口this.Close();}2.模拟计算器
//成员变量int status; //运算符 //加法按钮private void button1_Click(object sender, EventArgs e){status = 1;} //减法按钮private void button2_Click(object sender, EventArgs e){status = 2;} //乘法按钮private void button3_Click(object sender, EventArgs e){status = 3;} //除法按钮private void button4_Click(object sender, EventArgs e){status = 4;}private void button5_Click(object sender, EventArgs e){//得到计算结果，将结果展示在textbox3//判断运算符switch (status) {case 1:textBox3.Text = int.Parse(textBox1.Text) + int.Parse(textBox2.Text)+"";break;case 2:textBox3.Text = int.Parse(textBox1.Text) - int.Parse(textBox2.Text) + "";break;case 3:textBox3.Text = int.Parse(textBox1.Text) * int.Parse(textBox2.Text) + "";break;case 4://除法运算将数字转换为浮点型，否则会进行整除运算textBox3.Text = float.Parse(textBox1.Text) / float.Parse(textBox2.Text) + "";break;default:textBox3.Text = "请选择运算符";break;}}3.实时显示系统时间
//窗体加载时激活定时器 private void Form9_Load(object sender, EventArgs e){timer1.Enabled = true;} //定时器interval=1000private void timer1_Tick(object sender, EventArgs e){label1.Text=DateTime.Now.ToString("yyyy年MM月dd日 HH:mm:ss");}
数组
概念：把具有相同类型的若干元素按有序的形式组织起来的线性集合。这些有序排列的同类型元素的集合称为数组。
一维数组
概念：一维数组是具有相同数据类型的一组数据的线性集合，在程序中可以通过一维数组来完成一组相同数据类型数据的先行处理。
声明一维数组：
//语法： type[] arrayname //type:数据类型 //arrayname：数组名称 int[] ages;初始化数组：
//1.通过new运算符创建数组 int[] score = new int[5]; //为数组开辟了空间，并未完成赋值操作//2.声明数组时将其初始化 int[] score = new int[4]{78,66,95,82}; //开辟空间的同时完成赋值操作//3.省略new运算符和数组的长度，直接完成赋值 String[] names = {"张三","李四","王五","赵六"};//4.数组元素的单独赋值 names[2] = "王大翠";数据访问：
//选择性读取语法： 数组名[下标]Console.WriteLine(ages[3]);Console.WriteLine(names[0]);Console.WriteLine(score[7]);//遍历性读取for (int i=0;i<names.Length;i++) {Console.WriteLine(names[i]);}Console.ReadKey();特点：
- 数组是相同类型元素的集合
- 数组中各元素的存储是有先后顺序的，存放顺序按照保存的顺序。
- 访问数组元素要使用数组名加下标的方式来访问。
数组的实际应用
//数组中包含10个大小不等的数字,找出最大值。最小值。//键盘获取数组的长度Console.Write("请输入数组的长度：");int len = int.Parse(Console.ReadLine());//声明数组，长度使用自定义int[] a = new int[len];//循环写入数据for (int i = 0; i < a.Length; i++) {Console.Write("请输入第{0}个元素：",i+1);a[i] = int.Parse(Console.ReadLine());}//指定假想最大值int max = a[0];int min = a[0];for (int i=1;i<a.Length;i++) {if (a[i] > max){max = a[i];}if (a[i] < min) {min = a[i];}}Console.WriteLine("最大值为：{0}",max);Console.WriteLine("最小值为：{0}", min);Console.ReadKey();
多维数组
概念：包含两个下标，其数据结构类似于表状。
声明多维数组：
//规则结构二维数组语法（矩形数组） type[,] arraynamestring[,] names = new string[2,3]; //非规则结构二维数组(交错数组) int[,] a = new int[3][] //声明一个二维数组，只指定行数，不指定列数 a[0] = new int[3] //为第一行指定3列 a[1] = new int[1] //为第二行指定1列 a[2] = new int[6] //为第三行指定6列初始化多维数组：
int[,] a = new int[3,2]{{12,24},{85,33},{99,16}}二维数组遍历所有元素
//定义二维数组int[,] a = new int[3, 4] { { 1,2,3,4},{ 5,6,7,8},{ 9,10,11,12} };//外层循环遍历行数for(int i=0;i<a.GetLength(0);i++){ //getlength：获取指定维度的元素个数//内层循环遍历列数for (int j=0;j<a.GetLength(1);j++) {Console.Write(a[i,j]+" ");}Console.WriteLine();}Console.ReadKey();
数组的遍历
增强for循环：
//语法：foreach(数据类型 迭代变量 in 数组名)//遍历一维数组 int[] score = {78,98,88,45,65,78,11,23,100,112,201,330,380,255}; foreach (int a in score) {Console.WriteLine(a); } Console.ReadKey();//遍历二维数组 int[,] a = new int[3, 4] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };foreach (int temp in a){Console.WriteLine(temp);}Console.ReadKey();
数组的排序与查找
Array类常用方法
| 方法 | 说明 |
|---|---|
| copy | 将数组中的指定元素复制到另一个数组中 |
| copyto | 从指定目标数组索引处开始，将当前一位数组中的所有元素复制到另一个数组中 |
| exists | 判断数组中是否包含指定的元素 |
| getlength | 获取数组中指定维度的元素个数 |
| getvalue | 获取数组中指定位置的值 |
| reverse | 反转一维数组中元素的位置 |
| setvalue | 设置数组中指定位置的元素 |
| sort | 对一维数组元素进行排序 |
//原始数据
int[] a = {55,64,12,39,87,16,97,41,18,66,90};int[] b = new int[11];//copy方法Array.Copy(a,b,4);foreach (int i in b) {Console.WriteLine(i);}Console.WriteLine("=================================");//copyto方法a.CopyTo(b, 0);foreach (int i in b){Console.WriteLine(i);}Console.WriteLine("=================================");//getlength方法Console.WriteLine("a数组的元素个数为：{0}",a.GetLength(0));Console.WriteLine("=================================");//getvalue方法Console.WriteLine("a数组第三个元素为：{0}", a.GetValue(2));Console.WriteLine("=================================");//reverse方法Array.Reverse(a);Console.WriteLine("倒序后：");foreach (int item in a){Console.WriteLine(item);}Console.WriteLine("=================================");//setvalue方法a.SetValue(666, 0);Console.WriteLine("a数组第一个元素为：{0}", a.GetValue(0));Console.WriteLine("=================================");//sort方法Array.Sort(a);Console.WriteLine("排序后：");foreach (int i in a) {Console.WriteLine(i);}Console.ReadKey();
基础算法
1.排序算法
选择排序
原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
//选择排序 int[] array = {12,44,6,89,106,255,43,67,32,18}; //打印排序前的数组 foreach (int a in array) { Console.Write(a + " "); }Console.WriteLine(); int min; //记录最小值下标 int temp; //交换数据使用的临时变量 for (int i = 0; i < array.Length - 1; i++) { min = i; //将当前元素设置假象最小值 for (int j = i+1; j < array.Length; j++) {if (array[min] > array[j]) {min = j;} } if (min!=i) {temp = array[min];array[min] = array[i];array[i] = temp; } }//打印排序后的数组 foreach (int a in array) { Console.Write(a+" "); }Console.ReadKey();冒泡排序
原理：它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
int temp; //定义变量值交换所用的中间变量 //待排序数组 int[] array = { 12, 44, 6, 8, 106, 47, 43, 97, 32, 18 };for (int i=0;i<array.Length-1;i++) {for (int j=i+1;j<array.Length;j++) {if (array[i] > array[j]) {temp = array[i];array[i] = array[j];array[j] = temp;}} }foreach (int a in array) {Console.Write(a + " "); } Console.ReadKey();插入排序
原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
int[] array = { 12, 44, 6, 8, 106, 75, 43, 13, 178, 18 }; int min; for (int i=0;i<array.Length;i++) {min=array[i];int j = i - 1;while(j >= 0 && array[j] > min){array[j+1]=array[j];j--;}array[j + 1] = min; }foreach (int a in array) {Console.Write(a + " "); } Console.ReadKey();2.查找算法
顺序查找
原理：从数组的一边开始，逐个进行元素的比较，如果与给定的待查找元素相同，则查找成功。
int[] array = { 12, 44, 6, 8, 106, 75, 43, 13, 178, 18 }; Console.Write("请输入要查找的元素："); int num = int.Parse(Console.ReadLine()); Boolean flag = false; foreach (int i in array) {if (i == num){flag = true;} } if (flag) {Console.WriteLine("要查找的元素位于数组中"); } else { Console.WriteLine("要查找的元素不在该数组中"); } Console.ReadKey();二分查找法
❤适用于已排序的数组
//二分查找int[] array = { 12, 44, 6, 8, 106, 75, 43, 13, 178, 18 };//对数组元数据排序Array.Sort(array);Console.Write("请输入要查找的元素：");int num = int.Parse(Console.ReadLine());Boolean flag = false;//二分查找int low = 0; //起始查找位int high = array.Length-1; //默认查找结束位while (low<=high) {int mid = low+(high - low) / 2; //获取中间位下标if (array[mid] == num){Console.WriteLine(mid+1);flag = true;break;}else if (array[mid] < num){low = mid + 1;}else {high = high - 1;}}if (!flag) {Console.WriteLine("要查找的数组不在该数组中");}Console.ReadKey();
面向对象基础（OOP）
类
概念：是一个抽象数据类型，是对拥有共同属性和行为实体的统称，是创建对象的模板。
声明：
/* 访问修饰符 class 类名称{ 属性 方法 } */public class Person{ //属性 private string name; public int age; //方法 public void Speak(){ Console.writeline("你好"); } } //public:访问修饰符，表示当前类为公共类，可以在其他程序中调用 //类名称做到见名知意，遵守标识符命名规则 //类名称书写方式通常使用驼峰命名法（帕斯卡命名法） //大驼峰命名法：StudentName //小驼峰命名：Studentname //匈牙利命名法：stu_name类的成员
组成：
1.字段(fields)：字段用于存储数据，表示对象的状态，是类内部状态的一部分。
2.属性(properties)：提供对字段的访问与控制，可以用于封装字段的读取和写入操作，允许在访问字段时执行自定义逻辑，例如输入验证。
3.方法(methods)：定义了类的行为和操作，用于执行某些操作的代码块。
//定义字段 private string name; //私有字段 public int age; //公共字段//属性 public String name{ get{return name;} //获取属性值 set{name = value;} //设置属性值 }//方法 public void Speak(){ Console.WriteLine("你好"); }构造函数
概念：在对象创建时进行初始化，创建对象时自动调用构造函数
作用：为对象分配内存并设置初始值或执行其他必要的初始化任务。
声明：
public class person{ //构造函数 public person(){ //初始化操作 }} //构造函数名称要与类名保持一致 //构造函数没有返回类型 //构造函数可以包含参数，用于接受初始化时需要的信息//示例：创建对象时，对象中包含数据 //定义人类 public class person { //构造函数 public person() { name = "李四"; age = 21; id = 45; } public int id;//身份证号 public string name;//姓名 public int age;//年龄//说话 public void speak() { Console.WriteLine("大家好，我叫{0},今年{1}岁,编号是{2}",name,age,id); }}//创建对象 public static void Main(String[] args) {//创建一个对象 person zhangsan=new person(); //zhangsan.name = "张三"; //zhangsan.age = 18; //zhangsan.id = 13; Console.WriteLine(zhangsan.name); Console.WriteLine(zhangsan.age); Console.WriteLine(zhangsan.id); zhangsan.speak();Console.ReadKey(); }//根据person类创建对象，在没有赋值的情况下构造函数完成初始化操作，对象中包含李四信息。构造函数的重载
概念：方法名相同，参数列表不同。
//人类 public class person { //无参构造函数 public person() { name = "李四"; age = 21; id = 45; }//有参构造函数 public person(string name) { this.name = name; }//多参数构造函数 public person(int id,string name,int age) { this.id = id; this.name = name; this.age = age; }public int id;//身份证号 public string name;//姓名 public int age;//年龄//说话 public void speak() { Console.WriteLine("大家好，我叫{0},今年{1}岁,编号是{2}",name,age,id); } }//main方法 public static void Main(String[] args) {//创建一个对象 person zhangsan = new person(999,"王大锤",81); //根据参数个数自动匹配合适的构造函数 Console.WriteLine(zhangsan.name); Console.WriteLine(zhangsan.age); Console.WriteLine(zhangsan.id); zhangsan.speak();Console.ReadKey();}对象
**概念：**对抽象物体进行实例化，以类为模板创建对象
创建：
//使用new操作符创建对象 className objectName = new className(); //className:类名 //objectName:对象名 //new:创建对象关键字 person zhangsan=new person();访问对象成员：
- 字段：对象.字段名
- 属性：对象.属性
- 方法：对象.方法()
对象的生命周期
创建：分配内存
使用：对象的字段和属性被读取
销毁：垃圾回收机制自动销毁，释放对象占用的内存
//创建一个对象 person ls = new person(); //创建ls.name = "李四"; //使用--赋值 Console.WriteLine(ls.name);//取值属性
概念：属性是类的成员，用来访问和控制类的字段，属性提供了对字段的封装，可以通过属性读取和修改字段的值，而不直接暴露字段。
访问器：
- get访问器：获取属性值
- set访问器：设置属性值
作用：
- 属性是字段的包装器：属性允许通过类的接口来访问和操作字段，而不需要直接暴漏字段。
- 属性提供读取和写入的控制：通过get和set实现读取和设置
- 属性包含逻辑：访问或赋值时可以进行验证操作
语法：
访问修饰符 数据类型 属性名{ get{return 变量名 } set{ 变量名 = value } }//示例 //定义属性 private int age;//年龄 public int str {get{return age ;}set{if (value>18){age = value;}} }//访问属性//创建一个对象person ls = new person(); //创建ls.str = 99;Console.WriteLine(ls.str);//取值this关键字
概念：this表示当前类。可以使用this调用当前类的属性、方法以及构造方法，消除歧义。
//使用this关键字调用当前类直属属性public class person{ public person() {Console.WriteLine("无参构造");}//有参构造函数//使用this关键字调用无参构造public person(string name){this();this.name = name;}public int age;//年龄public int str{get{return this.age ;}set{if (value>18){this.age = value;}}}//使用this关键子调用成员方法//说话public void speak() {Console.WriteLine("大家好，我叫{0},今年{1}岁,编号是{2}",name,age,id);}//睡觉public void sleep() {this.speak();Console.WriteLine("zZZZZZZ");}}方法
概念：包含特定的代码块，是一个语句的集合，用于执行特定的功能或操作。
声明：
访问修饰符 返回值类型 方法名(参数列表){方法体retrun 返回值 //如果返回值类型为void,不需要设置返回值 }访问修饰符：public、private、protected 返回值类型：void表示无返回值 方法名：命名规则按照驼峰命名法(首字母大写) 参数列表：包含参数数据类型与参数名，多个参数使用逗号隔开 方法体：包含特定操作的代码集合 返回值：如果没有返回值，那么return语句省略,如果有返回值，返回值数据类型与方法声明语句中返回值数据类型保持一致。//定义有参有返回值方法 public int Sum(int x,int y) {int z = x + y;return z; }//调用方法 person ls=new person(); int z =ls.Sum(18,36); Console.WriteLine(z); Console.ReadKey();参数类型：
- 形式参数：定义方法时规定的参数类型以及参数名称。
- 实际参数:调用方法时实际传入的参数。
实参与形参的关系：
- 实参可以是常量、变量、表达式，但是数据类型一定要与形参保持一致。
- 形参名称与实参名称可以不一样。
参数的传递方式：
值传递（按值传递）：参数值的变化不用作用到原变量，而是将原变量中的值复制给形参
引用参数（按址传递）：参数值的变化会作用到原变量，参数与原变量使用同一个内存地址
定义形参时在对应形参前加ref
调用方法时，传入实参需要在实参前加ref
按址传递参数必须为变量，不能使用常量或表达式
//按值传递public int Sum(int x,int y) {x=x + y;return x; } //按值传递int z =ls.Sum(a,b);Console.WriteLine(z); //z=100Console.WriteLine("=============");Console.WriteLine(a); //a=20//按址传递public int Sum2(ref int x, int y) {x = x + y;return x;}//按址传递int w = ls.Sum2(ref a,b);Console.WriteLine(w); //w=100Console.WriteLine("=============");Console.WriteLine(a); //a=100Console.ReadKey();输出参数(out类型)
//输出参数public int Sum3(int x, int y,out int z) {z = x + y;return z;}//输出参数int sum;sum = ls.Sum3(a, b, out sum);Console.WriteLine(sum);Console.WriteLine("=============");Console.WriteLine(a);Console.WriteLine(b);数组参数(params类型)
//数组参数public int Sum4(params int[] a) {int result=0; //数组元素相加之和for (int i = 0; i < a.Length; i++) {result += a[i];}return result;}//数组参数//int[] array = new int[] { 12, 15, 13, 10, 18, 17, 19 }; //定义数组作为参数int result = ls.Sum4(25,36,98,74,53,14,22,66,73,28); //直接赋值转换为数组Console.WriteLine(result);Console.ReadKey();static关键字
静态成员类型：
- 静态字段：静态字段是类级别的字段。
- 静态属性：静态属性是可以用于获取或设置类级别的数据的特殊成员。
- 静态方法：静态方法是属于类而不是类的示例的方法，静态方法不对特定的示例进行操作。
静态成员的声明：
静态字段
public static int age;静态属性
public static int age{get;set;}静态方法
public static void speak(){}静态成员与实例成员的区别
- 静态成员属于类，实例成员属于类的实例（对象）
- 静态成员在整个应用程序中只有一个实例，而实例成员每个类实例都有自己的副本
- 静态成员可以通过类名访问，而实例成员需要通过对象访问
- 静态成员通常用于表示全局或共享数据，而实例成员用于表示对象特定的数据。
面向对象编程（oop）
基本特征：封装、继承、多态
属性封装
概念：为了保护字段的私密性，将字段封装至属性中，属性提供的访问器作为字段的访问接口。
声明：
访问修饰符 属性修饰符 类型 成员名 {访问器 } 属性修饰符：new、static、virtual、abstract、override 类型：字段数据类型 成员名：属性名称 访问器：set赋值访问器、get取值访问器 访问修饰符：public:公共修饰符,表示成员对任何的代码都是可见可访问的。private:私有访问修饰符，只能在定义它的类的内部访问。protected:受保护访问修饰符，对定义它的类及子类是可见和可访问的。internal:内部访问修饰符，对同一程序及中的代码是可见可访问的。protected internal:受保护内部访问修饰符，对同一程序集中的代码和该类的子类是可见可访问封装的目的：
- 数据隐藏：通过将数据声明为私有成员，只允许通过公共方法来访问和修改。
- 实现抽象：将夫擦的数据和操作进行抽象，仅提供公共接口使用。
- 代码复用：将相关的数据和操作封装为一个类，实现重复使用。
- 提高可维护性：将对象的状态和行为组织在一起，提高安全性和维护性。
示例代码
//定义类 class Animal //动物类{//封装为不可见状态private string name; //名称private int age; //年龄private char color; //颜色private int type; //类型 0：哺乳类 1:鸟类 2:爬行类 3:鱼类//将私有字段改造为属性，添加访问器public string Name { //访问器get{return name;}set{name = value;}}public int Age {get{return age;}set { age = value; }}public char Color { get { return color; }set { color = value; }}public int Type { get { return type; }set { type = value; }}//方法public void speak() {Console.WriteLine(name+age+color+type);}}//主程序 Animal dog = new Animal(); //实例化---对象 dog.Name = "旺财"; dog.Age = 2; dog.Color = '黄'; dog.Type = 0;dog.speak();继承
概念：类的继承性是指一个已存在的类的基础上定义一个新类，其中这个已存在的类被称为基类或父类，新定义的类叫做派生类或子类，子类继承了父类的属性和方法，也可以增加原本父类没有的属性和方法。
特点：
- 子类只能拥有一个父类，单一继承。
- 子类自动继承父类的属性和方法，但是不能继承父类的构造函数。
- 类的继承可以传递。
子类的声明
访问修饰符 class 类名:父类民 {子类的成员 }//父类class Animal //动物类---父类{public string name;public int age;public void speak() {Console.WriteLine("我叫{0}，今年{1}岁",name,age);}}//子类internal class dog:Animal{public string type;public string color;public void eat(){Console.WriteLine("{0}吃东西", type);}}//主程序//小狗对象dog dd = new dog();dd.age = 3;dd.name = "dd";dd.type = "柯基";dd.color = "黄";dd.eat();dd.speak();//动物对象Animal animal = new Animal();animal.name = "aa";animal.age = 8;animal.speak();//Console.WriteLine(dog.Name);Console.ReadKey();base关键字
概念:子类重写父类方法之后，使用base关键字可以调用原本父类的方法。
特点：子类重写方法的访问权限一定要大于父类方法的访问权限
//父类 class Animal //动物类---父类{public string name;public int age;protected void speak() {Console.WriteLine("我叫{0}，今年{1}岁",name,age);}} //子类 internal class dog:Animal{public string type;public string color;public void eat(){Console.WriteLine("{0}吃东西", type);}//方法的重写private void speak() {Console.WriteLine("dog speak...");base.speak(); //base关键字表示父类}}//主程序//小狗对象dog dd = new dog();dd.age = 3;dd.name = "dd";dd.type = "柯基";dd.color = "黄";dd.eat();dd.speak();继承中的构造函数与析构函数
概念：子类的构造函数会隐式调用父类的无参构造函数，如果父类也是由其他类派生的，会根据层次结构找到最顶层的父类，调用其无参构造。
多态
概念：同一事物可以拥有不同的形态，同一个对象可以拥有不同的类模板。
多态的实现：
使用new重新定义类的成员实现多态性。
class Animal //动物类---父类 {public string name;public int age;public void speak() {Console.WriteLine("我叫{0}，今年{1}岁",name,age);} }internal class dog:Animal //子类{public string type;public string color;public void eat(){Console.WriteLine("{0}吃东西", type);}public new void speak() {Console.WriteLine("dog speak..."); } }//主程序dog dd = new dog();dd.speak();2. 虚方法的重写实现多态性
//父类中声明虚方法 public virtual 返回值类型 方法名称(参数列表){ 方法体 }子类中覆盖虚方法
public override 返回值类型 方法名称（参数列表）{方法体 }父类与子类中的方法名称与参数列表必须完全一致，当不需要参数列表时省略参数列表。
class Animal //动物类---父类{//定义虚方法public virtual void eat() {Console.WriteLine("动物都能吃东西");}}//子类一 internal class Dog:Animal {//覆盖虚方法public override void eat(){Console.WriteLine("小狗吃骨头");} }//子类2internal class Cat:Animal{//虚方法覆盖public override void eat(){Console.WriteLine("小猫吃鱼");}}//主程序 Animal aa = new Animal(); Animal dd = new Dog(); Animal cc = new Cat(); aa.eat(); dd.eat(); cc.eat();
方法重载实现多态性
概念：再同一个类中定义多个具有相同名称但是参数列表不同的方法，实现多态性。
internal class Class7{//重载：方法名相同，参数列表或返回值类型可以不同public int Add(int a,int b) { return a+b;} public double Add(double a, double b) { return a+b;} }//主程序Class7 cls = new Class7();int sum = cls.Add(8, 9);Console.WriteLine(sum);double sum2 = cls.Add(3.14, 5.98);Console.WriteLine($"{sum2}");Console.ReadKey();抽象类
概念：抽象类不与具体的事物相联系，只表达一种抽象概念或行为。抽象类中可以包含抽象方法（没有方法 体），变量，常量，和方法实现体。抽象类只能作为父类被继承而不能实例化。
定义：
修饰符 abstract class 类名{类成员 } //实示例internal abstract class Class8 //抽象类{int id;string name;int Id {get { return id; }set { id = value; }}//普通方法public void eat(){Console.WriteLine("eat........");}//抽象方法public abstract void speak();}//子类internal class Class9 : Class8{public override void speak() {Console.WriteLine("class9 speak.....");}}//主程序Class9 cls = new Class9();cls.speak();cls.eat();接口
概念：接口只定义一组方法和属性的规范，而不包括具体的实现。只包含抽象方法。
接口的声明
访问修饰符 interface 接口名{//接口成员 }//访问修饰符只能使用public或internal //接口名命名规则与类名的命名规则相同，为了方便区分，接口名建议首字母加I //接口成员可以是属性、方法，不能包含常量、字段、构造函数和析构函数//示例internal interface Interface1{//属性string id {get;set;}//方法void eat(); }接口的实现
概念：接口通过实现类来实现，一个类只能有一个父类，但是可以实现多个接口。（单继承，多实现）
public class 类名:接口{抽象方法实现 }//接口实现类必须实现该接口的所有抽象方法 //接口可以继承其他接口，类可以同时实现接口与继承，父类名在前 internal class Class10 : Interface1 {string ID;public string id{get {return ID;}set {ID = value;}}public void eat(){Console.WriteLine("接口实现类-----id={0}eat....",ID);} }接口特征
- 接口类似于抽象类，实现接口的任何非抽象类型必须实现接口的所有成员
- 不能直接实例化接口
- 接口可以包含时间，索引器，方法和属性
- 接口不包含方法的实现
- 类可以实现多个接口
- 接口可以继承其他接口
接口多重实现
//接口1---顶级接口internal interface IPeople{string Name { set; get; }string Sex { set; get; }}//接口2---老师internal interface ITeacher:IPeople{void teach ();} // 接口3---学生internal interface IStudent:IPeople{void study();} //接口实现类 internal class Person:IPeople,ITeacher,IStudent {string name = "";string sex = "";public string Name{get {return name;}set {name = value;}}public string Sex{get{return sex;}set{sex = value;}}public void teach() {Console.WriteLine(Name+""+Sex+"教师");}public void study() {Console.WriteLine(Name + "" + Sex + "学生");} }//主程序Person person = new Person();ITeacher teacher = person; //使用接口实现类实例化老师接口teacher.Name = "张三";teacher.Sex = "女";teacher.teach();IStudent student = person; //使用接口实现类实例化学生接口student.Name = "李四"; student.Sex = "女";student.study();显式接口成员的实现
internal interface IMyInterface1{int Add();}internal interface IMyInterface2{int Add();}internal class Class12:IMyInterface1,IMyInterface2{int IMyInterface1.Add() { //指向IMyInterface1中的抽象方法return 3 + 8;}int IMyInterface2.Add() { //指向IMyInterface2中的抽象方法return 10 + 20;}}//主程序//接口实现类对象Class12 cls = new Class12();//IMyInterfasce1实例化对象IMyInterface1 face1 = cls;int a=face1.Add();Console.WriteLine(a);//IMyInterfasce2实例化对象IMyInterface2 face2 = cls;int b=face2.Add();Console.WriteLine(b);Console.ReadKey();委托
概念：委托是动态调用方法的类型，使用委托将方法封装在委托对象中，将委托对象传递给调用引用方法的代码。将方法作为参数进行传递。
特点：
- 完全面向对象，是安全的数据类型
- 允许将方法作为参数进行传递
- 可用于定义回调函数
- 可以把多个方法链接在一起，可同时启动多个处理程序
- 不需要与方法精确匹配
委托的声明
访问修饰符 delegate 返回类型 委托名称(参数列表);//委托类型匹配规则 //1.具有相同的签名，即参数数据，数据类型，顺序相同。 //2.具有相同的返回值类型。// 声明一个委托，用来引用具有两个int型参数且返回值也为int的方法 public delegate int MyDelegate(int a,int b);委托的实现（实例化委托）
委托类型 委托对象 = new 委托类型(要引用的方法名);MyDelegate dele = new MyDelegate();示例
//声明委托public delegate int MyDelegate(int a, int b);//方法1static int Sum(int a, int b) {return a + b;}//方法2static int Dec(int a, int b) {return a - b;}//方法3static int Mul(int a, int b) {return a * b;}//方法4static int div(int a, int b){return a / b;}//主程序public static void Main(String[] args) {//实例化委托MyDelegate a = Sum;Console.WriteLine(a(8, 3));a = Dec;Console.WriteLine(a(8, 3));a = Mul;Console.WriteLine(a(8, 3));a = div;Console.WriteLine(a(8, 3));Console.ReadKey();} }
C#常用类的属性和方法
Math类
公共字段
名称 功能说明 实例 结果 E 自然对数的底，数学常数e Math.E 2.71828182845905 PI 圆周率 Math.PI 3.1415926 Console.WriteLine(Math.E); Console.WriteLine(Math.PI);常见方法
方法 说明 Abs(number) 返回参数的绝对值 Pow(number1,number2) 返回指定数字的指定次幂 Sqrt(number) 返回指定参数的算数平方根 Ceiling(number) 返回大于或等于该数的最小整数—向上取整 Floor(number) 返回小于或等于该数的最大整数—向下取整 Exp(number) 返回e的指定次幂 Log(number1.number2) 返回指定数字在使用指定底数时的对数 Log(number) 返回指定数字的自然对数 Log10(number) 返回指定数字以10为底的对数 Max(number1,number2) 返回两个数中较大的一个 Min(number1,number2) 返回两个数中较小的一个 Sign(number) 返回指定数字的符号，如果n为整数，返回值为1，如果n为负数，返回值为-1，如果n为0，返回值就为0 Sin(number) 返回指定角度的正弦值 Cos(number) 返回指定角度的余弦值 Tan(number) 返回指定角度的正切值 Round(number)
Round(number,number)将小数就近舍入到指定长度，四舍六入五成双 String类
常见属性
属性 说明 Char 获取此字符串中位于指定字符位置的字符 Length 获取此字符串中的字符数 常见方法
方法 说明 Equals 主要用于比较两个字符串是否相同 Compare 用来比较两个字符串是否相等 Contains 检查字符串中是否包含某字符 Concat 将多个字符串拼接为一个新字符串 Copy 赋值字符串 Format 将字符串格式化为指定格式 IndexOf 查找某字符在该字符串中首次出现的索引位置 Insert 向字符串指定位置插入新字符串 Remove 从字符串指定位置开始删除指定长度的字符 Replace 将字符串中某个字符或字符串替换为其他的字符或字符串 IsNullOfEmpty 判断字符串是否为空串或空对象 Join 将字符串数组串联指定的字符，形成新的字符串 Split 将字符串拆分成字符串数组 ToLower 将字符串转换为小写 ToUpper 将字符串转换为大写 ToCharArray 将字符串的字符复制到字符数组 Trim 将字符串左右两边的空格删除 Substring 从字符串指定位置截取指定长度的字符串 示例
//Equals String str1 = "Hello World"; String str2 = "hello World"; Console.WriteLine(str1.Equals(str2)); //false Console.WriteLine(String.Equals(str1, str2));//false//CompareString str1 = "Hallo World";String str2 = "Hello World";Console.WriteLine(String.Compare(str1, str2)); //false//ContainsString str1 = "Hallo World";String str2 = "wor";String str3 = "Wor";Console.WriteLine(str1.Contains(str2)); //falseConsole.WriteLine(str1.Contains(str3)); //true//ConcatString str1 = "Hello";String str2 = " ";String str3 = "Wor";String str4 = "ld";Console.WriteLine(String.Concat(str1,str2,str3,str4)); //Hello World//Copy String str1 = "Hello"; String str2 = String.Copy(str1);Console.WriteLine(str1); //Hello Console.WriteLine(str2); //Hello//FormatConsole.WriteLine(String.Format("{0:N}", 670008)); //670,008.00//IndexOf String str1 = "we are the world"; Console.WriteLine(str1.IndexOf("a")); //3//Insert String str1 = "we are the world"; Console.WriteLine(str1.Insert(2, "insert")); //weinsert are the world//RemoveString str1 = "we are the world";Console.WriteLine(str1.Remove(3,4)); //we the world//Replace String str1 = "we are the world";Console.WriteLine(str1.Replace("e","E")); //wE arE thE world//IsNullOrEmptyString str1 = "we are the world";String str2 = "";Console.WriteLine(String.IsNullOrEmpty(str1)); //falseConsole.WriteLine(String.IsNullOrEmpty(str2)); //true//join String[] name = { "小明", "小红", "小王" }; Console.WriteLine(String.Join("&", name)); //小明&小红&小王//Split String str1 = "we are the world"; String[] array = str1.Split(' '); foreach (String str2 in array) {Console.WriteLine(str2); //we are then world }//ToLower //ToUpper String str1 = "We Are The World"; Console.WriteLine(str1.ToLower()); //we are the world Console.WriteLine(str1.ToUpper()); //WE ARE THE WORLD//ToArrayChar String str1 = "We Are The World";char[] array=str1.ToCharArray(); foreach (char chr in array) {Console.WriteLine(chr); }//TrimString str1 = " We Are The World ";Console.WriteLine(str1.Trim()); //We Are The World//SubstringString str1 = " We Are The World ";Console.WriteLine(str1.Substring(4,7)); //Are The
DateTime类
取值范围：0001年1月1日午夜0:0:00~9999年12月31日网上23:59:59
日期时间变量的定义
DateTime 日期时间变量 = new DateTime(年,月,日,时,分,秒);DateTime date1 = new DateTime(2025, 6, 16); DateTime date2 = new DateTime(2025, 7, 17, 8, 56, 55);常见的属性
属性 说明 Today 获取当前日期，静态属性 Now 获取当前的时间，静态属性 Date 获取日期部分 Day 获取日 Month 获取月 Year 获取年 Hour 获取时 Minute 获取分钟 Second 获取秒 //静态属性使用类名可以直接访问Console.WriteLine(DateTime.Today);Console.WriteLine(DateTime.Now);//非静态属性需要使用对象访问DateTime date = new DateTime(2025, 6, 16, 9, 7, 7); Console.WriteLine(date.Date);Console.WriteLine(date.Day); Console.WriteLine(date.Month);Console.WriteLine(date.Year); Console.WriteLine(date.Hour);Console.WriteLine(date.Minute); Console.WriteLine(date.Second);Random类
随机对象声明
Random rand = new Random()常见方法
方法 说明 Next() 产生一个非负随机整数 Next(非负整数) 产生随机数范围0~小于非负整数 Next(整数1,整数2) 产生整数1(包含)~整数2(不包含)之间的随机整数 NextDouble() 产生0.0~1.0(不包含)之间的双精度浮点随机数 示例
//创建随机对象Random rand = new Random();//生成5个随机整数数 Console.WriteLine("生成5个随机整数数");for (int i = 0; i < 5; i++) {Console.WriteLine(rand.Next());}Console.WriteLine("========================");//生成5个0~100之间的随机正整数Console.WriteLine("生成5个0~100之间的随机正整数");for (int i = 0; i < 5; i++){Console.WriteLine(rand.Next(100));}Console.WriteLine("========================");//生成5个两位随机正整数Console.WriteLine("生成5个两位随机正整数");for (int i = 0; i < 5; i++){Console.WriteLine(rand.Next(10,100));}Console.WriteLine("========================");//生成5个取值范围0~1.0之间的随机小数Console.WriteLine("生成5个取值范围0~1.0之间的随机小数");for (int i = 0; i < 5; i++){Console.WriteLine(rand.NextDouble());}Console.WriteLine("========================");Console.ReadKey();Convert类
方法 说明 ToBoolean 转换为布尔型 ToChar 转换为字符型 ToDateTime 转换为日期时间型 ToDecimal 转换为货币型 ToDouble 转换为双精度类型 ToSingle 转换为单精度浮点型 ToString 转换为字符串型 //ToBoolean//数值型转布尔型,0:false 非0：trueint a = 1;double b = -2.1;Console.WriteLine(Convert.ToBoolean(a));Console.WriteLine(Convert.ToBoolean(b));//字符串转布尔string str = "true";string str1 = "false";Console.WriteLine(Convert.ToBoolean(str));Console.WriteLine(Convert.ToBoolean(str1));//ToChar//字符串转字符string a = "a";Console.WriteLine(Convert.ToChar(a));//整型转字符（依照ASII码）int x = 65;int y = 97;Console.WriteLine(Convert.ToChar(x));Console.WriteLine(Convert.ToChar(y));//ToDateTime//字符串转日期string str = "2025/06/16";Console.WriteLine(Convert.ToDateTime(str));Console.ReadKey();//ToDecimal//布尔型转数值型Boolean a = true;Boolean b = false;Console.WriteLine(Convert.ToDecimal(a));Console.WriteLine(Convert.ToDecimal(b));//字符串转数值string str = "3.1415926";Console.WriteLine(Convert.ToDecimal(str));Console.ReadKey();//ToDouble//布尔型转数值型Boolean a = true;Boolean b = false;Console.WriteLine(Convert.ToDouble(a));Console.WriteLine(Convert.ToDouble(b));//字符串转数值string str = "3.1415926";Console.WriteLine(Convert.ToDouble(str));Console.ReadKey();//ToSingle //布尔型转数值型 Boolean a = true; Boolean b = false; Console.WriteLine(Convert.ToSingle(a)); Console.WriteLine(Convert.ToSingle(b));//字符串转数值 string str = "3.1415926"; Console.WriteLine(Convert.ToSingle(str)); Console.ReadKey();//ToString //万物皆可ToString int a = 1; Single b = 1.3f; double c = 3.14; decimal d = 5.55555M; Boolean e = false; char f = 'a'; DateTime g = DateTime.Today;Console.WriteLine(Convert.ToString(a)); Console.WriteLine(Convert.ToString(b)); Console.WriteLine(Convert.ToString(c)); Console.WriteLine(Convert.ToString(d)); Console.WriteLine(Convert.ToString(e)); Console.WriteLine(Convert.ToString(f)); Console.WriteLine(Convert.ToString(g)); Console.ReadKey();
C#文件操作
文件分类
- 根据文件性质划分
- 程序文件：可以由计算机执行的程序，包括原文件和可执行文件，如.exe、.cs
- 数据文件：数据文件用来存放普通的数据，如.txt、.xlsx
- 根据文件的存取方式划分
- 顺序文件：由一系列字符按照某种顺序排列形成，适用于读写连续块中的文本文件，不宜存储太长的文件。
- 优点：占空间少，容易使用
- 缺点：维护困难，修改数据需要将整个文件读入内存修改。
- 随机文件：以随机的方式存取文件，随机文件适用于读写有固定长度多字段记录的文件。
- 二进制文件：按照二进制的方式来存放的文件。
创建文件
File类
Create方法
File.Create(新建文件路径/文件名.文件格式);File.Create("D:\\C#-study\\file.txt"); File.Create(@"D:\C#-study\file2.txt"); //@标志提示编译器不讲\视为转置字符Copy方法
File.Copy(原文件地址\文件名.格式,目标文件夹\文件名.格式); File.Copy("D:\\C#-study\\file.txt","D:\\database\\file.txt"); File.Copy("D:\\C#-study\\file2.txt","D:\\database\\file3.txt"); //复制后的文件可以修改文件名Move方法
File.Move(原文件地址\文件名.格式,目标文件夹\文件名.格式);File.Move("D:\\C#-study\\file2.txt", "D:\\database\\file2.txt");
Delete方法
File.Delete(文件路径\文件名.格式);File.Delete("D:\\C#-study\\file.txt");Exists方法
File.Exists(文件路径\文件名.格式) //该文件存在返回true，如果不存在返回false//检查D盘database文件夹下是否存在file4文本文件，如果存在则忽略，不存在则创建该文件if (File.Exists("D:\\database\\file8.txt")){ Console.WriteLine("该文件已存在~");} else {File.Create("D:\\database\\file8.txt"); Console.WriteLine("文件创建成功~");}Console.ReadKey();
- Replace()方法
File.Replace(原文件名,目标文件名，目标文件的备份名)//将database文件夹下file8.txt的内容替换file2.txt的内容，file2的内容备份到C#-study文件夹下的file2.txt中File.Replace("D:\\database\\file8.txt", "D:\\database\\file2.txt", "D:\\C#-study\\file2.txt");FileInfo类
常见属性
属性 说明 Name 返回文件的名称，而不是完整的文件路径位置 Attributes 获取或者是设置文档的属性 CreatetionTime 获取或设置当前fileinfo对象的创建时间 DiretoryName 获取或这hi文件的完整路径 Exists 判断文件是否存在 FullName 获取文件的完整路径 IsReadOnly 获取或设置文件是否为只读属性 Length 获取文件的大小 FileInfo file = new FileInfo("D:\\database\\file7.txt");file.Create();Console.WriteLine(file.Name); Console.WriteLine(file.Attributes);Console.WriteLine(file.CreationTime);Console.WriteLine(file.DirectoryName);Console.WriteLine(file.Exists);Console.WriteLine(file.FullName);Console.WriteLine(file.IsReadOnly);Console.WriteLine(file.Length);常见方法
方法名 说明 Create 创建文件 CopyTo 复制文件 Delete 删除文件 MoveTo 移动文件 Open 打开文件 Replace 替换文件 流与FileStream类
创建方式
1.FileStream(string,FileMode) //只读方式 2.fileStream(string,FileMode,FileAccess) //fileAccess：read/readwrite/write创建模式
模式名称 说明 Append 如果文件已存在则追加在源文件内容后，不存在则新建文件，只能同FileAccess.Write一起使用 Create 如果文件不存在则创建新文件，如果文件存在则将原文件内容替换 CreateNew 直接创建新文件，如果文件存在报异常 Open 打开文件，如果文件不存在报异常 OpenOrCreate 打开文件，如果文件不存在则创建新文件 Truncate 打开一个现有文件，将内容清空并替换，保留文件的初始创建时间，为你教案不存在报异常。 FileStream file = new FileStream("D:\\database\\file5.txt",FileMode.CreateNew);读写文件
使用FileStream类读写流文件
写文件
WriteByte方法
语法:FileStream对象.WriteByte(Byte value)//将0~9写入文件中FileStream file = new FileStream("D:\\database\\file4.txt",FileMode.Create,FileAccess.Write); for (byte i = 0; i <= 9; i++) {file.WriteByte(i); } //关闭文件 file.Close();语法：FileStream对象.Write(数组名,文件写入起始位置,写入字节数或者二进制数据元素的个数)//将26英文字母写入文件//FileStreamFileStream file = new FileStream("D:\\database\\file4.txt",FileMode.Create,FileAccess.Write);//将字母对应ASCII编码存放至数组Byte[] array = new byte[26];for (int i = 0; i < 26; i++){array[i] = (Byte)(i+65);}//写入数据file.Write(array, 0, 26);//关闭文件file.Close();读文件
ReadByte方法
语法：FileStream.ReadByte()//将file4文件中的内容读取至控制台 //FileStreamFileStream file = new FileStream("D:\\database\\file4.txt",FileMode.Open,FileAccess.Read);for (int i = 0; i < file.Length; i++) {Console.WriteLine(Convert.ToChar(file.ReadByte())); }file.Close();Console.ReadKey();##### 2. Read方法```c# 语法：FileStream对象.Read(数组名,文件起始位置，读取长度)//FileStream FileStream file = new FileStream("D:\\database\\file4.txt",FileMode.Open,FileAccess.Read);//定义数组接受读取数据Byte[] array = new Byte[26];//将文件中0~26位的字符保存至array数组file.Read(array, 0, 26);//遍历数组内容foreach (Byte item in array){Console.WriteLine(Convert.ToChar(item));}file.Close();Console.ReadKey();```##### 使用StreamReader类和StreamWriter类读写文本文件使用StreamReader读取文本文件```tex 实例化StreamReader 构造函数重载 1.Public StreamReader(String path) path:文件的完整路径+文件名.格式2.Public StreamReader(Stream stream) stream:一个打开的流，一般是FileStreame对象3.Public StreamReader(string path,bool detectEncoding) detectEncoding:自动检测文件中使用的编码格式4.Public StreamReader(string path,Encoding encoding) encoding:指定便编码格式 ASCII:一个英文字母为一个字节，一个汉字为两个字节 UTF-8:一个英文字母占一个字节，一个汉字占三个字节 Unicode:一个英文字母占一个字节，一个汉字占两个字节，英文符号占一个字节，中文符号占两个字节 UFT-16:一个英文字母或汉字都占两个字节 UTF-32:任何一个字符都占4个字节读取文件
Read()
//一次读取一个字符，读取点自动后移//创建StreamReader对象StreamReader stream = new StreamReader("D:\\database\\file4.txt",Encoding.ASCII);int num = stream.Read();while (num != -1) {Console.WriteLine(Convert.ToChar(num));num = stream.Read();} stream.Close(); //关闭文件Console.ReadKey();ReadLine()
//从文本流中读取一行//创建StreamReader对象StreamReader stream = new StreamReader("D:\\database\\file5.txt",Encoding.UTF8);string str;do{str = stream.ReadLine();Console.WriteLine(str);} while (str!= null);stream.Close(); //关闭文件Console.ReadKey();
ReadToEnd()
//从文本流当前位置到文件末尾一次性读取至字符串变量中//创建StreamReader对象StreamReader stream = new StreamReader("D:\\database\\file5.txt",Encoding.UTF8);string str = stream.ReadToEnd();Console.WriteLine(str);stream.Close(); //关闭文件Console.ReadKey();写入文件
StreamWriter实例化 构造函数重载 1.Public StreamWriter(string path) 2.Public StreamWriter(Stream stream) 3.Public StreamWriter(string path,bool append) 4.Public StreamWriter(string path,bool append,Encoding encoding)append:如果设置为True,则将数据追加至文件末尾，如果设置为false则覆盖原文件Write()和WriteLine()
//不换行写入//创建StreamReader对象StreamWriter stream = new StreamWriter("D:\\database\\file5.txt",true,Encoding.ASCII);//写入单个字符char chr = 'a';stream.Write(chr);//写入字符串String str = "Welcome to China";stream.Write(str);//写入字符数组char[] chars = new char[10];for (int i = 0; i < chars.Length; i++){chars[i] = Convert.ToChar(i.ToString());}stream.Write(chars);//WriteLine()写入数据后换行String str2 = "Hello World";String str3 = "I'm a Chinese";stream.WriteLine(str2);stream.WriteLine(str3);stream.Close(); //关闭文件Console.ReadKey();使用BinaryReader和BinaryWriter类读写二进制文件
说明：BinaryReader和BinaryWriter对象不能直接只用文件，只能引用文件流。
//创建文件流对象 FileStream stream = new FileStream("D:\\database\\file5.txt"); //引用文件流对象 BinaryReader reader = new BinaryReader(stream); 或 BinaryWriter reader = new BinaryWriter(stream);BinaryWriter写入文件
方法 说明 Write(char[],int32,int32) 将字符数组部分写入当前流 Write(Byte[],int32,int32) 将字节数组写入当前流 Write(Uint32) 将无符号整数写入当前流 Write(String) 将字符串写入当前流 Write(Single) 将单精度写入当前流 Write(char[]) 将字符数组写入当前流 Write(Double) 将双精度值写入当前流 Write(Boolean) 将逻辑型写入当前流 //创建文件流对象FileStream file = new FileStream("D:\\database\\file6.txt",FileMode.Open,FileAccess.Write);//创建二进制读写对象BinaryWriter bw = new BinaryWriter(file);//写入文件String str = "Hello Wrold";bw.Write(str);file.Close(); //关闭文件BinaryReader读取文件
方法 说明 PeekChar 返回下一个可用的字符，并不改变光标位置 Read 读取字符，光标后移 ReadBoolean 读取Boolean类型值，光标后移 ReadByte 读取下一个字节，光标后移 ReadBytes 读取固定长度的字节，光标后移 ReadChar 读取下一个字符，光标后移 ReadChars 读取固定长度的字符，光标后移 ReadInt32 读取整型数据，光标后移 ReadString 读取字符串 //创建文件流对象FileStream file = new FileStream("D:\\database\\file6.txt",FileMode.Open,FileAccess.Read);//创建二进制读写对象BinaryReader bw = new BinaryReader(file);//读取文件char[] chr = bw.ReadChars(11);foreach (char item in chr){Console.WriteLine(item);}file.Close(); //关闭文件Console.ReadKey();
C#图形操作
绘图的基本步骤
- 创建Graphics对象
- 创建绘图工具，创建画笔或画刷，定义画笔颜色，线条等
- 使用Graphics类画，点，线，矩形，圆等方法绘图
- 清空Graphics对象
- 释放资源
Graphics类
功能：Graphics时GDI+的核心，绘图之前必须在指定的窗体上创建一个Graphics对象，才能调用其类的方法绘制图形。
创建Graphics对象
Paint事件
private void Form1_Paint(object sender, PaintEventArgs e){//创建Graphics对象Graphics g = e.Graphics;}CreateGraphics()方法
private void Form1_Load(object sender, EventArgs e){Graphics g = this.CreateGraphics(); }Graphics.FromImage()
private void Form1_Load(object sender, EventArgs e) {Bitmap mbit = new Bitmap(@"D:\我的文档\Pictures\Camera Roll\图片1.jpg");Graphics g = Graphics.FromImage(mbit);}Graphics类常用方法
方法 功能 Clear 清楚整个会画面并指定背景色的填充 Dispose 释放绘图工具资源 DrawArc 绘制一段弧线 DrawBezier 绘制有四个点定义的贝塞尔样本 DrawBeziers 从一点结构的数组绘制一系统的贝塞尔样本 DrawCurve 绘制一组指定点结构的技术样条 DrawEllipse 绘制椭圆 DrawImage 按原始大小绘制指定的image对象 DrawLine 绘制线条 Drawlines 绘制连接的多组线条 DrawPath 绘制Graphics路径对象 GrawPie 绘制扇形 DrawPolygon 绘制多边形 DrawRectangle 绘制矩形 DrawRectangles 绘制多个矩形 DrawString 绘制指定文本字符串 FillEllipse 填充椭圆 FillPath 填充Graphics路径对象内部 FillPie 填充扇形 FillPolygon 填充多边形 FillRectangle 填充矩形内部 FillRectangles 填充多个矩形内部 FromImage 从指定image对象创建新Graphids对象 Save 保存当前状态 private void button1_Click(object sender, EventArgs e){//1.创建Graphics对象Graphics g = this.CreateGraphics();//2.创建绘图工具Pen mypen = new Pen(Color.Red,20);//3.画线//定义起点Point p1 = new Point(100,100);//定义终点Point p2 = new Point(100,500);//绘制g.DrawLine(mypen,p1,p2);//4.释放资源g.Dispose();}笔（Pen）
//构造函数 public Pen(Color color,float width) //颜色表示方式//标准色卡：Black、Red、Green...//FormArgb颜色表示方式Color.FromArgb(Int32)Color.FromArgb(Int32，Color)Color.FromArgb(Int32,Int32,Int32)Color.FromArgb(alpha,Int32,Int32,Int32)创建画笔工具
Pen pen = new Pen(Color.FromArgb(125,66,10),10);画刷（Brush）
功能：使用不同形式的画刷填充封闭空间
分类：
SolidBrush:定义单色画笔
//构造函数 public SolidBrush(Color color);//示例private void button1_Click(object sender, EventArgs e){//1.创建Graphics对象Graphics g = this.CreateGraphics();//2.创建画笔对象Pen mypen = new Pen(Color.FromArgb(128,64,13),3);//绘制矩形---画笔g.DrawRectangle(mypen, 30,30,100,100);//x坐标，y坐标，宽度，高度//创建画刷对象SolidBrush solid=new SolidBrush(Color.Green);//填充矩形---画刷g.FillRectangle(solid,31,31,99,99);//4.释放资源g.Dispose();}HatchBrush:提供一种特定样式的图形
//构造函数 public HatchBrush(HatchStyle hatchstyle,Color foreColer)//hatchstyle:表示绘制图案，c#内置了56中图案// BackwardDiagonal:从右上到左下对角线的线条图案// Cross:由水平线和垂直线组成的方格图案// DarkDownwardDiagonal:从顶点到底点向右倾斜的对角线图案//示例private void button2_Click(object sender, EventArgs e){//1.创建Graphics对象Graphics g = this.CreateGraphics();//2.创建画笔对象Pen mypen = new Pen(Color.FromArgb(128, 64, 13), 3);//绘制矩形---画笔g.DrawRectangle(mypen, 230, 30, 100, 100);//x坐标，y坐标，宽度，高度//创建画刷对象HatchBrush hatch=new HatchBrush(HatchStyle.DottedGrid, Color.Green);//填充矩形---画刷g.FillRectangle(hatch, 231, 31, 99, 99);//4.释放资源g.Dispose();}LineraGradientBrush类：提供一种渐变色彩的特效
//构造函数 public LineraGradientBrush(Point point1,Point point2,Color color1,Color color2)//point1:表示线性渐变的开始点，由一对数值表示坐标//point2:表示线性渐变结束点，由一对数值表示坐标//color1:渐变开始颜色//color2:渐变结束颜色//示例private void button3_Click(object sender, EventArgs e){//1.创建Graphics对象Graphics g = this.CreateGraphics();//2.创建画笔对象Pen mypen = new Pen(Color.FromArgb(128, 64, 13), 3);//绘制矩形---画笔g.DrawRectangle(mypen, 430, 30, 100, 100);//x坐标，y坐标，宽度，高度//创建画刷对象//创建渐变关键点Point ponit1=new Point(50,100);Point ponit2 = new Point(200, 150);LinearGradientBrush lin = new LinearGradientBrush(ponit1,ponit2,Color.Red,Color.Green);//填充矩形---画刷g.FillRectangle(lin, 431, 31, 99, 99);//4.释放资源g.Dispose(); }
绘制图形
public void DrawLine(Pen pen,Point p1,Point p2) //p1、p2:定义直线的起点和终点public void DrawLine(Pen pen,int x1,int y1,int x2,int y2)//x1、y1:表示起点坐标//x2、y2:表示重点的坐标//示例private void button1_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red,10);//定义直线关键点Point p1 = new Point(10, 50);Point p2 = new Point(10, 150);//绘制直线g.DrawLine(pen, p1, p2);//释放资源g.Dispose(); }2. 绘制矩形
//方法 public void DrawRectangle(Pen pen,int x,int y,int width,int height) //x，y:矩形左上角的坐标 //width：矩形宽度 //height:矩形的高度//示例 private void button2_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//绘制矩形g.DrawRectangle(pen, 50, 50, 100, 100);//释放资源g.Dispose();}
绘制椭圆
//方法 public void DrawEllipse(Pen pen,int x,int y,int width,int height) //x，y:椭圆左上角的坐标 //width：椭圆宽度 //height:椭圆的高度 //C#中没有绘制标准圆的方法，如果要绘制标准圆，需将宽高比设置为1：1即可//示例private void button4_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//绘制椭圆g.DrawEllipse(pen, 450, 50, 150, 100);//释放资源g.Dispose(); }绘制圆弧
//方法 public void DrawArc(Pen pen,Rectangle rect,float stratAngle,float sweepAngle) //rect:定义的一个矩形，定义了圆弧的边界。 //stratAngle:以x轴到弧线起始点沿顺时针方向度量的角，该角以度为单位 //sweepAngle:从stratAngle参数到弧线的结束点沿顺时针方向度量的角度//示例private void button5_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics(); //创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建矩形对象Rectangle rect= new Rectangle(10,200,100,100);//绘制圆弧g.DrawArc(pen,rect,0,-180);//释放资源g.Dispose(); }绘制扇形
//方法 public void DrawPie(Pen pen,Rectangle rect,float stratAngle,float sweepAngle)//rect:定义的一个矩形，定义了圆弧的边界。 //stratAngle:以x轴到弧线起始点沿顺时针方向度量的角，该角以度为单位 //sweepAngle:从stratAngle参数到弧线的结束点沿顺时针方向度量的角度//示例 private void button6_Click(object sender, EventArgs e) {//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建矩形对象Rectangle rect = new Rectangle(150, 200, 100, 100);//绘制圆弧g.DrawPie(pen, rect, 0, -90); //释放资源g.Dispose();}//方法public void DrawPolygon(Pen pen,Point[] points)//points:Point结构数组，表示多边形的顶点。//示例private void button7_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建Point集合Point p1 = new Point(340,200);Point p2 = new Point(320, 240);Point p3 = new Point(285, 240);Point p4 = new Point(315, 265);Point p5 = new Point(295, 300);Point p6 = new Point(340, 280);Point p7 = new Point(385, 300);Point p8 = new Point(365, 265);Point p9 = new Point(395, 240);Point p10 = new Point(360, 240);Point[] points = { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 };//绘制圆弧g.DrawPolygon(pen, points);//释放资源g.Dispose();}
字体和图形处理
绘制文本
//字体对象构造函数public Font(FontFamily family,float emSize,Fontstyle style)//绘制字体方法 public void DrawString(string s,Font font,Brush brush,float x.float y)//示例private void button1_Click(object sender, EventArgs e){//创建绘图对象Graphics g = CreateGraphics();//创建字体对象Font font = new Font("仿宋体", 20, FontStyle.Bold);//创建画刷对象Brush brush = new SolidBrush(Color.Red);//书写内容string str = "这是使用绘图工具制作而成";//使用绘图工具书写文字g.DrawString(str, font, brush, 100, 250);//释放资源g.Dispose();}绘制图像
//方法 public void DrawImage(Image image,int x,int y) public void DrawImage(Image image,int x,int y,int width,int height)//image:图片文件，包含图片路径//示例 private void button2_Click(object sender, EventArgs e) {//创建绘图对象Graphics g = CreateGraphics();//读取图片Image image = Image.FromFile("D:\\我的文档\\Pictures\\Camera Roll\\图片1.jpg");//绘制图像g.DrawImage(image,100,25,200,200);//释放资源g.Dispose(); }
数据库应用(MySQL)
数据库连接字符串常用参数
参数 说明 Provider 这个属性用于设置或返回连接提供程序的名称，仅用于OleDbConnection对象 Connection Timeout 在中止尝试并产生异常之前，等待服务器的连接时长，默认为15秒 Database 数据库名称 Server 连接打开时使用的sql server名称 password 密码 user 账户 Integrated Security 连接是否安全 C#连接MySql步骤
- 引用工具包(Mysql.Data.ddl)
- 添加代码：using Mysql.Data.Mysqlclient
- 创建Connection连接字符串
Connection对象
//创建Connection对象 SqlConnection conn = new SqlConnection(ConnString)//打开数据库连接 conn.Open();//关闭数据库连接 conn.Close();//示例//引入工具包using MySql.Data.MySqlClient;//定义连接字符串string str = "server=localhost;database=test;user=root;password=123456";//创建连接对象MySqlConnection conn = new MySqlConnection(str);//打开连接conn.Open();Console.WriteLine("连接成功");Console.ReadKey();conn.Close();
private void button5_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics(); //创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建矩形对象Rectangle rect= new Rectangle(10,200,100,100);//绘制圆弧g.DrawArc(pen,rect,0,-180);//释放资源g.Dispose();}
绘制扇形
//方法 public void DrawPie(Pen pen,Rectangle rect,float stratAngle,float sweepAngle)//rect:定义的一个矩形，定义了圆弧的边界。 //stratAngle:以x轴到弧线起始点沿顺时针方向度量的角，该角以度为单位 //sweepAngle:从stratAngle参数到弧线的结束点沿顺时针方向度量的角度//示例 private void button6_Click(object sender, EventArgs e) {//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建矩形对象Rectangle rect = new Rectangle(150, 200, 100, 100);//绘制圆弧g.DrawPie(pen, rect, 0, -90); //释放资源g.Dispose();}//方法public void DrawPolygon(Pen pen,Point[] points)//points:Point结构数组，表示多边形的顶点。//示例private void button7_Click(object sender, EventArgs e){//创建绘图工具对象Graphics g = CreateGraphics();//创建画笔工具Pen pen = new Pen(Color.Red, 3);//创建Point集合Point p1 = new Point(340,200);Point p2 = new Point(320, 240);Point p3 = new Point(285, 240);Point p4 = new Point(315, 265);Point p5 = new Point(295, 300);Point p6 = new Point(340, 280);Point p7 = new Point(385, 300);Point p8 = new Point(365, 265);Point p9 = new Point(395, 240);Point p10 = new Point(360, 240);Point[] points = { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 };//绘制圆弧g.DrawPolygon(pen, points);//释放资源g.Dispose();}[外链图片转存中…(img-oDsuGYa9-1751011907492)]
字体和图形处理
绘制文本
//字体对象构造函数public Font(FontFamily family,float emSize,Fontstyle style)//绘制字体方法 public void DrawString(string s,Font font,Brush brush,float x.float y)//示例private void button1_Click(object sender, EventArgs e){//创建绘图对象Graphics g = CreateGraphics();//创建字体对象Font font = new Font("仿宋体", 20, FontStyle.Bold);//创建画刷对象Brush brush = new SolidBrush(Color.Red);//书写内容string str = "这是使用绘图工具制作而成";//使用绘图工具书写文字g.DrawString(str, font, brush, 100, 250);//释放资源g.Dispose();}绘制图像
//方法 public void DrawImage(Image image,int x,int y) public void DrawImage(Image image,int x,int y,int width,int height)//image:图片文件，包含图片路径//示例 private void button2_Click(object sender, EventArgs e) {//创建绘图对象Graphics g = CreateGraphics();//读取图片Image image = Image.FromFile("D:\\我的文档\\Pictures\\Camera Roll\\图片1.jpg");//绘制图像g.DrawImage(image,100,25,200,200);//释放资源g.Dispose(); }[外链图片转存中…(img-JjW7RFRP-1751011907493)]
数据库应用(MySQL)
数据库连接字符串常用参数
参数 说明 Provider 这个属性用于设置或返回连接提供程序的名称，仅用于OleDbConnection对象 Connection Timeout 在中止尝试并产生异常之前，等待服务器的连接时长，默认为15秒 Database 数据库名称 Server 连接打开时使用的sql server名称 password 密码 user 账户 Integrated Security 连接是否安全 C#连接MySql步骤
- 引用工具包(Mysql.Data.ddl)
- 添加代码：using Mysql.Data.Mysqlclient
- 创建Connection连接字符串
Connection对象
//创建Connection对象 SqlConnection conn = new SqlConnection(ConnString)//打开数据库连接 conn.Open();//关闭数据库连接 conn.Close();//示例//引入工具包using MySql.Data.MySqlClient;//定义连接字符串string str = "server=localhost;database=test;user=root;password=123456";//创建连接对象MySqlConnection conn = new MySqlConnection(str);//打开连接conn.Open();Console.WriteLine("连接成功");Console.ReadKey();conn.Close();