C# 基础知识（一）

---

一，简介

C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。
C# 是专为公共语言基础结构（CLI）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。

C# 成为一种广泛应用的专业语言的原因有以下几点：

• 现代的、通用的编程语言。
• 面向对象
• 面向组件
• 容易学习
• 结构化语言
• 可以产生高效率的程序
• 可以在多种计算机平台上编译
• .Net 框架的一部分。

C# 强大的编程功能
虽然 C# 的构想十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言，但是它与 Java 非常相似，有许多强大的编程功能

下面列出 C# 一些重要的功能：

• 布尔条件（Boolean Conditions）
• 自动垃圾回收（Automatic Garbage Collection）
• 标准库（Standard Library）
• 组件版本（Assembly Versioning）
• 属性（Properties）和事件（Events）
• 委托（Delegates）和事件管理（Events Management）
• 易于使用的泛型（Generics）
• 索引器（Indexers）
• 条件编译（Conditional Compilation）
• 简单的多线程（Multithreading）
• LINQ 和 Lambda 表达式
• 集成 Windows

二，环境

C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。

.Net 框架（.Net Framework）
.Net 框架是一个创新的平台，可以编写出下面类型的应用程序：

• Windows 应用程序
• Web 应用程序
• Web 服务

.Net 框架应用程序是多平台的应用程序。框架的设计方式使它适用于下列各种语言：
C#、C++、Visual Basic、Jscript、COBOL 等等。
所有这些语言可以访问框架，彼此之间也可以互相交互。

.Net 框架由一个巨大的代码库组成，用于 C# 等客户端语言。下面列出一些 .Net 框架的组件：

• 公共语言运行库（Common Language Runtime - CLR）
• .Net 框架类库（.Net Framework Class Library）
• 公共语言规范（Common Language Specification）
• 通用类型系统（Common Type System）
• 元数据（Metadata）和组件（Assemblies）
• Windows 窗体（Windows Forms）
• ASP.Net 和 ASP.Net AJAX
• ADO.Net
• Windows 工作流基础（Windows Workflow Foundation - WF）
• Windows 显示基础（Windows Presentation Foundation）
• Windows 通信基础（Windows Communication Foundation - WCF）
• LINQ

C# 编程的开发工具

C# 的集成开发环境（Integrated Development Environment - IDE）
微软（Microsoft）提供了下列用于 C# 编程的开发工具：

• Visual Studio (VS) (推荐)
• Visual C# 2010 Express (VCE)
• Visual Web Developer

在 Linux 或 Mac OS 上编写 C# 程序

虽然 .NET 框架是运行在 Windows 操作系统上，但是也有一些运行于其它操作系统上的版本可供选择。Mono 是 .NET 框架的一个开源版本，它包含了一个 C# 编译器，且可运行于多种操作系统上，比如各种版本的 Linux 和 Mac OS。

Mono 的目的不仅仅是跨平台地运行微软 .NET 应用程序，而且也为 Linux 开发者提供了更好的开发工具。Mono 可运行在多种操作系统上，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。

三，基本语法

执行 C# 代码的过程包括下列步骤：

1.选择编译器
2.将代码编译为 MSIL
3.将MSIL编译为本机代码
4.运行代码
5.垃圾回收
注：MSIL包括用于加载，存储和初始化对象以及对对象调用方法的指令，还包括用于算术和逻辑运算，控制流，直接内存访问，异常处理和其他操作的指令。

在面向对象的编程方法中：

• 类和对象是核心
• 对象由类建模而成
• 把类转换为对象的过程称为类的实例化
• 对象是消息，数据和行为的组合
• 对象代表一个实实在在存在的实体（实际物体）或者实际概念
• 对象往往有边界，有属性，有方法（特定用途）

面向对象的程序设计思想是现代软件开发的基础

面向对象的程序由各种各样的类，对象和方法组成

一般而言，对象具有一下特性：

• 对象有状态，对象的状态由对象的各种属性和相应值构成
• 对象可以显示行为（即方法），对象的行为（方法）使对象可以完成相应功能
• 对象有一个唯一的身份，对象的身份可以把它与其他对象区分开来
  （两个对象可能什么都相同，但是它们不可能有相同的身份）

各种定义

using 关键字：用于在程序中包含命名空间。一个程序可以包含多个 using 语句。在任何 C# 程序中的第一条语句都是：

using System;

class 关键字：用于声明一个类。

注释：用于解释代码，编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止；单行注释是用 ‘//’ 符号表示。

C# 中 // 注释和 /// 注的区别：：C# 引入了新的 XML 注释，即我们在某个函数前新起一行，输入 ///，VS.Net 会自动增加 XML 格式的注释
// 不会被编译，而 /// 会被编译
所以使用 /// 会减慢编译速度（但不会影响执行速度）
但使用 /// 会在其它的人调用你的代码时提供智能感知（通常在Form。Designer.cs 窗口会自动生成 /// 注释的程序）

