常用格式举例：
（1） int i=12345;
this.textBox1.Text=i.ToString();
（6） DateTime dt =new DateTime(2003,5,25);
this.textBox1.Text=dt.ToString("yy.M.d");
//结果 03.5.25
this.textBox2.Text=dt.ToString(“yyyy年M月”);
//结果 2003年5月
（7） int i=123;
double j=123.45;
string s=string.Format("i:{0,-7},j:{1,7}",i,j);
//-7表示左对齐，占7位
this.textBox1.Text=s ;
//结果i:123 ,j: 123.45

//结果 12345（this指当前对象，或叫当前类的实例）
this.textBox2.Text=i.ToString("d8");
//结果 00012345
（2） int i=123;
double j=123.45;
string s1=string.Format("the value is {0,7:d}",i);
string s2=string.Format("the value is {0,7:f3}",j);
this.textBox1.Text=s1 ;
//结果 the value is 123
this.textBox2.Text=s2;
//结果 the value is 123.450
（3） double i=12345.6789
this.textBox1.Text=i.ToString("f2");//结果 12345.68
（4）double i=12345.6789;
this.textBox1.Text=i.ToString("n"); //结果 12,345.68
this.textBox2.Text=i.ToString(“n4”); //结果 12,345.6789
（5）double i=0.126;
string s=string.Format("the value is {0:p}",i);
this.textBox1.Text=i.ToString("p"); //结果 12.6%
this.textBox2.Text=s; //结果 the value is 12.6%

数组
特点：所有的元素类型都相同。
//一维数组

string[] arr={"c","c++"};
string[] mystrings=new string[3];
int[] intArr1=new int[4]{0,1,2,3};
int[] intArr2={5,6,7};
int nvar=5;
//二维数组
int[,] arr = {{0,1}, {2,3}, {4,5}};
int[,] myArr = new int[5,3];
//锯齿型数组
string[][] stra=new string[3][];
stra[0]=new string[2]{"a11","a12"};
stra[1]=new string[3]{"b11","b12","b13"};
stra[2]=new string[5]{"a","e","i","o","u"};

类型之间的转换
位数少的转换为位数多的，可以使用隐式转换；
位数多的转换为位数少的，要使用显式转换。

装箱和拆箱
int i=123; //数值类型
object box=i; //装箱操作
int j=(int)box; //拆箱操作

值类型
所有的值类型都隐含地声明了一个公共的无参数的构造函数，这个构造函数叫做默认构造函数。默认构造函数返回一个初始为零的值类型的实例，称之为默认值。
对于sbyte、byte、short、ushort、int、uint、long、ulong ，默认值为0。
对于char，默认值是‘\x0000’
对于float，默认值是0.0F
对于double，默认值是0.0D
对于decimal，默认值是0.0M
对于bool，默认值是false
对于一个枚举类型，默认值是0
对于一个结构类型，默认值的设置就是把所有值类型的 域都设置为它们各自的默认值，把所有的引用类型的域赋为空

简单类型
C#提供一套预定义的结构类型叫做简单类型。简单类型用保留字定义，这些保留字仅仅是在System名字空间里预定义的结构类型的化名。比如int是保留字，System.Int32是在System名字空间中预定义类型。一个简单类型和它化名的结构类型是完全一样的，也就是说写int和写System.Int32是一样的。
简单类型主要有整型、浮点类型、小数类型、布尔类型、字符型

整型
C#中支持9种整型：sbyte、byte、short、ushort、int、 uint、long、ulong和char。
Sbyte：代表有符号的8位整数，数值范围从-128 ～ 127
Byte：代表无符号的8位整数，数值范围从0～255
Short：代表有符号的16位整数，范围从-32768 ～ 32767
ushort：代表有符号的16位整数，范围从-32768 ～ 32767
Int：代表有符号的32位整数，范围从-2147483648 ～ 2147483648
uint：代表无符号的32位整数，范围从0 ～ 4294967295
Long：代表有符号的64位整数，范围从 -9223372036854775808 ～ 9223372036854775808
Ulong：代表无符号的64位整数，范围从 0 ～ 18446744073709551615
char：代表无符号的16位整数，数值范围从0～65535。
Char类型的可能值对应于统一字符编码标准（Unicode）的字符集。
Char类型与其他整数类型相比有以下两点不同之处：
1、没有其他类型到char类型的隐式转换。即使是对于sbyte，byte和ushort这样能完全使用char类型代表其值的类型， sbyte，byte和ushort到char的隐式转换也不存在。
2、char类型的常量必须被写为字符形式，如果用整数形式，则必须带有类型转换前缀。比如（char）10
赋值形式有三种：
char chsomechar=“A”;
char chsomechar=“\x0065”; 十六进制
char chsomechar=“\u0065 ； unicode表示法

浮点类型

