C#基础知识总结

子曰：“温故而知新，可以为师矣。”

纯粹个人为巩固下基础，有技术问题可以评论，但个人不做任何回答，不做任何解释！

C#文件

a.“.cs”文件

C#语言源代码文件

b.“.csproj”
.csproj文件是.C#的工程文件，其中记录了与工程有关的相关信息，例如包含的文件，程序的版本，所生成的文件的类型和位置的信息等。

c.“.sln”

.sln文件是解决方案文件（后缀为sln的文件）表示一个项目组，他通常包含一个项目中所有的工程文件信息。

注意：.sln文件包含项目信息是最为齐全，以后的工作学习中，尽量拷贝.sln文件，其次是.csproj文件，最次是.cs文件。

1.注释

using System;

namespace Test1 {     ///

    /// 定义一个类     ///

    class Program     {         //申明一个变量         private static string Name = "First Program";

        ///

        /// 主函数         ///

        ///         static void Main(string[] args)         {             /*控制台打印“Hello World!”             等同于Console.WriteLine("Hello World!");*/             Console.WriteLine(Name);         }     } }

三种注释方式：

(1).单行注释   //

(2).多行注释  /*要注释的内容*/       注意:多行注释不能嵌套使用

(3).文档注释 ///     文档注释可以用来注释方法,也可以用来注释类.










2.命名空间

using System.Collections.Generic; //引用集合的命名空间

namespace Test2 //标识命名空间Test2的作用范围，如果其他明明空间下的类要引用Program类，那么必须先using Test2 {     class Program     {         public List list;         static void Main(string[] args)         {         }     } }

命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。namespace 关键字用于声明包含一组相关对象的作用域。

3.访问修饰符

①private，私有访问修饰符，被private访问修饰符修饰的成员只有在当前类的内部可以访问，其他地方一律不得访问。类中成员不用修饰符，默认为private。

②protected，受保护修饰符，表示当前类内部可以访问，并且所有的子类内部也可以访问。

③internal，项目内部修饰符，当前程序集内部。类的默认访问修饰符是internal。

注：protected和internal访问修饰符无所谓哪个更“可访问”，因为判断标准不一样。

protected只看是否是当前类内部或者所有子类内部，与是否在同 一个程序集无关。

internal只看是否在一个程序集内，与其是否有继承关系无关。

④protected internal，项目内部受保护修饰符，兼具protected和internal的特性，当前类内部，所有子类内部，当前程序集内部都可以访问。

⑤public，共有访问修饰符，没有限制，任何地方可以访问。

所有在命名空间中直接定义的类型，比如类、委托、枚举、结构。。。。。。的访问修饰符只能是public或internal。

using System;

namespace ConsoleApp2
{
    class Program : Test
    {
        static void Main(string[] args)
        {
            Test test = new Test();
            Console.WriteLine(test.InternalName);
            Console.WriteLine(test.ProtectedInternalName);
            Console.WriteLine(test.PublicName);
            //Console.WriteLine(test.PrivateName);   //报错，不可访问
            //Console.WriteLine(test.ProtectedName);   //报错，不可访问 
            Program p = new Program();
            Console.WriteLine(p.ProtectedName);
            Console.ReadKey();
        }
    }

    class Test
    {
        private string PrivateName = "private";
        protected string ProtectedName = "protected";
        internal string InternalName = "internal";
        public string PublicName = "public";
        protected internal string ProtectedInternalName = "protected internal";
    }
}

4.关键字

关键字是对编译器具有特殊意义的预定义保留标识符。它们不能在程序中用作标识符，除非它们有一个 @ 前缀。例如，@if 是一个合法的标识符，而 if 不是合法的标识符，因为它是关键字。

 C# 程序任意部分中的保留标识符的关键字：

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（泛型修饰符）	int	interface
internal	is	lock	long
namespace	new	null	object
operator	out	out（泛型修饰符）	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	using static
virtual	void	volatile	while

上下文关键字：在特定的上下文中作为关键字使用；除此特定的上下文外，可被允许作为自定义标识符使用。下面是C#上下文关键字：

add	alias	ascending
async	await	descending
dynamic	from	get
global	group	into
join	let	nameof
orderby	partial（类型）	partial（方法）
remove	select	set
value	var	when（筛选条件）
where（泛型类型约束）	where（查询子句）	yield

5.static关键字

static意思是静态，可以修饰类、字段、属性、方法
标记为static的就不用创建实例对象调用了，可以通过类名直接点出来

书面一点的说法：C#所有的对象都将创建在托管堆上。实例化后的类型我们称之为对象，核心特征便是拥有了一份“类”特有的数据成员拷贝。这些为特有的对象所持有的数据成员我们称之为实例成员。相反那些不为特有的对象所持有的数据成员我们称之为静态成员，在类中用static修饰符声明。仅对静态数据成员实施操作的称为静态函数成员。

using System;

namespace ConsoleApp5
{
    class Program
    {
        static void Main(string[] args)
        {
            //调用的时候，只需要用类名去点
            Console.WriteLine(Test.Name);
            Test test = new Test();
            //Console.WriteLine(test.Name);  //报错，只能用类名去点，不能用实例去点
        }
    }

