一周学会C#.doc

一周学会C#（前言）

C#才鸟(QQ:249178521)

大家好！C#作为微软在21世纪推出的新语言，它有着其他语言无法比拟的优势。但如何在短时间内迅速掌握它，却是一个比较难的问题。但如果你看完这个教程后，你一定会理解并掌握C#。
这个教程共分六个部分，今天先介绍C#中比较基本的概念。
1.总体框架
Hiker.cs 类名不一定等于文件名
using System; //每一个程序必须在开头使用这一语句
public sealed class HitchHiker
{
public static void Main()//程序从Main开始执行
{
int result;
result = 9 * 6;
int thirteen;
thirteen = 13;
Console.Write(result / thirteen); //输出函数
Console.Write(result % thirteen);
}
}
//上面各语句的具体用法以后会介绍
/* 这个程序用来
* 演示C#的总体框架
*/
注意：上面的程序中，符号//表示注释，在//后面的同一行上的内容是注释;
/*和*/ 这间的内容都是注释
你可以在windows的命令行提示符下键入：csc Hiker.cs
进行编译产生可执行文件Hiker.exe
然后在windows的命令行提示符下键入：Hiker，你就可以看到在屏幕上显视42
(注：你必须装有.net framework)

program
execution
starts
at Main
和Java不一样，C#源文件名不一定要和C#源文件中包含的类名相同。single-line comment
C#对大小写敏感，所以Main的首字母为大写的M(这一点大家要注意，尤其是熟悉C语言的朋友)。
你可以定义一个返回值为int的Main函数，当返回值为0时表示成功：
public static int Main() { ... return 0; }
你也可以定义Main函数的返回值为void：
public static void Main() { ... }
你还可以定义Main函数接收一个string数组：
public static void Main(string[] args)
{
foreach (string args in args) {
System.Console.WriteLine(arg);
}
}
程序中的Main函数必须为static。
2.标识符
标识符起名的规则：
ü 局部变量、局部常量、非公有实例域、函数参数使用camelCase规则；其他类型的标识符使用PascalCase规则。
privateStyle camelCase规则（第一个单词的首字母小写，其余单词的首字母大写）
PublicStyle PascalCase规则（所有单词的首字母大写）
ü 尽量不要使用缩写。
Message，而不要使用msg。
ü 不要使用匈牙利命名法。
public sealed class GrammarHelper
{ ...
public QualifiedSymbol Optional(AnySymbol symbol)
{ ... }
private AnyMultiplicity optional =
new OptionalMultiplicity();
}
3.关键字
C#中76个关键字：
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 int interface
internal is lock long namespace
new null object operator 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 virtual void
while
5个在某些情况下是关键字：
get set value add remove
C#中有76个在任何情况下都有固定意思的关键字。另外还有5个在特定情况下才有固定意思的标识符。例如，value能用来作为变量名，但有一种情况例外，那就是它用作属性/索引器的set语句的时候是一关键字。
但你可以在关键字前加@来使它可以用作变量名：
int @int = 42;
不过在一般情况下不要使用这种变量名。
你也可以使用@来产生跨越几行的字符串，这对于产生正则表达式非常有用。例如：
string pattern = @"
( # start the group
abra(cad)? # match abra and optional cad
)+"; # one or more occurrences
如果你要在字符串中包含双引号，那你可以这样：
string quote = @"""quote""";
4.标点符号
{ 和 } 组成语句块
分号表示一个语句的结束
using System;
public sealed class Hiker
{
public static void Main()
{
int result;
result = 9 * 6;
int thirteen;
thirteen = 13;
Console.Write(result / thirteen);
Console.Write(result % thirteen);
}
}
一个C#的“类/结构/枚举”的定义不需要一个终止的分号。
public sealed class Hiker
{
...
} // 没有;是正确的
然而你可以使用一个终止的分号，但对程序没有任何影响：
public sealed class Hiker
{
...
}; //有;是可以的但不推荐
在Java中，一个函数的定义中可以有一个结尾分号，但在C#中是不允许的。
public sealed class Hiker
{
public void Hitch() { ... }; //;是不正确的
} // 没有;是正确的
5.声明
声明是在一个块中引入变量
u 每个变量有一个标识符和一个类型
u 每个变量的类型不能被改变
using System;
public sealed class Hiker
{
public static void Main()
{
int result;
result = 9 * 6;
int thirteen;
thirteen = 13;
Console.Write(result / thirteen);
Console.Write(result % thirteen);
}
}
这样声明一个变量是非法的：这个变量可能不会被用到。例如：
if (...)
int x = 42; //编译时出错
else
...
6.表达式
表达式是用来计算的!
w 每个表达式产生一个值
w 每个表达式必须只有单边作用
w 每个变量只有被赋值后才能使用
using System;
public sealed class Hiker
{
public static void Main()
{
int result;
result = 9 * 6;
int thirteen;
thirteen = 13;
Console.Write(result / thirteen);
Console.Write(result % thirteen);
}
}
C#不允许任何一个表达式读取变量的值，除非编译器知道这个变量已经被初始化或已经被赋值。例如，下面的语句会导致编译器错误：
int m;
if (...) {
m = 42;
}
Console.WriteLine(m);// 编译器错误，因为m有可能不会被赋值
7.取值
类型 取值 解释
bool true false 布尔型
float 3.14 实型
double 3.1415 双精度型
char 'X' 字符型
int 9 整型
string "Hello" 字符串
object null 对象
8.操作符
操作符 类型
+ - * / %（取余数） 算术
&& || ! ?: 逻辑
< <= > >= 关系
== != 相等
= 赋值
9．编程风格
· 较正规的编程风格
w 在一个二元操作符的每一边都加一个空格
w 在每一个逗号后面而不是前面加一个空格
w 每一个关键字后面加一个空格
w 一行一个语句
w 分号前不要有空格
w 函数的园括号和参数之间不加空格
w 在一元操作符和操作数之间不加空格
在一个二元操作符的每一边都加一个空格：
Console.WriteLine("{0}", result / 13); //推荐
Console.WriteLine("{0}", result/13); //不推荐
在每一个逗号后面而不是前面加一个空格：
Console.WriteLine("{0}", result / 13); //推荐
Console.WriteLine("{0}",result / 13); //不推荐
每一个关键字后面加一个空格：
if (OneLine(comment)) ... //推荐
if(OneLine(comment)) ... //不推荐
分号前不要有空格：
Console.WriteLine("{0}", result / 13); //推荐
Console.WriteLine("{0}", result / 13) ; //不推荐
函数的园括号和参数之间不加空格：
if (OneLine(comment)) ... //推荐
if (OneLine( comment )) ... //不推荐
在一元操作符和操作数之间不加空格：
++keywordCount; //推荐
++ keywordCount; //不推荐
10.找错
bool checked;
... 1