成员变量：变量是类的属性或数据成员，用于存储数据。

成员函数：函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。

C# 类的实例化：通过已有的类（class）创建出该类的一个对象（object），这一过程就叫做类的实例化。

标识符：标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：

• 标识符必须以字母开头，后面可以跟一系列的字母、数字（ 0 - 9 ）或下划线（ _ ）。
• 标识符中的第一个字符不能是数字。
• 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! @ # % ^ & * ( ) [ ] { } . ; : " ’ / \。但是，可以使用下划线（ _ ）。
• 标识符不能是 C# 关键字。

C# 关键字：关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果想使用这些关键字作为标识符，可以在关键字前面加上@字符作为前缀。在 C# 中，有些标识符在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。

下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：

保留关键字列表

abstract	as	base	bool	break	byte	case
catch	char	checked	class	const	continue	decimal
default	delegate	do	double	else	enum	event
explicit	extern	false	finally	fixed	float	for
foreach	goto	if	implicit	in	in (generic modifier)	int
interface	internal	is	lock	long	namespace	new
null	object	operator	out	out（generic modifier)	override	params
private	protected	public	readonly	ref	return	sbyte
sealed	short	sizeof	stackalloc	static	string	struct
switch	this	throw	true	try	typeof	uint
ulong	unchecked	unsafe	ushort	using	virtual	void
volatile	while

上下文关键字列表

add	alias	ascending	descending	dynamic	from	get
global	group	into	join	let	orderby	partial (type)
partial (method)	remove	select	set

字段：属性在类的声明中用变量表示，这样的变量称为字段（field）。
字段是在类声明的内部声明的，但是位于类的方法声明体之外。当类的每个对象维护自己的属性副本时，代表属性的字段又称为实例变量。

方法（Method)：描述了类实际执行任务的机制，从形式上看，相当于C语言的函数

字段和方法都具有访问权限，主要为代码的安全考虑
通常有 3 种访问权限：private（私有的）, public（公共的）, protected（保护的）
使用权限：

• private 修饰的字段或者方法只允许在类的内部使用
• public 修饰的字段或者方法则没有什么限制，从类的外部可以直接使用
• protected 修饰的字段和方法可以在派生类中使用

命名空间：namespace中文多翻译为名字空间（或者命名空间）。
名字空间是用来组织和重用代码的编译单元，所谓namespace，是指标识符的各种可见范围。

System（名字空间）.Console（类名）.WriteLine（方法名）(“hello”)（要输出的函数参数）;

在名字的开头使用 using 语句表示引用该名字空间，在代码书写中可以省略名字空间 。namespace 是 C# 的一个关键字，实际上，它只是起到标识作用，把需要的内容放到一起，细化管理，也可以定义自己的命名空间。
在新建C#项目时，会自动地把所有的东西放到一个新的名字空间里，这个名字空间默认的名字就是项目的名字

Main()：一个项目可以就是你开发的一个软件，从扩展名来看，应用程序都会编译为一个 .exe 文件，既然是.exe文件，就表明它是可以被执行的。表现在程序中，这些应用程序都有一个主程序入口点，即Main()。
而类库，Windows控件等，则没有这个入口点，所以不能直接执行，而仅提供一些功能，给其他项目调用。这样的程序后缀名为 .dll
Visual Studio除了建立了一个控制台项目之外，该项目同时还属于一个解决方案

现在以下面这段代码为例找找这四种分别是什么：

• 类
• 字段
• 方法
• 主函数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace liti
{
    class Program
    {
        static void Main(string[] args)  //主函数
        {
            MyClass haha = new MyClass();  //创建新的类的实例
            haha.SayHello();  //执行类里面的方法
        }
    }
    class MyClass  //类，MyClass是类名，可以自己命名，需要符合标识符的规定
    {
        private int x;  //成员字段，可以存储一个数据
        //因为使用权限是private，所以不可以在主函数里不可访问x
        public void SayHello()  //成员方法，相当于c语言里的函数
        //因为使用权限是public，所以可以在主函数里可以访问SayHello
        {
            Console.WriteLine("hello world!");
        }
    }
}

输入和输出

在一行输入一个数据，求两个数的和

• Console.Read()：在一行输入一个字符
• Console.ReadLine()：在一行输入一串字符
• Console.Write()：输出时不换行
• Console.WriteLine()：输出时换行

using System;
namespace liti
{
    class Program
    {
        static void Main(string[] args) 
        {
        	//在一行输入一个数据
            //Console.Read();  //读取一个字符
            string s = Console.ReadLine();  //读取一行字符 
            int x = Convert.ToInt32(s);  //将字符串转换为整数
            s = Console.ReadLine();
            int y = Convert.ToInt32(s);  //必须手动转换
            int z = x + y;  
            //Console.Write(z);  //输出后不换行
            Console.WriteLine(z);  //输出后自动换行
            //z会自动转换为字符输出
        }
    } 
}

在一行输入多个数据，并求和

