1 基本语法的学习
与法学习主要包含了以下几个方面：
（1） 基本的数据类型；
（2） 字符串；
（3） 控制语句；
（4） c#特殊的关键字；
（5） 异常处理机制；
1.1 基本的数据类型
比较特殊的几个类型有：decimal；非齐整数组；
定义常量的方式：
（1）常量
public const double gravitationalConstant = 6.673e-11;
不要和直接量混合了。
所谓的直接量其实就是直接给出一个数值，类似于汇编里头的立即数。
（2）变量的作用域；
这点和delphi稍微有点不同，在c#中，变量的作用域是按照大括号来划分的，比如：
public static void main()
{
int x=10;
if (x==10)
{
int y=100; //这个变量只在这个if语句内部有效
}
}
（3）类型转换
类型转换主要分为：自动类型转换和强制类型转换。
强制类型转换采用和java一样的方式；
int I=(int)(10/3);
也就是这个类型一定要用括号括起来。
自动类型转换则必须满足两个条件：格式兼容；目标类型的取值范围大于源类型。
1.2 数组
数组，c#中的数组是作为对象来实现的，所有具备了许多优点
数组的定义格式如下：
int[] testArray = new int[10];
数组可以在创建的时候初始化；
int[] nums = {100,101,102,103,104,105,106,108,109};
等同于
int[] nums = new int[] {100,101,102,103,104,105,106,108,109};
还等同于
int[] nums = new int[10] {100,101,102,103,104,105,106,108,109};
多维数组的声明，感觉有点怪异：
int[,] Two = new int[3,4];
int[,,] Three = new int[3,4,5];
非齐整数组；就是允许每一维的长度不同；
声明的格式如下：
int[][] jagged = new int[3][];
jagged[0] = new int[3];
jagged[1] = new int[4];
jagged[2] = new int[5];
这样的格式我好像也在java里头看到过，不过有点不确定了。
数组的length属性；
这里又分为一般的数组和非齐整数组，非齐整数组其实是数组的数组；
foreach循环；
在循环的过程中，迭代变量是只读的，因为不能通过迭代变量来改变数组的内容。
使用方法如下：
int[] temp = {3,4,5} ;
foreach(int x in temp)
{
Console.WriteLine(“temp[i] is : {0}”,x);
}
1.3 字符串
字符串的格式化输出；
Console.WriteLine(“My Name is {0}”,”Yangguichun”);
在c#中，字符串并不像在其他的语言中一样，是字符的数组，它是对象。我记得java中的字符串也是对象。毫无疑问，c#学的是java的那一套，因为将字符串作为对象在java中已经被验证是可行的，所以为什么不用呢。既然学习的是java的那一套，我估计java中给字符串提供的那一套方法在这里也是有的。
虽然字符串不是字符的数组，但是字符串还是允许使用如下的形式；
string s =” this is a string”;
Console.WriteLine(s[0]); //将输出t
不过却有点例外，就是不能够通过下标来给字符串赋值。因为据说一个字符串一旦创建，就不能修改了，是个常量。
字符串还允许使用==和!=，因为字符串类重载了这两个运算符。其他的运算符则和一般的应用一样，比较的是引用。
字符串一旦创建之后是不可改变的，如果要使用可改变的字符串，那么可以使用System.Text中的StringBuilder类。
在switch中可以使用字符串，这是所学过的其他语言中都不具备的功能，这个功能很棒。
2 面向对象特性的学习
面向对象特性的学习主要包含以下几个方面：
（1） 接口；
（2） 虚方法；
（3） 面向对象方面的特殊的关键字；
2.1 类、对象和方法
2.1.1 重载
首先来看一下重载，c#中的重载和delphi也有些不同，首先它并不需要overload关键字；其次一般方法的重载和构造函数的重载有所不同，重载的构造函数中的一个要调用另外一个的方法是：
class TestConstructor
{
public TestConstructor()
{
Console.WriteLine("Constructor 1");
}
public TestConstructor(string name):this()
{
Console.WriteLine("Constructor 2 "+ name );
}
}
而一般函数的方式则和delphi的相似。
class TestConstructor
{
public TestConstructor()
{
Console.WriteLine("Constructor 1");
}
public void TestOverload()
{
Console.WriteLine("overload 1");
}
public void TestOverload( string name )
{
Console.WriteLine( " before " );
TestOverload();
Console.WriteLine( " after " );
}
public static void Main()
{
TestConstructor test = new TestConstructor("3");
test.TestOverload("test");
}
}
则输出为：
before
Overload 1
after
2.1.2 ref和out关键字。
这两个关键字和delphi的var和out关键字相似，ref和var唯一的不同在于：如果某个方法的参数有ref，那么在调用该方法的时候传送进来的参数也要用ref来修饰。
此外，对象的因用也可以用ref来修饰。
2.1.3 可变元参数
（1）一般函数的变元
有些类似于delphi的format函数的那个参数的声明方式。
在这里采用的声明方式为：
public void TestParams(params int[] args)
{
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
}
这里给出的只是int类型的情况，其实和delphi的format函数的参数还不完全一样，如果要在一个数组中兼容各种类型，那么就要采用如下的声明方式。
class TestParams
{
public void Test(params object[] args)
{
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
}
}
（2）Main函数的变元
这个变元和一般函数的变元有所不同，格式如下：
public static void Main(string[] args)
{
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
}
2.1.4 函数的返回类型可以是数组
以前我所学过的其他的语言的函数都无法返回数组，但是c#可以，因为在c#中，数组是作为对象来实现的。
public int[] TestArray()
{
int[] result = new int[10];
for (int i = 0; i < result.Length; i++)
{
result[i] = i;
}
return result;