安装Visual Studio。
下载地址:https://visualstudio.microsoft.com/zh-hans/
可以选择社区版本,是可以免费使用的。
下载之后配置安装。
按照自己的工作需要,勾选相应的组件和安装位置,进行安装即可。
目前C#开发的两种框架
运行于windows的.Net Framework
可以跨平台的.Net6
创建一个新项目
web、服务、控制台、库、桌面用的比较多,初学阶段使用控制台程序。
创建一个新项目
至此一个新项目创建完成
编写hello world
// 系统默认引用的命名空间
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 定义命名空间
namespace ZJF.SayHi
{
// 定义类
internal class Program
{
// Main方法是程序的唯一入口
static void Main(string[] args)
{
// 输出Hello world
Console.WriteLine("Hello C# world! ");
// 保持输入
Console.ReadLine();
}
}
}
解决方案和项目是一对多的关系,一个解决方案下面可以有至少一个或者多个项目,我的理解可能是比较大的系统,分模块开发的过程
程序集信息描述了项目的元信息。比如版权信息,版本信息,程序集名称等。
程序集信息可以从两个位置看到
1 项目文件夹下面的Properties
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 有关程序集的一般信息由以下
// 控制。更改这些特性值可修改
// 与程序集关联的信息。
[assembly: AssemblyTitle("ZJF.SayHi")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ZJF.SayHi")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 将 ComVisible 设置为 false 会使此程序集中的类型
//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
//请将此类型的 ComVisible 特性设置为 true。
[assembly: ComVisible(false)]
// 如果此项目向 COM 公开,则下列 GUID 用于类型库的 ID
[assembly: Guid("fa954032-1d23-4d86-adc3-64505c285241")]
// 程序集的版本信息由下列四个值组成:
//
// 主版本
// 次版本
// 生成号
// 修订号
//
//可以指定所有这些值,也可以使用“生成号”和“修订号”的默认值
//通过使用 "*",如下所示:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
2 鼠标右键项目名选择属性,也可以通过界面修改程序集信息
引用自己封装的模块或者是第三方的模块,也叫程序集
每个项目有且只能有一个,而且不能改名字!
每个项目必须有且只能有一个程序入口,程序入口类必须有一个Main的静态方法。
解决方案就是一系列程序模块的组合,解决方案可以统一编译,同一更新。
生成解决方案:生成exe可执行文件
重新生成解决方案:删除已经生成的可执行文件,重新生成
清除解决方案:清理掉解决方案
Debug
调试模式,可以打断点,观察程序的执行过程
Release
把已经调试好的程序发布,Release后的程序更加轻量级,编译器内部做了优化
托管代码
在.Net 平台下面写的程序, C# , java
非托管代码
编译之后,直接运行在OS中, C
CLS : 公共语言规范 ,解决不同语言之间的语法问题
CTS: 通用类型系统,解决不同开发语言之间的数据类型差异
在面向对象编程语言中,类是程序的基本单元,用类可以封装要处理的数据(字段、属性)、和具体的处理过程(方法)
一个C#程序的抽象
引入命名空间
namespace 命名空间名称
{
class 类名称
{
字段 属性
构造方法
方法
public 返回值 方法名称(参数)
{
// 方法具体代码
}
}
}
// 引入的命名空间
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 当前类所在的命名空间
namespace ZJF.SayHi
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello C# world! ");
Console.ReadLine();
}
}
}
命名空间原则
命名空间引入时间
示例代码一:引用不同命名空间中的类的使用场景
关于默认命名空间
默认的命名空间是项目名称,可以通过鼠标右键,选择属性,修改默认的命名空间,要根据实际的项目情况,规划命名空间,命名空间可以让程序更有层次感,结构更清晰。
当然,我们也可以在程序源代码直接手动修改命名空间。
项目名/program.cs 这是入口文件
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi
{
internal class Program
{
static void Main(string[] args)
{
TestClass testClass = new TestClass();
testClass.TestID = 1;
testClass.TestName = "test";
TestClass2 testClass2 = new TestClass2();
testClass2.TestID = 2;
testClass2.TestName = "test";
}
}
}
项目名/TestClass1.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi
{
class TestClass
{
public string TestName { get; set; }
public int TestID { get; set; }
}
}
项目名/TestClass2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi.Test2
{
internal class TestClass2
{
public string TestName { get; set; }
public int TestID { get; set; }
}
}
在这个示例中,TestClass1与Program具有相同的命名空间,TestClass2具有不同的命名空间,如果直接使用TestClass2会直接编译错误:
未找到类型或者命名空间,提醒使用using引入
如果需要使用TestClass2,那么需要在Program中添加命名空间的引用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
#region 处理命名空间引入错误
using ZJF.SayHi.Test2;
#endregion
namespace ZJF.SayHi
{
internal class Program
{
static void Main(string[] args)
{
TestClass testClass = new TestClass();
testClass.TestID = 1;
testClass.TestName = "test";
TestClass2 testClass2 = new TestClass2();
testClass2.TestID = 2;
testClass2.TestName = "test";
}
}
}
示例代码2:不同的命名空间中有相同名称的类,使用完全限定名
不同的命名空间中,允许有相同名称的类型,但是在其他的命名空间中引用的时候,只能使用全限定名。
全限定名=命名空间.类名
项目名/TestClass2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi.Test2
{
internal class TestClass2
{
public string TestName { get; set; }
public int TestID { get; set; }
}
}
项目名/TestClass3.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi.Test3
{
internal class TestClass2
{
public string TestName { get; set; }
public int TestID { get; set; }
public void SayHello()
{
Console.WriteLine($"{this.TestName} say hello");
}
}
}
项目名/Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZJF.SayHi.Test2;
using ZJF.SayHi.Test3;
namespace ZJF.SayHi
{
internal class Program
{
static void Main(string[] args)
{
TestClass2 testClass2 = new TestClass2();
testClass2.TestID = 2;
testClass2.TestName = "test";
TestClass2 testClass3 = new TestClass2();
testClass3.TestID = 3;
testClass3.TestName = "test";
}
}
}
同时引用两个不同的命名空间,分别是ZJF.SayHi.Test2和ZJF.SayHi.Test3,这两个命名空间中具有相同的类TestClass2。
在Program中引用之后,会出现报错:TestClass2不存在明确的引用。
解决方案(使用全限定名)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.SayHi
{
internal class Program
{
static void Main(string[] args)
{
// 修改成全限定名
ZJF.SayHi.Test2.TestClass2 testClass2 = new ZJF.SayHi.Test2.TestClass2();
testClass2.TestID = 2;
testClass2.TestName = "test";
ZJF.SayHi.Test3.TestClass2 testClass3 = new ZJF.SayHi.Test3.TestClass2();
testClass3.TestID = 3;
testClass3.TestName = "test";
}
}
}
全限定名,除能够处理这种不同命名空间相同类名情况,后面还会用于反射中!
数值型
非数值型
字符
字符串
布尔
日期
DateTime
DateTime dt = Convert.ToDateTime("2022-1-1")
数组
集合
对象
表示一个数据的存储空间,地址的别名,其实是C语言中的指针,存储变量地址的变量,只是C#弱化了指针的概念。
变量三要素
变量使用方法
变量命名规范
类、属性、方法命名
当行注释
// 注释
文档注释
namespace ZJF.DataTypeAndVar
{
internal class Program
{
///
/// 入口静态方法
///
///
static void Main(string[] args)
{
}
}
}
类名和方法名和程序上面一定要加一些注释,方便自己理解或者团队开发者理解。
示例代码,在同一个解决方案中创建一个类库,并引用该类库
右键解决方案,添加新项目。创建一个新的类库。
类库的代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
//类库中Class1类所在的命名空间是TestDLL
namespace TestDLL
{
public class Class1
{
}
}
创建成功之后在解决方案下面有两个项目,分别是类库和一个控制台项目。
在控制台项目中使用类库中的类,需要两个步骤:
1 引用类库
2 引入命名空间
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 使用类库的命名空间
using TestDLL;
namespace ZJF.DataTypeAndVar
{
internal class Program
{
///
/// 入口静态方法
///
///
static void Main(string[] args)
{
// 实例化类库中的类
Class1 class1 = new Class1();
}
}
}
static void Test1()
{
Console.WriteLine("今天天气怎么样?");
Console.Write("天气很好呀");
Console.Write("有什么计划吗?\n");
Console.WriteLine("去郊游那");
}
输出:
今天天气怎么样?
天气很好呀有什么计划吗?
去郊游那
Console.WriteLine 等价于 Console.Write + “\n”
从控制台输入的字符默认是字符串类型,可以通过字符串接收信息。
static void Test2() {
Console.WriteLine("欢迎使用信息录入系统");
Console.WriteLine("请输入姓名:");
string name = Console.ReadLine();
Console.WriteLine("请输入电话:");
string phone = Console.ReadLine();
Console.WriteLine("姓名:"+name+"电话: "+phone);
}
输出:
欢迎使用信息录入系统
请输入姓名:
zhansan
请输入电话:
1231
姓名:zhansan电话: 1231
Console.Read 和 Console.ReadLine于Write和Writeline相同
static void Test3()
{
string name = "kobe";
int age = 41;
string hobby = "打篮球";
// 直接拼接
string result1 = "姓名:" + name + "年龄:" + age + "爱好:" + hobby;
// 格式化方式
// 使用$符号格式化
string result3 = $"姓名:{name},年龄:{age},爱好:{hobby}";
Console.WriteLine(result1);
Console.WriteLine("姓名:{0},年龄:{1},爱好:{2}", name, age, hobby);
Console.WriteLine(result3);
}
最常用的是使用$符号。
int a = 1; 这是一个赋值运算符操作
static void Test4() {
// 赋值运算符
int a = 10;
int b = 20;
// +
Console.WriteLine($"a+b={a+b}");
// -
Console.WriteLine($"a-b={a - b}");
// *
Console.WriteLine($"a*b={a * b}");
// /
Console.WriteLine($"a/b={a/b}");
// % 求模
Console.WriteLine($"a%b={a%b}");
// += -= *= /= %=
Console.WriteLine($"a+=40={a+=40}");
// ++ --
Console.WriteLine($"a++={a++}");
Console.WriteLine($"a--={a--}");
Console.WriteLine($"--a={--a}");
Console.WriteLine($"++a={++a}");
}
输出结果:
a+b=30
a-b=-10
a*b=200
a/b=0
a%b=10
a+=40=50
a++=50
a–=51
–a=49
++a=50
其他的算术运算符都比较好理解
主要理解一下++ –
++ – 在变量的后面是先输出在进行加减1操作
相反,如果在变量的前面是先加减1操作,然后再进行输出
大于、小于、等于、大于等于、小于等于
比较运算符一般用于值类型,string被当作值类型使用。
自动类型转换
目标类型 > 使用的数据类型
从int转到double,自动类型转换,小范围的类型可以安全的放在大范围的类型。
举个例子:
本来一个装大象的冰箱,现在用这个冰箱装猴子,肯定是可以装下的。
强制类型转换
目标类型 < 使用的数据类型
大范围的数据类型转换成小范围的数据类型。
显示类型转换 int result =(int)a + b;
引用类型需要先转换成浮点类型,然后在转换成整数类型。
代码
自动类型转换
static void Test1() {
int a = 100;
double b = a;
Console.WriteLine($"a={a},b={b}");
}
输出:a=100,b=100
小类型的int转换成大类型的double,是自动转换过来的。
强制类型转换
static void Test2()
{
double a = 100;
int b = a;
Console.WriteLine($"a={a},b={b}");
}
直接报错:无法将类型“double”隐式转换为“int”。存在一个显式转换
static void Test2()
{
double a = 100;
int b = (int)a; // 将double类型强制转换成int类型,丢失部分精度
Console.WriteLine($"a={a},b={b}");
}
输出:a=100,b=100
理解类型的有效表示形式
如果用一个字符串表示整数类型的值:那么“100”就是整数类型的有效表示形式,“100.5”就不是整数类型的有效表示形式,而是浮点数类型的有效表示形式。
代码
字符串转换成值类型
static void Test3()
{
string a = "100";
string b = "100.5";
int c = int.Parse(a);
double d = double.Parse(b);
Console.WriteLine($"c={c},d={d}");
}
输出:c=100,d=100.5
如果将整数表达形式的字符串转换成浮点数表达形式的字符串,会直接报错
static void Test4()
{
string a = "100.5";
int b= int.Parse(a); // 输入的字符串格式不正确
Console.WriteLine(b);
}
使用两次转换解决这个问题
static void Test5()
{
string a = "100.6";
int b = (int)double.Parse(a);
Console.WriteLine(b);
}
输出100
值类型转换成字符串类型 ToString
static void Test6() {
double a = 100.8;
Console.WriteLine(a.ToString()); //100.8
}
万能转换器同样要求转换的内容是目标类型的有效表示形式
代码
static void Test7()
{
int a = Convert.ToInt32("1");
double b = Convert.ToDouble("100.89");
string c = Convert.ToString(1111);
Console.WriteLine($"a={a},b={b},c={c}");
}
使用条件选择一定要知道,逻辑运算符:
语法
if(condition){
// 条件体
}
实际应用
假如有一个网站,需要满足18岁之后才能够观看,可以使用if语句进行测试
static void Test1() {
Console.WriteLine("请输入年龄:");
int age = int.Parse(Console.ReadLine());
if (age >= 18) {
Console.WriteLine("欢迎观看");
return;
}
Console.WriteLine("您无法观看此网页");
return;
}
语法
if(condition){
// 条件体
}else{
// 条件体
}
实际应用
假如考试成绩超过80分,就合格,发奖状,否则不合格,叫家长。
static void Test2()
{
Console.WriteLine("请输入分数:");
int score = int.Parse(Console.ReadLine());
if (score >= 80)
{
Console.WriteLine("考试合格,发奖状!");
}
else {
Console.WriteLine("考试不合格,叫家长!");
}
}
对考试成绩进行等级划分,分为A,B,C,D四个等级。
static void Test3()
{
Console.WriteLine("请输入分数:");
int score = int.Parse(Console.ReadLine());
char grade;
if (score < 60)
{
grade = 'D';
}
else if (score < 70)
{
grade = 'C';
}
else if (score < 80)
{
grade = 'B';
}
else if (score < 100)
{
grade = 'A';
}
else
{
grade = ' ';
Console.WriteLine("输入不合法!");
}
Console.WriteLine($"本次考试的成绩等级为:{grade}");
}
对于运算符比较多的时候,用小括号控制优先级
优先级排队
对if…else…结构的简单写法
语法
condition ? 为真的表达式 : 为假的表达式
代码测试
static void Test5() {
int a = 1;
int b = 2;
int max = a > b ? a : b;
Console.WriteLine($"较大值:{max}");
}
switch与多重if的比较
相同点
都是用来处理多分支条件的结构
不同点
switch 语法
switch(type){
case value:{
// 语句
// break;
}
case value:{
// 语句
// break;
}
default:{
// 语句
// break;
}
}
代码
static void Test6()
{
string choice = Console.ReadLine();
switch (choice)
{
case "A":
{
Console.WriteLine("选择A");
break;
}
case "B":
{
Console.WriteLine("选择B");
break;
}
case "C":
{
Console.WriteLine("选择B");
break;
}
case "D":
{
Console.WriteLine("选择B");
break;
}
default: {
Console.WriteLine("不合法");
break;
}
}
固定循环次数使用for
代码
使用for循环计算1-100的累加和
static void Test2()
{
int sum = 0;
for (int i = 0; i <= 100; i++)
{
sum += i;
}
Console.WriteLine(sum);
}
输出为:5050
双层循环
假设有一个场景, 我们给三个人测量身高,为保证测量的准确性,我们每个人测试三次,求平均值,最终输出身高最高那个人的身高值。
static void Test3()
{
double[] avgArr = new double[3];
for (int i = 0; i < 3; i++)
{
double avg, total = 0;
for (int j = 0; j < 3; j++)
{
Console.WriteLine($"请输入第{j}个人的身高:");
double h = double.Parse(Console.ReadLine());
total += h;
}
avg = total / 3;
Console.WriteLine($"第{i}个人的平均身高:{avg}");
avgArr[i] = avg;
}
double max = 0;
foreach (var item in avgArr)
{
if (item > max)
{
max = item; }
}
Console.WriteLine($"身高最大值:{max}");
}
while 循环适用于不固定循环次数的场景。
代码
通过flag确定循环的启动和停止
while (flag) {
// 循环体
}
do…while 无论怎样至少执行一次循环,while循环条件判断失败一次都不会执行。
IndexOf,返回字符串中一个字符的索引位置,找不到返回-1
注意: 索引的初始位置是0.
static void Test4() {
string email = "[email protected]";
int a = email.IndexOf('@');
int b = email.IndexOf("qq.com");
Console.WriteLine($"@ index is {a}; qq.com index is {b}"); // @ index is 13; qq.com index is 14
}
Length,返回字符串的长度
注意:空格也是一个字符
static void Test4() {
string email = "[email protected]";
int a = email.IndexOf('@');
int b = email.IndexOf("qq.com");
Console.WriteLine($"@ index is {a}; qq.com index is {b}"); // @ index is 13; qq.com index is 14
Console.WriteLine("+++++++++++++++++++++++++++++++++++++++");
int c = email.Length;
Console.WriteLine($"email len = {c}"); // email len = 20
}
Substring 字符串截取,从一个长字符串截取一部分字符串
语法
string result = xxx.SubString(startIndex, endIndex)
代码
static void Test5() {
string email = "[email protected]";
string number = email.Substring(0, 8);
Console.WriteLine(number); // 12421341
}
static void Test5() {
string email = "[email protected]";
string number = email.Substring(0, 8);
Console.WriteLine(number);
Console.WriteLine("+++++++++++++++++");
string number1 = email.Substring(0, email.IndexOf('@')); // 12421341
Console.WriteLine(number1);
string type = email.Substring(email.IndexOf('@') + 1); // 163.com
Console.WriteLine(type);
}
使用IndexOf配合Substring可以很好的解决获取字符串。
字符串比较
注意:区分大小写
常用比较方法 ==
static void Test6()
{
string name1 = "kobe";
string name2 = "Kobe";
string name3 = "kobe";
Console.WriteLine("name1==name2 "+ (name1==name2)); // 注意这里必须加括号,因为优先级问题
Console.WriteLine("name1==name3 " + (name1 == name3));
}
输出结果:
name1name2 False
name1name3 True
使用方法比较 xxx.Equals
static void Test6()
{
string name1 = "kobe";
string name2 = "Kobe";
string name3 = "kobe";
Console.WriteLine("name1==name2 " + (name1 == name2));
Console.WriteLine("name1==name3 " + (name1 == name3));
Console.WriteLine("name1==name2 " + name1.Equals(name2)); // 这里不用加括号,因为对象.方法的优先级高
Console.WriteLine("name1==name3 " + name1.Equals(name3));
}
这里的输出结果和刚刚的输出结果一样的。
ToLower 转换成小写
对于有些忽略大小写的场景比较,可以把两个比较的字符串统一变成大写,或者统一变成小写。
static void Test7() {
string s1 = "fsdaFFkkfdsagvgKK";
string s1ToLower = s1.ToLower();
string s1ToUpper = s1.ToUpper();
Console.WriteLine(s1ToUpper);
Console.WriteLine(s1ToLower);
}
ToUpper转换成大写
同上
Equals 比较方法
注意:== 或者 Equals方法默认只能比较”值类型“和”字符串类型“,对象类型是不能进行比较的
Trim 前后去空格
TrimStart 获取字符串前面的空格
TrimEnd 获取字符串后面的空格
LastIndexOf 匹配最后一个字符的位置
static void Test8()
{
string email = "[email protected]@163.com";
int index = email.LastIndexOf('@');
Console.WriteLine(index); // 10
}
定义空值的两种方式:
方式1
string empty = ""
方式2
string empty = string.Empty
代码
static void Test9() {
string s1 = "";
string s2 = string.Empty;
Console.WriteLine("s1==s2" + (s1 == s2)); // True
}
空对象被赋值为null
null 关键字是一个空值
null与”“是两回事、
不能使用null调用方法
未将对象引用到对象的示例
StringBuilder类
反斜杠 \ “.\\Envs\\Python”
使用但反斜杠的场景都需要转义。
@ @“.\Envs\Python”
注意:写到配置文件中不需要转义
如何使用配置文件中的配置内容
分割 Split
组合 Join
static void Test10() {
string s1 = "AA BB CC DD";
string[] arr = s1.Split(); // 默认使用空格分割
foreach (var item in arr)
{
Console.WriteLine(item);
}
string s2 = string.Join("-", arr);
Console.WriteLine(s2);
}
结果:
AA
BB
CC
DD
AA-BB-CC-DD
定义
数组也是一个变量,是一个具有连续空间,并且能够存储相同类型数据的空间
基本要素
操作数据的步骤
声明数组
// 语法
类型[] 数组名
int[] scores // 声明一个数组,注意,只是声明。
数组实例化
数组需要实例化,数组也是一个类型,所以需要分配空间。必须写清楚数组长度,否则不知道分配多大的空间
// 语法
// 已声明
scores = new int[5];
// 未声明
int[] scores = new int[5];
数组赋值
// 通过下标赋值:
int[0] = 10
int[1] = 11
int[2] = 12
int[3] = 14
int[4] = 16
// 声明+实例化+元素赋值放在一行中,适用于数组元素已经确定的场景
方式1:
int[] scores = new int[3]{1,2,3}
方式2:
int[] scores = new int[]{1,2,3,4,5}
方式3:
int[] scores = {1,2,3,4,5}
for 循环
语法
for (int i =0; i < arr.Length; i++){
arr[i] // 对元素操作
}
实际代码,对数组中的每个元素加1,随后在输出
foreach循环
不关注索引,使用foreach
语法
foreach(int item in arr){
item // 就是每一个元素类型
}
实际代码
值类型
基本数据类型再传递变量值时,传递的是变量的副本,开辟新的空间。
引用类型
引用类型变量传递自己,也就是变量本身,没有开辟新空间
常用的引用数据类型:
String是.Net Framework的类
string是C#的关键字,也是String类的别名,表示一种数据类型,映射为.Net中的String
使用string时编译器会把它编译成String
string关键字,不能作为类、结构、枚举、字段、变量、方法、属性的名字,而String不是关键字,可以使用
一个值不希望被别人修改的时候,可以使用常量
常量名建议全部大写
常量必须在定义的同时初始化,不能先定义后初始化
语法
const double PI = 3.14
实际测试:
static void Test11() {
const double PI = 3.14;
PI = 3.141; // 报错
Console.WriteLine(PI);
}
基本概念
作用:可以用来定义”有限个变量值“,方便选择使用,避免出错
特点:可以变送一组描述性的名称,还可以有对应的整数值
语法
// 定义
public enum Gender{
Mela = 1, //整数值可以有也可以没有。
Female = 0
}
// 使用
Gender gender = Gender.Male
gender = "m" // 非法赋值,必须是枚举中的一个元素。
实际应用
internal class Program
{
static void Main(string[] args)
{
Test1();
Console.Read();
}
static void Test1() {
Gender gender = Gender.Femela;
Console.WriteLine(gender);
Console.WriteLine((int)gender);
gender = Gender.Mela;
Console.WriteLine(gender);
}
}
public enum Gender{
Mela = 1,
Femela = 0
}
public enum Week {
Sun,
Sat,
Fri,
Sur,
Wed,
Thu,
Mon
}
}
输出结果:
Femela
0
Mela
编程大概有两种方式,分别是面向过程和面向对象。
面向过程可以实现所有的需求,但是面向过程的程序缺少模块化。
面向对象有两个比较重要的概念,分别是类和对象,类也是一种数据类型,描述了一类对象中的所有属性和方法。类主要是抽象能力。
对象:
类中的内容
定义类的语法
定义类 类名使用Pascal命名法:首字母必须大写.属性和方法一般首字母大写,字段首字母小写
访问修饰符 关键字 类名
public class Person
{
// 字段
// 属性
// 方法
}
创建对象
// 类型 变量名 = 关键字 类名() 构造函数
Person person = new Person();
获取属性
person.Attr
设置属性
person.Attr = "xxxx"
调用方法
person.Method()
类的访问修饰符
程序集的概念
一个类库,或者一个exe可执行文件,叫做一个程序集
public
public允许类被程序集外部访问
internal
internal不允许被程序集外部访问
小tips
成员变量(字段)和局部变量
成员变量(字段)
成员变量设置在类内方法外,成员变量一般用于类内部使用,一般设置访问优先级为private,不建议设置public的成员变量
局部变量
局部变量在类中的方法内
代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class Person
{
private string _desc = string.Empty; // 成员变量(字段)
public int PId { get; set; }
public string Job { get; set; }
public string Name { get; set; }
public void ShowInfo() {
int name = "Any"; // 局部变量
Console.WriteLine($"PId={PId},Job={Job},Name={name}");
}
}
}
创建类,并实例化
创建类
在项目中创建一个People类。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class People
{
public int PId { get; set; }
public string Name { get; set; }
public string Description { get; set; }
public void ShowInfo()
{
Console.WriteLine($"PId={PId},Name={Name},Desc={Description}");
}
}
}
实例化类
在Program类中访问Person类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
public class Program
{
static void Main(string[] args)
{
Test1();
Console.Read();
}
static void Test1() {
People people= new People();
people.PId = 1;
people.Name = "Test";
people.Description = "Description";
people.ShowInfo();
}
}
}
输出为:PId=1,Name=Test,Desc=Description
使用ildasm 查看C#的字节码
ildasm是一个反编译工具,通过这个工具可以把C#的源代码反编译成C#的中间语言(其实就是C#)的字节码。使用C#虚拟机运行的字节码。
所在位置:C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8 Tools
ildasm软件的空白图
查看源代码的文件夹:
将debug文件夹中的可执行文件exe拖入到IL DASM中:
点击任何一个组件可以看到里面的字节码:
自动为每个属性定义了一个成员变量,也可以手动设置成员变量用于保存属性的值
属性只是一个接口,真正保存数据的是字段
手动定义字段来保存属性的值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class People
{
private int _pid = 0; // 定义成员变量并赋初始值为0
public int PId {
get {
return _pid; // 属性的get方法返回成员变量的值
}
set {
_pid= value; // 属性的set方法设置成员变量的值
}
}
public string Name { get; set; }
public string Description { get; set; }
public void ShowInfo()
{
Console.WriteLine($"PId={PId},Name={Name},Desc={Description}");
}
}
}
查看手动设置成员变量反编译的结果
注意:编译器没有为PId属性创建新的k__BackingField字段,而是使用了手动的 _pid成员变量。
自动属性与手动设置成员变量与属性关联具有相同的效果
public int PId {get; set;}
//等价于
private int _pid = 0;
public int PId {
get {
return _pid;
}
set {
_pid = value // 这里的value是编译器确定的
}
}
// 当调用obj.PId 时 返回 _pid 成员变量的值
// 当调用obj.PId = xxx 给属性赋值时,将xxx赋值给_pid
在C# 3.0版本开始使用自动属性,在之前的版本都是通过手动与成员变量做关联。
在使用断点调试时,当给属性赋值时,调用了set方法,给对应的成员变量赋值,当读取属性值时,调用了get方法,从对应的成员变量获取值。
属性本身并没有保存任何数据,数据是保存到属性对应的私有成员变量中。
属性的作用是访问对象数据的入口。
成员变量(字段)
字段是为类的内部方法、或者方法之间传递数据使用,强调对内使用
访问修饰符:一般成员变量都是用private修饰,基本不用public
读写:字段读写均可,也可以用readonly限制为只读,但是不能添加业务逻辑,比如一个人的身高,用户输入超过3米,显然是不合理的,这种使用字段就很难限制。
代码
可以直接获取成员变量和设置成员变量的值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class People
{
//public readonly int _age;
public int _age;
}
}
static void Test2() {
People people = new People();
people._age = 11; // 直接设置成员变量的值
Console.WriteLine(people._age); // 获取成员变量的值
}
可以或者只读属性的值,但是不能设置只读属性的值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class People
{
public readonly int _age;
//public int _age;
}
}
static void Test2() {
People people = new People();
people._age = 11; // 无法分配到只读字段 直接编译无法通过
Console.WriteLine(people._age);
}
属性
属性是对外提供数据访问、本身不保存数据,强调对外使用,对外部的接口
修饰符:属性都是用public修饰、从来不用private
读写:属性可以轻松的实现单独读写控制,并且可以添加任意需要的逻辑
对于一些场景,必须使用属性,比如dgv列表必须强制使用属性
代码
为属性添加业务逻辑,比如人类,年龄这个属性,不允许超过100岁,超过100直接设置成100
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;
namespace OopProperty
{
internal class People
{
private int _age;
public int Age
{
get
{
return _age;
}
set
{
if (value > 100)
{
_age = 100;
}
else
{
_age = value;
}
}
}
}
}
static void Test3()
{
People people = new People();
people.Age = 101;
Console.WriteLine(people.Age);
People people1 = new People();
people1.Age = 11;
Console.WriteLine(people1.Age);
}
同样可以设置只读属性,把set删除即可
属性直接初始化
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;
namespace OopProperty
{
internal class People
{
public string Name { get; set; } = "张三";
}
}
static void Test4() {
People people = new People();
Console.WriteLine(people.Name); // 张三
people.Name = "里斯";
Console.WriteLine(people.Name); // 里斯
}
属性表达式,设置只读属性的三种不同方式
直接使用箭头函数
public class People{
public int Age {get=>100;}
}
变种方式2
public class People{
public int Age =>100;}
}
变种方式3
public class People{
public int Age {get;} = "111"
}
一个类的属性可以是另一个类
比如一个汽车类,有一台发动机,发动机也是一种类。
定义发动机类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class Turbo
{
public float Volumn { get; set; }
public string Type { get; set; }
}
}
定义汽车类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopProperty
{
internal class Car
{
public string Brand { get; set; }
public Turbo CarTurbo { get; set; }
public void ShowInfo() {
Console.WriteLine($"汽车品牌:{Brand},发动机型号:{CarTurbo.Type},发动机排量:{CarTurbo.Volumn}L" );
}
}
}
调用方代码
static void Test5() {
Turbo ea888 = new Turbo();
ea888.Type = "EA888";
ea888.Volumn = 2.0f;
Car audiA6 = new Car();
audiA6.Brand = "audi";
audiA6.CarTurbo = ea888;
audiA6.ShowInfo();
}
输出:汽车品牌:audi,发动机型号:EA888,发动机排量:2L
测试访问修饰符,类的默认访问修饰符为internal
在解决方案中创建一个新的类库
在解决方案中有一个控制台的项目有一个类库的项目,类库的项目和控制台项目分别属于两个不同的程序集
在类库项目中随便创建一个类,定义为internal类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ClassLibrary1
{
internal class Class1
{
public int MyProperty { get; set; }
}
}
在控制台项目中引入类库,引用命名空间,使用类
static void Test6() {
Class1 c1 = new Class1(); // Class1不可访问,一位内它具有一定的保护级别
}
在控制台项目中使用类库中的public类
namespace ClassLibrary1
{
public class Class1
{
public int MyProperty { get; set; }
}
}
修改访问修饰符之后,就不再报错了。
定义
构造方法是在对象创建的时候,调用的方法,通过构造方法对实例进行初始化。
Object obj = new Object()
// 大家都知道,通过new关键字,创建一个类的实例,也叫类的实例化
// new关键字其实就是在堆中开辟了一块内存
// Object()就是调用类的构造方法,在构造方法中,可以对实例进行初始化
类实例化的过程可以分割成两步,第一步是开辟内存,第二步是初始化
一个类中,在我们没有添加任何构造方法的时候,编译器会生成一个无参数的构造方法。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Person
{
}
}
通过IL DSAM反编译工具,查看反编译后的结果,一个空白类中会默认有一个无参数无返回值的构造方法,当然了,所有的构造方法都不能有返回值。
创建构造方法
语法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Person
{
public Person()
{
Console.WriteLine("无参数构造方法");
}
}
}
在另外的一个类中,实例化这个类:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Program
{
static void Main(string[] args)
{
Test1();
Console.Read();
}
static void Test1() {
Person person = new Person();
}
}
}
打印:无参数构造方法
这就说明,在实例化的过程中,执行了构造方法。
构造方法可以重载
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Person
{
public Person() {
Console.WriteLine("无参数构造方法");
}
public string Name { get; set; } = string.Empty;
public int Age { get; set; } = 0;
public Person(string name) {
Console.WriteLine("有一个name参数的构造方法");
Name = name;
}
public Person(string name,int age) : this(name)
{
Console.WriteLine("有两个参数的构造方法");
Age = age;
}
}
}
构造方法可以进行嵌套
public Person(string name,int age) : this(name)
{
Console.WriteLine("有两个参数的构造方法");
Age = age;
}
// 构造方法:this() 会根据this中参数的不同,调用其他的不同的构造方法
赋值的成员变量
显示声明的属性
构造方法
代码:
注意:下面代码注释中标注的数字代码初始化的顺序
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Person
{
private int _id = 1000; // #1
public Person()
{
Console.WriteLine("无参数构造方法");
}
public string Name { get; set; } = string.Empty; // #2
public int Age { get; set; } = 0; // #3
public Person(string name)
{
Console.WriteLine("有一个name参数的构造方法");
Name = name;
}
public Person(string name, int age) : this(name) // #4
{
Console.WriteLine("有两个参数的构造方法");
Age = age;
}
}
}
成员变量必须先初始化,否则属性就无法初始化,因为属性的数据存储在成员变量中,不管是自动属性还是手动设置的属性。
一个构造方法调用其他的构造方法
如果一个类中,有三个构造方法:
分别是:
无参构造方法
有一个参数的构造方法,对应Name属性
有两个参数的构造方法,对应Name属性和Age属性
public class Person{
public string Name{get;set;}
public int Age {get; set;}
public Person(){
}
public Person(string name){
Name = name;
}
public Person(string name, int age){
Name = name; // 这行其实就是一个参数的构造函数
Age = age;
}
// 这种情况下会出现很多重复的代码
// 对于这种情况可以使用以下情况进行简化:
public Person(string name, int age):this(name){
Age = age;
}
}
在类中通过this访问属性、字段、方法
this 指代的其实就是当前类的一个实例对象,通过this关键字,可以获取成员变量、属性和方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Student
{
public int Id { get; set; }
public string Name { get; set; }
private string _hobby;
public string Hobby
{
get
{
return this._hobby;
}
set
{
this._hobby = value;
}
}
public Student() { }
public Student(int id, string name, string hobby) {
this.Id= id; // this.Id 调用的是属性
this.Name = name;
this.Hobby = hobby;
}
public void Method1()
{
this.Method2();
}
public void Method2()
{
Console.WriteLine($"{this.Id},{this.Name},{this.Hobby}");
}
}
}
对象初始化器是显示的给对象进行初始化,对象初始化器与对象内部的构造方法需要配合使用,而不是相互替代的关系。
语法
Person person = new Person(){
Id = 1000, // 注意。这里是逗号
Name = "稀罕"
}; // 注意,这里的;一定要加
实际使用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Car
{
public Car() { }
public Car(string type)
{
Type = type;
}
public string Type { get; set; }
public string Year { get; set; }
public void ShowInfo()
{
Console.WriteLine($"{this.Type}:{this.Year}");
}
}
}
调用方代码:
static void Test3() {
Car car = new Car("audi") {
Type ="bmw", // 对象初始化器覆盖了构造函数初始化的属性值
Year = "2020"
};
car.ShowInfo(); // bmw:2020
}
语法
方法名使用Pascal命名法,必须首字母大写
访问修饰符 返回值类型 方法名(参数列表){
// 方法体
}
代码
无参数,没有返回值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Car
{
public Car() { }
public Car(string type)
{
Type = type;
}
public string Type { get; set; }
public string Year { get; set; }
public void ShowInfo()
{
Console.WriteLine($"{this.Type}:{this.Year}");
}
}
}
无参数,有返回值
public string OutInfo() {
string info = $"{Type}:{Year}";
return info;
}
使用调用方进行调用:
static void Test4()
{
Car car = new Car("audi");
car.Year = "1111";
string info = car.OutInfo();
Console.WriteLine(info);
}
有参数,没有返回值
public void HasParamNoRet(int start)
{
start += 100;
Console.WriteLine($"{start}");
}
调用
有参数,有返回值
public int HasParamHasRet(int start)
{
return start += 100;
}
调用
static void Test5() {
Car car = new Car("奔驰");
car.Year = "1141";
car.HasParamNoRet(11);
int result = car.HasParamHasRet(11);
Console.WriteLine("result="+result);
}
返回数组
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OopMethod
{
internal class Tyre
{
public Tyre() { }
public Tyre(int addr) {
Addr = addr;
}
public int Addr { get; set; }
}
}
public Tyre[] TyreArray() {
Tyre t1 = new Tyre(1);
Tyre t2 = new Tyre(2);
Tyre t3 = new Tyre(3);
Tyre t4 = new Tyre(4);
Tyre[] Tyres = new Tyre[4];
Tyres[0] = t1;
Tyres[1] = t2;
Tyres[2] = t3;
Tyres[3] = t4;
return Tyres;
}
}
返回对象
public Engine GetEngine() {
Engine engine= new Engine("ea888");
return engine;
}
调用方代码
static void Test6() {
Car car = new Car("沃尔沃");
Tyre[] results = car.TyreArray();
foreach (var item in results)
{
Console.WriteLine($"轮胎位置:{item.Addr}");
}
Console.WriteLine("____________________________________");
Engine e = car.GetEngine();
Console.WriteLine(e.Name);
}
输出:
轮胎位置:1
轮胎位置:2
轮胎位置:3
轮胎位置:4
ea888
定义
实例方法是通过对象.实例方法进行调用的
静态方法是通过类名.静态方法进行调用的
静态方法的特点是不需要构建对象就可以直接使用。
静态方法跟随类一起加载,被加载在栈空间,并且不会被垃圾回收,直到程序退出执行。
静态方法中不能访问实例字段、方法、属性。只能访问静态字段、属性。
当一个方法的参数不固定时,用params关键字实现可变参数
语法
修饰符 返回类型 方法名(params 类型[] 变量名){
// 方法体
}
使用不确定参数的注意点:
测试代码
public void ShowInfo2(int a, string[] info) {
foreach (var item in info)
{
Console.WriteLine(item);
}
}
调用方:
static void Test7() {
Car car = new Car("夏利");
car.Year = "1990";
car.ShowInfo2(1,new string[] { "11", "12", "13" });
}
使用params关键字:
public void ShowInfo3(int a, params string[] info)
{
foreach (var item in info)
{
Console.WriteLine(item);
}
}
调用方:
static void Test7() {
Car car = new Car("夏利");
car.Year = "1990";
car.ShowInfo3(1,"11", "12", "13" );
}
.Net虚拟机自带垃圾回收机制,不需要程序员操作。
泛型(generic)是编程语言的一种风格,要求程序员明确特定的类型在进行初始化工作。
数组和集合类型比较相似,集合比数组更加灵活,可以动态的扩展。
语法
//List
List nameArr = new List(); // 创建一个实例
常用操作
static void Test8()
{
// 实例化一个集合对象
List nameList = new List();
// 增加元素
nameList.Add("张三");
nameList.Add("李四");
// 获取元素的个数
Console.WriteLine("当前List的长度是:" + nameList.Count);
// 集合的初始化器
List player = new List() { "kebi", "james", "curry" };
// 集合转换成数据
string[] res = player.ToArray();
// 将数组放到这个结构中
player.AddRange(new string[] { "haga发生", "fasfa范德萨" });
// 集合添加数组
string[] names = { "柯布", "柯南" };
// 删除其中一个
player.Remove("haga发生");
player.AddRange(names);
// 按照索引删除
player.RemoveAt(1);
// 在指定位置插入元素
player.Insert(1, "张三"); // 在索引1的位置,也就是第二个元素,插入张三
// 判断一个元素是否在这个集合内
bool isExists = player.Contains("张三");
// 清除所有:
player.Clear();
}
集合初始化器
static void Test9() {
List names = new List() {
"张三",
"李四",
"王五",
"马六"
};
foreach (var item in names) {
Console.WriteLine($"{item}");
}
}
输出:
“张三”,
“李四”,
“王五”,
“马六”
集合复制
static void Test9()
{
List names = new List() {
"张三",
"李四",
"王五",
"马六"
};
List newNames = new List(names);
foreach (var item in names)
{
Console.WriteLine($"{item}");
}
foreach (var item in newNames)
{
Console.WriteLine($"new-{item}");
}
}
输出:
张三
李四
王五
马六
new-张三
new-李四
new-王五
new-马六
语法
Dictinary infos = new Dictinary();
一般k都是字符串类型的
v可以是对象,也可以是别的类型
Dictinary的结构:
k1:v1
k2:v2
k3:v3
字典初始化器
static void Test10() {
Dictionary infos = new Dictionary() {
["张三"] = "喜欢读书",
["李四"] = "喜欢唱歌"
};
foreach (var item in infos.Keys) {
Console.WriteLine($"keys:{item}");
}
foreach (var item in infos.Values) {
Console.WriteLine($"values:{item}");
}
}
输出:
keys:张三
keys:李四
values:喜欢读书
values:喜欢唱歌
字典的常用方法与集合的常用方法是相同的
概念
类与类之间的继承,主要是继承属性和方法,比如生活中的祖辈与父辈之间的继承。
继承必须具有单根性,一个类只能有一个父类,不能同时继承多个类,也不能循环继承和反向继承
代码测试1
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._01_继承
{
internal class Person
{
public Person() { }
public string name { get; set; }
public int age { get; set; }
public string gender { get; set; }
public void doEat() {
Console.WriteLine("吃饭ing...");
}
}
}
Student.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._01_继承
{
internal class Student:Person
{
public Student() { }
public string School { get; set; }
public void study() {
Console.WriteLine($"{this.name} is study in {this.School}");
}
}
}
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZJF.advance._01_继承;
namespace ZJF.advance
{
internal class Program
{
static void Main(string[] args)
{
Test1();
Console.ReadLine();
}
static void Test1() {
Student s1 = new Student();
s1.name = "张三";
s1.age = 1;
s1.gender = "男";
s1.School = "希望学校";
s1.study();
}
}
}
这套代码的执行流程如下:
1. 先执行Student的无参构造,然后执行Person的无参构造
测试代码2
有参构造方法:
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._01_继承
{
internal class Person
{
public Person() { }
public Person(string name) {
this.name = name;
}
public Person(string name, int age):this(name) {
this.age = age;
}
public Person(string name, int age, string gender):this(name,age)
{
this.gender = gender;
}
public string name { get; set; }
public int age { get; set; }
public string gender { get; set; }
public void doEat() {
Console.WriteLine("吃饭ing...");
}
}
}
Student.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._01_继承
{
internal class Student:Person
{
public Student() { }
public Student(string name, int age, string gender, string school) : base(name, age, gender) {
this.School = school;
}
public Student(string school)
{
this.School = school;
}
public string School { get; set; }
public void study() {
Console.WriteLine($"{this.name} is study in {this.School}");
}
}
}
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZJF.advance._01_继承;
namespace ZJF.advance
{
internal class Program
{
static void Main(string[] args)
{
Test1();
Console.ReadLine();
}
static void Test1() {
Student s1 = new Student("李四",2,"nv","清华大学");
s1.study();
}
}
}
代码执行顺序:
1. Student s1 = new Student("李四",2,"nv","清华大学");
2.
3.
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AMczgdu1-1684052960420)(D:\markdown\C#系列\CSharp高级进阶.assets\image-20230429210033497.png)]
【1】子类构造方法没明确调角父类的哪个构造方法时,默认调用父类的无参数构造方法。(前提:父类必须要有无参数的构造方法)
【2】父类没有无参数的构造方法,子类构造方法,必须显式的说明调用父类的哪个有参数的构造方法。
【3】注意:调用父类的构造方法,请使用base关键字。
this关键字
this关键字表示当前类的实例,在构造方法中用于指向当前类的实例
用法1:在构造方法中
用法2: 在构造方法传递中
用法三:在类内部调用内部的属性或者方法
base关键字
base关键字表示调用当前类的父类中的属性或者方法
protected关键字修饰的属性或者方法,只能在父类或者子类类内使用,不能在对象中使用
private关键字是私有对象,只能在父类中使用,子类不可见
抽象方法必须在抽象类中
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._03_kw_abstract
{
// 抽象方法必须放在抽象类中,否则会报错
public abstract class Person
{
public string name { get; set; }
public string gender { get; set; }
public Person() { }
public Person(string name, string gender)
{
this.name = name;
this.gender = gender;
}
// 声明抽象方法,抽象方法在父类中不需要写明函数体
// 抽象方法的目的是规范子类的方法名,形参、和返回值,如果不是抽象方法,子类可以重写也也可以不重写
public abstract void Play();
}
}
子类实现
子类必须重写抽象类的抽象方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._03_kw_abstract
{
public class Student:Person
{
public override void Play() {
Console.WriteLine("学生放学后开始玩耍!");
}
}
}
如果非抽象子类不重写抽象方法会报错:
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._03_kw_abstract
{
public class Student:Person
{
//public override void Play() {
// Console.WriteLine("学生放学后开始玩耍!");
//}
}
}
//错误 CS0534 “Student”不实现继承的抽象成员“Person.Play()” ZJF.advance // //D:\code\csharp_home\ZJF.advance\ZJF.advance\03_kw_abstract\Student.cs 9 活动
如果子类是抽象类可以不重写抽象方法
namespace ZJF.advance._03_kw_abstract
{
public abstract class Student:Person
{
}
}
// 如果子类也是抽象类,那么可以不实现抽象方法
注意:
抽象方法不能直接new
抽象方法必须在抽象类中
抽象类中可以没有抽象方法
同一个抽象方法,不同子类实现,由父类实例调用
引言
多态是面向对象的很重要特性,通过多态可以很好的实现面向对象编程中的开-闭原则。
开:增加类:通过增加不同的功能类实现需求的变化
闭:修改类:尽量不因为需求的变化修改类的内部
多态的基本实现原理
// 父类类型对象调用抽象方法,可以访问到不同子类的实现
public abstract class Car{
public abstract void run();
}
// 定义两个不同品牌的汽车继承自Car类
public class Audi:Car{
public override void run(){
Console.WriteLine("奥迪因为Quattro跑的很快!");
}
}
public class BMW:Car{
public override void run(){
Console.WriteLine("宝马的操控性很好!")
}
}
public class Program{
public static void main(){
Car car = new Audi();
car.run(); // 具体执行哪个run是根据等号右边的实例对象决定的
// 输出:奥迪因为Quattro跑的很快
car = new BMW();
car.run();
// 输出:宝马的操控性很好
}
}
继承多态的两种实现方式
多态的目的更多的是为了系统的扩展性。
比如一个关系数据库管理系统,可以对接不同的关系数据库,可以这样实现:
定义一个数据库抽象父类,并且定义抽象方法,实现两个子类
public abstract class Database{
public abstract void runSQL();
}
public class MysqlDB:Database{
public override void runSQL(){
Console.WriteLine("Mysql数据库执行SQL");
}
}
public class PgsqlDB:Database{
public override void runSQL(){
Console.WriteLine("PgSQL数据库执行SQL")
}
}
使用类中的方法
public class Program{
public static void main(){
}
public static Test1(){
Database db = getDB()
db.runSQL()
}
public static Database getDB(){
return MysqlDB()
}
}
如果需要扩展这个类
// 添加一个新的扩展类
public class OracleSQL:Database{
public override void runSQL(){
Console.WriteLine("Oracle数据库执行SQL")
}
}
使用类中的方法
// 不需要修改Test1这个方法
// 只需要修改getDB()方法即可
public static Database getDB(){
return OracleDB()
}
子类对象做为方法的返回值
上面数据库中的案例所示
父类对象做为方法的形式参数
public static Test1(Database db){
db.runSQL()
}
// 使用Test1
Test1(MysqlDB())
父类内部由默认实现的方法,对子类的实现没有强制性,子类可以重写也可以不重写,虚方法也可以实现多态
定义
语法
public virtual void FuncName(){
// 虚方法默认的方法体
}
虚方法和抽象方法的使用选择
如果父类需要由默认的实现,使用虚方法,如果父类不需要默认实现,使用抽象方法
子类可以实现虚方法,也可以不实现虚方法,使用父类默认的虚方法实现
Father.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._05_虚方法
{
internal class Father
{
public virtual void money() {
Console.WriteLine("爸爸有钱都是儿子的");
}
}
}
Son.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._05_虚方法
{
internal class Son:Father
{
public override void money() // 可以重写也可以不重写
{
base.money(); // 默认调用父类实现的默认方法,也可以加一些自己的实现
Console.WriteLine("儿子自己也赚了一笔钱!");
}
}
}
在子类方法中,使用new关键字,可以实现对父类“同名方法”的覆写。
接口是规范了一系列方法的集合
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._07_接口
{
public interface IPerson
{
void Eat();
void Sleep();
string Speek(string info);
}
}
接口的关键是interface,一般接口名称都是以大写字母I开头,
接口类中只能定义方法,不能实现方法,定义方法的格式如下:
返回值类型 方法名(参数类型 参数名)
接口中的方法不能写仿问修饰符
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._07_接口
{
public class PersonImpl : IPerson
{
public string Name { get; set; }
public PersonImpl() { }
public PersonImpl(string name)
{
this.Name = name;
}
public void Eat()
{
Console.WriteLine($"{this.Name} is eating......");
}
public void Sleep()
{
Console.WriteLine($"{this.Name} is Sleeping......");
}
public string Speek(string info)
{
Console.WriteLine($"{this.Name} is Speeking.....{info}.");
return "hhh";
}
}
}
接口的实现类通常命名为XxxxImpl 表示对IXxxx类的实现。
实现类必须实现接口类的所有方法,所以接口类必须遵循最小化原则,一个接口只负责特定的事情。
前面讲了通过继承抽象类实现多态,也可以通过接口实现多态。
通过继承实现多态有两种方式:
方式1:抽象类对象做为返回值
static void Test1(){
BaseObj baseobj = GetObj();
baseobj.xxx();
}
static void GetObj(){
return SonObj(); // SonObj必须是BaseObj的子类
}
方式2:抽象类对象做为函数参数
static void Test2(BaseObj obj){
obj.xxx();
}
// 调用者代码:
Test2(SunObj())
通过接口实现多态
IScreen.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._08_接口2
{
///
/// 屏幕接口类
///
public interface IScreen
{
///
/// 打开
///
void Open();
///
/// 关闭
///
void Close();
///
/// 表演节目
///
///
void Show(string info);
}
}
TVScreenImpl.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._08_接口2
{
public class TVScreenImpl : IScreen
{
public void Close()
{
Console.WriteLine("关闭电视屏幕"); ;
}
public void Open()
{
Console.WriteLine("打开电视屏幕");
}
public void Show(string info)
{
Console.WriteLine($"电视屏幕播放:{info}");
}
}
}
PadScreenImpl.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.advance._08_接口2
{
public class PadScreenImpl : IScreen
{
public void Close()
{
Console.WriteLine("Pad关闭屏幕");
}
public void Open()
{
Console.WriteLine("Pad打开屏幕");
}
public void Show(string info)
{
Console.WriteLine($"Pad查看{info}");
}
}
}
使用层:
static void Test6() {
IScreen screen = GetScreen();
screen.Open();
screen.Close();
screen.Show("体育频道");
}
static IScreen GetScreen()
{
//return new TVScreenImpl(); // 只需要返回不同的实现类即可
return new PadScreenImpl();
}
使用层:接口对象做为方法
static void Test7(IScreen obj) {
obj.Open();
obj.Close();
obj.Show("体育频道");
}
// 调用方调用Test7
Test7(new TVScreenImpl()); // 传递对象到
Test7(new PadScreenImpl());
通过使用一个“程序集”把我们要使用得类的“命名空间、类名”通过“字符串”方式,使用反射技术,从而得到这个类的对象。
创建类的对象,有两种方式:
直接创建
new XXX
反射创建
通过反射创建
基本使用
示例代码1
Car 接口
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.InterfaceReflection._1.接口反射
{
public interface ICar
{
string Name { get; set; } // 定义属性
string Description { get; set; } // 定义属性
void Run(); // 定义方法
}
}
Audi接口实现类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.InterfaceReflection._1.接口反射
{
public class AudiImpl : ICar
{
private string _name;
private string _description;
public string Name { get => this._name; set => this._name=value; }
public string Description { get => this._description; set => this._description=value; }
public Audi() { } // 无参构造方法
public Audi(string name, string des) { // 有参构造方法
this._name = name;
this._description = des;
}
public void Run()
{
Console.WriteLine($"{this.Name} is Running!!!"); // 实现Run方法
}
}
}
使用反射创建对象
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// 【1】 添加引用
using System.Reflection;
using ZJF.InterfaceReflection._1.接口反射;
namespace ZJF.InterfaceReflection
{
internal class Program
{
static void Main(string[] args)
{
// 【4】 测试
Test1();
Console.ReadLine();
}
static void Test1() {
// 【2】 使用new创建模块
Car audi = new Audi("奥迪", "good car");
audi.Run();
try {
// 【3】 使用反射创建模块
// 【3.1】Load("程序集").CreateInstance("全连接类名称")
var tag = (Car)Assembly.Load("ZJF.InterfaceReflection").CreateInstance("ZJF.InterfaceReflection._1.接口反射.Audi");
tag.Name = "奥迪111";
tag.Description = "good car !!!!!";
tag.Run();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
示例代码2
将程序集和完整类名通过配置文件提供给用户,提供很好的扩展性。
定义一下配置文件App.config
// 程序集可以是可执行文件,也可以是dll文件
定义对象工厂类ObjectFactory.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using ZJF.InterfaceReflection._1.接口反射;
namespace ZJF.InterfaceReflection._2.反射工厂类
{
public class ObjectFactory
{
// 【1】 定义程序集名称
private static string assName = ConfigurationManager.AppSettings["assName"];
public static Car GetObject() {
// 【2】 定义类名
string className = ConfigurationManager.AppSettings["className"];
// 【3】 返回程序集对象
return (Car)Assembly.Load(assName).CreateInstance(className);
}
}
}
调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using ZJF.InterfaceReflection._1.接口反射;
using ZJF.InterfaceReflection._2.反射工厂类;
namespace ZJF.InterfaceReflection
{
internal class Program
{
static void Main(string[] args)
{
//Test1();
Test2();
Console.ReadLine();
}
static void Test2() {
var obj = ObjectFactory.GetObject();
obj.Name = "奥迪汽车";
obj.Run();
}
}
}
示例代码三
通过反射来实现扩展
1、回顾前面:泛型集合List、Dictionary
所在命名空间:System.Collections.Generic;
2、泛型最大的好处:定义的时候,不明确具体的类型,谁使用,谁明确类型。让某一个方法,或者某一个类更具有通用性。
3、泛型概念:它是一种程序特性,泛化(将具体的,扩展为一般的)方法参数的类型。
4、泛型使用:泛型集合、泛型方法、泛型类、泛型委托…
5、泛型延伸:为了后面学习高级委托、多线程做准备。
泛型最大的好处就是:在定义的时候不明确类型,在使用的时候明确类型,让程序具有很好的泛化性,提高程序的通用性
List是一个容器,容器内可以存储任意类型的变量,可以是基本类型也可以是引用类型。
List的用法
先准备一个实体学生类:Student.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.GenericTech._01_回顾List和Dictionary
{
public class Student
{
// 学生ID
public int SId { get; set; }
// 姓名
public string Name { get; set; }
// 年龄
public int Age { get; set; }
public Student() { }
public Student(int sId, string name, int age)
{
SId = sId;
Name = name;
Age = age;
}
public void Info() {
Console.WriteLine($"同学:{this.Name} 今年 {this.Age}岁了!");
}
}
}
创建一个测试类TestListDict.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.GenericTech._01_回顾List和Dictionary
{
public class TestListDict
{
public void Test1() {
List nameList = new List() {
"张三",
"李四",
"王五"
};
Console.WriteLine($"nameList 一共有{nameList.Count}个元素");
foreach (string name in nameList)
{
Console.WriteLine($"{name}");
}
}
public void Test2()
{
List nums = new List();
for (int i = 0; i < 10; i++) {
nums.Add(i);
}
Console.WriteLine($"nums 中一共有{nums.Count}个元素");
foreach (int i in nums)
{
Console.WriteLine(i);
}
}
public void Test3() {
List students= new List() {
new Student(1, "张三", 18),
new Student(2, "李四", 19),
new Student(3, "王五", 20),
new Student(4, "马六", 21)
};
Console.WriteLine($"总共有:{students.Count}位同学");
foreach (Student student in students)
{
student.Info();
}
}
}
}
Test1方法中:List中存储的类型是string
Test2方法中:List中存储的类型是int
Test3方法中:List中存储的是实体类Student,List中常用的就是类型
调用测试类:Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZJF.GenericTech._01_回顾List和Dictionary;
namespace ZJF.GenericTech
{
internal class Program
{
static void Main(string[] args)
{
Test1();
Console.Read();
}
static void Test1() {
// 实例化
TestListDict tt = new TestListDict();
tt.Test1(); // 调用方法1
tt.Test2();
tt.Test3();
}
}
}
运行结果:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B8l63xWR-1684052960422)(D:\markdown\C#系列\CSharp高级进阶.assets\image-20230513105431066.png)]
Dictonary用法
Dictionary是一对Key Value ,一个key对应一个value
字典用法
public void Test4()
{
Dictionary books = new Dictionary() {
{ "罗贯中","《三国演义》"},
{ "施耐庵","《西游记》"},
{ "曹雪芹", "《红楼梦》"},
{ "吴承恩", "《水浒传》"}
};
Console.WriteLine($"一共有{books.Count}本书;");
foreach (string author in books.Keys)
{
Console.WriteLine($"{author}:{books[author]}");
}
}
我们需要一个计算器,这个计算器需要整数运算和浮点数运算,我们先不用泛型实现这个类:
Calc.cs
通过重载来支持不同的数据类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.GenericTech._02_引入泛型
{
public class Calc
{
static int Add(int x, int y) {
return x + y;
}
static float Add(float x, float y) {
return x + y;
}
static int Sub(int x, int y) {
return x - y;
}
static float Sub(float x, float y) {
return x - y;
}
}
}
这种写法需要写很多多余的代码。
定义泛型类:在定义的时候不需要明确类型,在使用的时候在明确类型。提高类的通用性。
定义一个泛型类
Stack.cs
创建一个栈类,栈是一个后进先出的数据结构
namespace ZJF.GenericTech._03_泛型基础
{
// 泛型类
internal class Stack
{
// 私有成员变量,用于存储元素
private T[] storage;
// 私有成员变量,用于记录索引
private int index;
// 私有成员变量,用于确定容量
private int capacity=10;
public Stack() {
this.storage = new T[10];
this.index = 0;
}
// 压栈:泛型方法
public void Push(T item) {
if (this.storage.Length < this.capacity)
{
this.storage[index] = item;
this.index++;
}
else {
throw new Exception("stack is full");
}
}
// 弹出:泛型返回值
public T Pop() {
if (this.storage.Length <= 0)
{
T temp = this.storage[index - 1];
this.index--;
return temp;
}
else {
throw new Exception("空");
}
}
}
}
测试类:
static void Test2()
{
Stack intStack = new Stack();
intStack.Push(1);
intStack.Push(2);
intStack.Push(3);
intStack.Push(4);
intStack.Push(5);
Console.WriteLine(intStack.Pop());
Console.WriteLine(intStack.Pop());
Console.WriteLine(intStack.Pop());
Console.WriteLine(intStack.Pop());
Console.WriteLine(intStack.Pop());
}
返回结果:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W5tWabcF-1684052960422)(D:\markdown\C#系列\CSharp高级进阶.assets\image-20230513114809677.png)]
代码运行结果与预期是相同的,最后被压栈的元素,最先一个被弹出。
public class MyGeneric
{
private T1 t1;
private T2 t2;
public MyGeneric() {
t1 = default(T1);
t2 = default(T2);
}
public void Info() {
Console.WriteLine($"{this.t1}-{this.t2}");
}
}
如上面代码所示:一个泛型类,需要在构造方法中对两个私有变量进行初始化,值类型的默认值是0,引用类型的默认值是null
public class MyGeneric
{
private T1 t1;
private T2 t2;
public MyGeneric() {
t1 = 0;
t2 = null;
}
public void Info() {
Console.WriteLine($"{this.t1}-{this.t2}");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dWtd312b-1684052960423)(D:\markdown\C#系列\CSharp高级进阶.assets\image-20230513120926770.png)]
vs 也很智能的给了提醒,因为在编译阶段并不知道t1和t2的类型,需要到运行阶段才能知道,default关键字的作用就是用使用时类型的初始值赋值给这个属性。
dynamic关键字让c#在编译阶段不检查变量的类型
值类型约束
where T : struct 表示类型参数必须是不可为 null 的值类型。
// 值类型约束
public class MyGenericList where T : struct
{
// 类成员...
}
由于所有值类型都具有可访问的无参数构造函数,因此 struct 约束也表示 new() 约束,所以 struct 约束不能与 new() 约束和 unmanaged 约束一起使用。
引用类型约束
where T : class 表示类型参数必须是的引用类型。
// 引用类型约束
public class MyGenericList where T : class
{
// 类成员...
}
此约束还应用于任何类、接口、委托或数组类型。 在可为 null 的上下文中,T 必须是不可为 null 的引用类型。
可为空引用类型约束
where T : class? 表示类型参数必须是可为 null 或不可为 null 的引用类型。
// 引用类型约束
public class MyGenericList where T : class?
{
// 类成员...
}
此约束还应用于任何类、接口、委托或数组类型。
不可为空约束
where T : notnull 表示类型参数必须是不可为 null 的类型。
// 引用类型约束
public class MyGenericList where T : notnull
{
// 类成员...
}
参数可以是不可为 null 的引用类型,也可以是不可为 null 的值类型。
基方法约束
where T : default 表示重写方法或提供显式接口实现时,如果需要指定不受约束的类型参数,此约束可解决歧义。
// 引用类型约束
public class MyGenericList where T : default
{
// 类成员...
}
default 约束表示基方法,但不包含 class 或 struct 约束。
非托管类型约束
where T : unmanaged 表示类型参数必须是不可为 null 的非托管类型。
// 引用类型约束
public class MyGenericList where T : unmanaged
{
// 类成员...
}
unmanaged 约束也表示 struct 约束,且不能与 struct 约束或 new() 约束结合使用。
构造函数约束
where T : new() 表示类型参数必须具有公共无参数构造函数。
// 引用类型约束
public class MyGenericList where T : new()
{
// 类成员...
}
当构造函数约束与其他约束一起使用时,new() 约束必须最后指定。 new() 约束不能与 struct 和 unmanaged 约束结合使用。
基类名约束
where T :<基类名> 表示类型参数必须是指定的基类或派生自指定的基类。
// 引用类型约束
public class MyGenericList where T :<基类名>
{
// 类成员...
}
在可为 null 的上下文中,T 必须是从指定基类派生的不可为 null 的引用类型。
可为空的基类名约束
where T :<基类名>? 表示类型参数必须是指定的基类或派生自指定的基类。
// 引用类型约束
public class MyGenericList where T :<基类名>?
{
// 类成员...
}
在可为 null 的上下文中,T 可以是从指定基类派生的可为 null 或不可为 null 的类型。
接口类型约束
where T :<接口名称> 表示类型参数必须是指定的接口或实现指定的接口。
// 引用类型约束
public class MyGenericList where T :<接口名称>
{
// 类成员...
}
可指定多个接口约束。 约束接口也可以是泛型。 在的可为 null 的上下文中,T 必须是实现指定接口的不可为 null 的类型。
可为空接口类型约束
where T :<接口名称>? 表示类型参数必须是指定的接口或实现指定的接口。
// 引用类型约束
public class MyGenericList where T :<接口名称>?
{
// 类成员...
}
可指定多个接口约束。 约束接口也可以是泛型。 在可为 null 的上下文中,T 可以是可为 null 的引用类型、不可为 null 的引用类型或值类型。 T 不能是可为 null 的值类型。
自定义约束
where T : U 表示为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。
// 引用类型约束
public class MyGenericList where T : U
{
// 类成员...
}
在可为 null 的上下文中,如果 U 是不可为 null 的引用类型,T 必须是不可为 null 的引用类型。 如果 U 是可为 null 的引用类型,则 T 可以是可为 null 的引用类型,也可以是不可为 null 的引用类型。
假设有两个类,一个类是AA,AA类中aa方法,一个类是BB,BB类中有bb方法,如果在AA类中调用bb方法,可以在BB类中定义一个属性位AA类的对象,但是如果在BB类中调用调用aa方法就很难实现了,这就是委托的应用场景。
委托相当于中介,我们通过中介找到房东,没有中介我们就找不到房东。
AA.cs
public class AA
{
public void aa() {
Console.WriteLine("我是AA类的aa方法");
}
}
BB.cs
public class BB
{
public AA Aa { get; set; }
public BB(AA a) {
Aa = a;
}
public void bb() {
Aa.aa();
Console.WriteLine("我是BB类的bb方法");
}
}
Program.cs
public class Program
{
static void Main(string[] args)
{
Test1();
Console.Read();
}
static void Test1() {
AA a = new AA();
BB b = new BB(a);
b.bb();}
}
【1】声明委托类型(定义方法的原型),一般委托都要声明在类的外面,委托本身也是一种特殊的数据类型。
【2】编写具体方法(符合方法的原型)
【3】创建委托变量
【4】关联委托方法(将某一个或多个具体的方法和一个委托变量关联)
【5】使用委托变量(调用所关联的方法)
多路委托:一个委托变量关联了若干方法,当调用委托变量的时候,所关联的方法会按照关联的顺序依次执行。
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZJF.DelegateTest._01_引入委托;
using ZJF.DelegateTest._02_委托使用方法;
namespace ZJF.DelegateTest
{
internal class Program
{
static void Main(string[] args)
{
Test2();
Console.Read();
}
static void Test2() {
DelegateTest1 dt1 = new DelegateTest1();
//【3】创建委托变量
SayHi sayHi = new SayHi(dt1.TestSayHi);
//【4】关联委托方法(将某一个或多个具体的方法和一个委托变量关联)
sayHi += dt1.TestSayHello;
//【5】使用委托变量(调用所关联的方法)
sayHi();
}
}
// 【1】声明委托类型(定义方法的原型),一般委托都要声明在类的外面,委托本身也是一种特殊的数据类型。
public delegate void SayHi();
}
DelegateTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.DelegateTest._02_委托使用方法
{
public class DelegateTest1
{
// 委托原型:public delegate void sayHi()
// 委托实现:public void TestSayHi()
//【2】编写具体方法(符合方法的原型)
public void TestSayHi() {
Console.WriteLine("hello1");
}
public void TestSayHello() {
Console.WriteLine("hello2");
}
}
}
窗体之间的逆向传值
实现窗体之间的逆向传值,父窗体可以轻松把值交给子窗体,子窗体想要把值交给父窗体,那就需要使用委托了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-13mj6Lm8-1684052960423)(D:\markdown\C#系列\CSharp高级进阶.assets\image-20230514151417074.png)]
FrmChild.cs
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;
namespace ZJF.DelegateWindowTest
{
public partial class FrmChild : Form
{
public FrmChild()
{
InitializeComponent();
}
public TransferMsg SendMsg { get; set; }
private void button1_Click(object sender, EventArgs e)
{
// 【5】调用委托变量
SendMsg(this.childMsg.Text);
}
}
}
FrmMain.cs
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;
namespace ZJF.DelegateWindowTest
{
public partial class FrmMain : Form
{
public FrmMain()
{
InitializeComponent();
}
// 【2】编写具体方法(准备逆向调用的方法,和声明委托在同一个类中)
public void RecvivedMsg(string value)
{
this.mainMsg.Text += value + "\r\n";
}
private void button1_Click(object sender, EventArgs e)
{
for (int i = 0; i < 3; i++)
{
FrmChild frm = new FrmChild();
frm.Show();
// 【3】这一步很关键,将委托变量与执行函数进行了关联。
frm.SendMsg += RecvivedMsg;
}
}
}
//【1】声明委托类型(在哪个类中都可以,建议调用哪个方法,就在哪个类中)
public delegate void TransferMsg(string value);
}
梳理一下逻辑
父窗体将信息广播给子窗体
通过多路委托实现,多路委托能够很好的实现广播机制。
语法
基础语法
delegate (params){
// 方法体
}
使用delegate关键字创建匿名方法,这个匿名方法可以用于直接关联委托变量。
一般的委托用法
namespace ZJF.Anonymous
{
public class Program
{
public static void Main(string[] args)
{
Test1();
Console.Read();
}
// 【3】委托背后的方法
public static int AddCalc(int a, int b) {
return a + b;
}
public static void Test1()
{
// 【2】 关联委托
Add addDelegate = new Add(AddCalc);
Console.WriteLine( addDelegate(1,2) );
}
}
//【1】定义一个委托
public delegate int Add(int x, int y);
}
这里面需要注意的是,委托关联的函数都是需要定义的,我们使用匿名方法来简化这个程序、
使用匿名方法简化定义
namespace ZJF.Anonymous
{
public class Program
{
public static void Main(string[] args)
{
Test1();
Console.Read();
}
//public static int AddCalc(int a, int b) {
// return a + b;
//}
public static void Test1()
{
// 通过匿名方法直接关联委托变量,简化操作
Add addDelegate = delegate(int x, int y) { return x + y; };
Console.WriteLine( addDelegate(1,2) );
}
}
public delegate int Add(int x, int y);
}
匿名方法好处:将具体方法和委托直接关联到一起,如果委托只需要一个方法的时候,匿名方法肯定是显得简单。
Lambda表达式:在C#3.0出现的。使用这种表达的可以更简练的编写代码块。
CalculatorDelegate cal3 = (int a, int b) => { return a + b; };
CalculatorDelegate cal4 = (a, b) => a - b;
【1】在Lambda表达式中参数类型可以是明确类型,也可以是推断类型。
【2】如果是推断类型,则参数类型可以由编译根据上下文自动推断出来。
【3】运算符=> 读作goes to ,运算符左边输入参数(如果有),右边是表达式或语句块。
【4】表达式两种方式:
(input args)=>表达式 # 单一表达式
(input args)=>{ 语句1;语句2;语句3....} # 多条语句
【5】Lambda表达式和匿名方法的比较
第一、Lambda表达式本身就是匿名方法。
第二、Lambda表达式允许不指明参数类型,但是匿名方法必须要明确。
第三、Lambda表达式允许单一的表达式或多条语句组成,而匿名方法不允许单一表达式。
测试
namespace ZJF.Anonymous
{
public class Program
{
public static void Main(string[] args)
{
Test2();
Console.Read();
}
//public static int AddCalc(int a, int b) {
// return a + b;
//}
public static void Test1()
{
Add addDelegate = delegate(int x, int y) { return x + y; };
Console.WriteLine( addDelegate(1,2) );
}
public static void Test2() {
Add addDelegate = (a, b) => { return a + b; }; // 使用lambda表达式更简单
Console.WriteLine(addDelegate(1,2));
}
}
public delegate int Add(int x, int y);
}
1、为什要使用泛型委托?
普通委托在数据类型的限定上非常严格的。有时候我们需求变化,可能适应不了。
2、泛型委托定义:本质上和泛型方法是非常相似的,泛型委托关联的时候,可以是具体方法、匿名方法、也可以是lambda表达式。
MyGenericDelegate.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ZJF.Anonymous._01_自定义泛型委托
{
public class MyGenericDelegate
{
public static void Test1()
{
//【1】使用泛型委托关联具体方法
CalculateAdd calc = new CalculateAdd(Add);
Console.WriteLine(calc(1, 2));
CalculateAdd calc2 = new CalculateAdd(Sub);
Console.WriteLine(calc2(1.0, 2));
// 【2】使用泛型委托关联匿名方法
CalculateAdd calc3 = delegate (int x, int y) { return x + y; };
CalculateAdd calc4 = delegate (double x, double y) { return x - y; };
Console.WriteLine(calc3(1, 2));
Console.WriteLine(calc4(1.0, 2));
// 【3】 使用泛型委托关联lambda表达式
CalculateAdd calc5 = (x, y) => { return x + y; };
CalculateAdd calc6 = (x, y) => { return x - y; };
Console.WriteLine(calc5(1, 2));
Console.WriteLine(calc6(1.0, 2));
}
public static int Add(int x, int y)
{
return x + y;
}
public static double Sub(double x, double y)
{
return x - y;
}
}
// 【1】自定义泛型委托
public delegate T CalculateAdd(T x, T y);
}