一、C#简介
C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。C#看起来与Java有着惊人的相似；它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。但是C#与Java有着明显的不同，它借鉴了Delphi的一个特点，与COM（组件对象模型）是直接集成的，而且它是微软公司 .NET windows网络框架的主角。

　　C#是一种安全的、稳定的、简单的、优雅的，由C和C++衍生出来的面向对象的编程语言。它在继承C和C++强大功能的同时去掉了一些它们的复杂特性（例如没有宏以及不允许多重继承）。C#综合了VB简单的可视化操作和C++的高运行效率，以其强大的操作能力、优雅的语法风格、创新的语言特性和便捷的面向组件编程的支持成为.NET开发的首选语言。


二、Create a New C# Project
环境：Visual Studio  (VS)

编译 & 执行 C# 程序

如果您使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：

1、启动 Visual Studio，在菜单栏上选择 File -> New -> Project，从模板中选择 Visual C#，然后选择 Windows，选择 Console Application，为您的项目制定一个名称，然后点击 OK 按钮；

2、新项目会出现在解决方案资源管理器（Solution Explorer）中，在代码编辑器（Code Editor）中编写代码，点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 输出结果。

或者通过命令符工具

打开一个文本编辑器，添加上面提到的代码，保存文件为 helloworld.cs

打开命令提示符工具，定位到文件所保存的目录

键入 csc helloworld.cs 并按下 enter 键来编译代码

如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件

接下来，键入 helloworld 来执行程序。

您将看到 “Hello World” 打印在屏幕上。



三、C# 代码
using System;
namespace HelloWorldApplication
{
    /* 类名为 HelloWorld */
    class HelloWorld
    {
        /* main函数 */
        static void Main(string[] args)
        {
            /* 我的第一个 C# 程序 */
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }
    }
}

1.using System：using 关键字用于在程序中包含 System 命名空间，一个程序一般有多个using 语句；
2.namespace声明：一个 namespace 是一系列的类，HelloWorldApplication 命名空间包含了类 HelloWorld；
3.class 声明：类 HelloWorld 包含了程序使用的数据和方法声明，类一般包含多个方法，方法定义了类的行为，在这里HelloWorld 类只有一个 Main 方法；
4.Main 方法：是所有 C# 程序的 入口点，Main 方法说明当执行时 类将做什么动作，Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。
5.WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法，该语句会在屏幕上显示消息 “Hello,World!”；

　　Console.ReadKey(); 是针对 VS.NET 用户，这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。


四、C# 基本语法
1.using 关键字
	在任何 C# 程序中的第一条语句都是：using System
	using 关键字用于在程序中包含命名空间,一个程序可以包含多个 using 语句

2. class 关键字
	class 关键字用于声明一个类

3. C# 注释
	多行注释以 /* 开始，并以字符 */ 终止，如下所示:
		/* This program demonstrates
		The basic syntax of C# programming 
		Language */
	单行注释是用 '//' 符号表示。例如：
		//end class Rectangle    

4.成员变量: 变量是类的属性或数据成员,用于存储数据
  成员函数: 函数是一系列执行指定任务的语句,类的成员函数是在类内声明的
  标识符: 标识符是用来识别类、变量、函数或任何其它用户定义的项目

5.C#关键字
	关键字是 C# 编译器预定义的保留字,这些关键字不能用作标识符



五、C# 数据类型
在 C# 中，变量分为以下几种类型：
值类型（Value types） 引用类型（Reference types） 指针类型（Pointer types）
1.值类型（Value types）
值类型（Value types）:
	bool		布尔值	
	byte		8 位无符号整数	
	char		16 位 Unicode 字符	
	decimal		128 位精确的十进制值
	double		64 位双精度浮点型	
	float		32 位单精度浮点型	
	int			32 位有符号整数类型	
	long		64 位有符号整数类型	
	sbyte		8 位有符号整数类型	
	short		16 位有符号整数类型	
	uint		32 位无符号整数类型	
	ulong		64 位无符号整数类型	
	ushort		16 位无符号整数类型



2.引用类型（Reference types）