• ss1 = s1.Split(’ ')：将输入的数据根据空格分解为子串
• Console.WriteLine(“和是{0}”, sum)：带格式输出

using System;
namespace liti
{
    class Program
    {
        static void Main(string[] args) 
        {
            //在一行输入多个数据
            string s1 = Console.ReadLine();  //输入数据，中间用空格隔开
            string[] ss1 = s1.Split(' ');  //Split方法表示按括号内分隔符拆分字符串
            //s1 是一个类，类中有很多方法，比如Split方法
            double[] a = new double[ss1.Length];  //分配新的空间
            double sum = 0;
            for (int i = 0; i < ss1.Length; i++)
            {
                a[i] = Convert.ToDouble(ss1[i]);  //将字符串转换为double型
                sum = sum + a[i];  //求和
            }
            Console.WriteLine(sum);
            //带格式输出
            Console.WriteLine("和是{0}", sum);  //大括号里的数必须从0开始
        }
    } 
}

类型转换

类型转换是把数据从一种类型转换为另一种类型。在 C# 中，类型转换有两种形式：

• 隐式类型转换 这些转换是 C# 默认的以安全方式进行的转换。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
• 显式类型转换 这些转换是通过用户使用预定义的函数显示完成的。显式转换需要强制转换运算符。

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

序号	方法	描述
1	ToBoolean	如果可能的话，把类型转换为布尔型。
2	ToByte	把类型转换为字节类型。
3	ToChar	如果可能的话，把类型转换为单个 Unicode 字符类型。
4	ToDateTime	把类型（整数或字符串类型）转换为日期-时间结构。
5	ToDecimal	把浮点型或整数类型转换为十进制类型。
6	ToDouble	把类型转换为双精度浮点型。
7	ToInt16	把类型转换为 16 位整数类型。
8	ToInt32	把类型转换为 32 位整数类型。
9	ToInt64	把类型转换为 64 位整数类型。
10	ToSbyte	把类型转换为有符号字节类型。
11	ToSingle	把类型转换为小浮点数类型。
12	ToString	把类型转换为字符串类型。
13	ToType	把类型转换为指定类型。
14	ToUInt16	把类型转换为 16 位无符号整数类型。
15	ToUInt32	把类型转换为 32 位无符号整数类型。
16	ToUInt64	把类型转换为 64 位无符号整数类型。

四， 数据类型

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

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

值类型

值类型变量可以直接分配给其一个值。它们是从类 System.ValueType 中派生的。值类型直接包含数据。比如 int、char、float，它们分别存储数字、字母和浮点数。当声明一个 int 类型的变量时，系统将会分配内存来存储它的值。

如需得到一个类型或一个变量在特定平台上的准确大小，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。

引用类型
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
换句话说，它们指向的是一个内存位置。使用多重变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由多重变量之中的一个改变的，其他变量会自动相应这种值的变化。例如，内置的引用类型有：object、dynamic 和 string。

对象类型
对象类型是 C# 通用类型系统（CTS）中所有数据类型基类。 Object 是 System.Object 类的别名。对象类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

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

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

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

声明动态类型的语法：

dynamic = value;

例如：

dynamic d = 20;

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

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

指针类型
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。

char* cptr;  //声明指针
int* iptr;

根据代码了解下列知识：

• 变量的声明
• 表达式
• 值变量
• 引用变量

       int x;  //声明变量
       int y = 90;  //声明常量
       float a, b, c;  //声明多个变量 
       float d = a + b + c;  //表达式
       bool k = a > b;  //值为真或假
       const double PI = 3.14159;  //声明符号常量
       decimal balabala = 0.0m;  
       //以上变量为值类型变量
       int[] num = new int[100];  //引用型变量
      

NET

NET中类型的两个基本类别是“值类型”和“引用类型”。

值类型：基元类型，枚举，结构
值类型包括：

• 所有数字数据类型
• Boolean, Char 和 Data
• 所有结构，即使其成员是引用类型
• 枚举，因为其基础类型总是SByte, Short, Integer, Long, Byte

引用类型：类，字符串，标准模块，接口，数组，委托
引用类型包括：

• string
• 所有数组，即使其元素是值类型
• 类类型，如Form
• 委托
• 自描述类型
• 指针类型
• 接口类型
  
  根类型 System.Object, 它非常特殊，因为它既不是引用类型也不是值类型，而且不能实例化
  数据在内存中的分配位置，取决于该变量的数据类型

C# 数据类型

• 值类型：C#数据存储，栈空间，堆空间（垃圾回收）值类型的变量，所有的数值类型等，struct 结构，直接在栈里分配存储，方法结束后销毁。
• 引用类型：所有的类类型，数组，string等；在堆里用 new 来分配空间，通过垃圾回收（GC）来管理；同时将分配的内存标识（句柄）放到栈里。

对于引用类型，两个变量可能引用同一个对象
对于值类型，每个变量都有它们自己的数据副本

C#值类型

• 简单类型
  
• 枚举类型

定义：枚举类型是具有命名常量的独特的类型。每种枚举类型都具有一个基础类型，该基础类型必须是八种整数之一（如果没有声明是哪一种基础类型，默认是int类型）

枚举的声明：

访问修辞符 enum 枚举名：基础类型
{
     枚举成员
}

枚举成员是该枚举类型的命名常数
任何两个枚举成员不能具有相同的名称
简单的枚举示例：

public enum time:uint
{
	Morning = 1,
	Afternoon = 2,    //枚举成员之间用逗号隔开
	Evening = 3    //最后一个枚举成员后面没有逗号
}

如果没有给枚举成员赋值，默认为0。以后的枚举成员值由前一个枚举成员的值加1得到
System.Enum 本身不是枚举类型。它是一个类类型，所有枚举类型都是从它派生的

• 结构类型

定义：结构是使用 struct 关键字定义的，与类相似，都表示可以包含数据成员和函数成员的数据结构。
结构是一种值类型，并且不需要堆分配（不使用 new 运算符）
结构不能声明默认构造函数或析构函数
简单的结构示例：

struct Haha
{
	public int x;    
	public int y;
	public static string str = null;    //静态变量可以初始化
	public Haha(int x, int y)    //带参数的构造函数
	{
		this.x = x;
		this.y = y;
		Console.WriteLine("x = {0}, y = {1}, str = {2}", x, y, str);
	}
}   

关于枚举和结构如何使用的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace litii
{ 
    class Program
    {
        struct Haha    //结构
        {
            public int age;
            public string name;
        }
        enum DayTime    //枚举
        {
            Morning,
            Afternoon,
            Evening
        }
        static void Main(string[] args)     //主函数
        {
            Haha s1;
            s1.age = 18;
            Haha[] s2 = new Haha[100];
            DayTime d1;
            d1 = DayTime.Morning;  
        }
    }
}

C#引用类型

• 类类型
• 接口类型
• 数组类型
• 委托类型

C#类型由用户定义的类别：类类型，结构类型，接口类型，枚举类型，委托类型

引用类型的值都被当做 “ 对象 ” 来处理
值类型的值则通过执行装箱和拆箱操作亦按对象处理
示例：

	int i = 123;
	object o = i;    //装箱
	int j = (int)o;    //拆箱

由于这种统一性，使用 object 类型的通用库既可以用于引用类型，又可以用于值类型

五，运算

关于后缀：

C#提供的字符类型数据按照国际上公认的标准，采用 Unicode 字符集。一个Unicode 字符的长度为 16 位（ bit ），它可以用来表示世界上大部分语言种类。所有 Unicode 字符的集合构成字符类型。字符类型的类型标识符是 char, 因此也可称为 char 类型。
在表示一个字符常数时，单引号内的有效字符数量必须且只能是一个，并且不能是单引号或则反斜杠（ \ ) 。
一个字符串是被双引号包含的一系列字符。

