课程内容：

　第一章：.net概述

　第二章：编写c#程序

　第三章：类型

　第四章：流程控制

　第五章：数组与集合

　第六章：面向对象

　第七章：类

　第八章：继承

　第九章：接口

　第十章：委托与事件

课程的下载地址：

FTP:\\guest:guest@121.52.209.180:26

 Winform和asp.net的课程还在讲授过程中。 

现在就说说struct。struct既然是个值类型，自然应该在线程堆栈上。对于struct，在一定程度上与class非常相像，接下来，我们来分析一下。

    class program

    {

        static void Main(string[] args)

        {

            STR str1;

            str1.Method("str1");//第一种方法，直接定义

            STR str2 = new STR();

            str2.Method("str2"); //第二种方法，通过new关键字

        } 

    }

    struct STR

    {

        public void Method(string Par)

        {

            Console.WriteLine("参数是:"+Par);

        }

}

我们看到，结构中，我们可能有两种方法来调用结构内部的成员，一个是直接定义来调用，也可以通过new关键字来定义调用，这是与类不同的，类必需经过实例化（new）来定义调用（静态成员是通过类名调用，没有定义）。

接下来再看一个例子。

 class program

    {

        static void Main(string[] args)

        {

            STR str1;//第一种

            str1.count = 100;//赋值

            Console.WriteLine(str1.count);

            STR str2 = new STR();//第二种

            Console.WriteLine(str2.count);

        } 

    }

    struct STR

    {

      public int count;

}

当结构体中定义一个全局变量时（类中叫字段），这个count是没有值的，这是与类不同的，在类中，所有的字段都有默认值，结构中是没有的。既然没有默认值，那在第二种实例化直接调用时，str2.count输出的为什么是0，这个0是没有事前赋值的。如果是类，我们知道，类是有构造函数的，如果我们不显式写上构造函数，CLR会自动给我们加上一个没有参数的构造函数的，并且这个构造函数是可以被显式的写出来的。同样，结构也是有一个构造函数，但这个构造函数是不能够写出来的，并且这个构造函数很特别，我们从第二种就能看出，只要用new关键字来实例化结构，就会把count给初始化成0，也就是那个不能写出来的无参构造函数会初始化所有的结构中的全局变量。对于第一种，因为没有调用无参的构造函数，所以必需去显式的给结构中的全局变量去赋值。

如果结构里有有参构造函数，代码如下：

    class program

    {

        static void Main(string[] args)

        {

            STR str = new STR("");//实例化

            Console.WriteLine(str.count);

        } 

    }

    struct STR

    {

      public int count;

      public STR(string str)

      {

          count = 1;

      }

 }

会发现，如果是个有参构造函数，在构造中必需去初始化结构中的全局变量，因为如果用有参构造函数的话，无参的就不会得到调用，结构中的全局变量就得不到初始化，所以必需在有参构造函数中去初始化它。如果有多个全局变量，都得在这个有参构造函数中去实例化它们。

    class ExtClass

    {

        string s = "字段";

        public class NestClass

        {

            ExtClass EC = new ExtClass();

            //问题一: EC.s  

            public void saya()

            {

            }

        }

        public void FF()

        {

            NestClass NC = new NestClass();

            //问题二:NC.EC

        }

}

第一个问题：在“问题一”的地方怎么用EC调用不出s这个字段，按道理说，NestClass与s都是类ExtClass 的成员，他们的修饰符不管是private还是public，都是能互相访问到的。这个理解应该不算错误，因为我们知道，在同一个类中，成员之间是可以该问的，与修饰没有关系，但现在一个问题是EC.s是调用不出来的。其实问题不在于成员调用成员，在于在类内部去调用对象的成员，这是不充许的，这种调用只能在成员的内部去应用（本质上是在方法内部去调用，因为不管理是属性，还是索引器是在get或set的实现部分去调用的，get和set本质是又都是方法，所以说本质上是在方法的实现中调用。）