引用类型不包含存储在变量中的实际数据,但它们包含对变量的引用。换句话说，它们指的是一个内存位置。使用多个变量时,引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。

内置的引用类型有：object、dynamic 和 string
-> 对象（Object）类型
	对象（Object）类型 是 C# 中所有数据类型的终极基类Object 是 System.Object 类的别名。所以对象（Object）类型可以
被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是,在分配值之前，需要先进行类型转换。

	装箱操作: 当一个值类型转换为对象类型时
	拆箱操作: 当一个对象类型转换为值类型时

	object obj;
	obj = 100; // 这是装箱

-> 动态（Dynamic）类型
可以存储任何类型的值在动态数据类型变量中,这些变量的类型检查是在运行时发生的

声明动态类型的语法：dynamic <variable_name> = value;

例如：dynamic d = 20;
	动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的
类型检查是在运行时发生的

->字符串（string）类型
	字符串（string）类型 允许您给变量分配任何字符串值,字符串（string）类型是 System.String 类的别名。它是从
对象（Object）类型派生的,字符串（string）类型的值可以通过两种形式进行分配：引号和 @引号

例如：
string str = "baidu.com";
一个 @引号字符串：@"baidu.com";

	C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待
比如：
	string str = @"C:\Windows";
	等价于：string str = "C:\\Windows";
	
用户自定义引用类型有：class、interface 或 delegate



六、C# 类型转换方法
C# 提供了下列常用的内置类型转换方法
序号	 方法     &               描 述

 1	ToChar 		   把类型转换为单个 Unicode 字符类型
 2	ToDateTime     把类型（整数或字符串类型）转换为 日期-时间 结构
 3	ToDecimal      把浮点型或整数类型转换为十进制类型
 4	ToDouble  		把类型转换为双精度浮点型
 5	ToInt16 / ToInt32 / ToInt64  	把类型转换为 16/32/64 位整数类型
 6	ToString  		把类型转换为字符串类型
 7	ToType  		把类型转换为指定类型
 8	ToUInt16  		把类型转换为 16 位无符号整数类型



七、C# 中
-> 运算符（算术、关系、逻辑、位、赋值、其他）
-> 判断、循环、访问修饰符、方法
-> 数组、字符串、枚举、Class
-> 继承、多态、重载
-> 接口 、命名空间、正则表达式、异常处理
和Java类似

下面列出 C# 一些重要的功能：
布尔条件（Boolean Conditions）

自动垃圾回收（Automatic Garbage Collection）

标准库（Standard Library）

组件版本（Assembly Versioning）

属性（Properties）和事件（Events）

委托（Delegates）和事件管理（Events Management）

易于使用的泛型（Generics）

索引器（Indexers）

条件编译（Conditional Compilation）

简单的多线程（Multithreading）

LINQ 和 Lambda 表达式

集成 Windows


八、Java 和 C# 的相同点和区别
相同点：

　　都是面向对象的语言，也就是说，它们都能实现面向对象的思想(封装,继承,多态)



区别：
1、开发环境

　　C# 用Visual Studio，而JAVA用idea、Eclipse；跨平台Java用虚拟机，C#用Framework；Java所有平台都支持，而C#只有Windows和Linux支持。

　　很多网友认为C#语言比Java更先进，如在泛型和linq上，这只能说C#编程体验好。Sun初衷是把Java设计成一个跨平台的Runtime，而Microsoft只是把.Net做成Windows的一个扩展。
2、目前市场上Java比C#占优势

　　很多大公司选用Java，如京东，淘宝和百度，现状是在企业更通用，Java做Web类开发很强大，C#做窗体类开发更好。
3、安全性

　　Java是开源的，因此在安全性能上是有一些欠缺的，C#经常应用于后台内部网络的开发，C#的安全性是很有保障的。
语法上区别：
  1.C#中的命名空间是namespace,类似于Java中的package（包）,在Java中导入包用import而c#中用using;

  2.c#和Java都是从main函数入口的，但是c#中的main函数的首字母必须大写,而且有4种写法;

  3.数据类型：Java跟c#基本都差不多,但是Java的String类型的首字母必须大写,而c#中可以小写也可以大写;还有布尔型,Java中是boolean,c#中是bool;
  
  4.输出：c#有三种方式输出：Cosole.WriteLine()、Cosole.WriteLine(要输出的值)、 Cosole.WriteLine("格式字符串"，变量列表); 前两种的用法