C#支持的字符串常数：

1.常规字符串常数
2.逐字字符串常数：@ 开头的字符串
例如：@ “ 计算机 ”
逐字字符串常数同常规字符串常数的区别在于，在逐字字符串常数的双引号中，每个字符都代表其最原始的意义，在逐字字符串常数中没有转义字符。

推断类型可以是内置类型，匿名类型，用户定义类型或,NET Framework 类库中定义的类型。

	var i = 10;    //隐式声明
	int i = 10;    //显示声明
	//两句功能一样，前者更加方便简介一些

表达式

概念：表达式是由运算符将运算对象（如常数，变量和函数等）连接起来的具有合法语义的式子。
注：如果除数和被除数均为整数类型，则结果也是整数。（只取整数部分）
“ % ” 运算符两侧均应为整型数据，其运算结果为两个运算对象作除法运算的余数。

位运算符：

1.按位与（ & ）：两个整型数据中的二进制做 “ 与 ” 运算。
“ 与 ” 运算规则为：如果参加运算的两个二进制位均为 1 ，则结果为 1 ，否则结果为 0 。

2.按位或（ | ）：两个整形数据中的二进制位做 “ 或 ” 运算。
“ 或 ” 运算规则为：只要参加运算的两个二进制位中有一个为 1 ，则结果就是 1；只有在参加运算的两个 2 进制位均为 0 的情况下结果才是 0。

3.按位异或（ ^ )：两个整型数据中的二进制位做 “ 异或 ” 运算。
“ 异或 ” 运算规则为：如果参加运算的两个二进制位不同则运算结果为 1，相同则结果为 0。

4.按位取反（ ~ ）：按位取反是单目运算符，只需一个运算对象，按位取反运算将作为运算对象的整型数据中的二进制位做 “ 求反 ” 运算。
“ 求反 ”运算规则：如果原来的二进制位为 1，则运算结果为 0，否则结果为 1，即运算结果和原来的数据相反。

5.左移位运算符（ << )：左移位运算符用于将整型数据中的各个二进制位全部左移若干位，并在该数据的右端添加相同个数的 0。