第二个问题：用NC去调用EC。从代码中，我们能知识，EC这个对象是NestClass类，的一个字段，现在的NestClass类与FF方法又都在ExtClass类的内部，同属于这个类的成员，怎么又访问不到了呢？其实在这里有一个概念问题，就是类成员的问题，这里的类成员不是普通的方法，属性等，而是一个类，一个嵌套类，对于一个类来说，不管是内部还是外部，它还是一个完整人体系的，它也有自己的成员，并且这个类的成员同样有自己的修饰符，我们知道，在类内部，如果不给成员添加修饰符的话，默认为private，这时的EC的修饰符是private，是私有的，它是不能会被本类外部的类或成员访问的，也可以这样去理解，NestClass类与FF方法是一个等级的（同属于类ExtClass的成员），FF与NestClass类内部的成员不属于一个级别的（NestClass内部的private成员只对NestClass其他成员来说是能访问到的），所以在FF方法中是没有办法访问到类NestClass内部的私有成员的，如果现在我们把EC的实例化前加一个public，就可以在FF方法内去使用NC.EC来调用EC了。

从上面的例子可以看出来，不管是类还是嵌套类，类的通用的一些规则都是一样的，不会因为位置的不同而不同。但嵌套类出现的地方是比较特殊的，这时我们要分清级别（及类与成员）的关系，去分析应用。

在C#3.0中有一个动态类型，var，它可以定义不同的类型，系统在第一次编译时会根据上下文来判断这个变量的准确类型。

下面看个例子：

C#代码：

static void Main(string[] args)

        {

            var i = 10;

            var d = 1.2;

            var f = 1.1f;

            var str = new string[] { "a","b"};

        }

IL代码：

.method private hidebysig static void Main(string[] args) cil managed

{

 .entrypoint

 // 代码大小       50 (0x32)

 .maxstack 3

 .locals init ([0] int32 i,

           [1] float64 d,

           [2] float32 f,

           [3] string[] str,

           [4] string[] CS$0$0000)

 IL_0000: nop

 IL_0001: ldc.i4.s   10

 IL_0003: stloc.0

 IL_0004: ldc.r8     1.2

 IL_000d: stloc.1

 IL_000e: ldc.r4     1.1

  IL_0013: stloc.2

 IL_0014: ldc.i4.2

 IL_0015: newarr     [mscorlib]System.String

 IL_001a: stloc.s    CS$0$0000

 IL_001c: ldloc.s    CS$0$0000

 IL_001e: ldc.i4.0

 IL_001f: ldstr      "a"

 IL_0024: stelem.ref

 IL_0025: ldloc.s    CS$0$0000

 IL_0027: ldc.i4.1

 IL_0028: ldstr      "b"

 IL_002d: stelem.ref

 IL_002e: ldloc.s    CS$0$0000

 IL_0030: stloc.3

 IL_0031: ret

} // end of method Program::Main

我们可以看到，在C#中定义了几种类型，都是以var定义的，并且都是方法内部的局部变量。但在IL中我们会看到（红色代码）定义的局部变量会有准确的类型。

下面我们来看一下在vs2010中，C#4.0中的一个新的类型dynamic，我们同样来定义一个方法：

static void Main()

        {

            var i = 10;

            var d = 1.2;

            var f = 1.1f;

            var str = new string[] { "a", "b" }; 

            dynamic i1 = 10;

            dynamic d1 = 1.2;

            dynamic f1 = 1.1f;

            dynamic str1 = new string[] { "a", "b" }; 

        }

再来看看他的IL

.method private hidebysig static void Main() cil managed