与Java中的System.out.println()方法的用法相同,第三种方式是根据占位符输出的,比Java更加方便;

  5.控制流语句：c#跟Java类似,还有c#中的switch如果case后面有内容必须要有break;Java可以没有break;

  6.方法中传递的参数：两种语言都使用值传递与引用传递,C#的引用传递的关键字是ref与out;ref侧重于修改,out侧重于输出,而Java中都以传值方式;

  7.访问修饰符：C#中的访问修饰符与Java中的基本对应,但多出了一个internal,简而言之,C#有5种类型的可访问性,如下所示:
	public：成员可以从任何代码访问
	protected：成员只能从派生类访问
	internal：成员只能从同一程序集的内部访问
	protected：成员只能从同一程序集内的派生类访问
	private：成员只能在当前类的内部访问

  8.由于C#中不存在final关键词,如果想要某个类不再被派生,你可以使用sealed关键词密封;

  9.集合：两种语言都有集合ArrayList,还有通过键访问值的 Java 中是HashMap而 c# 中是HashTable;c#比Java多泛型集合List<T>与Dictionary<K,V>
更容易了,无需拆箱装箱了,更安全;

  10.继承：Java中用关键字extends,c#只用"："就行了.调用父类的构造方法Java用super关键字,而c#用base关键字;
  
  11.多态：抽象类和抽象方法两种语言都用abstract关键字,Java中另外一个类如果继承了它,实现直接重写此方法就可以;而c#必须加上关键字override实现,
C#还比Java多一种虚方法来实现多态;

  12.接口：都用关键字interface定义,Java实现用关键字implements;c#用"："实现。在C#中,接口内的所有方法默认都是公用方法。在Java中,方法声明可以
带有public修饰符(即使这并非必要),但在C#中 显式为接口的方法指定public修饰符是非法的;

  13.C# 中的is操作符与Java中的instanceof操作符一样,两者都可以用来测试某个对象的实例是否属于特定的类型。在Java中没有与C#中的as操作符等价的
操作符,as操作符与is操作符非常相似,但它更富有"进取心"：如果类型正确的话,as操作符会尝试把被测试的对象引用转换成目标类型;否则它把变量引用设置成null。

c#学习c#学习c#学习c#学习c#学习c#学习

C#学习路线
导读

有的初学者对于如何开始学习C#感到无从下手，不知看哪些书，或者是看什么视频，没有目的性，这样就会影响学习效率，也会影响学习的热情。最重要的是很多同学学之前问很多和学习无关的问题，比如：C#是不是不如JAVA好？C#有前途吗？等等。博主认为现在观望还不如现在学习。本篇文章介绍了博主自己总结的C#学路线。如果大家有什么更好的想法或者好的建议可以共同探讨。

　　有的同学对直接看书有比较强的吸收能力，我建议从《C#入门经典》开始学习，过度到《C#高级编程》和《深入理解C#》。学习C#前提是下载好Visual Studio，配合书上的代码进行动手练习，动手非常重要。

　　Visual Studio 2017下载路径：https://visualstudio.microsoft.com/zh-hans/downloads/

本篇文章剩余部分主要是介绍利用微软C#官方文档和网上资源学习。

掌握C#基本语法

　　1.C# 快速入门：https://docs.microsoft.com/zh-cn/dotnet/csharp/quick-starts/index

此部分官方文档给初学者一些入门的认知，它可以直接在浏览器敲出代码，并且能够直观的显示出来。这部分包含了第一个"Hello World"程序，数字类型介绍，分支和循环，字符串类型处理，集合类型List的初探。

　　2.C# 语言介绍(C#的基础知识)：https://docs.microsoft.com/zh-cn/dotnet/csharp/tour-of-csharp/index

这部分官方文档介绍程序的基本结构，类型和变量，表达式，语句，类和对象，结构，数组，枚举等方面知识。把这一部分看完，大概会对C#有一定的认识，但是可能不明白的地方也有很多，不要急，只需要多看多敲代码，在后续学习的过程中，会一步一步把前面有问题的地方弄明白。