6.右移位运算符（ >> )：右移位运算符用于将整型数据中的各个二进制位全部右移若干位，并在该数据的左端添加相同个数的 0。

C#中的数学函数大多是 Math 类的静态方法，而 Math 类在名字空间 System 中。
例如：

	double y = Math.Cos(0.5);

面向对象的编程

面向对象编程（ Object Oriented Programming, OOP, 面向对象程序设计）是一种计算机编程架构。

面向对象编程中的概念主要包括：
类，对象，数据抽象，数据封装，继承，动态绑定，多态性，消息传递。
最基本的特征：封装，继承，多态

通过继承可以创建：派生类，基类
派生类可以从其基类中继承属性和方法

继承的目的：代码的重用

多态性是指不同类的对象对同一消息作出不同的响应
多态的作用：实现接口重用

类是对一些具有相同数据和操作的事物的描述
在C#中，数据称为字段，操作称为方法

类的其中两个成员：

• 字段成员，它存储与类的实例相关的数据
• 方法成员，它是执行代码。方法成员通常模拟类所表示的现实世界事物的功能和操作。

修饰符

类修饰符：限定声明类的一种符号

• 访问修饰符
  
• 其他修饰符
  
  类成员可以在类主体内部以任何顺序声明。

成员修饰符：

• 访问修饰符
  （1）私有的（ private ）：声明私有成员，系统缺省值是 private
  （2）公有的（ public ）：声明公有成员
  （3）保护的（ protected ）：不能被类外对象访问，可以被派生类的方法与属性引用
  （4）内部的（ internal ）：只能在程序集内使用
  （5）受保护内部的（ protected internal ）
• 其他修饰符
  （1）abstract ：指示该方法或属性没有实现
  （2）const ：指定域或局部变量的值不能被改动
  （3）event ：声明一个事件
  （4）extern ：指示方法在外部实现
  （5）override ：对由基类继承成员的新实现
  （6）readonly：指示一个域只能在声明时以及相同类的内部被赋值
  （7）static ：指示类的静态成员，为全体类的对象所共有

字段初始值：
每种类型的默认值都是0；bool型时是false；引用类型默认为null。

构造方法：没有返回值，名字和类名相同，可以传递参数，可以重载
例如：

public Person()    //没有参数的构造方法
{
	Name = "lili";
	Age = 18;
	Weight = 126;
}

属性

类的属性：C#中属性体现了对象的封装性。

属性是类、结构体和接口的命名成员。类或结构体中的成员变量或方法称为域。属性是域的扩展，且可使用相同的语法来访问。它们使用访问器让私有域的值可被读写或操作。

属性不会确定存储位置。相反，它们具有可读写或计算它们值的访问器。
例如，有一个名为 Student 的类，带有 age、name 和 code 的私有域。我们不能在类的范围以外直接访问这些域，但是我们可以拥有访问这些私有域的属性。
访问器

属性的访问器包含有助于获取（读取或计算）或设置（写入）属性的可执行语句。访问器声明可包含一个 get 访问器、一个 set 访问器，或者同时包含二者。

private string id = "1919";
public string ID
{
	get 
	{
		return id;
	}
	set
	{
		id = value;
	}
}
    // public string ID { get; set; }    与上面代码效果一样	

数据类型的存储方式，位置：

栈是一个内存数组，是一个LIFO（last-in first-out，后进先出）的数据结构。
栈存储几种类型的数据：

• 变量的值
• 程序当前的执行环境
• 传递给方法的参数

堆是一块内存区域，在堆里可以分配大块的内存用于存储某类型的数据
所有引用类型的数据都会分配到堆里面（使用 new 分配内存）
值类型只需要一段单独的内存，用于存储实际的数据
引用类型需要两端内存：
第一段存储实际的数据，位于堆中；
第二段是一个引用，指向数据在堆中存放位置。

看下面一道例题理解下列知识：

• 类
• 构造函数（构造方法）
• 析构方法：不带有参数，没有重载，不能继承
• 属性
• 访问权限

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace litii
{ 
    class Program
    {
        
        static void Main(string[] args)   
        {
            Hero baizd = new Hero();
            baizd.AddLife();
            baizd.Life = 90;     //自动调用属性中的set过程，90这个值会传递给value
            int k = baizd.Life;    //自动调用属性中的get过程
            //属性在等号左边调用set过程，属性在等号右边调用get过程
        }
    }

    class Hero    //类
    {
        private string name;    //字段
        private  int life = 50;

        public int Life  //属性
        {
            get
            {
                return life;
            }
            set    //根据需要写不同的代码
            {
                if (value < 0)
                    life = 0;
                else
                {
                    if (value > 100)
                        life = 100;
                    else
                        life = value;
                }
            }
        }

        public string Name     //属性
        {
            get
            {
                return name;
            }
            set   
            {
                name = value;
            }
        }
        public int Age { get; set; }   //如果不需要做任何处理，可以这样写（可不写）
        //效果和 Name 属性一样

        public void AddLife()    //方法
        {
            life++;
        }

        public Hero()    //构造方法，在创建实例的时候自动被调用，且只被调用一次
        {
            life = 0;    //如果一个类没有写构造方法，系统会自动添加一个构造方法
            name = " ";     //不需要写返回值
        }

        ~Hero()    //默认权限为private
        {
               //析构方法，销毁构造方法
        }
    }
}

