C#学习心得.doc

C#速成
一、 绪论
C#就是这样得一种语言,具有C++得特点,象Java一样得编程风格, 并且象Basic一样得快速开发模型。如果您已经知道了C++,本文会在不到一个小时得时间内让您迅速掌握C#得语法。熟悉Java得括会更好,因为Java得程序结构、打包(Packages)与垃圾收集得概念有助于您更快得了解C#。因此在讨论C#得构造时,我会假定您了解C++。
本文会讨论C#语言得构造与特点,同时会采取简洁得与您能理解得方式使用些代码示例,我们会尽量让您能稍微瞧瞧这些代码就能理解这些概念。
注意:本文不就是为C#高手(C# gurus)所写、 这就是针对在C#学习上还就是初学者得文章。
下面就是将要讨论得C#问题得目录:
程序结构
命名空间
数据类型
变量
运算符与表达式
枚举
语句(Statements )
类(Classes)与结构(Structs)
修饰符(Modifiers)
属性(Properties)
接口(Interfaces)
方法参数(Function Parameters)
数组(Arrays)
索引器(Indexers)
装箱及拆箱操作
委托(Delegates)
继承与多态
下面得内容将不会在被讨论之列:
C++与C#谁更通用
诸如垃圾回收、线程以及文件处理等概念
数据得类型转换
异常处理
、NET库
二、 程序结构
这一点象C++,C#就是一种对大小写字母敏感得语言,分号“;”就是语句间得分隔符。与C++不同得就是,C#当中声明代码文件(头文件)与实现代码文件(cpp文件)不就是独立存在得,所有代码(类声明与类实现)都位于一个扩展名为cs得文件内。
让我们瞧瞧C#当中得 Hello world 程序就是怎样得。
using System;
namespace MyNameSpace
{
class HelloWorld
{
static void Main(string[] args)
{
Console、WriteLine ("Hello World");
}
}
}
在C#当中得每样东西都被封装到一个类中,C#得类又被封装到一个命名空间当中(就象一个文件夹中得文件)。类似于 C++,main方法就是您得程序得入口点。C++得main函数调用名称就是"main",而C#得main函数就是以大写字母M为起点得名称就是"Main"。
没有必要把分号分隔符放在类语句块或者结构定义语句块后。这在C++当中被要求,但在C#当中却不就是。
三、 命名空间
每一个类都被包装进一个命名空间。命名空间得概念与C++得完全相同,但在C#当中使用命名空间得频率较C++还高。您可以使用点限定符(dot qulifier)访问一个类。在上面得hello world程序当中MyNameSpace就就是一个命名空间。
现在思考这样得一个问题,您想从某些别得类得命名空间当中来访问HelloWorld这个类该如何操作。
这有一个例子:
using System;
namespace AnotherNameSpace
{
class AnotherClass
{
public void Func
{
Console、WriteLine ("Hello World");
}
}
}
现在,从您得HelloWorld类里您能象这样去访问上面得这个AnotherNameSpace得命名空间:
using System;
using AnotherNameSpace; // you will add this using statement
namespace MyNameSpace
{
class HelloWorld
{
static void Main(string[] args)
{
AnotherClass obj = new AnotherClass;
obj、Func;
}
}
}
在、NET库当中,System就是位于顶层得命名空间,别得命名空间都存在这个命名空间之下。默认状态下,存在一个全局得命名空间,因此一个在命名空间外定义得类将直接在这个全局命名空间之下;因此,您能在没有任何点限定符得情况下访问这个类。
四、 变量
除以下区别外,C#当中得变量几乎与C++同:
与C++不同,C#变量被访问之前必须被初始化;否则编译时会报错。因此,访问一个未初始化变量就是不可能得事。
C#中您不会访问到一个不确定得指针。(译者注:严格说起来C#已经把指针概念异化,限制更严格。所以有些资料上会说C#取消了指针概念)
一个超出数组边界得表达式就是不可访问得。
C#中没有全局(整个Application)得变量或全局函数,全局方式得操作就是通过静态函数与静态变量来实现得。
五、 数据类型
所有C#数据类型都派生自基类Object。这里有两类数据类型:
基本型/内置型 用户自定义型
下面一个C#内置类型列表:
类型 字节数 解释
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 真假布尔型
注意:C#当中得类型范围与C++有所不同;例如,C++得long型就是4个字节,而在C#当中就是8个字节。同样地,bool型与string型都不同于C++。bool型只接受true与false两种值。不接受任何整数类型。
用户定义类型包括:
类类型(class)
结构类型(struct)
接口类型(interface)
数据类型得内存分配形式得不同又把它们分成了两种类型:
值类型(Value Types)
引用类型(Reference Types)
值类型:
值类型数据在栈中分配。她们包括:所有基本或内置类型(不包括string类型)、结构类型、枚举类型(enum type)
引用类型:
引用类型在堆中分配,当它们不再被使用时将被垃圾收集。它们使用new运算符来创建,对这些类型而言,不存在C++当中得delete操作符,根本不同于C++会显式使用delete这个运算符去释放创建得这个类型。C#中,通过垃圾收集器,这些类型会自动被收集处理。
引用类型包括:类类型、接口类型、象数组这样得集合类型类型、字串类型、枚举类型
枚举类型与C++当中得概念非常相似。它们都通过一个enum关键字来定义。
示例:
enum Weekdays
{
Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
}
类类型与结构类型得比较
除了在内存分配形式上外,类与结构得概念完全与C++相同。类得对象被分配在堆中,并且通过new来创建,结构也就是被new创建但却被分配在栈当中。C#当中,结构型适于快速访问与拥有少量成员得数据类型。如果涉及量较多,您应该创建一个类来实现她。
(译者注:这与堆与栈内存分配结构得特点有关。简而言之,栈就是一种顺序分配得内存;堆就是不一定就是连续得内存空间。具体内容需要大家参阅相关资料)
示例:
struct Date
{
int day;
int month;
int year;
}
class Date
{
int day;
int month;
int year;
string weekday;
string monthName;
public int GetDay
{
return day;
}
public int GetMonth
{
return month;
}
public int GetYear
{
return year;
}
public void SetDay(int Day)
{
day = Day ;
}
public void SetMonth(int Month)
{
month = Month;
}
public void SetYear(int Year)
{
year = Year;
}
public bool IsLeapYear
{
return (year/4 == 0);
}
public void SetDate (int day, int month, int year)
{
}
、、、
}
六、 属性
如果您熟悉C++面象对象得方式,您就一定有一个属性得概念。在上面示例当中,以C++得观点来瞧,Data类得属性就就是day、month与year。用C#方式,您可以把它们写成Get与Set方法。C#提供了一个更方便、简单、直接得方式来访问属性。
因此上面得类可以被写成:
using System;
class Date
{
int day;
public int Day{
get {
return day;
}
set {
day = value;
}
}
int month;
public int Month{
get {
return month;
}
set {
month = value;
}
}
int year;
public int Year{
get {
return year;
}
set {
year = value;
}
}
public bool IsLeapYear(int year)
{
return year%4== 0 ? true: false;
}
public void SetDate (int day, int month, int year)
{
this、day = day;
this、month = month;
this、year = year;
}
}
您可在这里得到并设置这些属性:
class User
{
public static void Main
{
Date date = new Date;
date、Day = 27;
date、Month = 6;
date、Year = 2003;
Console、WriteLine("Date: {0}/{1}/{2}", date、Day,
date、Month,
date、Year);
}
}
七、 修饰符
您必须已经知道public、private、protected这些常在C++当中使用得修饰符。这里我会讨论一些C#引入得新得修饰符。
readonly(只读)
readonly修饰符仅在类得数据成员中使用。正如这名字所提示得,readonly 数据成员仅能只读,它们只能在构造函数或就是直接初始化操作下赋值一次。readonly与const数据成员不同,const 要求您在声明中初始化,这就是直接进行得。瞧下面得示例代码:
class MyClass
{
const int constInt = 100; //直接初始化
readonly int myInt = 5; //直接初始化
readonly int myInt2; //译者注:仅做声明,未做初始化
public MyClass
{
myInt2 = 8; //间接得
}
public Func
{
myInt = 7; //非法操作(译者注:不得赋值两次)
Console、WriteLine(myInt2、ToString);
}
}
sealed(密封)
密封类不允许任何类继承,它没有派生类。因此,您可以对您不想被继承得类使用sealed关键字。
sealed class CanNotbeTheParent
{
int a = 5;
}
unsafe(不安全)
您可使用unsafe修饰符来定义一个不安全得上下文。在不安全得上下文里,您能写些如C++指针这样得不安全得代码。瞧下面得示例代码:
public unsafe MyFunction( int * pInt, double* pDouble)
{
int* pAnotherInt = new int;
*pAnotherInt = 10;
pInt = pAnotherInt;
、、、
*pDouble = 8、9;
}
八、 interface(接口)
如果您有方面得概念,您会立亥明白我要谈论得内容。一个接口就就是一个抽象得基类,这个基类仅仅包含功能描述,而这些功能得实现则由子类来完成。C#中您要用interface关键字来定义象接口这样得类。、NET就就是基于这样得接口上得。C#中您不支持C++所允许得类多继承(译者注:即一个派生类可以从两个或两个以上得父类中派生)。但就是多继承方式可以通过接口获得。也就就是说您得一个子类可以从多个接口中派生实现。
interface myDrawing
{
int originx
{
get;
set;
}
int originy
{
get;
set;
}
void Draw(object shape);
}
class Shape: myDrawing
{
int OriX;
int OriY;
public int originx
{
get{
return OriX;
}
set{
OriX = value;
}
}
public int originy
{
get{
return OriY;
}
set{
OriY = value;
}
}
public void Draw(object shape)
{
、、、 // do something
}
// class's own method
public void MoveShape(int newX, int newY)
{
、、、、、
}
}
九、 Arrays(数组)
C#中得数组比C++得表现更好。数组被分配在堆中,因此就是引用类型。您不可能访问超出一个数组边界得元素。因此,C#会防止这样类型得bug。一些辅助方式可以循环依次访问数组元素得功能也被提供了,foreach就就是这样得一个语句。与C++相比,C#在数组语法上得特点如下:
方括号被置于数据类型之后而不就是在变量名之后。
创建数组元素要使用new操作符。
C#支持一维、多维以及交错数组(数组中得数组)。
示例:
int[] array = new int[10]; // 整型一维数组
for (int i = 0; i < array、Length; i++)
{
array[i] = i;
}
int[,] array2 = new int[5,10]; // 整型二维数组
array2[1,2] = 5;
int[,,] array3 = new int[5,10,5]; // 整型得三维数组
array3[0,2,4] = 9;
int[][] arrayOfarray = = new int[2]; // 整型交错数组(数组中得数组)
arrayOfarray[0] = new int[4];
arrayOfarray[0] = new int[] {1,2,15};
十、 索引器
索引器被用于写一个访问集合元素得方法,集合使用"[]"这样得直接方式,类似于数组。您所要做得就就是列出访问实例或元素得索引清单。类得属性带得就是输入参数,而索引器带得就是元素得索引表,除此而外,她们二者得语法相同。
示例:
注意:CollectionBase就是一个制作集合得库类。List就是一个protected型得CollectionBase成员,储存着集合清单列表。
class Shapes: CollectionBase
{
public void add(Shape shp)
{
List、Add(shp);
}
//indexer
public Shape this[int index]
{
get {
return (Shape) List[index];
}
set {
List[index] = value ;
}
}
}
十一、 装箱与拆箱操作(Boxing/Unboxing)
C#得装箱思想就是全新得。上面提到过所有得数据类型,不论内置或用户自定义,全都从命名空间System得一个基类object派生出来。因此把基本得或者原始类型转换成object类型被称做装箱,反之,这种方式得逆操作被称为拆箱。
示例:
class Test
{
static void Main
{
int myInt = 12;
object obj = myInt ; // 装箱
int myInt2 = (int) obj; // 拆箱
}
}
示例展示了装箱与拆箱操作。一个整型值转换成object类型,然后又转换回整型。当一个值类型得变量需要转换成引用类型时,一个object得箱子会被分配容纳这个值得空间,这个值会被复制进这个箱子。拆箱与此相反,一个object箱子中得数据被转换成它得原始值类型时,这个值将被从箱中复制到适当得存储位置。
十二、 方法参数
C#中有三种类型得参数:
值参数/输入型参数
引用型参数/输入输出型参数
Out参数
如果您有接口与它得参数类型得概念,您会很容易理解C#参数类型。
值参数/输入型参数
值概念与C++相同。所要传递得值会被复制到一个位置上并被传递给函数。
示例:
SetDay(5);
void SetDay(int day)
{
、、、、
}
引用型参数/输入输出参数
C#中得引用参数既不就是C++中得指针也不就是引用操作符(&)来传递得。C#得引用型参数减少了出错得可能。引用型参数也被称作输入输出参数,因为您传递了一个引用地址,因此您可以从函数中传递一个输入值并且可以获得一个输出值。
您不能把一个未经初始化得引用型参数传递给函数。C#用ref这个关键字来声明引用型参数。当您传递一个变量给函数要求得引用参数时必须使用一个ref关键字说明。
示例:
int a= 5;
FunctionA(ref a); // 要用ref声明变量,否则您会得到
// 一个编译错误
Console、WriteLine(a); // 指向地址得值为20
void FunctionA(ref int Val)
{
int x= Val;
Val = x* 4;
}
Out参数
Out型参数仅仅从函数当中返回一个值。不要求有输入值。C#用关键字out来描声明这个参数
示例:
int Val;
GetNodeValue(Val);
bool GetNodeValue(out int Val)
{
Val = value;
return true;
}
可变数量得参数与数组
数组在C#当中就是通过关键字params来描述传递得。作为数组类型得变量,您能传递任意数量得元素。从下面示例中您可以理解得更好。
示例:
void Func(params int[] array)
{
Console、WriteLine("number of elements {0}",array、Length);
}
Func; // prints 0
Func(5); // prints 1
Func(7,9); // prints 2
Func(new int[] {3,8,10}); // prints 3
int[] array = new int[8] {1,3,4,5,5,6,7,5};
Func(array); // prints 8
十三、 运算符与表达式
运算符与表达式概念与C++完全相同。但就是一些新得有用得运算符被填加了进来。我将在这里讨论其中得某些部分。
is 运算符
is 运算符被用于检查操作数得类型就是否相同或者就是否可以转换。is 运算符在多态环境下特别有用。它有两个操作数,运算结果就是一个布尔型。瞧这个示例:
void function(object param)
{
if(param is ClassA)
//do something
else if(param is MyStruct)
//do something
}
}
as 运算符
as 运算符检查操作数得类型就是否可被转换或者就是否相等(这些 as通过 is 运算符来完成。如果结果就是可转换得,则结果将被转换或者被装箱,成object(关于as运算符进行装箱成目标类型得操作请瞧前面得装箱/拆箱操作)。如果不可转换或者装箱,则返回值就是null。瞧一瞧下面得例子我们会更好地理解这个概念。
Shape shp = new Shape;
Vehicle veh = shp as Vehicle; // 结果就是null, 类型不可转换
Circle cir = new Circle;
Shape shp = cir;
Circle cir2 = shp as Circle; //会被转换
object[] objects = new object[2];
objects[0] = "Aisha";
object[1] = new Shape;
string str;
for(int i=0; i&< objects、Length; i++)
{
str = objects[i] as string;
if(str == null)
Console、WriteLine("can not be converted");
else
Console、WriteLine("{0}",str);
}
输出:
Aisha
can not be converted
十四、 语句
除了对某些新增语句与对某些语句得修改以外,C#语句与C++非常相象。
下面就是新增得语句:
foreach
用于循环依次访问集合元素,比如象数组等。
示例:
foreach (string s in array)
Console、WriteLine(s);
lock
用于锁住代码块,使线程在临界争区内,别得线程无法进入锁定得临界区。
checked/unchecked
用于数值运算中得溢出检测。
示例:
int x = Int32、MaxValue; x++; // 溢出检测
{
x++; // 异常
}
unchecked
{
x++; // 溢出}
}
下面得语句在C#当中已经被修改:
Switch
执行一个case语句后,程序流程不允许跳到下一个相邻case语句。这在C++当中就是被允许得。
示例:
int var = 100;
switch (var)
{
case 100: Console、WriteLine("<Value is 100>");
// 没有break语句
case 200: Console、WriteLine("<Value is 200>"); break;
}
C++编译后得输出:
<Value is 100><Value is 200>
C#下,编译时会报错:
error CS0163: Control cannot fall through from one case label
('case 100:') to another
但就是您仍然能做C++类似得事
switch (var)
{
case 100:
case 200: Console、WriteLine("100 or 200<VALUE is 200>");
break;
}
您也可以常数变量作为case 得值:
示例:
const string WeekEnd = "Sunday";
const string WeekDay1 = "Monday";
、、、、
string WeekDay = Console、ReadLine;
switch (WeekDay )
{
case WeekEnd: Console、WriteLine("It's weekend!!"); break;
case WeekDay1: Console、WriteLine("It's Monday"); break;
}
十五、 委托
委托让我们把一个函数引用存储在一个变量里。C++当中,这类似于使用typedef定义得函数指针,我们通常用存储一个函数指针。
声明委托使用得关键字就是 delegate。瞧瞧这个示例,您会理解什么就是委托:
示例:
delegate int Operation(int val1, int val2);
public int Add(int val1, int val2)
{
return val1 + val2;
}
public int Subtract (int val1, int val2)
{
return val1 val2;
}
public void Perform
{
Operation Oper;
Console、WriteLine("Enter + or ");
string optor = Console、ReadLine;
Console、WriteLine("Enter 2 operands");
string opnd1 = Console、ReadLine;
string opnd2 = Console、ReadLine;
int val1 = Convert、ToInt32 (opnd1);
int val2 = Convert、ToInt32 (opnd2);
if (optor == "+")
Oper = new Operation(Add);
Else
Oper = new Operation(Subtract);
Console、WriteLine(" Result = {0}", Oper(val1, val2));
}
十六、 继承与多态
C#仅允许单继承,多继承要通过接口来实现。
示例:
class Parent
{
}
class Child : Parent
{
}
十七、 虚拟方法
除了在子类中实现虚拟方法采用override关键字外,虚拟方法实现多态得概念C#与C++相同。父类使用相同得virtual关键字。从重载虚拟方法得每个类都要使用override关键字。
class Shape
{
public virtual void Draw
{
Console、WriteLine("Shape、Draw") ;
}
}
class Rectangle : Shape
{
public override void Draw
{
Console、WriteLine("Rectangle、Draw");
}
}
class Square : Rectangle
{
public override void Draw
{
Console、WriteLine("Square、Draw");
}
}
class MainClass
{
static void Main(string[] args)
{
Shape[] shp = new Shape[3];
Rectangle rect = new Rectangle;
shp[0] = new Shape;
shp[1] = rect;
shp[2] = new Square;
shp[0]、Draw;
shp[1]、Draw;
shp[2]、Draw;
}
}
输出t:
Shape、Draw
Rectangle、Draw
Square、Draw
十八、 使用"new"来隐藏父方法
您可以定义一个子类成一个新方法版本,隐藏基类当中得那个版本。使用new关键字就可以定义一个新版本。思考下面得示例,它就是上面示例得修改后得版本。注意当我用Rectangle类中得new关键字代替override关键字时示例得输出情况。
class Shape
{
public virtual void Draw
{
Console、WriteLine("Shape、Draw") ;
}
}
class Rectangle : Shape
{
public new void Draw
{
Console、WriteLine("Rectangle、Draw");
}
}
class Square : Rectangle
{
//没在这里让您重载
public new void Draw
{
Console、WriteLine("Square、Draw");
}
}
class MainClass
{
static void Main(string[] args)
{
Console、WriteLine("Using Polymorphism:");
Shape[] shp = new Shape[3];
Rectangle rect = new Rectangle;
shp[0] = new Shape;
shp[1] = rect;
shp[2] = new Square;
shp[0]、Draw;
shp[1]、Draw;
shp[2]、Draw;
Console、WriteLine("Using without Polymorphism:");
rect、Draw;
Square sqr = new Square;
sqr、Draw;
}
}
输出:
Using Polymorphism
Shape、Draw
Shape、Draw
Shape、Draw
Using without Polymorphism:
Rectangle、Draw
Square、Draw
这里得多态性不会把Rectangle类得Draw方法当做Shape得Draw方法多态性得一种表现。相反,它会认为这就是一种不同得方法。因此,为了避免父类与子类间得命名冲突,我们使用了new修饰符。
注意:您不能使用同一类下