　　3.C# 教程：https://docs.microsoft.com/zh-cn/dotnet/csharp/tutorials/index

教程部分介绍了控制台的I/O，异步编程模型的基础知识，Web通信、JSON 序列化和面向对象的 C# 语言功能，以及LINQ查询的知识。

　　4.C# 编程指南：https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/index

这一部分是对第二部分的深入介绍，其中有很多相关的示例，也是学习C#基础知识比较重要的一部分。学习这部分前提是前面的内容已经学习完成(具有一定的C#编程知识)。

学习完上面的部分，且动手敲完里面的例子，相信你对C#已经有一个不错的认识。这时候需要看进阶的知识来巩固学习成果。

　　5.C# 演练：https://docs.microsoft.com/zh-cn/dotnet/csharp/walkthroughs

这部分内容包含了C#更强大的功能，异步编程，设计Windows组件，Windows窗体的介绍，数据操作，和LINQ查询，编写可视化工具等。

　　6.C# 中的新增功能：https://docs.microsoft.com/zh-cn/dotnet/csharp/whats-new/index

介绍了C#的版本，和每次版本中的新增内容，有助于让我们更了解C#的进化史，从而更好的应用它。

附带：

C# 语言参考：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/index

C# 语言规范(英文版)：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/language-specification/index

C#进阶之路

1.网上寻找编程练习题来带到练手的目的，并且巩固和学习新的C#知识，在这一过程中，一定要学会调试代码，可以提高学习的效率和查错速度。

2.学习数据开发技术，与数据库的交互技术ADO.NET

3.深入学习C#面向对象基础技能：封装，继承，多态的思想

4.碎片时间可以用来看红 黑 联 盟的C#文章，简短的介绍，可以提高认识：https://www.2cto.com/kf/ware/cs/index.html

项目实践

　　自己动手编写一些小而精的项目，达到整体认识的效果，比如经典的"坦克大战"，“图书管理系统”，这些都是很"轻量级"的。当你把"坦克大战"项目编写完毕，就可以进行更大的项目设计，增加权限管理等等。

.NET Core学习

　　现在微软在极力推荐跨平台，.NET Core可以实现在多平台运行，是以后微软重要的方向。所以学习上面知识之后一定要了解.NET Core，跟上时代发展的步伐。

 /* 我的第一个 C# 程序*/
      Console.WriteLine("Hello World!");
      Console.ReadKey();

编写 Console.Readkey(); 这个函数是为了在控制台窗口停留一下，直到敲击键盘为止。

不然运行时，"Hello World!" 这句话会在控制台窗口一闪而过，没法查看。

 

1.C# 简介

.Net 框架的一部分。

.Net 框架（.Net Framework）

.Net 框架是一个创新的平台，能帮您编写出下面类型的应用程序：

Windows 应用程序
Web 应用程序
Web 服务
一个 C# 程序主要包括以下部分：

命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
 

程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
下一行是 namespace 声明。一个 namespace 是一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
 

2.C# 基本语法

using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // 成员变量
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;    
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

成员变量

变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。

成员函数

函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。我们举例的类 Rectangle 包含了三个成员函数： AcceptDetails、GetArea 和 Display。

实例化一个类

在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。

 

3.C# 数据类型

在 C# 中，变量分为以下几种类型：

值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）
 

3.1 值类型（Value types）

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。



 

3.2 引用类型（Reference types）

内置的 引用类型有：object、dynamic 和 string。

当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。

object obj;
obj = 100; // 这是装箱

 

动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

dynamic <variable_name> = value;
dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。

 

3.3 字符串（String）类型

字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。

String str = "runoob.com";
string str = @"C:\Windows";

 

指针类型（Pointer types）

指针类型变量存储另一种类型的内存地址

type* identifier;
char* cptr;
int* iptr;

 

4. C# 类型转换

隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。
 

4.1 C# 类型转换方法

C# 提供了下列内置的类型转换方法：