六，控制结构

• 选择结构

例题：输入三个数判断这三个数是否可以构成三角形

using System;
namespace litii
{ 
    class Program
    {  
        static void Main(string[] args)   
        {
            double a, b, c;
            //string s = Console.ReadLine();
            var s = Console.ReadLine();
            var ss = s.Split(' ');
            a = Convert.ToDouble(ss[0]);
            b = Convert.ToDouble(ss[1]);
            c = Convert.ToDouble(ss[2]);
            if (a + b > c && b + c > a && a + c > b) 
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");    
            }
        }
    }
}

• 循环结构
  例题：输入a（1~9），求 a + aa + aaa + aaaa + aaaaa + aaaaaaa 的值

using System;
namespace litii
{ 
    class Program
    {
        
        static void Main(string[] args)   
        {
            int a;
            var s = Console.ReadLine();
            a = Convert.ToInt32(s);
            int sum = 0;
            int aNext = a;

            //int n = 0;
            //while (n < 7)
            //{
            //    sum = sum + aNext;
            //    aNext = aNext * 10 + a;
            //    n++;
            //}

            //int n = 0;
            //do
            //{
            //    sum = sum + aNext;
            //    aNext = aNext * 10 + a;
            //    n++;
            //} while (n < 7);

            for (int i = 1; i <= 7; i++)
            {
                sum = sum + aNext;
                aNext = aNext * 10 + a;
            }

            Console.WriteLine("Sum={0}", sum);
        }
    }
}

• 其他控制语句：switch，break，continue

using System;
namespace litii
{ 
    class Program
    {
        static void Main(string[] args)   
        {
            var s = Console.ReadLine();
            int garde = Convert.ToInt32(s);
            int f;
            switch (garde / 10)
            {
                case 10:    //什么都没有可以不加break
                case 9:
                    f = 5;
                    break;
                case 8:
                    f = 4;
                    break;
                case 7:
                    f = 3;
                    break;
                default:
                    f = 1;
                    break;
            }
            Console.WriteLine("f={0}", f);
            for (int i = 0; i < 3; i++)
            {
                if (f == 1)
                {
                    continue;
                }
                else
                {
                    Console.WriteLine("nice!");
                }
            }
        }
    }
}

七，数组

一维数组

• 数组中的变量又称为数组元素，变量的下标又称为索引号或位置序号
• 数组是类中的引用类型，它继承 .NET 类库中名为 System.Array 的公共基类，这样可直接使用该基类中定义的各种属性和方法

声明和创建一维数组

    int[] arr = new int [5];
    //数组类型[] 数组名 = new 数组类型[数组长度]
    int[] arr1 = new int[5]{1,2,3,4,5};    //初始化
    // int[] arr1 = new int[]{1,2,3,4,5};     //简略的写法
    // int[] arr1 = {1,2,3,4,5};     //简略的写法
    //初始值的个数要和数组长度一致
    //数组的长度可以是变量

多维数组

• C#支持多维数组（二维及以上维数，最高32维）
• 数组类型的维数也称为数组类型的秩，它是数组类型的方括号之间逗号个数加上1

	//二维数组
	int[,] arr = new int[2,3];    //声明
	int[,] arr = new int[2,3]{{1, 2, 3},{4, 5, 6}};    //初始化
	int[,] arr = new int[,]{{1, 2, 3},{4, 5, 6}};     //简略的写法
	int[,] arr = new {{1, 2, 3},{4, 5, 6}};    //大括号里的大括号不可以省略
	//数组类型[,] 数组名 = new 数组类型[m, n];
	//m, n可以是变量或常量表达式

交错数组

• 交错数组是元素为数组的数组
• 交错数组元素的长度可以不同
• 利用交错数组可以更有效地使用内存空间

	//二维交错数组
	int[][] jagarr = new int[3][];    //交错数组的声明,第二个[]中不用写数值
	jagarr[0] = new int[5];
	jagarr[1] = new int[4];
	jagarr[2] = new int[2];
	//初始化
	jagarr[0] = new int[]{1, 2, 3, 4, 5};
	jagarr[1] = new int[]{11, 22, 33, 44,};
	jagarr[2] = new int[]{123, 456};

例题：随机填充一维数组，并在数组中顺序查找
产生 100 个 1~99 之间的随机整数，填充数组
输入一个 1~99 之间的数，如果该数字在数组中，则输出该数字在数组中的下标，
如果不在，输出-1，如果有多个，仅输出第一个匹配的下标