{

 .entrypoint

 // Code size       117 (0x75)

 .maxstack 3

 .locals init ([0] int32 i,

           [1] float64 d,

           [2] float32 f,

           [3] string[] str,

           [4] object i1,

           [5] object d1,

           [6] object f1,

           [7] object str1,

           [8] string[] CS$0$0000)

 IL_0000: nop

 IL_0001: ldc.i4.s   10

 IL_0003: stloc.0

 IL_0004: ldc.r8     1.2

 IL_000d: stloc.1

 IL_000e: ldc.r4     1.1

 IL_0013: stloc.2

 IL_0014: ldc.i4.2

 IL_0015: newarr     [mscorlib]System.String

 IL_001a: stloc.s    CS$0$0000

 IL_001c: ldloc.s    CS$0$0000

 IL_001e: ldc.i4.0

 IL_001f: ldstr      "a"

 IL_0024: stelem.ref

 IL_0025: ldloc.s    CS$0$0000

 IL_0027: ldc.i4.1

 IL_0028: ldstr      "b"

 IL_002d: stelem.ref

 IL_002e: ldloc.s    CS$0$0000

 IL_0030: stloc.3

 IL_0031: ldc.i4.s   10

 IL_0033: box        [mscorlib]System.Int32

 IL_0038: stloc.s    i1

 IL_003a: ldc.r8     1.2

 IL_0043: box        [mscorlib]System.Double

 IL_0048: stloc.s    d1

 IL_004a: ldc.r4     1.1

 IL_004f: box        [mscorlib]System.Single

 IL_0054: stloc.s    f1

 IL_0056: ldc.i4.2

 IL_0057: newarr     [mscorlib]System.String

 IL_005c: stloc.s    CS$0$0000

 IL_005e: ldloc.s    CS$0$0000

 IL_0060: ldc.i4.0

 IL_0061: ldstr      "a"

  IL_0066: stelem.ref

 IL_0067: ldloc.s    CS$0$0000

 IL_0069: ldc.i4.1

 IL_006a: ldstr      "b"

 IL_006f: stelem.ref

 IL_0070: ldloc.s    CS$0$0000

 IL_0072: stloc.s    str1

 IL_0074: ret

} // end of method File::Main

我们看到C#中的代码基本没变，就是把var换成dynamic，在IL中，var的没有变化，但用dynamic定义的类型(红色代码部分)，除了string[]外都是object类型，如果这样看来，dynamic其不是就是object吗？不是的，往下看，会发现每个类型在初始化时就个box，就是装箱，装到dynamic这种类型中了，看来dynamic是个引用类型，是真的吗？

现在我们从装折箱角度来看一下这dynamic与object的区别。

     static void Method()

        {         

            int i = 10;

            object o = i;

            int j = (int)o;

            dynamic d = i;

            int k = (int)d;

        }

来看一下IL：

.method private hidebysig static void Method() cil managed