public static void main()
{ ... } 2

int matched = symbol.Match(input)
if (matched > 0)
{
....
} 3

char optional = "?";
string theory = 'complex'; 4

int matched = 0_or_more(symbol);
... 5

第1段程序的错误：checked是一个关键字
第2段程序的错误：不是main，而是Main
第3段程序的错误：变量声明语句没有分号
第4段程序的错误：字符值必须用单引号表示，字符串必须用双引号表示
第5段程序的错误：第一个错误是标识符不能以数字开头;第二个错误是不能用下划线作标识符。

一周学会C#（函数）
C#才鸟（QQ:249178521）
1.前言
· C#不支持全局函数
w 所有的函数必须在类内部声明
· 无源文件和头文件之分
w 所有的函数必须声明的时候被实现
int NotAllowed() //错误，C#没有全局函数
{
...
}
sealed class Methods
{
void Inline()
{ ...
}
void Error()
{ ...
}; //错误，函数不能有结尾分号
int AlsoError(); //错误，函数必须声明的时候被实现
}
和Java一样，C#不允许有全局函数。所有的函数必须在类或结构内实现。函数是类或结构的成员，函数也被称为方法。
C#允许可以在类的声明中加入结尾分号，例如：
sealed class Methods
{
...
};//可以有结尾分号
但是，C#不允许在函数的声明中加入结尾分号，例如：
sealed class Methods
{
void NotAllowed() {...} ; //错误，函数不能有结尾分号
}
2.声明函数
· 函数参数列表
w 各参数以逗号隔开
w 参数必须命名
w 没有参数时括号不能省略
sealed class Methods
{
void Error(float) //错误，参数没有命名
{ ...
}
void NoError(float delta)
{ ...
}

int Error(void) //错误，无参数时不允许使用void
{ ...
}
int NoError()
{ ...
}
}
3. 值型参数
· 一般的函数参数是实参的一个拷贝
w 实参必须预先被赋值
w 实参可以是常量类型
sealed class ParameterPassing
{
static void Method(int parameter)
{
parameter = 42;
}
static void Main()
{
int arg = 0;
Console.Write(arg); //结果为0
Method(arg);
Console.Write(arg); //结果为0
}
}
（注：为了叙述的方便，以后所出现的“参数”这个词均指函数参数，也就是所谓的形参）
没有被ref 或 out修饰的函数参数是一个值型参数。值型参数只有在该参数所属的函数被调用的时候才存在，并且用调用时所传递的实参的值来进行初始化。当函数调用结束时，值型参数不复存在。
只有被预先赋值的实参才能被传递给值型参数，例如：
int arg; // arg没有被赋初值
Method(arg);//错误，实参必须预先赋初值
传递给函数的实参可以是纯粹的数而不是变量，例如：
Method(42);
Method(21 + 21);
4.引用型参数
· 引用型参数是实参的一个别名
w 没有发生复制
w 实参必须预先被赋值
w 实参必须是一个变量类型
w 实参和函数参数都要有ref
sealed class ParameterPassing
{
static void Method(ref int parameter)
{
parameter = 42;
}
static void Main()
{
int arg = 0;
Console.Write(arg); //结果为0
Method(ref arg);
Console.Write(arg); //结果为42
}
}
函数参数有ref修饰符时，被称为引用型参数。引用型参数不产生新的存储区间。实际上，引用型参数是函数调用时所传递的实参所代表的变量的别名。结果是引用型参数只是实参所代表的变量的另一个名字。
ref修饰符必须同时出现在函数声明语句和函数调用语句中。
只有被预先赋值的实参才能被传递给引用型参数，例如：
int arg; // arg没有被赋初值
Method(ref arg);//错误，实参必须预先赋初值
传递给引用型参数的实参必须是变量类型，而不能是纯粹的值或常量。
Method(ref 42); //错误，引用型参数的实参不能是纯粹的值
const int arg = 42;
Method(ref arg); //错误，引用型参数的实参不能是常量
5.out型参数
· out型参数是实参的一个别名
w 没有发生复制
w 实参不必预先赋值
w 实参必须是变量类型
w 函数参数必须被预先赋值才能使用
w 实参和函数参数都要有out
sealed class ParameterPassing
{
static void Method(out int parameter)
{
parameter = 42;
}
static void Main()
{
int arg;
//Console.Write(arg);
Method(out arg);
Console.Write(arg); //结果为42
}
}
函数参数有out修饰符时，被称为out型参数。out型参数不产生新的存储区间。实际上，out型参数是函数调用时所传递的实参所代表的变量的别名。结果是out型参数只是实参所代表的变量的另一个名字。
out修饰符必须同时出现在函数声明语句和函数调用语句中。
没有被预先赋值的实参能够被传递给引用型参数，例如：
int arg; // arg没有被赋初值
Method(out arg);//正确，实参可以不赋初值
传递给out型参数的实参必须是变量类型，而不能是纯粹的值或常量。
Method(out 42); //错误，out型参数的实参不能是纯粹的值
const int arg = 42;
Method(out arg); //错误，out型参数的实参不能是常量
6.in型参数?
· readonly, const 和 in, 都是C# 关键字
w 它们不能被用于函数参数
w ref/out 型参数总是被赋于写的权力
7.函数重载
· 一个类中的函数可以有同一个名字，称为重载
w 函数名和参数称为标识
w 标识必须唯一
w 返回值类型不是标识
namespace System
{
public sealed class Console
{
public static void WriteLine()
{ ... }
public static void WriteLine(int value)
{ ... }
public static void WriteLine(double value)
{ ... }
...
public static void WriteLine(object value)
{ ... }
...
}
}
和C++与Java一样，C#允许一个类声明两个以上的同名函数，只要参数的类型或个数不同。这就是重载。但是，一个类不能包含标识为相同的实例函数和静态函数，例如：
sealed class Illegal
{
void Overload() { ... }
static void Overload() { ... }//错误
}
和C++与Java一样，返回值的类型不是标识的一部分，不能被用作重载的标准，例如：
sealed class AlsoIllegal
{
int Random() { ... }
double Random() { ... }//错误
}
8.ref/out重载
· ref / out 在大部分情况下是标识的一部分!
w 你可以重载一个ref型参数和一个普通参数
w 你可以重载一个out型参数和一个普通参数
w 你不可以重载一个ref型参数和一个out型参数
sealed class Overloading
{
void Allowed( int parameter)
{ ... }
void Allowed(ref int parameter)
{ ... }
//正确，重载一个ref型参数和一个普通参数

void AlsoAllowed( int parameter)
{ ... }
void AlsoAllowed(out int parameter)
{ ... }
//正确，重载一个out型参数和一个普通参数

void NotAllowed(ref int parameter)
{ ... }
void NotAllowed(out int parameter)
{ ... }
//错误，不能重载一个ref型参数和一个out型参数
}
ref和out修饰符可以是一个函数的标识。但是你不能同时重载ref和out型参数。ref和out修饰符在某种意义上是“安全的“，因为只有ref型实参才能传递给ref型函数参数，只有out型实参才能传递给out型函数参数。但是，当调用函数的时候，你会非常容易忘记ref和out修饰符，所以最好不要重载ref和out型参数。例如：
sealed class Overloading
{
public static void Example(int parameter)
{ ... }
public static void Example(ref int parameter)
{ ... }
static void Main()
{
int argument = 42;
Example(argument);//在这儿非常容易忘记ref修饰符
}
}
9.访问规则
l 函数参数或返回值不能比所属函数的访问级别低
sealed class T { ... } //类的默认访问级别是internal
public sealed class Bad
{
public void Parameter(T t) //错误，函数的访问级别（public）比参数高
{ ... }
public T Return() //错误，函数的访问级别（public）比返回值高
{ ... }
}
public sealed class Good
{
private void Parameter(T t) //正确，函数的访问级别（private）比参数低
{ ... }
private T Return() //正确，函数的访问级别（private）比返回值低

{ ... }
}
10.找错误
sealed class Buggy
{
void Defaulted(double d = 0.0) 1
{ ...
}
void ReadOnly(const ref Wibble w) 2
{ ...
}
ref int ReturnType() 3
{ ...
}
ref int fieldModifier; 4
}
第1个函数的错误是：C#中函数不能拥有缺省参数。
第2个函数的错误是：ref型参数不能用const修饰，因为ref型参数是可能变化的。
第3,4个函数的错误是：ref和out型参数只能用于函数参数和实参。
C#中可以通过函数重载的办法实现缺省参数的功能，以下是实现的方法：
sealed class Overload
{
void DefaultArgument() { DefaultArgument(0.0); }
void DefaultArgument(double d) { ... }
}