using System;
namespace lii
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = new int[100];
            Random r = new Random();
            for (int i = 0; i < a.Length; i++) 
            {
                a[i] = r.Next(1, 100);  
                //括号里为产生随机数的上限和下限，下限可取，上限不可取
            }
            foreach(int k in a)  //输出
            {
                Console.Write("{0} ", k);
            }  
            int m = Convert.ToInt32(Console.ReadLine());
            for (int i = 0; i < a.Length; i++)
            {
                if (m == a[i])
                {
                    Console.WriteLine("m的位置{0}",i);
                    return;
                }
            }
            Console.WriteLine("-1"); 
        }
    }
}

利用交错数组生成杨辉三角

using System;

namespace lii
{
    class Program
    {
        static void Main(string[] args)
        {
            const int N = 10;
            int[][] pas = new int[N][];  //定义交错数组
            for(int i = 0; i < N; i++)
                pas[i] = new int[i + 1];    //为交错数组分配空间

            pas[0][0] = 1;
            for(int i = 1; i < N; i++)
            {
                pas[i][0] = 1;
                pas[i][i] = 1;
                for(int j = 1; j < i; j++)
                    pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
            }
            for(int i = 0; i < N; i++)
            {
                for(int j = 0; j <= i; j++)
                {
                    Console.Write("{0,-4}",pas[i][j]);
                }
                Console.WriteLine();
            }
        }
    }
}

八，方法

静态方法和静态变量

• 用 static 修饰符声明的成员称为静态成员
• 使用 static 声明的成员（域，字段）变量称为静态变量
• 用 static 声明的方法称为静态方法
• 静态成员是属于类所有，不需要预先创建类的实例就能访问
• 静态成员的访问形式为：类名.静态成员，而不是“对象名.静态成员”。
• 即静态成员是直接从类级访问，而不是从实例级访问
• 类的所有对象共享静态变量
• 类的静态变量仅占有一块内存空间，且该空间是不能被撤销的
• 在静态方法中只允许访问类的静态成员，而不允许访问其实例成员（即非静态成员）
• 在实例方法中（即非静态方法）中，可以访问类中的任何成员（包括静态和非静态成员）

方法的声明：
方法在类或结构中声明，声明时需要指定访问级别（即访问修饰符），返回值，方法名，方法参数以及方法体。

方法的使用:
有返回值，方法调用仅作为表达式的形式出现

using System;

namespace lii
{
    class Program
    {
        static void Main(string[] args)  //静态方法
        {
            sun s = new sun();
            sun s1 = new sun();
            //s.sm();   //error
            sun.sm();   //"."之前是类名，不是实例名
            Console.WriteLine(sun.count++);  //参数必须是静态的
        }
    }
    class sun
    {
        public static int count = 0;
        public int a = 0;
        public static void sm()
        {
            Console.WriteLine("haha");
        }
        public sun()
        {
            count++;
        }
    }
}

方法的参数传递：

• 值传递
• 不使用任何修饰符标记的参数。值参数采用值方式传递（简称值传递或默认传递）。
• 值方式传递是指在进行方法调用时，系统将实参的值复制给形参变量（即形参是实参值的一个副本），这时，方法中可使用或修改形参变量的值，但不会影响或改变实参的值。

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 10;
            int b = 99;
            Swap(a, b);
            Console.WriteLine("a={0},b={1}", a, b);  //输出的 a = 10, b = 99
            Swap2(ref a, ref b);
            Console.WriteLine("a={0},b={1}",a, b); //输出 a = 99, b = 10
        }

        static void Swap(int a,int b)    //值参数进行值传递
        {
            int t = a;
            a = b;
            b = t;
            Console.WriteLine("a={0},b={1}", a, b);   //输出的 a = 99, b = 10
        }

        static void Swap2(ref int a, ref int b)   //值参数进行引用传递
        {
            int t = a;
            a = b;
            b = t;
            Console.WriteLine("a={0},b={1}", a, b); //输出的 a = 99, b = 10
        }
    }
}

• 引用参数采用引用传递。
• 引用传递是指实参传递给形参时，不是将实参变量的值复制给形参，而是将实参的引用（即实参变量的地址）复制给形参。
• 形参作为实参的别名与实参共享同一内存单元。因此方法中使用形参就如同使用实参一样，形参的值变了，实参值也就变了。
• 使用 ref 修饰符标记的参数（声明和调用时都要标记）

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = { 1, 2, 3 };
            AddOne(a);
            foreach (int k in a)
                Console.WriteLine(k);   // 输出为 1 2 3
            AddOne2(ref a);
            foreach (int k in a)
                Console.WriteLine(k);   // 输出为 12 13 14 15
        }

        static void AddOne(int[] a)    //引用参数进行值传递
        {
            a = new int[4] { 11, 12, 13, 14 };  //如果不加该语句输出为 2 3 4
            for (int i = 0; i < a.Length; i++)
            {
                a[i]++;
            }
        }

        static void AddOne2(ref int[] a)   //引用参数进行引用传递
        {
            a = new int[4] { 11, 12, 13, 14 };  //如果不加该语句输出为 3 4 5
            for (int i = 0; i < a.Length; i++)
            {
                a[i]++;
            }
        }
    }
}