    class Test
    {
        //声明一个静态成员
        public static string Name = "zhangsan";
    }
}

static关键字：http://www.cnblogs.com/xinaixia/p/5768148.html 点击打开链接

6.this关键字

最常见的用法：代表当前类的实例

using System;

namespace ConsoleApp6 {     class Program     {         private string Name = "zhangsan";

        static void Main(string[] args)         {             Program p = new Program();             Console.WriteLine(p.GetName());             Console.ReadKey();         }

        private string GetName()         {             Program p = new Program();             p.Fun(this); //将当前类的对象当作参数             return this.Name;   //返回当前类的对象的Name                    }

        private void Fun(Program p)         {

        }     } }

7.标识符

标识符是给变量、用户定义的类型和这些类型的成员指定的名称。标识符区分大小写。aaaa 和Aaaa是不同的变量.
必须以一个字母或下划线开头，可以包含数字字符，但数字不能作为首字母.

C#标识符的命名规则：
程序中的变量名、常量名、类名、方法名，都叫做标识符。C#有一套标识符的命名规则，如果命名时不遵守规则，就会出错。这套规则简单说有下面三条：
①标识符只能由英文字母、数字和下划线组成，不能包含空格和其他字符。
错误的标识符声明：string $user; //错在使用了其他字符
②变量名不能用数字开头。
错误的标识符声明：double 6h;//错在用数字开头
③不能用关键字当变量名。
错误的标识符声明：char static ;//错在用关键字static做变量名

using System;

namespace ConsoleApp1
{
    class Program
    {
        private string Name;
        private string _Name;
        //private string 123;     //数字不能作为首字母，报错
        //private string %Name;   //出现下划线以外的字符，报错
        //private string if;        //关键字不能作为标识符

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

8.变量和常量

常量：顾名思义，就是不会改变的。
 我们平时书写的数字（比如3.14159）、字符（比如“Q”），他们都是一些常量。
在使用这些常量的时候，有些常量很重要而且经常用到，比如圆周率3.14159，在圆相关的计算中经常用到，可以使用自定义常量来定义，一般我们使用const关键字定义常量，被const修饰的，不能改变其值。

using System;  
  
namespace ConsoleApp8  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            const float Pi = 3.1415926f;  
            //Pi = 0;   //会报错，const修饰，标识Pi是常量，修改值会报错            //const float PI;  //报错，没有赋值  
            Console.WriteLine(Pi);  
            Console.ReadKey();  
        }  
    }  
}

常量只能是：sbyte,byte,short,ushort,int,uint,long,ulong,char,float,double,decimal,bool,string等类型，创建常量时，必须给出初始值

变量：

变量代表这一块内存空间,我们可以通过变量名称向内存存/取数据.有变量就不需要我们记忆复杂的内存地址了.

变量声明规则（基本等同于）：

1.变量名只能由数字，字幕和下划线组成；

2.变量明德第一个字母不能是数字

3.不能使用关键字作为变量名

4.在某一个变量的作用域内，不能出现和该变量相同名字的变量

变量的作用域：可以访问该变量的区域

1.只要字段所属的类在某个作用域内，那么该字段也在该作用域内（看所属的类的作用域，也就是常说的实参--全局变量）

2.同居不变量存在于标识声明该变量的快语句或者方法结束的封闭花括号之前的作用域内（看花括号的作用域，也就是常说的形参--局部变量）

3.for/while/if等，变量作用域在循环体或者语句块中

using System;

namespace ConsoleApp8
{
    class Program
    {
        private string Name = "zhangsan";   //全局变量，其范围整个program类
        private Test test;

        static void Main(string[] args)
        {

        }

        public void Fun(string name)   //局部变脸，起范雯Fun方法中
        {
            Name = name;
            for (int i = 0; i < 100; i++)   //变量i的范围，for循环中
            {
                //float i = 0.1f;   //在循环中由一个变量i，作用范围是整个循环，在定义一个变量i会报错
            }
        }
    }

