C#语言

C#语言

(一)第一个C#程序

(1).NET与C#

1、.NTE的含义:.NET是Micorsoft.NET的简称,基于Windows平台的一种技术,它包含了能在.NET Framework平台运行的所有编程语言。它同时也是C#的运行环境,.NET是属于微软公司所有。

2、C#的含义C#是一种全新的语言,它是专为.NET开发而设计的编程语言。同时也是微软为奠定其下一代互联网霸主地位而打造的,是Microsoft.NET平台运行的主流语言。

(2)第一个C#程序的创建

1、C#程序的创建

​ 启动Visual Studio 2019 ——> 新建项目——> 生成可执行文件 ——> 开始运行

2、认识C#程序

(1)C#中的关键字

​ namespace 关键字:namespace是C#的命名空间,也是C#中组织代码的方式,作用类似于Java中的package(包)。

​ using关键字:在Java中,如果导入其他包,应该使用import关键字。而在C#中,使用using关键字来引用其他命名空间,它的作用和Java中的import类似。

​ class关键字:C#和Java一样是面向对象的一种语言,在C#中class关键字也表示类。

注:C#中不要求类名必须与源文件的名称一致。

​ Main()方法:在C#中的Main()方法和Java中的main()方法的作用是一样的,是程序运行的入口,应用程序从这里开始运行。

​ 在C#中的Main()方法有如下四种形式:

static void Main(string[] args){}
static void Main(){}
static int Main(string[] args){}
static int Main(){}

​ 关键代码:Main()方法中添加的两行代码就是这个小程序的关键代码,是用来输出和输入的。

​ 代码如下:

Console.WriteLine("Hello World");		//从控制台输出内容
Console.ReadLine();					   //从控制台输入

(3)C#中的变量和常量

1、C#中的数据类型

​ 如下表所示:

常用数据类型JavaC#举例
整型intint年龄
浮点型floatfloat成绩
双精度型doubledouble圆周率
字符串型Stringstring姓名
布尔型booleanbool是否为少数民族

注:在为浮点型变量赋值时,C#语言要求赋值数据必须以字母f或F结束。

2、C#中的变量

​ C#中的变量声明方式与Java是相同的。 语法:数据类型 变量名称;

​ C#的变量命名规则与Java也基本相同,只是"$"符号在C#中是不能使用的,因此变量的命名规则可以简单总结为以下三条:

​ 组成:52个英文字母(AZ,az)、10个数字(0~9)、下划线(_),除此之外不能含有其他的字符。

​ 开头:只能以字母或下划线开头。

​ 不能使用的:不能是C#中的关键字。

3、C#中的常量

​ 常量的定义:常量就是在程序运行过程中保持不变的值。

​ 语法:

const 数据类型常量名称  = 值;

​ 例如:

	public const int dayMax = 7 ;  //定义常量dayMax

​ 常量的命名规范如下:

​ 1、常量名称必须具有一定的实际意义;

​ 2、常量名最好是以 大写字来命名,中间可根据意义的连接性用下划线做连接;

​ 3、常量名称长度最好不要超过25个字符;

(4)Console类

1、C#向控制台输出

​ 利用Console.WriteLine()方法输出有三种方式:

​ 方法一:

Console.WriteLine();

​ 方法二:

Console.WriteLine(要输出的值);

​ 方法三:

Console.WriteLine("格式字符串",变量列表);
//这是C#中的新语法,先举个例子:
string couruse = "C#";
Console.WriteLine("我的课程名称是:{0}",couruse);
//在这里{}里面的值,我们称之为占位符,占位符从0开始。

2、C#从控制台读入

​ 与Console.WriteLine()对应,从控制台输入可以使用Console.ReadLine()方法。Write是写的意思,Read是读的意思。

语法:Console.ReadLine();

​ 例如:

//输入名字

string name = Console.ReadLine();

//输入年龄
//类型的转换
int age = int.Parse(Consloe.ReadLine());

注:数据类型.Parse()方法的作用是把字符串转换为该数组类型。

(5)类和对象

1、自定义方法

​ 除了使用.NET提供的类的方法,也可以在类中添加自定义的方法。在C#中定义方法的语法与Java语法类似。语法如下:

