C#基础语法总结
C#3.5
第一部分 基础知识
1.C#语法规则
(1)标示符，关键字，用户变量区分大小写；在输入命名时首字母要大写，第二个字段首字母也要大写；
(2)习惯用分号结尾(；)和花括号{}；
(3)NameSpace命名空间，用于将同名的类区分在不同名称的命名空间内；
(4)Using用法是引用一个程序集中的命名空间的名称，然后就可以在代码中直接调用该命名空间中的所有方法；
(5)行注示：双斜杠(//)；
块注示：/**/
代码提示信息
#region "提示信息"
//内容
#endRegion
(6)文件-新建-项目-控制台模板应用程序
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TextHello
{
class Program
{
static void Main(string[] args) //程序的入口，采用静态方法
{
System.Console.ReadLine(); //输入流信息
System.Console.WriteLine("Hello World"); //输出流信息
}
}
}
注：Main()函数；
static void Main()
static void Main(string［］ args)//args是函数命令行参数
static int Main()//返回一个表示函数终止状态的int值
static int Main(string［］ args)//返回一个表示函数终止状态的int值
(7)断行符分号（；），换行符号(\N),字符串连接符加号（+）；
(8)Windows模板应用程序有两种
一种是Windows应用程序界面，另一种是WPF是微软最新一代客户端展现层技术,利用它编写的应用程序可以在桌面和Internet之间搭起桥梁，未
来占有较大的优势；
以后所的有Windows界面以WPF为主；
(9)变量和常量：在程序运行时临时存储信息的容器，变量的生生命周期采决于变量的作用域，变量在声明时C#不允许隐式声明，在使用之前必
须先给变量赋初值，因为未赋值之前变量的值是随机的；例如：
int i;
string text;//在循环外未初始化
for (i = 0;i<10;i++)
{
text = "Line" + Convert.ToString(i);//在循环中未初始化，在退出循环的时候会丢失值，再引用就出错。
Console.WriteLine("{0}",text);
}
//Console.WriteLine("Last txet output in loop:{0}",text);//出错。
常量： Const int intTwo = 2 (必须声明的同时赋值)
全局变量:static/const 变量名//const定义的全局变量是只读的,当全局变量与局部变量同名时，局部变量优先，要用类似class1.myString来
引用全局变量。
(10)八种常用数据类型
A:
整型int n=10;
长整型：long m=20L;
浮点型：float x=6.35F;//单精度
双精度：double y=6.789;
货币型：decimal p=16.890M;
字符串：string str="world";
字符型：char ch='A';
逻辑型：bool flag=true;
object类
object类是预定义类System.Object的别名，它是所有其他类型的基类。c#中所有类型都直接或间接从object类中继承。因此，一个object类的
变量可以赋予任何类型的值。
int i=30;
object obj1;
obj1=i;
object obj2='a';
类型转换：Convert.ToString（变量1） 或( short ）变量2
B:
基本类型：
类型 字节数 解释
byte 1 无符号字节型
sbyte 1 有符号字节型
short 2 有符号短字节型
ushort 2 无符号短字节型
int 4 有符号整型
uint 4 无符号整型
long 8 有符号长整型
ulong 8 无符号长整型
float 4 浮点数
double 8 双精度数
decimal 8 固定精度数
string unicode字串型
char unicode字符型
bool 真假布尔型//只接受true和false两种值。不接受任何整数类型。
用户定义类型包括：
类类型(class)
结构类型(struct)
接口类型(interface)
(11)用户定义格式
A:结构
struct 结构名:
｛
访问方式1 变量类型1 变量名1;//访问方式public/private
访问方式2 变量类型2 变量名2;
...
｝
结构名 结构变量名;
结构变量名.枚举值=...;
B:类的定义
class 类名
...{
//类成员
}
实例：
classs Teacher {
public string Name; // 老师姓名
public uint Age; // 老师年龄
public string Phone; // 老师电话
public string Address; // 老师通讯地址
}
注意：类的成员变量访问修饰符都使用了public，在其他类中可以访问。
声明对象的语法如下：
类名 对象名=new 类名();
访问类的成员变量的语法如下：
对象名.变量名
下面声明一个Teacher对象，即实例化类Teacher，代码如下：
Teacher t=new Teacher();
t.Name=”小刘”;
----------------
using System;
class Teacher {
public string Name; // 老师姓名
public uint Age; // 老师年龄
public string Phone; // 老师电话
public string Address; // 老师通讯地址
}
class Test{
public static void Main() {
Teacher t=new Teacher(); // 实例化Teacher类
t.Name=”小刘”;
t.Age=35;
t.Phone=”13381335310″;
t.Address=”北京大学”;
Console.WriteLine(“该老师姓名={0},年龄={1},电话={2},通讯地址={3}”,
t.Name,t.Age,t.Phone,t.Address);
}
C:接口
interface IMyInterface
...{
//接口成员
}
(12)数组
A:一维数组格式：量类型［］ 数组名 = new 变量类型[元素个数]...{元素0,元素1,元素2...}
For循环到.Length
for(i=0,i<friendNames.Length,i++)
{
Console.WriteLine(friendNames［i］);
}
B:Foreach进行只读访问
foreach(string listName in friendNames)
...{
Console.WriteLine(listName);
}
一维实例：
//数值数组
int[] n = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//int[] n = {1,2,3,4,5,6,7,8,9,10 };
int y;
for (y = 0; y < n.Length ; y++)
{
Console.WriteLine("arry value:n[{0}]={1}\n", y,n[y]);
}
//字串数组
string[] b = { "abcdefghij","123","369" };
foreach(string listName in b) //一维数组流读取机制
{
Console.WriteLine(listName);//按行读取
}
C:二维数组(多维)
格式： 变量类型［,］ 数组名 = new 变量类型[一维元素个数,二维元素个数]...{...{元素00,元素01,元素02...},...{元素10,元素11,元素
12...}...}
//二维实例：
//二维字串数组
//string[,] list=new string[3,3]{{"abc","123","456"},{"abc","123","456"},{"abc","123","456"}};
//string[,] list ={ { "abc", "123", "456" }, { "abc", "123", "456" }, { "abc", "123", "456" } };
string[,] arryedu = new string[5,2] { { "初中 ", "10 " }, { "高中 ", "11 " },
{ "中技 ", "12 " }, { "中专 ", "13 " }, { "大专 ", "14 " } };
int edunum;
for (edunum = 0; edunum < 5; edunum++)
{
Console.WriteLine("arry value:{0},{1}\n", arryedu[edunum, 0], arryedu[edunum, 1]);
}
//二维字符数组
char[,] str = {{'a','b','c'},{'a','b','c'},{'a','b','c'} };
int u, p;
for (u = 0; u < 3;u++ )
{
for (p = 0; p < 3;p++ )
{
Console.WriteLine("values:str[{0},{1}]={2}",u,p,str[u,p]);
}
}
(13)运算符：按优先级顺序排列
算术运算符：前缀的++和-- ,前缀一元的+和- 乘 * 除 / 求余 % 加 + 减 -
位移运算符：<<,>>
比较运算符：小于 < 大于 > 小于等于 <= 大于等于 >=
比较运算符：==,!=
逻辑运算符：&
逻辑运算符：^
逻辑运算符：|
逻辑运算符：&&
逻辑运算符：||
比较运算符：等于 =
*=
/=
%=
+=
-=
<<=
>>=
&=
^= |=
后缀的++和--
(14)字符串操作：
string myString = "I have a dream.";
char myChar = myString［2］;//把string变量当作只读的char数组使用，不能改写myString［2］
char［］ myChars = myString.ToCharArray();
char［］separator = ｛' '｝;//设定分隔符
string［］ myWords =myString.Split(separator);//分隔成数组
Console.WriteLine("myString have {0} chars",myString.Length);
myString=myString.ToLower();//转小写
myString=myString.ToUpper();//转大写
myString=myString.Trim();//删前后空格
myString=myString.TrimStart();//删前空格
myString=myString.TrimEnd();//删后空格
myString=myString.PadLeft(位数);//前补空格到指定位数
myString=myString.PadRight(位数);//后补空格到指定位数
myString=myString.PadLeft(位数,字符);//前补指定字符到指定位数
char［］ trimChars = ｛"e","#","*"｝;
myString = myString.trim(trimChars);//删指定字符
2.控件流程
流程控制：if..else if…else if…else switch…case while for do…while break continue
(1)条件语句
Ａ，If语句：通用判断
If （条件1）
单行代码1;
Else
单行代码2;
If （条件1）
｛多条语句；｝
Else
｛多条语句；｝
Ｂ，Switch语句：用于同条件多结果判断
Switch (条件)
...{
Case 结果1:
代码1;
break;
Case 结果2:
代码2;
break;
Case 结果3:
代码3;
goto Case 结果2;//此时Case..相当于一个Label
Case 结果4:
代码4;
Return;
Case 结果5:
Case 结果6:
Case 结果7:
代码567;//只要满足上面三个Case之一就执行。
break;
...
Default:
代码;
break;
｝
Ｃ，三元运算语句：(条件)?True结果:False结果
常用于简单赋值语句：string myString = (myInteger<10)?"Less than 10":"Great than or equal to";
或者用于简单格式化文本语句：Console.WriteLine("I am {0} year{1} old.",myinteger,myinteger==1?"":"s");
(2)，循环语句：
Ａ，Do...While： 当条件为True时循环。ss
Do
...{...}While(条件);//分号不可少
Ｂ，While...： 当条件为True 时循环。
While(条件)
...{...}
Ｃ，For...： 使用计数器循环。
For (变量;条件;操作)//可以在此时声明变量，但作用域就仅限于循环内了。
...{...
Break;//跳出整个循环
Return;
Continue;//中止当前循环,继续下一个循环
Goto 标签;//禁止从循环外部用goto跳入循环内部
}
第二部 面向对象
面向对象的关键概念
抽象（Abstraction）
封装（Encapsulation）
多态（Polymorphism）
继承（Inheritance）
1. 访问修饰符
c#的访问修饰是权限控制的一个子集在编程中,需要用访问修饰符来指定其访问权限
目前 C# 支持使用以下访问修饰符之一来指定其可访问性
public 是类和类成员的访问修饰符，公共访问是允许的最高访问级别，类内类外都有访问权限；
private 是一个成员访问修饰符，私有访问是允许的最低访问级别，私有成员只有在声明它们的类和结构体中才是可访问。
protected 是一个成员访问修饰符，只有在它受保护的类中或者派生类中可以访问该类中成员。
internal 是类和类成员的访问修饰符，同一程序集中的任何代码都可以访问该类型或成员，但其他程序集中的代码不可以。
protected internal 同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。
访问关键字：
base->访问基类的成员。
this->引用调用一个方法的当前对象。
2. 可以作用于类和结构的修饰符
(1) abstract：指示某个类只能是其他类的基类。
可以和类、方法、属性、索引器及事件一起使用。在类声明中使用 abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽
象类中的成员必须通过从抽象类派生的类来实现。
(2) sealed：指定类不能被继承。
可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。当应用于方
法或属性时，sealed修饰符必须始终与override一起使用。
在类声明中使用 sealed修饰符可防止继承此类
(3) static：声明属于类型本身而不是属于特定对象的成员。
声明属于类型本身而不是属于特定对象的静态成员。可用于类、字段、方法、属性、运算符、事件和构造函数，但不能用于索引器、析构函数
或类以外的类型。
(4) partial：在整个同一程序集中定义分部类和结构。
分部类型定义允许将类、结构或接口的定义拆分到多个文件中。
3. 只能用在方法或变量的修饰符
(1) const：指定无法修改字段或局部变量的值。
用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数，不能被修改。
(2) new：从基类成员隐藏继承的成员。
在用作修饰符时，new关键字可以显式隐藏从基类继承的成员。隐藏继承的成员意味着该成 员的派生版本将替换基类版本。在不使用 new修饰
符的情况下隐藏成员是允许的，但会生成警告。使用 new显式隐藏成员会取消此警告，并记录代之以派生版本这一事实。
若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并使用 new修饰符修饰该成员。
对同一成员同时使用 new和override是错误的，因为这两个修饰符在含义上相互排斥。使用 new会用同样的名称创建一个新成员并使原始成员
变为隐藏的，而 override则扩展继承成员的实现。
(3) virtual：在派生类中声明其实现可由重写成员更改的方法或访问器。
用于修饰方法、属性、索引器或事件声明，并且允许在派生类中重写这些对象。
调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，如果没有派生类重写该成员，则它可能是原始
成员。
默认情况下，方法是非虚拟的。不能重写非虚方法。
virtual修饰符不能与 static、abstract和 override修饰符一起使用。
除了声明和调用语法不同外，虚拟属性的行为与抽象方法一样。
(4) override：提供从基类继承的虚拟成员的新实现。
要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现，必须使用 override修饰符。
(5) readonly：声明一个字段，该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。
是可以在字段上使用的修饰符。当字段声明包括 readonly修饰符时，该声明引入的字段赋值只能作为声明的一部分出现，或者出现在同一类的
构造函数中。在此示例中，字段year的值无法在ChangeYear方法中更改，即使在类构造函数中给它赋了值。
4. 特殊作用的修饰符
(1) event：声明事件。
类和结构使用事件将出现的可能影响对象状态的事件通知给对象。
(2) extern：指示在外部实现方法。
用于声明在外部实现的方法。extern修饰符的常见用法是在使用 Interop 服务 调入非托管代码时与DllImport属性一起使用；在这种情况下，
该方法还必须声明为 static。
extern关键字还可以定义外部程序集别名，使得可以从单个程序集中引用同一组件的不同版本。
将 abstract和 extern修饰符一起使用来修改同一成员是错误的。使用 extern修饰符意味着方法在 C# 代码的外部实现，而使用 abstract修
饰符意味着在类中未提供方法实现。
(3) unsafe：声明不安全的上下文。该上下文是任何涉及指针的操作所必需的。
(4) volatile：指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。
volatile关键字表示字段可能被多个并发执行线程修改。声明为 volatile的字段不受编译器优化（假定由单个线程访问）的限制。这样可以确
保该字段在任何时间呈现的都是最新的值。
volatile修饰符通常用于由多个线程访问而不使用 lock 语句（C# 参考）语句对访问进行序列化的字段。
volatile关键字可应用于以下类型：
（1）引用类型。
（2）指针类型（在不安全的上下文中）。
（3）整型，如 sbyte、byte、short、ushort、int、uint、char、float 和 bool。
（4）具有整数基类型的枚举类型。
（5）已知为引用类型的泛型类型参数。
（6）IntPtr 和 UIntPtr。