    class Test
    {

    }
}

9.数据类型

数据类型	说明	取值范围	对应于System程序集中的结构
sbyte	有符号8位整数	-128-127	SByte
byte	无符号8位整数	0-255	Byte
short	有符号16位整数	-32768-32767	Int16
ushort	无符号16位整数	0-65535	UInt16
Int	有符号32位整数	-2147489648-2147483647	Int32
uint	无符号32位整数	0-42994967295	UInt32
long	有符号64位整数	-263-263	Int64
ulong	无符号64位整数	0-264	UInt64

float	32位单精度实数	1.5*10-45-3.4*1038
double	64位双精度实数	5.0*10-324-1.7*10308
demcimal	128位十进制实数	1.0*10-28-7.9*1028

char

unicode字符

10.类和对象

类：从定义上来讲，具有相似行为的对象的集合，称为类。类是C#面向对象编程的基本单元，从代码的角度看，它是属性和方法的集合。

对象：从上面可以看出，类是抽象的，把许多相似行为的对象抽象成数据模型，而对象是现实中的实体。万事万物皆为对象，是面向对象的核心思想。

对象3要素：属性（对象是什么）、方法（对象能做什么）、事件（对象如何响应）

using System;

namespace ConsoleApp1 {     class Program  //定义一个类     {         //主函数，Mian方法         static void Main(string[] args)         {

        }     } }

using System;

namespace ConsoleApp1 {     class People 定义一个人类     {         People zhangsan = new People(); //定义一个人类对象zhangsan     } }

举个例子：人是一个类，张三同学是类的一个对象。

11.运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：
a.算术运算符

下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

int a = 21;
int b = 10;
int c;

c = a + b;
Console.WriteLine("Line 1 - c 的值是 {0}", c);
c = a - b;
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a * b;
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = a / b;
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a % b;
Console.WriteLine("Line 5 - c 的值是 {0}", c);

// ++a 先进行自增运算再赋值
c = ++a;
Console.WriteLine("Line 6 - c 的值是 {0}", c);

// 此时 a 的值为 22
// --a 先进行自减运算再赋值
c = --a;
Console.WriteLine("Line 7 - c 的值是 {0}", c);
Console.ReadLine();

结果是：
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21

b.关系运算符

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

c.逻辑运算符

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

d.位运算符

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A | B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

e.赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |= 2 等同于 C = C | 2

f.其他运算符

运算符	描述	实例
sizeof()	返回数据类型的大小。	sizeof(int)，将返回 4.
typeof()	返回 class 的类型。	typeof(StreamReader);
&	返回变量的地址。	&a; 将得到变量的实际地址。
*	变量的指针。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则为 X : 否则为 Y
is	判断对象是否为某一类型。	If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。
as	强制转换，即使转换失败也不会抛出异常。	Object obj = new StringReader("Hello"); StringReader r = obj as StringReader;

12.运算符优先级

优先级	运算符	名称或含义	使用形式	结合方向	说明
1	后置++	后置自增运算符	变量名++	左到右
	后置--	后置自减运算符	变量名--
	[ ]	数组下标	数组名[整型表达式]
	( )	圆括号	（表达式）/函数名(形参表)
	.	成员选择（对象）	对象.成员名
	->	成员选择（指针）	对象指针->成员名
2	-	负号运算符	-表达式	右到左	单目运算符
	(类型)	强制类型转换	(数据类型)表达式
	前置++	前置自增运算符	++变量名		单目运算符
	前置--	前置自减运算符	--变量名		单目运算符
	*	取值运算符	*指针表达式		单目运算符
	&	取地址运算符	&左值表达式		单目运算符
	!	逻辑非运算符	!表达式		单目运算符
	~	按位取反运算符	~表达式		单目运算符
	sizeof	长度运算符	sizeof 表达式/sizeof(类型)
3	*	乘	表达式*表达式	左到右	双目运算符
	/	除	表达式/表达式		双目运算符
	%	余数（取模）	整型表达式%整型表达式		双目运算符
4	+	加	表达式+表达式	左到右	双目运算符
	-	减	表达式-表达式		双目运算符
5	<<	左移	表达式<<表达式	左到右	双目运算符
	>>	右移	表达式>>表达式		双目运算符
6	>	大于	表达式>表达式	左到右	双目运算符
	>=	大于等于	表达式>=表达式		双目运算符
	<	小于	表达式<表达式		双目运算符
	<=	小于等于	表达式<=表达式		双目运算符
7	==	等于	表达式==表达式	左到右	双目运算符
	!=	不等于	表达式!= 表达式		双目运算符
8	&	按位与	整型表达式&整型表达式	左到右	双目运算符
9	^	按位异或	整型表达式^整型表达式	左到右	双目运算符
10	|	按位或	整型表达式|整型表达式	左到右	双目运算符
11	&&	逻辑与	表达式&&表达式	左到右	双目运算符
12	||	逻辑或	表达式||表达式	左到右	双目运算符
13	?:	条件运算符	表达式1? 表达式2: 表达式3	右到左	三目运算符
14	=	赋值运算符	变量=表达式	右到左
	/=	除后赋值	变量/=表达式
	*=	乘后赋值	变量*=表达式
	%=	取模后赋值	变量%=表达式
	+=	加后赋值	变量+=表达式
	-=	减后赋值	变量-=表达式
	<<=	左移后赋值	变量<<=表达式
	>>=	右移后赋值	变量>>=表达式
	&=	按位与后赋值	变量&=表达式
	^=	按位异或后赋值	变量^=表达式
	|=	按位或后赋值	变量|=表达式
15	,	逗号运算符	表达式,表达式,…	左到右	从左向右顺序运算

13.表达式

表达式由操作数 (operand) 和运算符 (operator) 构成。表达式的运算符指示对操作数适用什么样的运算。

例如：

int i = 0;  //赋值表达式

i += 1;     //运算表达式

标准输入输出：输入 语句：System.Console.Write();
或者System.Console.WriteLine();（两种输出区别：仅仅在于换行与否）
                输出System.Console.Read(); //只输入一个字符
                或者System.Console.ReadLine();//输入字符串

14.语句

类别	C# 关键字
选择语句	if、else、switch、case
迭代语句	do、for、foreach、in、while
跳转语句	break、continue、default、goto、return、yield
异常处理语句	throw、try-catch、try-finally、try-catch-finally
Checked 和 unchecked	checked、unchecked
fixed 语句	fixed
lock 语句	lock

标准输入输出：

输入语句： System.Console.Write();或者System.Console.WriteLine();（两种输出区别：仅仅在于换行与否）
输出语句System.Console.Read();  或者System.Console.ReadLine();

15.方法

一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序至少有一个带有 Main 方法的类。

using System;

namespace ConsoleApp15
{
    class Program
    {
        //主函数，Main函数，C#程序的入口
        static void Main(string[] args)
        {

        }
    }
}

using System;

namespace ConsoleApp15
{
    class Program
    {
        private string Name = "zhangsan";
        private static string _Name = "lisi";