out参数
输出（OUT参数）
使用一个方法，返回 2 个整数的和以及差

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            int x1 = 7;
            int x2 = 11;
            int x3;
            int x4;
            AddM(x1, x2 ,out x3, out x4);  //用out函数不用给变量赋初值
            Console.WriteLine("{0},{1}", x3, x4);
        }
        static void AddM(int x1, int x2, out int x3, out int x4)
        {
            x3 = x1 + x2;
            x4 = x1 - x2;
        }
    }
}

可选参数和命名参数

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 7;
            int b = 10;
            char c = 'Y';
            Sun(a, b, c);
            Sun(a,b);   //正确
            Sun(a, 1, c);
            Sun(a, c: c);  //命名参数
        }
        static void Sun(int a, int b = 1, char c = 'R') // b,c为可选参数
        {
            a = a + 1;
            Console.WriteLine("{0},{1},{2}", a, b, c);
        }  
    }
}

运行结果

8,10,Y
8,10,R
8,1,Y
8,1,Y

变长参数表
使用变长参数，求若干个整数的平均值

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Average(1));
            Console.WriteLine(Average(1, 2, 3, 4));
        }
        static double Average(params int[] a)  //变长参数表
        {
            int b = a.GetLength(0);
            double s = 0;
            foreach (int k in a)
                s += k;
            return s / b;
        }       
    }
}

方法的重载

• 重载（Overload）
• 方法参数数目不同
• 方法拥有相同数目的参数，但参数的类型不一样
• 方法拥有相同数目的参数和参数类型，但是参数类型出现的先后顺序不一样
• 构成重载的方法与方法的返回值类型无关

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            double area = Area(3d, 4d, 5d);
            double area1 = Area(3, 4, 5);
        }
        static double Area(double a,double b,double c)
        {
            Console.WriteLine("1");
            double s = (a + b + c) / 2;
            return Math.Sqrt(s * (s - a) * (s - b) * (s - c));
        }
        static double Area(double a,double h)
        {
            Console.WriteLine("2");
            return (a * h) / 2;
        }
        static double Area(int a, int b,double theta)
        {
            Console.WriteLine("3");
            return (a * b * Math.Sin(theta)) / 2;
        }
    }
}

readonly：如果类中变量的值在构造函数中进行初始化，初始化后就不能修改，但不同的对象调用构造函数时可以将该变量初始化为不同的值，这样变量可以使用readonly关键字进行修饰，只读变量

九，继承

面向对象程序设计中最重要的一个概念就是继承（inheritance）。继承允许我们在另一个类中定义一个新的类，这使得它更容易创建和维护一个应用程序。这也提供了一个机会来重用代码的功能，加快实现时间。

创建一个类的时候，不是要写全新的数据成员和成员函数，程序员可以指定新的类继承一个已经存在的类的成员。已有的类称为基类（base class），新的类称为派生类（derived class）。

基类和派生类

派生类只能有一个直接基类，但一个基类可以有多个直接派生类。继承是可以传递的。定义要从其他类派生的类时，派生类会隐式获得基类的所有成员（除了其构造函数和终结器）。派生类因而可以重用基类中的代码，而无需重新实现。在派生类中，可以添加更多成员。通过这种方法，派生类可扩展基类的功能。

复数类

using System;

namespace titi
{
    class Program
    {
        static void Main(string[] args)
        {
            Complex x1 = new Complex(2, 3);
            Complex x2 = new Complex(5.6, 7.8);
            Complex x3 = x1.ADD(x2);
            x3.Show();
            Complex x4 = Complex.Add(x1, x2);
            x4.Show();
        }        
    }
    public class Complex
    {
        private double real;
        private double image;
        public Complex()
        {
            real = image = 0;
        }
        public Complex (double real,double image)
        {
            this.real = real;
            this.image = image;
        }
        public void Set(double real,double image)
        {
            this.real = real;
            this.image = image;
        }
        public double GetReal()
        {
            return real;
        }
        public double GetImage()
        {
            return image;
        }
        public Complex ADD(Complex x)
        {
            Complex temp = new Complex();
            temp.real = this.real + x.real;
            temp.image = this.image + x.image;
            return temp;
        }
        public static Complex Add(Complex x1,Complex x2)
        {
            Complex temp = new Complex();
            temp.real = x1.real + x2.real;
            temp.image = x1.image + x2.image;
            return temp;
        }
        public Complex Sub(Complex x)
        {
            Complex temp = new Complex();
            temp.real = this.real - x.real;
            temp.image = this.image - x.image;
            return temp;
        }
        public void Show()
        {
            Console.Write("{0}+{1}i", real, image);
        }
    }
}