ToBoolean 如果可能的话，把类型转换为布尔型。
ToByte 把类型转换为字节类型。
ToChar 如果可能的话，把类型转换为单个 Unicode 字符类型。
ToDateTime
ToDecimal 把浮点型或整数类型转换为十进制类型。
。。。
 

5. C# 变量



 

C# 中的变量定义

int i, j, k;
char c, ch;
float f, salary;
double d;

 

接受来自用户的值

System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。例如：

int num;
num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据

 

6.C# 常量

 

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。

整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。

这里有一些整数常量的实例：

212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法：8 不是一个八进制数字 */
032UU       /* 非法：不能重复后缀 */

 

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */

 

浮点常量

一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

 

字符常量

字符常量是括在单引号里，例如，'x'，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或者一个通用字符



 

7. C# 运算符

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符
c = a++: 先将 a 赋值给 c，再对 a 进行自增运算。
c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 。
c = a--: 先将 a 赋值给 c，再对 a 进行自减运算。
c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 。
 Console.WriteLine("c 的值是 {0}", c);

 

 

7.1 关系运算



 

7.2 逻辑运算符



 

 

7.3 位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：



 

 

7.4 赋值运算符



 

7.5 其他运算符

下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :



 

7.6 C# 中的运算符优先级

 



 

8. C# 封装

C# 支持的访问修饰符如下所示：

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。
protected：只有该类对象及其子类对象可以访问
Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承
internal：同一个程序集的对象可以访问；
nternal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。
protected internal：访问限于当前程序集或派生自包含类的类型。
 

9. C# 方法

要使用一个方法，您需要：

定义方法
调用方法
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

Access Specifier：访问修饰符，这个决定了变量或方法对于另一个类的可见性。
Return type：返回类型，一个方法可以返回一个值。返回类型是方法返回的值的数据类型。如果方法不返回任何值，则返回类型为 void。
Method name：方法名称，是一个唯一的标识符，且是大小写敏感的。它不能与类中声明的其他标识符相同。
Parameter list：参数列表，使用圆括号括起来，该参数是用来传递和接收方法的数据。参数列表是指方法的参数类型、顺序和数量。参数是可选的，也就是说，一个方法可能不包含参数。
Method body：方法主体，包含了完成任务所需的指令集。
 

按引用传递参数

引用参数是一个对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。

在 C# 中，使用 ref 关键字声明引用参数。下面的实例演示了这点：

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(ref int x, ref int y)
      {
         int temp;


         temp = x; /* 保存 x 的值 */
         x = y;    /* 把 y 赋值给 x */
         y = temp; /* 把 temp 赋值给 y */
       }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         int b = 200;


         Console.WriteLine("在交换之前，a 的值： {0}", a);
         Console.WriteLine("在交换之前，b 的值： {0}", b);


         /* 调用函数来交换值 */
         n.swap(ref a, ref b);


         Console.WriteLine("在交换之后，a 的值： {0}", a);
         Console.WriteLine("在交换之后，b 的值： {0}", b);
 
         Console.ReadLine();


      }
  

 

按输出传递参数

return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似

 

using System;


namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         
         Console.WriteLine("在方法调用之前，a 的值： {0}", a);
         
         /* 调用函数来获取值 */
         n.getValue(out a);


         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.ReadLine();


      }
   }

 

 

C# 可空类型（Nullable）

? : 单问号用于对 int,double,bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型是 NullAble 类型的。

 

int? i = 3 
等同于
Nullable<int> i = new Nullable<int>(3);


int i; //默认值0
int? ii; //默认值null

?? : 双问号 可用于判断一个变量在为 null 时返回一个指定的值。

Nullable< bool > 变量可以被赋值为 true 或 false 或 null。

< data_type> ? <variable_name> = null;

 

int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;
         
         bool? boolval = new bool?();


         // 显示值
         
         Console.WriteLine("显示可空类型的值： {0}, {1}, {2}, {3}", 
                            num1, num2, num3, num4);
         Console.WriteLine("一个可空的布尔值： {0}", boolval);
         Console.ReadLine();

 

显示可空类型的值： , 45,  , 3.14157
一个可空的布尔值：

 