        //主函数，Main函数，C#程序的入口
        static void Main(string[] args)
        {

        }

        /// 

        /// 带返回值的方法，返回一个string类型的变量；带返回值的方法，必须要有return；
        /// 
        /// 
        private string GetName()
        {
            return Name;
        }

        /// 

        /// 不带返回值的方法，也可以说返回值为空的方法
        /// 
        /// 
        private void SetName(string name)
        {
            Name = name;
        }

        /// 

        /// 带返回值的静态方法，返回一个string类型的变量；带返回值的静态方法，必须要有return；
        /// 
        /// 
        private static string _GetName()
        {
            return _Name;
        }

        /// 

        /// 不带返回值的静态方法，也可以说返回值为空的静态方法
        /// 
        /// 
        private static void _SetName(string name)
        {
            _Name = name;
        }
    }
}

16.枚举

枚举使用enum关键字来声明，与类同级。 枚举本身可以有修饰符，但枚举的成员始终是公共的，不能有访问修饰符。枚举本身的修饰符仅能使用public和internal。 枚举是值类型，隐式继承自System.Enum，不能手动修改。System.Enum本身是引用类型，继承自System.ValueType。 枚举都是隐式密封的，不允许作为基类派生子类。 枚举类型的枚举成员均为静态，且默认为Int32类型。 每个枚举成员均具有相关联的常数值。此值的类型就是枚举的底层数据类型。每个枚举成员的常数值必须在该枚举的底层数据类型的范围之内。如果没有明确指定底层数据类型则默认的数据类型是int类型。 枚举成员不能相同，但枚举的值可以相同。 枚举最后一个成员的逗号和大括号后面的分号可以省略

using System;

namespace ConsoleApp16
{
    class Program
    {
        private Country MyCountry = Country.China;
        static void Main(string[] args)
        {
            Program p = new Program();
            if (p.MyCountry == Country.China)
            {
                Console.WriteLine("我是中国人！");
            }
        }
    }

    enum Country              //声明一个国家的枚举
    {
        China,
        USA,
        England,
        France
    }
}

17.字符串string

string 类型表示零个或多个 Unicode 字符的序列， string 为引用类型

using System;

namespace ConsoleApp15
{
    class Program
    {
        private string Name = "zhangsan";    //定义一个字符串变量
        private static string _Name = "lisi";    //定义一个静态的字符串变量