{

 // Code size       89 (0x59)

  .maxstack 4

 .locals init ([0] int32 i,

           [1] object o,

           [2] int32 j,

           [3] object d,

           [4] int32 k)

 IL_0000: nop

 IL_0001: ldc.i4.s   10

 IL_0003: stloc.0

 IL_0004: ldloc.0

 IL_0005: box        [mscorlib]System.Int32

 IL_000a: stloc.1

 IL_000b: ldloc.1

 IL_000c: unbox.any [mscorlib]System.Int32

 IL_0011: stloc.2

 IL_0012: ldloc.0

 IL_0013: box        [mscorlib]System.Int32

 IL_0018: stloc.3

 IL_0019: ldsfld     class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>> ConsoleApplication2.File/'<Method>o__SiteContainer0'::'<>p__Site1'

 IL_001e: brtrue.s   IL_0041

 IL_0020: call       class [System.Core]Microsoft.CSharp.RuntimeBinder.RuntimeBinder [System.Core]Microsoft.CSharp.RuntimeBinder.RuntimeBinder::GetInstance()

 IL_0025: ldtoken    [mscorlib]System.Int32

 IL_002a: call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)

 IL_002f: ldc.i4.1

 IL_0030: newobj     instance void [System.Core]Microsoft.CSharp.RuntimeBinder.CSharpConversionPayload::.ctor(class [System.Core]Microsoft.CSharp.RuntimeBinder.RuntimeBinder,

                                                                                                                class [mscorlib]System.Type,

                                                                                                                valuetype [System.Core]Microsoft.CSharp.RuntimeBinder.CSharpConversionPayload/ConversionKindEnum)

 IL_0035: call       class [System.Core]System.Scripting.Actions.CallSite`1<!0> class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>>::Create(class [System.Core]System.Scripting.Actions.CallSiteBinder)

 IL_003a: stsfld     class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>> ConsoleApplication2.File/'<Method>o__SiteContainer0'::'<>p__Site1'

 IL_003f: br.s       IL_0041

 IL_0041: ldsfld     class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>> ConsoleApplication2.File/'<Method>o__SiteContainer0'::'<>p__Site1'

 IL_0046: ldfld      !0 class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>>::Target

 IL_004b: ldsfld     class [System.Core]System.Scripting.Actions.CallSite`1<class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>> ConsoleApplication2.File/'<Method>o__SiteContainer0'::'<>p__Site1'

 IL_0050: ldloc.3

 IL_0051: callvirt   instance !2 class [System.Core]System.Func`3<class [System.Core]System.Scripting.Actions.CallSite,object,int32>::Invoke(!0,

                                                                                                                                               !1)

 IL_0056: stloc.s    k

 IL_0058: ret

} // end of method File::Method

我们会发现int i到object o是box，object o到int i是unbox，但dynamic d = i; int k = (int)d;前一行代码是box，但后一行就不是简单的unbox，看来object与dynamic则是不同的，是一个全新的类型，当然低层做了很多工作。

var与dynamic还一个区别是应用范围，var只能在类成员内部去应用，也就是来充当类成员的局部变量，但dynamic的应用范围就大了，他和一个基本的类型是一样的，可以在有其他类型的任何地方应用。也就是我们的变量动态到任何地方了，不像var只是在一定范围内。

今年是第17届WinHEC，同是也是在中国的第二次，今年是单独的WindHEC。

本次WinHEC的看点是Windows7-这个众说纷纭的下一代操作系统。认我们看看官方网站的说法：

被众多未知谜团与神秘光环所笼罩的微软下一代 Windows 操作系统— Windows 7 将在 WinHEC 2008 China 的舞台上首次揭秘！在此，您将预览 Windows 7 的众多新特性，进一步提升您对技术发展方向的深入认知与判断，获得在 Windows 7 平台上开发驱动程序和应用程序的最新知识，制定 Windows 7 时代的产品开发战略。
　　大会现场和体验区将为大家演示 Windows 7 的各个新功能，包括 Windows 7 device stage，多点触控，数字家庭，DirectX，. NET Micro Framework，Windows Sideshow 和 Virtualization,以及其他微软最新技术如 Windows Home Server, ,Surface 和中国新一代的标准包括数字高清 DMB-TH 与移动宽带。

看来Windows7的看头真还不少。

有了重要性，再来看看我产参会可以获的是吧，不但有硬物性：

　还有软物质：

光盘的内容如下：

对于Developer来说年就是Software development kit了。

本次WinHEC还有一个亮点（对我来说是黑点），就是讲师了，先看看吧

这是我最怕的，因为我E文很差，不过对一些E文牛的人来说，零距离与微软的核心开发团队接触，也不失一件激动人心的事呀！

好，就说这些吧，接下来就在期待中了。

Quick Search位于Edit菜单中（快键菜单Ctrl+,），这个功能是为开发人员能够快速查找某个方法，属性，字段等类的成员和命名空间，后台cs文件名等，这个查询适用范围是相同解决方案。这个功能在aspx页面中不可用。

Quick Search是一个模呼查询的，如上图当我们输入m时，所有本解决方案中的的cs文件中有m的文件，命名空间，类，及类的成员都会显示出来这是最普通的模乎查询。选中要查找的方法名（或其他成员名），回车，本页中的该方法名就全部被选中。

还有其他的模糊查询，比如我们输入的是MN，Quick Search就会列出全部的有M和N的字符的方法或成员名，这里只能是大写，小写不起作用，也就是大写字母中间不分隔也会模糊查询，小写则不行。

还有就是在输入的字符中间加空格，比如输入m n 1，所有有m，n，1的方法名或成员名就会显示出来，并且这三个字符都出现在方法名中或成员名中。

2)     JS和标签的自动提示

在vs2010中，js代码和标签都加上了作用自动提示，就像在cs中的类成员提示一样。

签标

JS

3)     新增的控件

Web上

Winform

4)     源代码缩放

这是一个非常棒的效果，因为他对我这种职业的人非常有用，我是一位讲师，可能在我书写代码时，我需要代码字体适中，以便我书写代码，但这时可能与学员在投影上的视觉有冲突，他们看起来小，没关系，当我可以在CS代码上，按住Ctrl来滚动滚轮，对代码进行平滑的放大缩小。（其实这个cs编码区是一个用WPF做的文代查询区）不过遗憾的是，只有在cs的页面上能实现这个功能，如果js，css，HTML等都实现这个功能，我道上的人就该乐了。

5)     自动创建

 FileInfo FI = new FileInfo();

上面代码如果我们在cs中书写的话，不引入System.IO的话，要报错的，如果我们选中FileInfo，就会弹出来一个小标签vs2008如下：

 Vs2010如下：

可以看到多了两个选项，一项是Generate class for ’FileInfo’和Generate other…，前者是自动创建一个类，后者是弹出一个选项框，让用户选择，因为不只有类能new。

（其他还在整理中）

是一个有11个压缩文件的虚拟机文件，下载后大小是7.11G，解压后有两个文件VisualStudio2010CTP.vhd和VisualStudio2010CTP.vmc，前者是虚拟硬盘，后者是虚拟机文件，这两件文件的总容量是23G,我是用Microsoft Virtual PC 2007打开这个虚拟机文件的，我把这个“庞然大物”放到我的移动硬盘下，这样当我需要时，把这些文件加载到我虚拟机中应用。

启动虚拟机：

在Microsoft Virtual PC 2007的操作菜单下有个Ctrl+Alt+Del（或右Alt+Del）选项，单击进入下图：

用四个用户，并且都有口令，按照下载的文档提示（在下载的页面中）有如下文字

1.    To logon to the machine, click on Action Menu (Shortcut: Right Alt+Del) on the VPC console and use the following credentials:
To run the walkthroughs you must logon using the TFSSETUP account with password of 1Setuptfs.

The following logon accounts and passwords have been preconfigured on the VPC:

o Administrator: TFSSETUP, password: 1Setuptfs (use this account to explore the CTP)

o Administrator: Administrator,password: P2ssw0rd

o User: TFSREPORTS, password: 1Reports

o User: TFSSERVICE, password: 1Service

我们用TFS Setup用户登录，本用户密码是1Setuptfs。系统后，你会发现别有洞天，系统是windows2008，还有SQL2008，还有visual studio 2010，怪不得23G，都是大家伙。所以想了解一下SQL2008的朋友或了解windows2008的朋友都可以用这个虚拟机文件。

这里要注意的是，windows2008没有激活，有条件的朋友可以激活，试用的时间可以长点。当然可以把主机的网络共享，再把Microsoft Virtual PC 2007的编辑-设置，选择网络连接，把右边的适配置设成共享连接，即可在虚拟机内部激活系统了。

因为数值类型的分类是值类型和引用类型，所以方法的参数也有这两种类型。

值类型参数：

static void Main()

{

  int i=1;

Mehtod(i);

}

static void Method(int s)

{

  s=200;

}

如果方法的参数是值类型，调用者Main传递给被调用方法Method的是一个值类型的副本，即i的一个副本，i与方法Method中的s值相同，但一旦调用完毕两都就没有关系了。

引用类型：

static void Main()

{

  int[] arri=new int[]{1};

Method(arri);

}

static void Method(int[] arrs)

{

  Arrs[0]=200;

}

引用类型作为方法的参数时，调用者传递的是引用（与指针类似），即把arri数组的引用传给Method方法，这里只是把引用传递给方法，而非副本，这点就使在Main中的arri与在Method中的arrs引用的是同一个对象，在两个方法的任何地方使之改变都会影响另一个方法的数据的。

简单的说，值类型参数传递副本，引用类型参数传递引用。

接下来说说ref和out作为参数

先看一下下面的代码，

       static void F1(ref int i)

        {

            i = 100;

        }

        static void F2(out int i)

        {

            i = 100;

        }

看看这两个方法对应的IL

.method private hidebysig static void F1(int32& i) cil managed

{

 // 代码大小       6 (0x6)

 .maxstack 8

 IL_0000: nop

 IL_0001: ldarg.0

 IL_0002: ldc.i4.s   100

 IL_0004: stind.i4

 IL_0005: ret

} // end of method Program::F1

.method private hidebysig static void F2([out] int32& i) cil managed

{

 // 代码大小       6 (0x6)

 .maxstack 8

 IL_0000: nop

 IL_0001: ldarg.0

 IL_0002: ldc.i4.s   100

 IL_0004: stind.i4

 IL_0005: ret

} // end of method Program::F2

我们通过生成的中间语言看到，这两个方法只有一个差别就是在F2的参数中多了一个[out]，方法体中是全部一样的。其实对于CLR来说，这两个关键字是没有区别的，都是能以引用类型的方式来操作参数。

为什么在C#中要区分out和ref呢？主要是因为out是输入参数，只希望它从方法内得到值返回，而ref即要把参数带到方法，也可以带出参数，就是说这只是C#编辑器的愿望，所以在C#中是区别的，但在CLR在运得exe的元数据是不区另的（因为托管理程序是两次编译）。

下面通过另一个方法看看ref和out

static void F1(ref int i)

        {

            i = 100;

        }

        static void F1(int i)

        {

            i = 100;

        }

上面的代码放在一个类中是能通过编译的，因为构成了重载

我们看以看一下普通方法的IL

.method private hidebysig static void F1(int32 i) cil managed

{

 // 代码大小       6 (0x6)

 .maxstack 8

 IL_0000: nop

 IL_0001: ldc.i4.s   100

 IL_0003: starg.s    i

 IL_0005: ret

} // end of method Program::F1

最明显的差别是参数普通方法是int32 i，而加ref，out的是int32& i，参数的不同使重载成为可以。但ref和out，如果参数类型个数相同的话刚形不成重载，因为它们是相同的，不充许出现相同方法（方法的签名）。

        {

          White,

          Black,

          Yellow

        }

这是一个枚举，没有什么特别。

说一下枚举的特点吧，其实枚举就是一系列符号和一系列对应的值，在上面的例子中，枚举的基类型是Int32类型，这是默认的类型，对应的各个枚举项，White=0,Black=1;Yellow=2;这就是一个符号与值的对应，CLR在用枚举时，是用的值，并不是符号，符号是开发人员用来能明确其值的含义的。

所有枚举都是从System.Enum派生来的，System.Enum又是从System.ValueType派生来的，System.ValueType的父类是System.Object。即然从System.Enum派生的，当然枚举都属于值类型了。

现在我们看看IL中的Complexion枚举是个什么样子

在IL中我们能看到它是从System.Enum继承的，还会发现所有的符号都是一个常量，即static  literal这个标识。

其实可以用这样一个C#代码来说明枚举Complexion

Internal struct Complexion:System.Enum

{

 public const Complexion White==(Complexion)0;

 public const Complexion Black==(Complexion)1;

 public const Complexion Yellow==(Complexion)2;