[访问修饰符] 返回值类型 方法名(参数列表)
{
	//方法的主体
}

访问修饰符: 在C#中将会使用两个访问修饰符,一个是public(公有的),另一个是private(私有的)。

方法的返回值类型: 我们编写的方法是实现特定功能的模块,可供他人调用,在调用后可以返回一个值,这个返回值的数据类型就是方法的返回值类型,可以是int、float、double、bool、string等。如果方法不返回任何值,需要使用void关键字。

方法名: 每个自定义的方法都要有一个名称,方法的名称应该有明确的含义,这样别人在使用的时候就能清楚地知道这个方法能实现什么功能。

参数列表:可以向方法中传递参数,这些参数构成了参数列表。如果没有参数就不用参数列表。参数列表中的每个参数都是通过"类型参数名"形式进行声明的,各个参数之间用逗号分开。

方法的主体:方法的主体部分就是这个方法实现某一特定功能的代码。自定义方法时,应该先写方法的声明,包括访问修饰符、返回值类型、方法名、参数列表、然后写方法的主体。

2、理解类和对象

类是创建对象的模板,对象是类的一个具体实例。

​ C#语言中,定义类的语法:

[访问修饰符] class 类名
{
    //类的主体
}

​ C#在类中可以包含字段、属性和方法,每个类可以使用访问修饰符来设置该类的访问权限。

3、注释

​ 在C#中有四种注解:分别是:

​ 单行注释:// 文档注释:///

​ 块注释:/* */ 折叠注释:以#region 开头 ,以#endregion结尾

(二)C#语法快速热身

(1)选择结构

1、if选择结构

​ C#中if结构也分为四种结构:简单if结构、if…else结构、多重if结构、if嵌套结构;语法和Java中的语法一致,如下所示:

​ (1)简单if结构语法:

if(条件表达式)
{
    //代码块
}

​ (2)if…else结构语法:

if(条件表达式){
//代码块1
}
else
{
//代码块2
}

​ (3)多重if结构语法:

if(条件表达式1)
{
//代码块1
}
else if(条件表达式2)
{
//代码块2
}
else
{
//代码块3
}

​ (4)if嵌套语法:

if(条件表达式1)
{
if(条件表达式2)
{
//代码块1
}
else
{
//代码块2
}
}
else
{
//代码块3
}   

2、switch选择结构

​ C#switch选择结构语法:

表达方式一:

switch(表达式 )
{
    case 常量表达式 1:
            //语句1
            break;  //必须有
    case 常量表达式 2:
            //语句2
            break;  //必须有
        ......
            defaull:
        //语句n;
        	break;  //必须有
}

表达式二:

switch(表达式 )
{
    case 常量表达式 1:
    case 常量表达式 2:
            //语句1
            break;  //必须有
        ......
            defaull:
        //语句n;
        	break;  //必须有
}

注:在C#中的switch结构中的break是必须有的,但是如果case后面没有语句的话就不需要break。

(2)数组和循环

1、一维数组

(1)声明的数组

​ 在Java中声明数组的两种方式:

​ Java中的数组语法

//方式一
数据类型[] 数组名;
//方式二
数据类型 数组名[];

​ 但是在C#中只有一种声明方式

​ C#中的数组声明语法

数据类型[] 数组名;
例如:
int[] array;

(2)数组长度和数组下标

数组名.Length//数组长度
数组名[下标]//数组下标

2、对象数组

​ C#的对象数组与Java的对象数组并无差异。

​ 举例如下:

class Program
    {
        static void Main(string[] args)
        {
            Student[] stus = new Student[3];
            stus[0] = new Student();
            stus[0].name = "张浩";
            stus[0].score = 100;
            stus[1] = new Student();
            stus[1].name = "李成";
            stus[1].score = 99;
            stus[2] = new Student();
            stus[2].name = "江亦";
            stus[2].score = 95;
            Console.WriteLine("前三名学员的信息为:");
            foreach (Student stu in stus)
            {
                stu.showInfo();
            }
            Console.ReadLine();
        }
    }

3、循环数组

​ 在C#中有三种循环和Java中的循环是一样的,但是在C#中的foreach循环结构和Java中的不太一样。

(1)while循环

while(循环条件){
    //循环操作
}

(2)do-while循环