        //主函数，Main函数，C#程序的入口
        static void Main(string[] args)
        {

        }
    }
}

18.字符串操作

a---》字符串的声明：
　　1、string s=new string(char[] arr) ;   //根据一个字符数组声明字符串，即将字符字组转化为字符串。
　　2、string s=new string(char r,int i);    //生成 i 个字符 r 的字符串。
b---》字符串常用的静态方法：
　　1、Compare 字符串的比较（按照字典顺序）  
　　　　int result= string.Compare(string str1,string str2); 
　　　　当str1 > str2时，返回1
　　　　当str1 = str2时，返回0
　　　　当str1 < str2时，返回-1
　　　　string.Compare(string str1,string str2,bool ignoreCase)   //忽略大小写比较
　　2、Concat连接方法参数很多，常用的Concat(string str1，string str2);
　　　　string str=string.Concat("w","e"); //str="we";
　　3、Format参数化处理，相当于Console.WriteLine();
　　　　string str=String.Format("今天{0}很热","天气");//str="今天天气很热";
　　4、IsNullOrEmpty判断字符是否为null或者为空，返回值为bool；
　　　　string str1="hahha";　　　　
　　　　bool b1=string.IsNullOrEmpty(str);//b1=false;
　　　　string str2="";
　　　　bool b2=string.IsNullOrEmpty(str2);//b2=true;
　　　　string str3=null;
　　　　bool b3=string.IsNullOrEmpty(str3);//b3=true;
　　5、Join字符串的合并
　　　　string.Join(string str,string[] strArr);//将数组strArr中的内容拼接成一个新的字符串，并在对应数组的每两项间添加分隔符str
　　　　string strs=string.Join(",",string[]{"w","e","r","t"});//strs="w,e,r,t";
c---》字符串常用的实例方法：
　　1、Contains 判断字符串中是否包含某个字符,返回bool值。
　　　　string str="好累呀";
　　　　bool  b=str.Contains("累");//b=true;
　　2、EndsWith和StartsWith  判断是否是已某种字符串开始或者结束
　　　　string str="好大的雨呀";
　　　　bool  b1=str.StartsWith("大");//b1=false;
　　　　bool  b2-str.EndsWith("呀");//b2=true;
　　3、Equals 比较两个字符串是否相等
　　　　string str1="asd";
　　　　string str2="ert";
　　　　bool  b = str1.Equals(str2);  //b=false;
　　　　bool .Equals(string str, StringComparison.OrdinalIgnoreCase)   //表示不区分大小写
　　 4、IndexOf 和 LastIndexOf  判断字符串第一次出现（IndexOf）和最后一次出现（LastIndexOf  ）的位置，如果没有出现过则返回值为-1
　　　　string str ="今天的雨很大，天很冷";
　　　　int i=str.IndexOf("很"); //i=4;
　　　　int i=str.LastIndexOf("很");//j=8;
　　　　int m=str.IndexOf("小");//m=-1;
　　 5、Replace 字符串(字符也是可以的)替换，返回新的字符串
　　　　string str="好困呀";
　　　　string s=str.Replace("困","精神");//s="好精神呀";
　　 6、Insert 插入
　　　　在字符串的index位置上插入字符，原来的字符依次后移，变成一个新的字符串
　　　　string str="夜深了";
　　　　string s=str.Insert(1,"已经");//  s="夜已经深了"
　　 7、Remove删除字符串（字符）
　　　　在字符串中移除从startIndex开始，长度为length的字符串，剩下的字符合为一个新的字符串( = .Remove(startIndex,length);)
　　　　string str="夜已经深了";
　　　　string s=str.Remove(1,2);//s="夜深了";
　　 8、Split 将字符串以sep数组中的字符分割，分割后得到的内容存到一个数组中（string[] .Split(params char[] sep);）
　　　　string str="我，真的、好困；呀";
　　　　string[] s=str.Split(new char(){'，','、','；'});//s=string[]{"我","真的","好困","呀"};
　　 9、Substring 截取字符以index开始截取，并截取lenth个字符(string .Substring(index,lenth))
　　　　string str="还在下雨";
　　　　string s=str.Substring(2,2);//s="下雨";
　　 10、ToCharArray将字符串转化为字符数组（.ToCharArray()）
　　　　　string str="雨已经小了";
　　　　　char[] s=str.ToCharArray();//s=char[]{'雨',"已","经","小","了"};
　　 11、Trim() 出去两边的空格
　　　　  string str="  dd  ";
　　　　  string s=str.Trim();//s="dd";
　　 12、ToUpper（转换为大写）和ToLower（转换为小写）
　　　　　string s="RaSer";
　　　　　string s1=s.ToUpper();//s1="RASER";
　　　　　string s2=s.ToLower();//s2="raser";

19.结构体

C#中结构类型和类类型在语法上非常相似，他们都是一种数据结构，都可以包括数据成员和方法成员。

结构和类的区别：

1、结构是值类型，它在栈中分配空间；而类是引用类型，它在堆中分配空间，栈中保存的只是引用(所以结构比类快)。

2、结构类型直接存储成员数据，让其他类的数据位于对中，位于栈中的变量保存的是指向堆中数据对象的引用。

C#中的简单类型，如int、double、bool等都是结构类型。如果需要的话，甚至可以使用结构类型结合运算符运算重载，再为C#语言创建出一种新的值类型来。

由于结构是值类型，并且直接存储数据，因此在一个对象的主要成员为数据且数据量不大的情况下，使用结构会带来更好的性能。

结构和类的适用场合分析：

1、当堆栈的空间很有限，且有大量的逻辑对象时，创建类要比创建结构好一些；

2、对于点、矩形和颜色这样的轻量对象，假如要声明一个含有许多个颜色对象的数组，则CLR需要为每个对象分配内存，在这种情况下，使用结构的成本较低；

3、在表现抽象和多级别的对象层次时，类是最好的选择，因为结构不支持继承。

类和结构对比：