一周学会C#（值的类型）
C#才鸟（QQ:249178521）
1.整型
类型
位数
System.
与CLS兼容?
有无符号
sbyte
8
SByte
否
有
ushort
16
UInt16
否
无
uint
32
UInt32
否
无
ulong
64
UInt64
否
无

byte
8
Byte
是
无
short
16
Int16
是
有
int
32
Int32
是
有
long
64
Int64
是
有
有符号整形和字节型是属于“通用语言认证系统”(CLS)的。而无符号整形不属于CLS。
你可以使用原始的类型关键字（如int）或与之对应的别名（如System.Int32），这两种方法都是可行的。但唯一例外的情况是：当你把类型名作为.net framework函数实参的时候，你只能使用System.Int32，而不能使用int。例如，你必须这样调用：Type.GetType("System.Int32")，而Type.GetType("int")语句是错误的。这是因为int只是C#中的关键字，而.net framework函数是设计成在所有的.net语言中都通用的。必须注意的是byte在C#中是无符号的。
注意：byte和sbyt只有8位，因此它们不能作为数组的元素，因为数组元素的最小尺寸是16位（2字节）。
2.基本操作符
括号
(x)
访问成员
x.y
函数调用
f(x)
访问数组（不是元素）
a[x]
自增
x++
自减
x--
调用构造函数
new
获得类名
typeof
获得尺寸
sizeof（不安全的）
数值检查
(un)checked
基本操作符具有最高的优先级。
new只能在调用构造函数的时候使用，并且不能被用来重载。使用new来调用结构的构造函数会在栈(stack)中分配内存，而用new来调用类的构造函数会在堆(heap)中分配内存。在C#中，结构是值类型的，类是引用类型的。
sizeof返回类或一个表达式的尺寸，但它只能用在标识为unsafe的代码块中。
checked和unchecked操作符用来控制是否检查算术运算溢出。
3. 操作符的优先级别
基本操作符
见上表
一元操作符
+ - ! ~ ++x –-x (T)x
乘和除
* / %（取余数）
加和减
+ -
移位
<< >>
关系
< > <= >= is as
相等
== !=
位操作
& ^ | (注意：左边比右边级别高)
布尔
&& || ?: (注意：左边比右边级别高)
赋值
= *= /= %= += -= ...
所有的一元操作符都可以重载。
乘和除、加和减、移位、关系（is as 例外）、相等和位操作可以重载。
&&和||只能使用true/false转换操作符时才可以重载。
?:和=不能重载。
复合赋值操作符（如*= /=）可以重载。
4.连接
· 规则1
w 除了赋值操作符外的其他二元操作符都是左连接的。
x+y+z 应理解为 （x+y）+z
· 规则2
w 赋值操作符和?: 操作符是右连接的。
x=y=z 应理解为 x=(y=z)
x+=y+=z 应理解为 x+=(y+=z)
a?b:c?d:e 应理解为 a?b:(c?d:e)
5.计算时的顺序
· 操作数是严格地从左到右被计算的。
int m = 2;
int answer = ++m * ++m + ++m * ++m;
计算的顺序：
3 * ++m + ++m * ++m
3 * 4 + ++m * ++m
12 + ++m * ++m
12 + 5 * ++m
12 + 5 * 6
12 + 30
42
6.整数溢出
· 溢出错误
w un/checked ( 表达式 )
w un/checked｛语句 ｝
int m = ...
Method(checked(m * 2));
m = checked(m * 2);
checked
{
Method(m * 2);
m *= 2;
}

以上的每一句语句都进行溢出错误检查

Method(m * 2);
m *= 2;
以上的每一句语句在用csc /checked+ *.cs编译时，进行溢出错误检查
以上的每一句语句在用csc /checked- *.cs编译时，不进行溢出错误检查

Method(unchecked(m * 2));
m = unchecked(m * 2);
unchecked
{
Method(m * 2);
m *= 2;
}
以上的每一句语句都不进行溢出错误检查
checked(表达式)检查一个表达式的结果是否溢出。它可以用于任何一个表达式，但只只能对整数操作符起作用，因为只有这些操作符才产生溢出。这些操作符是：++, --, -（负号），+ -（减号）， * ，/ ，%以及整型之间的显式类型转换符。checked(表达式)的结果也是一个表达式，它可以被用来作为另一个表达式的一部分：