do{
    //循环操作
}while(循环条件);

(3)for循环

for(表达式1;表达式2;表达式3){
    //循环体
}

(4)foreach循环

foreach(元素类型 元素变量名 in 数组){
    //代码块
}

循环应用的区别如下:

​ while循环:是先判断条件表达式是否成立。若条件成立,则执行循环体;否则结束循环。

​ do-while循环:先执行依次循环再判断条件表达式是否成立。若条件成立,则继续循环;否则结束循环。

​ for循环:必须使用整型变量做循环计算器,通过条件表达式限定计数器变量值来控制循环。

​ foreach循环:用于遍历给定数组的所有值。

4、跳转语句

(1)break语句

​ break语句用于终止某个循环,使程序跳转到循环体外的下一条语句。在循环中位于break后的语句将不再执行,循环也停止执行。

(2)continue语句

​ 在for循环结构中,continue语句使程序先跳转到迭代部分,然后判定循环条件。如果为true,则继续下一次循环;否则,终止循环。在while循环结构中,continue语句执行完毕后,程序将直接判断循环条件。continue语句只能用在循环结构中。

(3)冒泡排序

​ 冒泡排序:冒泡排序的过程就像它的名称一样,如果把较小的数比作气泡,排序的过程就是气泡不断向上冒的过程,越小的数越高。冒泡排序算法是两两相邻比较;不满足条件就进行交换。

int[] array = {30,80,54,98,66,100};
int temp; //临时变量
//开始排序————使用冒泡排序进行升序排序
for(int i = 0;i<array.Length-1;i++)
{
    for(int j = 0; j < array.Length-1-i; j++)
    {
        if(array[j] > array[j+1])  //在这里大于符号(>)表示升序,小于符号(<)表示降序 
        {
            //交换元素
            temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
        }
    }
}

注:冒泡排序速记口诀(升序):

(1)N个数字来排队,两两相比小靠前。

(2)外层循环N-1,内层循环N-1-i。

(3)如果要降序排序,只要把程序中的大于号换成小于号就行了。

(三)使用属性升级MyBank

(1)private访问修饰符

private访问修饰符

访问修饰符访问权限访问级别
public不受任何限制最高
private只有类的内部可以使用最低

举例:

class Student
    {
        private string _name;//姓名
        public int _age = 19;//年龄
        public string _cardID = "110882199410252476";//身份证
        public void SetName(string name)
        {
            _name = name;
        }
        public void Say()
        {
            Console.WriteLine("大家好!我叫{0},今年{1}。",_name,_age);
        }
    }

(2)this关键字

​ this关键字:是指当前对象本身。通过this可以引用当前类的成员变量和方法,但是this不能在静态(static)成员中使用。

(3)C#属性

(1)C#属性

​ 在C#中,字段通常是私有的。如果要访问类中的字段,需要通过get和set访问器实现,这种结合了字段和方法的实现方式我们称之为属性(property)。

语法:

private string _name;
public string Name
{
get{return _name;}
set{_name = value;}
}

​ 在这里get表示返回值,也是只读形式;set表示赋值,也是只写形式;如果要在封装里表示读写模式,就要get和set一起使用,只读就只用get方法,只写就只用set方法。

(2)属性的数据类型

​ 定义类中的一个属性时,属性的数据类型必须与它所访问的字段类型一致。

(3)属性的访问类型

​ 属性除了可以约束数据访问外,还可以设置读、写属性来限定它的访问类型。属性的访问类型分为以下三种:

​ 只读属性:只包含get访问器。

​ 只写属性:只包含set访问器。

​ 读写属性:包含get和set访问器。

(4)值传递和引用传递

1、值传递

​ 值传递分为基本数据传递和引用型数据传递。

​ 基本数据类型:形参所做修改不会影响实。
​ 引用数据类型:形参对具体值的修改会影响实参。

2、地址传递

​ 地址传递也分为基本数据类型传递和引用型数据类型传递,但是地址传递无论是基本数据类型还是引用型数据类型,都会改变的实参。

​ 形参所做修改一定会影响实参实现方式:在形参和实参前面加ref。

(四)深入C#的String类

(1)C#中的String类

1、常用的字符串处理方法