                                                                        结构 　　　　　　　　　　　　　　　　　　 类
数据类型　　　　　　　　　　　　　　　 值类型　　　　　　　　　　　　　　　　　　引用类型
是否必须使用new运算符实例化　　　　　　否　　　　　　　　　　　　　　　　　　　　 是
是否可声明无参数的构造函数　　　　　　　否　　　　　　　　　　　　　　　　　　　　是
数据成员可否在声明的同时初始化　　　　　声明为const或static可以，数据成员不可以　   可以
直接派生自什么类型　　　　　　　　　　　System.ValueType　　　　　　　　　　　      有
是否有析构函数　　　　　　　　　　　　　无　　　　　　　　　　　　　　　　　　　　有
可否从类派生　　　　　　　　　　　　　　否　　　　　　　　　　　　　　　　　　　　可以
可否实现接口　　　　　　　　　　　　　　可以　　　　　　　　　　　　　　　　　　　可以
实例化时在栈还是在堆分配内存　　　　　　栈　　　　　　　　　　　　　　　　　　　　堆，栈中保存引用
该类型的变量可否被赋值为null　　　　　　 否　　　　　　　　　　　　　　　　　　　　可以
可否定义私有的无参构造函数　　　　　　　否　　　　　　　　　　　　　　　　　　　　可以
是否总有一个默认的无参构造函数　　　　   是　　　　　　　　　　　　　　　　　　　　 否

20.数组（下面都是以一维数组为例，多维数组有需求可以自行加深学习）

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。

所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素。

声明数组：

 class Program
    {
        //主函数，Main函数，C#程序的入口
        static void Main(string[] args)
        {
            Program[] arrayName;          //数组的声明，Program为数组类型，[]数组的维度，arrayName数组的名称

            arrayName = new Program[1];   //数组的初始化

            arrayName[0] = new Program(); //数组的赋值
        }
    }

21.数组的操作

a.数组的声明和赋值方式

int[] myArray;
 
int[] myArray = {1, 2, 3, 4};
 
int[] myArray = new int[4] {1, 2, 3, 4};

b.数组元素的获取

myArray[0];

c.foreach循环

string[] myArray = {"alily", "swen", "ben", "cat"};
foreach (var value in myArray) {
  Console.Write(value); // alily, swen, ben, cat
}

d.复制数组

// 当数组元素是值类型时，Clone()复制所有值
int[] intArray = {1, 2, 3};
int[] intArrayClone = (int[]) intArray.Clone(); // intArrayClone = {1, 2, 3}
 
// 当数组元素包含引用类型，则只复制引用
Person[] girl = {new Person{FirstName = "Sam", LastName = "Lennon"}, new Person{FirstName = "Ben", LastName = "Cartney"}};
Person[] girlClone = (Person[]) girl.Clone(); // girl和girlClone引用的Person对象是相同的，当修改girlClone中一个引用类型元素的属性时，也会改变girl中对应对象

e.数组排序

int[] num =new int[] { 5,2,3,4,1 };
 
Array.Sort(num);
 
foreach(int i in num)
 
Console.WriteLine(i);

f.数组比较

string a = "world";
string b = "hello";
int result = a.CompareTo(b); // 返回一个负数

22.泛型（简单描述，不做过多纠结，有一个概念就行）

泛型将类型参数的概念引入 .NET Framework，类型参数使得设计如下类和方法成为可能：这些类和方法将一个或多个类型的指定推迟到客户端代码声明并实例化该类或方法的时候。泛型通常与集合以及作用于集合的方法一起使用。