Null 合并运算符（ ?? ）

如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值

using System;
namespace CalculatorApplication
{
   class NullablesAtShow
   {
         
      static void Main(string[] args)
      {
         
         double? num1 = null;
         double? num2 = 3.14157;
         double num3;
         num3 = num1 ?? 5.34;      // num1 如果为空值则返回 5.34
         Console.WriteLine("num3 的值： {0}", num3);
         num3 = num2 ?? 5.34;
         Console.WriteLine("num3 的值： {0}", num3);
         Console.ReadLine();


      }
   }
}

 

num3 的值： 5.34
num3 的值： 3.14157

 

 10. C# 数组（Array）

datatype[] arrayName;

datatype 用于指定被存储在数组中的元素的类型。
[ ] 指定数组的秩（维度）。秩指定数组的大小。
arrayName 指定数组的名称。
 

初始化数组

声明一个数组不会在内存中初始化数组。当初始化数组变量时，您可以赋值给数组。

数组是一个引用类型，所以您需要使用 new 关键字来创建数组的实例。

double[] balance = new double[10];

 

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
         int i,j;




         /* 初始化数组 n 中的元素 */         
         for ( i = 0; i < 10; i++ )
         {
            n[ i ] = i + 100;
         }


         /* 输出每个数组元素的值 */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }

 

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

 

使用 foreach 循环

using System;


namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */




         /* 初始化数组 n 中的元素 */         
         for ( int i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }


         /* 输出每个数组元素的值 */
         foreach (int j in n )
         {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
         }
         Console.ReadKey();
      }
   

 

11. C# 多维数组

C# 支持多维数组。多维数组又称为矩形数组。

您可以声明一个 string 变量的二维数组，如下：

string [,] names;

或者，您可以声明一个 int 变量的三维数组，如下：

int [ , , ] m;

 

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

 

C# 传递数组给函数

在 C# 中，您可以传递数组作为函数的参数

 

using System;


namespace ArrayApplication
{
   class MyArray
   {
      double getAverage(int[] arr, int size)
      {
         int i;
         double avg;
         int sum = 0;


         for (i = 0; i < size; ++i)
         {
            sum += arr[i];
         }


         avg = (double)sum / size;
         return avg;
      }
      static void Main(string[] args)
      {
         MyArray app = new MyArray();
         /* 一个带有 5 个元素的 int 数组 */
         int [] balance = new int[]{1000, 2, 3, 17, 50};
         double avg;


         /* 传递数组的指针作为参数 */
         avg = app.getAverage(balance, 5 ) ;


         /* 输出返回值 */
         Console.WriteLine( "平均值是： {0} ", avg );
         Console.ReadKey();
      }
  

 

C# 参数数组

参数数组通常用于传递未知数量的参数给函数。

C# 提供了 params 关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以传递一组数组元素。params 的使用格式为：

public 返回类型 方法名称( params 类型名称[] 数组名称 )


using System;


namespace ArrayApplication
{
   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = 0;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }
      
   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(512, 720, 250, 567, 889);
         Console.WriteLine("总和是： {0}", sum);
         Console.ReadKey();
      }
   }


 

12. C# Array 类

 

Array 类的属性

IsFixedSize

获取一个值，该值指示数组是否带有固定大小。

IsReadOnly

获取一个值，该值指示数组是否只读

Length

获取一个 32 位整数，该值表示所有维度的数组中的元素总数。

LongLength

获取一个 64 位整数，该值表示所有维度的数组中的元素总数。

Rank

获取数组的秩（维度）。

 

Array 类的方法

Clear

根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。

 

C# 结构体

 

定义结构体

为了定义一个结构体，您必须使用 struct 语句。struct 语句为程序定义了一个带有多个成员的新的数据类型。

例如，您可以按照如下的方式声明 Book 结构：

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

补充：类与结构体的区别

1、结构体中声明的字段无法赋予初值，类可以:

结构体的构造函数中，必须为结构体所有字段赋值

 

类的对象是存储在堆空间中，结构存储在栈中。堆空间大，但访问速度较慢，栈空间小，访问速度相对更快。故而，当我们描述一个轻量级对象的时候，结构可提高效率，成本更低。当然，这也得从需求出发，

 