方法说明
bool Equals (string value)比较一个字符串与另一个字符串value的值是否相等,返回值为bool(布尔)值
int Compare(string strA,string strB)比较两个字符串的大小关系,返回一个整数
int IndexOf(string value)获取指定的value字符串在当前字符串中的第一个匹配项的位置
int LastIndexOf(string value)获取指定的value字符串在当前字符串中的最后一个匹配项的位置
string Join(string separator,string[] value)把字符串数组value中的每个字符串用来指定的分隔符separator连接,返回连接后的字符串
string[]Split(char separator)用指定的分隔符separator分割字符串,返回分割后的字符串数组
string Substring(int startIndex,int length)从指定的 位置startIndex开始检索长度为length的子字符串
string ToLower()获得字符串的小写形式
string ToUpper()获得字符串的大写形式
string Trim()去掉字符串前后两端多余的空格

2、连接分割字符串

​ 在C#中的字符串中的连接和分割有专门的方法;连接是Join()方法,分割是Split()方法。

splitStrings = inputString.Split(' ')//以空格作为分隔符分割字符串
joinString = string.Join("_",splitStrings)//将分割的字符串使用下划线连接起来

3、Format格式化

​ Format()方法允许把字符串、数字或布尔型的变量插入到格式字符串当中,它的语法和WriteLine()方法相似。语法如下:

String MyString = String.Format("格式字符串",参数列表);
//其中,格式字符串中包含固定文本和格式项,语法如下:
{索引[,对齐][:格式字符串]} //在这里[]中的内容可有可无
字符说明示例输出结果
C货币格式String.Format("{0:C3}",2000)¥2 000.000
D十进制格式String.Format("{0:D3}",2000)2000
F小数点后的位数固定String.Format("{0:F3}",2000)2000.000
N用逗号隔开的数字String.Format("{0:N}",250000)250,000
P百分比计数法String.Format("{0:P3}",0.29768)29.768
X十六进制格式String.Format("{0:X000}",12)C

(2)类型转换

1、简单的类型转换

​ (1)隐式类型转换

​ 对于任何数值类型A,只要其取值范围完全包含类型B的取值范围,就可以隐式转换为类型B。也就是说,int型可以隐式转换为float型或double型,float型可以隐式转换为double型。

​ (2)显式类型转换

​ 与隐式类型转换相反,当要把取值范围大的类型转换为取值范围小的类型时,就需要执行显示转换。

double score = 58.5;//原始分数
int bonus=5;//加分
int sum;//总分
sum=score+bonus;//计算总分		

2、数值类型与字符串之间的转换

(1)字符串转换为数值型

​ 当要把字符串转换为数值类型时,可以调用不同的数值类型的Parse()方法。例如:

int.Parse(string);		//字符串转换为整型
float.Parse(string);	//字符串转换为单精度浮点型
double.Parse(string);	//字符串转换为双精度浮点型

(2)数值型转化为字符串

​ 我们知道Parse()方法可以将字符串类型转换为数值型,其实C#中还有一个更全能的类——Convert类,它可以在各种基本类型之间执行数据类型的互相转换。Convert类为各种类型转换都提供了一个对应的方法,常用的方法如下表所示。

​ 1.字符串转换为数值型

int.Parse(Console.ReadLine());  //从控制台接收整数
int.Parse(string);   //将字符串转换成整型
float.Parse(string);   //将字符串转换成单精度浮点型
double.Parse(string);  //将字符串转换成双精度浮点型

​ 2.数值型转换为字符串

int age = 18;
string myage = age.ToString();

3、使用Convert类进行转换

方法说明
Convert.ToInt32()转换为整型(int)
Console.ToSingle()转换成单精度浮点型(float)
Console.ToDouble()转换成双精度浮点型(double)
Console.ToSting()转换成字符串类型(String)
  • 8
    点赞
  • 0
    评论
  • 26
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