 class Program
{
    static void Main(string[] args)
    {
        List list = new List();   指定一个泛型为int类型的集合
    }
}

23.集合

集合：专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

简单的讲，可以把集合看作是一个可变长度的数组。

24.抽象类

不能初始化的类被叫做抽象类。在C#中使用关键字 abstract 来定义抽象类和抽象方法。它们只提供部分实现，但是另一个类可以继承它并且能创建它们的实例。

abstract class ShapesClass
{
    abstract public int Area();
}

抽象类具有以下特征：

1.抽象类不能被实例化。

2.抽象类可以包含抽象方法和访问器

3.不能把抽象类用密封(sealed)来修饰，那就意味着类不能被继承，这违反抽象类被继承的原则。

4.一个派生于一个抽象类的非抽象类必须包括所有的继承来的抽象方法和访问器的实现

5.在方法和属性中使用abstract 关键字意味着包含它们的实现。

25.接口

接口定义了所有类继承接口时应遵循的语法， 指定一组函数成员而不实现成员的引用类型，其它类型和接口可以继承接口。

using System;

interface IMyInterface          //接口
{
	// 接口成员
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface   //继承接口
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()            //实现该接口的方法
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

26.继承

继承：面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。
当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。加入定义一个哺乳动物类和一个人类，那么我们可以让人类继承哺乳动物类

27.面对对象

面对对象的三大特性：封装，继承，多态，抽象（早期版本是四大特性，抽象也是）

(1)封装:为了实现某个功能而定义一连串的属性，方法，类等等，但是开发过程，实际上，并不需要我们了解每一行代码，只需调用相关的方法，属性或者接口等。就像

(2)继承：当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。

(3)多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。换句话说，实际上就是同一个类型的实例调用“相同”的方法，产生的结果是不同的。

 public void Sleep()
 {
   Console.WriteLine("Animal睡觉");
 }
 public int Sleep(int time)   //同样是Sleep方法，但是实现完全不同，因为参数不同
 {
   Console.WriteLine("Animal{0}点睡觉", time);
   return time;
 }

28.流程控制语句

a.选择语句

(1) if语句

(2) if…else 语句

(3) if…else if…else if ………else

class Program

    {

        static void Main(string[] args)

        {

            Console.Write("请输入一个字符");

            char c = (char)Console.Read();

            if (char.IsUpper(c))

            {

                Console.WriteLine("大写字母");

            }

            else if (char.IsLower(c))

            {

                Console.WriteLine("小写字母");

            }

            else if (char.IsDigit(c))

            {

                Console.WriteLine("数字");

            }

            else

            {

                Console.WriteLine("其他字符");

            }

        }

    }

(4)switch语句

switch (day)
{
　case 0 :
　　dayName = "Sunday";
　　break;
　case 1 :
　　dayName = "Monday";
　　break;
　case 2 :
　　dayName = "Tuesday";
　　break;
　default :
　　dayName = "Unknown";
　　break;
}

b.循环语句

(1) while循环

while(表达式)

{

   循环体

}

class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("循环结果为:");

            int n = 1;

            while (n < 6)

            {

                Console.WriteLine("循环第{0}次", n);

                n++;

            }

        }
}

(2)do…while循环

class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("循环结果为:");

            int n = 1;

            do

            {

                Console.WriteLine("循环第{0}次", n);

                n++;

            }

            while (n < 0);

        }

}

(3)for循环

class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("循环结果为:");

            for (int i = 0; i < 10; i++)

            {

                Console.WriteLine(i);

            }

        }

}

(4)foreach循环

int[] a = new int[3] {0,1,2  };//定义一个2行2列2纵深的3维数组a
foreach(int i in a)
{
    Console .WriteLine (i);
}

c.跳转语句

1.breack语句

while (i < 10)  
    {  
         if (i >= 0)  
           { Console.WriteLine("{0}", i);  
                  i--;  
           }  
          else   
           {  
               break;  
            }  
      }   

2.continue语句

 while (i<= 10)  
    {  
       if (i % 2 == 0)  
        {  
          i++;  
          continue;  
        }  
        Console.Write (i.ToString()+”,”);  
        i++;  
   }  

3.goto语句（基本不怎么使用）

4.retrun语句

 int Add(int a, int b)  
 {  
       return a + b;  
 }  

29.异常

异常是在程序执行期间出现的问题。

异常具有以下属性：

• 异常是最终全都派生自 System.Exception 的类型。

• 在可能抛出异常的语句周围使用 try 代码块。

• 在 try 代码块中出现异常后，控制流会跳转到调用堆栈中任意位置上的首个相关异常处理程序。 在 C# 中，catch 关键字用于定义异常处理程序。

• 如果给定的异常没有对应的异常处理程序，那么程序会停止执行，并显示错误消息。

• 除非可以处理异常并让应用程序一直处于已知状态，否则不捕获异常。 如果捕获 System.Exception，使用 catch 代码块末尾的throw 关键字重新抛出异常。

• 如果 catch 代码块定义异常变量，可以用它来详细了解所发生的异常类型。

• 使用 throw 关键字，程序可以显式生成异常。

• 异常对象包含错误详细信息，如调用堆栈的状态和错误的文本说明。

• 即使有异常抛出，finally 代码块中的代码仍会执行。 使用 finally 代码块可释放资源。例如，关闭在try 代码块中打开的任何流或文件。

• .NET Framework 中的托管异常在 Win32 结构化异常处理机制的基础之上实现。