13. C# 枚举（Enum）

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

C# 枚举是值类型

using System;
namespace EnumApplication
{
   class EnumProgram
   {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };


      static void Main(string[] args)
      {
         int WeekdayStart = (int)Days.Mon;
         int WeekdayEnd = (int)Days.Fri;
         Console.WriteLine("Monday: {0}", WeekdayStart);
         Console.WriteLine("Friday: {0}", WeekdayEnd);
         Console.ReadKey();
      }
   }
}

 

Monday: 1
Friday: 5

 

C# 类（Class）

对象是类的实例。构成类的方法和变量成为类的成员。

类的默认访问标识符是 internal，成员的默认访问标识符是 private。

如果要访问类的成员，你要使用点（.）运算符。
点运算符链接了对象的名称和成员的名称。
using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积


            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;


            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);


            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }

 

C# 中的构造函数

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。

构造函数的名称与类的名称完全相同，它没有任何返回类型。

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()
      {
         Console.WriteLine("对象已创建");
      }


      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }


      static void Main(string[] args)
      {
         Line line = new Line();    
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }


 

C# 类的静态成员

关键字 static 意味着类中只有一个该成员的实例

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();         
            Console.WriteLine("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}


s1 的变量 num： 6
s2 的变量 num： 6

 

将类成员函数声明为public static无需实例化即可调用类成员函数

using System;


namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = AddClass.Add(2, 3);  //编译通过
            Console.WriteLine(num);
        }
    }


    class AddClass
    {
        public static int Add(int x,int y)
        {
            return x + y;
        }
    }


 

 

15. C# 继承

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类

 

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

假设，有一个基类 Shape，它的派生类是 Rectangle：

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }


   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      { 
         return (width * height); 
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();


         Rect.setWidth(5);
         Rect.setHeight(7);


         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }

 

C# 不支持多重继承。但是，您可以使用接口来实现多重继承。

 

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }


   // 基类 PaintCost
   public interface PaintCost 
   {
      int getCost(int area);


   }
   // 派生类
   class Rectangle : Shape, PaintCost
   {
      public int getArea()
      {
         return (width * height);
      }
      public int getCost(int area)
      {
         return area * 70;
      }
   }
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();
         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.WriteLine("油漆总成本： ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }


 

C# 多态性

C# 提供了两种技术来实现静态多态性。分别为：

函数重载
运算符重载
 

函数重载

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。

 

动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

下面的程序演示了一个抽象类：

using System;
namespace PolymorphismApplication
{
   abstract class Shape
   {
      public abstract int area();
   }
   class Rectangle:  Shape
   {
      private int length;
      private int width;
      public Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      public override int area ()
      { 
         Console.WriteLine("Rectangle 类的面积：");
         return (width * length); 
      }
   }


   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("面积： {0}",a);
         Console.ReadKey();
      }
   }
}

 

 

当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual 声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。

动态多态性是通过 抽象类 和 虚方法 实现的

 

继承类中的重写虚函数需要声明关键字 override

 

 

C# 运算符重载

 operator 后跟运算符的符号来定义的

 

public static Box operator+ (Box b, Box c)
{
   Box box = new Box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

 

C# 接口（Interface）

接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。

接口使用 interface 关键字声明，它与类的声明类似。接口声明默认是 public 的。下面是一个接口声明的实例：

interface IMyInterface
{
    void MethodToImplement();
}

以上代码定义了接口 IMyInterface。通常接口命令以 I 字母开头

 

接口继承: InterfaceInheritance.cs

以下实例定义了两个接口 IMyInterface 和 IParentInterface。

如果一个接口继承其他接口，那么实现类或结构就需要实现所有接口的成员。

以下实例 IMyInterface 继承了 IParentInterface 接口，因此接口实现类必须实现 MethodToImplement() 和 ParentInterfaceMethod() 方法：

using System;


interface IParentInterface
{
    void ParentInterfaceMethod();
}


interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}


class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }


    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }


    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
   

 

C# 异常处理

try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。
catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。
finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。
throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成