目录 1. 介绍 1 1.1 Hello, world 1 1.2 类型 2 1.2.1 预定义类型 3 1.2.2 转换 5 1.2.3 数组类型 6 1.2.4 类型系统一致 7 1.3 变量和参数 8 1.4 自动内存管理 11 1.5 表达式 13 1.6 声明 14 1.7 类 17 1.7.1 常数 19 1.7.2 域 19 1.7.3 方法 20 1.7.4 属性 21 1.7.5 事件 22 1.7.6 操作符 23 1.7.7 索引 24 1.7.8 实例构造函数 25 1.7.9 析构函数 26 1.7.10 静态构造函数 26 1.7.11 继承 27 1.8 结构 28 1.9 接口 29 1.10 代表 30 1.11 联合 31 1.12 名称空间和集合 31 1.13 版本 33 1.14 特征 35 2. 语法结构 37 2.1 翻译的阶段 37 2.2 文法符号 37 2.3 预处理 38 2.3.1 预处理声明 38 2.3.2 #if, #elif, #else, #endif 39 2.3.3 预处理控制行 40 2.3.4 #line 41 2.3.5 预处理标识符 41 2.3.6 预处理表达式 41 2.3.7 与空白交互作用 42 2.4 语法分析 43 2.4.1 输入 43 2.4.2 输入字符 43 2.4.3 行结束符 43 2.4.4 注释 43 2.4.5 空白 44 2.4.6 标记 45 2.5 句法分析 45 2.5.1 标识符 45 2.5.2 关键字 46 2.5.3 数据符号 46 2.5.4 操作符和标点 51 2.5.5 Unicode 字符转意字符序列 51 3. 基本概念 53 3.1 声明 53 3.2 成员 55 3.2.1 名称空间成员 55 3.2.2 结构成员 55 3.2.3 枚举成员 55 3.2.4 类成员 56 3.2.5 接口成员 56 3.2.6 数组成员 56 3.2.7 代表成员 56 3.3 成员访问 56 3.3.1 声明可访问性 56 3.3.2 可访问性域 57 3.3.3 保护的访问 59 3.3.4 可访问性约束 60 3.4 签名和重载 60 3.5 范围 61 3.5.1 名称隐藏 63 3.6 名称空间或类型名称 65 3.6.1 合格的名称 66 4. 类型 67 4.1 数值类型 67 4.1.1 默认构造函数 68 4.1.2 结构类型 69 4.1.3 简单类型 69 4.1.4 整数类型 70 4.1.5 浮点类型 71 4.1.6 十进制类型 72 4.1.7 布尔类型 72 4.1.8 枚举类型 72 4.2 引用类型 72 4.2.1 类类型 73 4.2.2 对象类型 73 4.2.3 字符串类型 73 4.2.4 接口类型 74 4.2.5 数组类型 74 4.2.6 代表类型 74 4.3 包装和解包 74 4.3.1 包装转换 74 4.3.2 解包转换 75 5. 变量 77 5.1 变量类型 77 5.1.1 静态变量 77 5.1.2 实例变量 77 5.1.3 数组元素 78 5.1.4 数值参数 78 5.1.5 引用参数 78 5.1.6 输出参数 78 5.1.7 局部变量 79 5.2 默认值 79 5.3 明确赋值 79 5.3.1 初始赋值变量 81 5.3.2 非初始赋值变量 82 5.4 变量引用 82 6. 转换 83 6.1 隐式转换 83 6.1.1 同一性转换 83 6.1.2 隐式数值转换 83 6.1.3 隐式枚举转换 84 6.1.4 隐式引用转换 84 6.1.5 转换 84 6.1.6 隐式常数表达式转换 84 6.1.7 用户自定义隐式转换 85 6.2 显式转换 85 6.2.1 显式数值转换 85 6.2.2 显式枚举类型转换 86 6.2.3 显式引用类型转换 86 6.2.4 解包转换 87 6.2.5 用户自定义显式转换 87 6.3 标准转换 87 6.3.1 标准隐式转换 87 6.3.2 标准显式转换 88 6.4 用户定义转换 88 6.4.1 允许的用户自定义转换 88 6.4.2 用户自定义转换的取值 88 6.4.3 用户自定义隐式转换 89 6.4.4 用户自定义显式类型转换 89 7. 表达式 91 7.1 表达式分类 91 7.1.1 表达式的数值 92 7.2 操作符 92 7.2.1 操作符优先级和结合顺序 92 7.2.2 操作符重载 93 7.2.3 一元操作符重载分析 94 7.2.4 二元操作符重载分析 94 7.2.5 候选用户定义操作符 95 7.2.6 数字升级 95 7.3 成员查询 96 7.3.1 基类型 97 7.4 函数成员 97 7.4.1 参数列表 99 7.4.2 重载分析 100 7.4.3 功能成员调用 102 7.4.4 虚拟函数成员查找 103 7.4.5 接口函数成员查找 103 7.5 主要的表达式 103 7.5.1 文字 103 7.5.2 简单名称 104 7.5.3 加括号的表达式 105 7.5.4 成员访问 105 7.5.5 调用表达式 107 7.5.6 元素访问 109 7.5.7 This访问 110 7.5.8 基本访问 111 7.5.9 递增和递减后缀操作符 111 7.5.10 new操作符 112 7.5.11 typeof操作符 116 7.5.12 sizeof操作符 116 7.5.13 checked和unchecked操作符 117 7.6 一元表达式 119 7.6.1 一元正值运算符 119 7.6.2 一元负值运算符 119 7.6.3 逻辑非运算符 120 7.6.4 按位求补运算符 120 7.6.5 间接运算符 120 7.6.6 地址运算符 120 7.6.7 前缀增量和减量运算符 120 7.6.8 强制类型转换表达式 121 7.7 算术运算符 122 7.7.1 乘法运算符 122 7.7.2 除法运算符 123 7.7.3 余数运算符 124 7.7.4 加法运算符 124 7.7.5 减法运算符 126 7.8 移位运算符 127 7.9 关系运算符 128 7.9.1 整数比较运算符 129 7.9.2 浮点比较运算符 129 7.9.3 小数比较运算符 130 7.9.4 布尔相等运算符 130 7.9.5 枚举比较运算符 130 7.9.6 引用类型相等运算符 130 7.9.7 字符串相等运算符 132 7.9.8 代表相等运算符 132 7.9.9 is 运算符 132 7.10 逻辑运算符 133 7.10.1 整数逻辑运算符 133 7.10.2 枚举逻辑运算符 133 7.10.3 布尔逻辑运算符 134 7.11 条件逻辑运算符 134 7.11.1 布尔条件逻辑运算符 134 7.11.2 用户自定义的条件逻辑运算符 135 7.12 条件运算符 135 7.13 赋值运算符 136 7.13.1 简单赋值 136 7.13.2 组合赋值 138 7.13.3 事件赋值 139 7.14 表达式 139 7.15 常量表达式 139 7.16 布尔表达式 140 8. 语句 141 8.1 终点与可达性 141 8.2 块 142 8.2.1 语句列表 143 8.3 空语句 143 8.4 标号语句 144 8.5 声明语句 144 8.5.1 局部变量声明 144 8.5.2 局部常量声明 145 8.6 表达式语句 145 8.7 选择语句 146 8.7.1 if语句 146 8.7.2 Switch 语句 147 8.8 重复语句 150 8.8.1 while语句 151 8.8.2 do语句 151 8.8.3 for语句 151 8.8.4 foreach语句 153 8.9 跳转语句 154 8.9.1 break语句 154 8.9.2 continue语句 155 8.9.3 goto语句 155 8.9.4 return语句 156 8.9.5 throw语句 156 8.10 try语句 157 8.11 checked和unchecked语句 159 8.12 lock语句 159 9. 名称空间 161 9.1 编译单元 161 9.2 名称空间声明 161 9.3 使用指示 162 9.3.1 使用别名指示 163 9.3.2 使用名称空间指示 165 9.4 名称空间成员 166 9.5 类型声明 167 10. 类 169 10.1 类声明 169 10.1.1 类修饰符 169 10.1.2 类基础规范 170 10.1.3 类主体 172 10.2 类成员 172 10.2.1 继承 173 10.2.2 new修饰符 173 10.2.3 访问修饰符 174 10.2.4 要素类型 174 10.2.5 静态和实例成员 174 10.2.6 嵌套类型 175 10.3 常数 175 10.4 域 176 10.4.1 静态和实例域 177 10.4.2 只读域 178 10.4.3 域的初始化 179 10.4.4 变量初始化函数 179 10.5 方法 181 10.5.1 方法参数 182 10.5.2 静态和实例方法 185 10.5.3 虚拟方法 186 10.5.4 覆盖方法 187 10.5.5 抽象方法 189 10.5.6 外部方法 190 10.5.7 方法主体 191 10.5.8 方法重载 191 10.6 属性 191 10.6.1 静态属性 192 10.6.2 虚拟属性 192 10.6.3 覆盖属性 193 10.6.4 抽象属性 194 10.6.5 访问符 194 10.7 事件 199 10.8 索引 202 10.8.1 索引重载 205 10.8.2 虚拟索引 205 10.8.3 覆盖索引 205 10.8.4 抽象索引 206 10.9 操作符 206 10.9.1 一元操作符 207 10.9.2 二元操作符 207 10.9.3 转换操作符 208 10.10 实例构造函数 209 10.10.1 构造函数初始化函数 210 10.10.2 实例变量初始化函数 210 10.10.3 构造函数执行 210 10.10.4 默认构造函数 212 10.10.5 私有构造函数 213 10.10.6 可选的构造函数参数 213 10.11 析构函数 213 10.12 静态构造函数 214 10.12.1 类加载和初始化 215 11. 结构 217 11.1 结构声明 217 11.1.1 结构修饰符 217 11.1.2 接口 217 11.1.3 结构体 217 11.2 结构成员 217 11.3 结构例子 217 11.3.1 数据库整数类型 217 11.3.2 数据库布尔类型 219 12. 数组 221 12.1 数组类型 221 12.1.1 System.Array 类型 222 12.2 数组创建 222 12.3 数组元素访问 222 12.4 数组成员 222 12.5 数组协方差 222 12.6 数组初始化函数 223 13. 接口 225 13.1 接口声明 225 13.1.1 接口修饰符 225 13.1.2 基本接口 225 13.1.3 接口主体 226 13.2 接口成员 226 13.2.1 接口方法 227 13.2.2 接口属性 227 13.2.3 接口事件 228 13.2.4 接口索引 228 13.2.5 接口成员访问 228 13.3 完全有效的接口成员名称 230 13.4 接口实现 230 13.4.1 显式接口成员实现程序 231 13.4.2 接口映射 233 13.4.3 接口实现程序继承 235 13.4.4 接口重新实现程序 236 13.4.5 抽象类和接口 238 14. 枚举 239 14.1 枚举声明 239 14.2 枚举成员 240 14.3 枚举数值和操作 242 15. 代表 243 15.1 代表声明 243 15.1.1 可合并的代表类型 244 15.2 代表实例化 244 15.3 多点传送代表 244 15.4 代表调用 244 16. 异常 245 16.1 异常的产生 245 16.2 System.Exception 类 245 16.3 异常怎样被处理 245 16.4 通用异常类 246 17. 属性 247 17.1 属性类 247 17.1.1 AttributeUsage 属性 247 17.1.2 位置的和名称的参数 248 17.1.3 属性参数类型 248 17.2 规范 249 17.3 属性实例 251 17.3.1 一个属性的编译 251 17.3.2 一个属性实例的运行时检索 252 17.4 保留的属性 252 17.4.1 AttributeUsage 属性 252 17.4.2 条件属性 253 17.4.3 废弃的属性 255 18. 危险代码 257 18.1 危险代码 257 18.2 指针类型 257 19. 互用性 259 19.1 COMImport 属性 259 19.2 COMRegisterFunction 属性 259 19.3 COMSourceInterfaces 属性 260 19.4 COMVisible 属性 260 19.5 DispId 属性 260 19.6 DllImport 属性 260 19.7 FieldOffset 属性 261 19.8 GlobalObject 属性 261 19.9 Guid 属性 262 19.10 HasDefaultInterface 属性 262 19.11 ImportedFromTypeLib 属性 262 19.12 In 和 Out 属性 262 19.13 InterfaceType 属性 263 19.14 MarshalAs 属性 263 19.15 NoIDispatch 属性 264 19.16 NonSerialized 属性 264 19.17 Predeclared 属性 264 19.18 PreserveSig 属性 264 19.19 Serializable 属性 265 19.20 StructLayout 属性 265 19.21 TypeLibFunc 属性 265 19.22 TypeLibType 属性 265 19.23 TypeLibVar 属性 266 19.24 支持的枚举 266 20. 参考 269
©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值