所有异常对象的基类。
　　SystemException：运行时产生的所有错误的基类。
　　IndexOutOfRangeException：当一个数组的下标超出范围时运行时引发。
　　NullReferenceException：当一个空对象被引用时运行时引发。
　　InvalidOperationException：当对方法的调用对对象的当前状态无效时，由某些方法引发。
　　ArgumentException：所有参数异常的基类。
　　ArgumentNullException：在参数为空（不允许）的情况下，由方法引发。
　　ArgumentOutOfRangeException：当参数不在一个给定范围之内时，由方法引发。
　　InteropException：目标在或发生在CLR外面环境中的异常的基类。
　　ComException：包含COM类的HRESULT信息的异常。
　　SEHException：封装Win32结构异常处理信息的异常。
　　SqlException：封装了SQL操作异常。

　　常见具体的异常对象:
　　ArgumentNullException 一个空参数传递给方法，该方法不能接受该参数
　　ArgumentOutOfRangeException 参数值超出范围
　　ArithmeticException 出现算术上溢或者下溢
　　ArrayTypeMismatchException 试图在数组中存储错误类型的对象
　　BadImageFormatException 图形的格式错误
　　DivideByZeroException 除零异常
　　DllNotFoundException 找不到引用的DLL
　　FormatException 参数格式错误
　　IndexOutOfRangeException 数组索引超出范围
　　InvalidCastException 使用无效的类
　　InvalidOperationException 方法的调用时间错误
　　NotSupportedException 调用的方法在类中没有实现
　　NullReferenceException 试图使用一个未分配的引用
　　OutOfMemoryException 内存空间不够
　　StackOverflowException 堆栈溢出

30.线程

线程：程序的最小执行单位，轻量级单位

进程：可以认为是一个exe程序，在任务管理器中可以看到，一个进程可以包含很多线程

线程生命周期：开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。
下面列出了线程生命周期中的各种状态：
未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。
就绪状态：当线程准备好运行并等待 CPU 周期时的状况。
不可运行状态：下面的几种情况下线程是不可运行的：

已经调用 Sleep 方法
已经调用 Wait 方法
通过 I/O 操作阻塞
死亡状态：当线程已完成执行或已中止时的状况。

创建线程：

class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
        }
        
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            Console.ReadKey();
        }
    }

31.文件IO操作

这里讲解一些基本操作

1.创建文件夹

  //using System.IO;
   Directory.CreateDirectory(%%1); 

2.创建文件

using System.IO;
File.Create(%%1);

3.删除文件夹

using System.IO;
Directory.Delete(%%1);

4.删除文件

using System.IO;
File.Delete(%%1);

5.读取文件

using System.IO;
StreamReader s = File.OpenText(%%1);
string %%2 = null;
while ((%%2 = s.ReadLine()) != null){
         %%3
}
s.Close();

6.写文件

using System.IO;
FileInfo f = new FileInfo(%%1);
StreamWriter w = f.CreateText();
w.WriteLine(%%2);
w.Flush();
w.Close();

32.垃圾回收

一句话概括：C#是系统会在内存到达一定，自动回收垃圾内存（不用的变量，对象等），而不是使用完立即回收

垃圾回收的好处：

1、提高了软件开发的抽象度； 
2、程序员可以将精力集中在实际的问题上而不用分心来管理内存的问题； 
3、可以使模块的接口更加的清晰，减小模块间的偶合； 
4、大大减少了内存人为管理不当所带来的Bug； 
5、使内存管理更加高效。 

33.委托和事件

（1） 从数据结构来讲，委托是和类一样是一种用户自定义类型。
 （2） 从设计模式来讲，委托（类）提供了方法（对象）的抽象。

委托是方法的抽象，它存储的就是一系列具有相同签名和返回回类型的方法的地址。调用委托的时候，委托包含的所有方法将被执行。

委托的组成：

1.声明委托类型。

2.必须有一个方法包含了要执行的代码。

3.必须创建一个委托实例。

4.必须调用委托实例。

internal delegate void HelloCallBack(string name);
class Program
{
    static void Main(string[] args)
    {
        HelloCallBack helloShow = new HelloCallBack(ShowName);
 
        Console.ReadLine();
    }
 
    static void ShowName(string name)
    {
        Console.WriteLine(name);
    }        
}

事件

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些出现，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。事件是用于进程间通信。所以事件的应用非常广泛。

事件和委托过于复杂，有兴趣的可以单独寻找相关资料

34.单例

单例：该类有且仅有只有一个对象

public class Singleton
    {
        // 定义一个静态变量来保存类的实例
        private static Singleton uniqueInstance;

        // 定义私有构造函数，使外界不能创建该类实例
        private Singleton()
        {
        }

        /// 

        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// 
        /// 
        public static Singleton GetInstance()
        {
            // 如果类的实例不存在则创建，否则直接返回
            if (uniqueInstance == null)
            {
                uniqueInstance = new Singleton();
            }
            return uniqueInstance;
        }
    }

35.其他