C#支持两种浮点类型：float和double。
Float型所能表示的值的范围大约可以从1.5*10^-45～3.4* 10^38，精确到小数点后面7位。
Double型所能表示的值的范围大约可以从5.0*10^-324～1.7* 10^308，精确到小数点后面15位或16位。
如果二元操作中的其中一个操作数为浮点类型，那么另外一个操作数是整型或浮点类型，运算规则如下：
1、如果其中一个操作数是整型，则操作数被转换为另一个操作数的浮点数类型；
2、如果操作数之一为double，则另一操作数也被转换成double类型，运算以double类型的精度和取值范围进行，并且所得结果也为double类型；
3、否则，运算至少将以float类型的取值范围和精度进行，并且所得结果也为float型。

小数（decimal）类型

小数类型非常适用于金融和货币运算。数值范围从1.0*10^-28～7.9* 10^28，精确到小数点后面28位。
如果二元操作中的其中一个操作数是小数类型，那么另外一个从操作数是整型或小数类型。整型在运算前被转化为小数类型数。
如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太小的值，操作的结果将会变成0。
如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太大的值，就会触发溢出错误。
小数类型较浮点类型而言，具有更大的精确度，但是数值范围相对小了很多。
将浮点类型的数向小数类型的数转化时会产生溢出错误，将小数类型的数向浮点类型的数转化时会造成精确度的损失。因此，两种类型不存在隐式或显式转换。

布尔型：值为true或false。没有标准能实现布尔类型和其他类型的转换。
枚举类型：枚举类型的元素使用的类型只能是long、int、short、byte。默认类型是int。默认第一个元素的值是0，每一个连续的元素按1递增。可以给元素直接赋值。如：
enum monthnames {January=1,February, march=31};
可以强制定义其他类型，如：
enum monthnames : byte{January ,February,March};

结构类型

结构类型也是一种值类型，使用它的目的是用于创建小型的对象，用以节省内存.下面的例子表示一个使用byte类型的4个字段的IP地址。
using System;
Struct IP //声明结构
{ public byte b1,b2,b3,b4;}
Class test
{public static void Main()
{
IP myIP;
myIP.b1=192;
myIP.b2=168;
myIP.b3=1;
myIP.b4=101;
Console.Write(“{0}.{1}.”, myIP.b1, myIP.b2);
Console.Write(“{0}.{1}”, myIP.b3, myIP.b4);
}
}

引用类型

引用类型包括类类型、接口类型、代表类型和数组类型。
1、类类型
类 类型定义了一种数据结构，这个数据结构中包含了数据成员（如常量、字段和事件等），函数成员（如方法、属性、索引、操作、构造函数和析构函数等）和嵌套类型。支持继承。
2、对象类型
对象类型是其他所有类型最终的基础类型。在C＃中每一种类型都直接或者间接的源于object这个类类型。
3、字符串类型
字符串类型是直接从object中继承而来的密封类。String类型的值可以写成字符串文字的形式。

6、数组

数组是包含一串变量的数据结构。数组变量也称做数组元素，它们具有相同的类型，这种类型也称做数组元素类型。数组的元素类型可以是任何类型，包括数组类型。
数组用下标确定每一个数组元素的索引号。只有一个下标的数组称为一维数组，多于一个下标的数组称为多维数组。
例：int[] a={0,2,4,6,8}; 等价于int[] a=new int[] {0,2,4,6,8};
也可以这样初始化：a[0]=0; a[1]=2; a[2]=4; a[3]=6; a[4]=8;
int[] a; //int型的一维数组
int[,] a; //int型的二维数组
int[,,] a; //int型的三维数组
int[] []a; //int型的数组的数组
int[][][]a; //int型的数组的数组的数组
数组的每个维数的长度不是数组类型的一部分，维数的长度是在数组创建语句中指定的，而不是在数组类型中指定的，例如：
int[,,] a3=new int[10,20,30];
a3是是一个数组变量， int[,,] 没有指定数组的长度，数组创建语句new int[10,20,30]才指定。下面的例子创建一个数组的数组：
int[][] J=new int[3][];
J[0]=new int[] {1,2,3};
J[1]=new int[] {1,2,3,4,5,6};
J[2]=new int[] {1,2,3,4,5,6,7,8,9};

加框和消框

boxing和unboxing允许把任何值类型的值转化为对象(object)类型，或者把object类型转化为值类型，这样它就把值类型和引用类型紧密的结合起来了。
简单的说，加框操作就是数值类型转换为类型对象，消框操作就是类型对象转换为数值类型。
1、加框操作
给一个值加框指隐式地把任何数值类型转换成类型对象。当一个数值类型被加框时，一个对象实例就被分配，而且数值类型的值复制给新的对象。
如：int n=200;
object o=n; //加框操作
o=201;
Console .WriteLine(“{0}{1}”,n,o);
改变o值，n的值不变

2、消框是显式操作－必须告诉编译器，想从对象中抽取出哪一种值类型。当执行消框操作时，C＃检测所请求的值类型是否存储在对象实例中。
如：
int n=200;
object o=n;
int u=(int) u; //消框转化

操作符

语句