{

          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;

 public Int32 value_;

}

当然，上面的代码如果写到C#环境中是编译不过的，因为System.Enum是个特殊的类，不允许派生子类型。

在上面的伪代码中，可以看到，每个符号（White,Black,Yellow），都是一个常量，关且是Complexion类型的。

上面是一个委托的定义，委托向外提供了一种回调函数的机制，在.net中的委托是类型安全的，一个委托能实现对一类方法的回调，这个统一是通过委托的参数和返回值来实现的。

上面代码如果用IL来解释，是这个样子

如果用C#来表示，一个委托就成了下面的代码

  class DL:System .MulticastDelegate

   {

       public DL(Object object,IntPtr method);

       public virtual void Invoke(Int32 i);

       public virtual IAsyncResult BeginInvoke(Int32 i,AsyncCallback callback,Object object);

       public virtual void EndInvoke(IAsyncResult result);    

   }

当然，上面代码是通不过编译的，只是对应IL代码的表现。

在上面的类中，有一个构造函数，和三个方法，同时还有三个继承至MulticastDelegate的三个非公有字段_target，_methodPtr，_invocationList。

在构造函数中有两个参数，第一个是object类型，这里指的是被回调方法的对象，如果该方法是静态的，那么这个值就是null，第二个参数是个IntPtr，这个参数是回调方法。并且在构造器中，会把object赋给_target，IntPtr赋给_methodPtr来保存。

另外一个字段_invocationList是一个存放回调方法的链表。

static void Main(string[] args)

        {

            Program p = new Program();

            DL dl = new DL(p.FF);

            dl += p.FF;

            dl += FF1;

            dl(1);

        }

        public static void FF1(int i)

        {

            Console.WriteLine("d");

        }

        public void FF(int i)

        {

            Console.WriteLine(DateTime .Now .ToString ());

        }

上面代码的+=的过程，其实就是向_invocationList添加委托的过程。

还有代码中，我们调用了dl(1)，这个代码其实是dl.Invoke(1)。

后两个方法的使用，可参看http://www.cnblogs.com/axzxs2001/archive/2008/04/17/1157269.html。

首先来定义一个事件：

public event EventHandler SJ;

编译后，我们可以它的IL：

可以看到，IL中的事件并不是单纯的事件了，其实是分解成一个委托和两个方法了，如下代码：

private EvntHandler WT=null;

[MethodTmpl(MethodImplOptions.Synchronized)]

public void add_WT(EventHandler value)

{

   WT=(EventHandler)Delegate.Combine(WT,value)

}

[MethodTmpl(MethodImplOptions.Synchronized)]

public void remove_WT(EventHandler value)

{

   WT=(EventHandler)Delegate.Remove(WT,value)

}

其实就是一个委托作为字段，还提供了两上方法，一个是向委托列表中添加委托，一个是从委托列表中移除委托。

其实这里的add和remove对应着事件的+=和-=，假如我们WT+=new EventHandler(方法名),其实就是调用add_WT,把new EventHandler（方法）这个委托加入到委托列表中。

构造函数有两种，一种是实例构造函数，一种是静态构造函数。

现有一个类：

    class Test

    {    

}

这个类与下面的类完全等价

    class Test

    {

        static Test()

        {

        }

        public Test()

        {

        }   

 }

也就是说，如果定义完一个类后，IDE会自动在类的内部定义一个静态构造函和和一个实例化函数的。

这两个构造函数是有区别，静态构造函数只在该类的第一个对象被实例化时才调用，而实例化构造函数，则是在每次对象被实例化时调用。

实例构造函数可以有多个，通过参数来区分，或者参数的个数不同，或者参数的类型不能，也就是所谓的重载。但静态构造函数则有且只能有一个，并且不能有任何参数。

下面再看一下这个例子

class Test

{

        int a=1, b=2, c=3;

        int d;

        public Test()

        {

        }

        public Test(int i)

        {

        }

        public Test(string s)

        {

        }  

}

表面上看来没有什么，就是一个类中有三个构造函数，还有三个字段。

现在让我们看看IL吧

首先看一下这个类的IL

其中三个.ctor就是三个实例构造函数，双击三个构造函数来看一下它的IL代码：

Test()→.ctor:void()

.method public hidebysig specialname rtspecialname

        instance void .ctor() cil managed

{

 // 代码大小       31 (0x1f)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: ldc.i4.1

 IL_0002: stfld      int32 ConsoleApplication1.Test::a

 IL_0007: ldarg.0

 IL_0008: ldc.i4.2

 IL_0009: stfld      int32 ConsoleApplication1.Test::b

 IL_000e: ldarg.0

 IL_000f: ldc.i4.3

 IL_0010: stfld     int32 ConsoleApplication1.Test::c

 IL_0015: ldarg.0

 IL_0016: call       instance void [mscorlib]System.Object::.ctor()

 IL_001b: nop

 IL_001c: nop

 IL_001d: nop

 IL_001e: ret

} // end of method Test::.ctor

Test(int i)→.ctor:void(int32)

.method public hidebysig specialname rtspecialname

        instance void .ctor(int32 i) cil managed

{

 // 代码大小       31 (0x1f)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: ldc.i4.1

 IL_0002: stfld      int32 ConsoleApplication1.Test::a

 IL_0007: ldarg.0

 IL_0008: ldc.i4.2

 IL_0009: stfld      int32 ConsoleApplication1.Test::b

 IL_000e: ldarg.0

 IL_000f: ldc.i4.3

 IL_0010: stfld      int32 ConsoleApplication1.Test::c

 IL_0015: ldarg.0

 IL_0016: call       instance void [mscorlib]System.Object::.ctor()

 IL_001b: nop

 IL_001c: nop

 IL_001d: nop

 IL_001e: ret

} // end of method Test::.ctor

Test(string s)→.ctor:void(string)

.method public hidebysig specialname rtspecialname

        instance void .ctor(string s) cil managed

{

 // 代码大小       31 (0x1f)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: ldc.i4.1

 IL_0002: stfld      int32 ConsoleApplication1.Test::a

 IL_0007: ldarg.0

 IL_0008: ldc.i4.2

 IL_0009: stfld      int32 ConsoleApplication1.Test::b

 IL_000e: ldarg.0

 IL_000f: ldc.i4.3

 IL_0010: stfld      int32 ConsoleApplication1.Test::c

 IL_0015: ldarg.0

 IL_0016: call       instance void [mscorlib]System.Object::.ctor()

 IL_001b: nop

 IL_001c: nop

 IL_001d: nop

 IL_001e: ret

} // end of method Test::.ctor

很明显的看到，三个实例构造函数都对a,b,c进行了初始化赋值，即造成了代码的重复。

如果初始化的字段更多，构造函数更多，重复量就更大。

但值的注意的是，在Test类中有一个字段d，没有初始化，并且在所有的构造函数中也没有发现它，这个，就给我们避免代码重复提供了一个方法。

改造一下上面的代码：

class Test

    {

        int a,b,c;

        int d;

        public Test()

        {

            a = 1;

            b = 2;

            c = 3;

        }

        public Test(int i):this()

        {

        }

        public Test(string s):this()

        {

        }

    }

就在类中，先不去初始化字段，只在没有参数的实例构造函数中初始化，用其他构造函数来调用它，现在来看一下IL

Test()→.ctor:void()

.method public hidebysig specialname rtspecialname

        instance void .ctor() cil managed

{

 // 代码大小       31 (0x1f)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: call       instance void [mscorlib]System.Object::.ctor()

 IL_0006: nop

 IL_0007: nop

 IL_0008: ldarg.0

 IL_0009: ldc.i4.1

 IL_000a: stfld      int32 ConsoleApplication1.Test::a

 IL_000f: ldarg.0

 IL_0010: ldc.i4.2

 IL_0011: stfld      int32 ConsoleApplication1.Test::b

 IL_0016: ldarg.0

 IL_0017: ldc.i4.3

 IL_0018: stfld      int32 ConsoleApplication1.Test::c

 IL_001d: nop

 IL_001e: ret

} // end of method Test::.ctor

Test(int i)→.ctor:void(int32)

.method public hidebysig specialname rtspecialname

        instance void .ctor(int32 i) cil managed

{

 // 代码大小       10 (0xa)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: call       instance void ConsoleApplication1.Test::.ctor()

 IL_0006: nop

 IL_0007: nop

 IL_0008: nop

 IL_0009: ret

} // end of method Test::.ctor

Test(string s)→.ctor:void(string)

.method public hidebysig specialname rtspecialname

        instance void .ctor(string s) cil managed

{

 // 代码大小       10 (0xa)

 .maxstack 8

 IL_0000: ldarg.0

 IL_0001: call       instance void ConsoleApplication1.Test::.ctor()

 IL_0006: nop

 IL_0007: nop

 IL_0008: nop

 IL_0009: ret

} // end of method Test::.ctor

会发现，在有参数的两个构造函数中的IL要少很多，这样就能减少IL代码量。

在类中，如果有初始化的静态字段，会在静态构造函数中来实现，不过静态构造函数只能有一个，所以这个在代码量中问题不会存在。

值类型包括：简单类型（int ,double,long,bool,char等，string除外），struct,enum

引用类型：委托，类，接口，string，数组等

如果更简单的说，值类型就是结构和枚举，所有的简单类型都是一个结构，结构是从System.ValudType这个类继承下来的，枚举也继承至System.ValueType，SystemValueType的父类是System.Object。引用类型中典型的是类，所有类都继System.Object；

值类型位于线程堆栈中，引用类型位于托管堆中

先看如下代码：

cass Test_Class

{

 public int i=10;

}

static void Main()

{

   int i=5;

   Text_Class test=new Test_Class();

   test.i=100;

}

我们来看一下在线程堆栈和托管理堆在内存中的表示

线程堆栈中的i是Main方法中的局部变量，托管理堆中的i是test对象的一个字段。

我们对代码修一下

cass Test_Class

{

 public int i=10;

}

static void Main()

{

   int i=5;

   int j=I;

   Text_Class test=new Test_Class();

   test.i=100;

   Text_Class test1=test;

}

这段代码在执行时，对应的的线程堆栈和托管堆图解如下：

从上图我们就能看出值类型与引用类型的区别，值类型是具体的值，相互之间没有关系，引用类型是一个引用，如果两个对象指向一个引用，它们之间就互相影响。

说到值类型和引用类型不得不说一下装箱和折箱：

装箱，是将值类型转换成引用类型，折箱正好相反。

装箱的过程在内存中是怎样一个过程呢？

Static void Main()

{

 int i=5;

 object o=I; //装箱

 int j=(int)o; //折箱

}

装箱过程

1.         从托管堆上分配内存，并增加两个成员“类型对象指针”和“同步块索引”

2.         将值i=5复制在上一步分配的托管堆中

3.         把托管堆上的地址返回给o

需要说明的是，装箱时，o能记录下i的准确类型，也就是在折箱的时，折出的是具体的类型。

折箱相对简单，只是把堆中的数据部分取出来存到线程堆栈中对应的变量中。

装箱和折箱定义上相对简单，但在应用是上是很有技巧的，比如下面例子：

1、Console.WriteLine(“当前时间：”+DateTime.Now);

2、ConsoleWriteLine(“当前时间：”+DateTime.Now.ToString());

一般托管理程序分为

PE文件头：包含文件的类型，还有生成文件的时间

CLR头：包含CLR版本，入口方法的元数据标记

元数据：定义的类型和成员，引用的类型和成员

IL（中间语言）：编译源代码时生成的代码

现在来看一下托管理代码的运行，有这样一个简单的方法

using System;

class Democlass

{

    static void Main()

    {

        Console.WriteLine("谢谢！");

        Console.WriteLine("阅读。");

Console.WriteLine("再见！");

    }

}

当IDE把把这个代码编译成exe后，我们运行起这个exe(当然是在装有.net Framework的计算机上)，首先CLR会扫描所有这个Main方法中的类型，然后会创建一个用于管理这些类型的数据结构，虽然本例中只有一种类型Console，并且还是一个静态类。在这个数据结构中，存放着很到记录，每个记录与Console的一个方法对应着，每个记录中，包含着一个指向方法实现的内存地址。

当这个数据结构初始化时，CLR就将数据结构中的每条记录指向一个在CLR中已定义好的方法CallMethod(我假设的名子)，这个方法能根据记录找到方法实现，当执行Console.WriteLine(“谢谢！”)时，会在数据结构中找到对应的记录，这个记录会调起CallMethod方法，CallMethod这个方法要实现 步骤如下：

A.        调用元数据中的WriteLine方法(因为记录与CallMethod关联，记录指向方法的实现地址，所以CallMethod能调用WriteLine方法)

B.        从元数据中得到这个方法的IL

C.        申请一块内存空间

D.        把这个方法编译成CPU指令，放到申请的内存空间中

E.         然后这个方法返回到这个数据结构中的WriteLine方法对应的那条记录，用申请的内存地址替换掉这个记录包含指向方法实现的内存地址（这里就是用CPU指令所在的内存地址替换掉了实现方法的内存地址）

F.         返回Main方法的Console.WriteLine(“阅读”)

当CLR执行Main方法的Console.WriteLine(“阅读”)时，因为记录中的内存地址已变成了CPU指令所在的内存地址，所以这次，CallMethod方法就不用被重新调用，这就说明，一旦该方法第一次被调用过，以后的调用就相对的节省资源了。直到该程序中止退出。

Internet Explorer 8 Beta2 常见问题解答

http://forums.microsoft.com/china/ShowPost.aspx?PostID=3832844&SiteID=15&mode=1

Internet Explorer 8 Beta2 Top Features

http://forums.microsoft.com/china/ShowPost.aspx?PostID=3832911&SiteID=15&mode=1

IE 8 Beta 2中文版首份试用体验

http://forums.microsoft.com/china/ShowPost.aspx?PostID=3832938&SiteID=15

Vista

http://forums.microsoft.com/china/ShowForum.aspx?ForumID=1707&SiteID=15

http://angelmartina.blog.51cto.com/

C#的类型和对象在应用计算机内存时，大体用到两种内存，一个叫堆栈，另一个叫托管堆，下面我们用直角长方形来代表堆栈，用圆角长方形来代表托管堆。

首先讨论一下方法内部变量的存放。

先举个例子，有如下两个方法，Method_1和Add，分别如下：

public void Method_1()

{

 int value1=10;　　//1

 int value2=20;    //2

 int value3=Add(value,value); //3

}

public int Add(int n1,int n2)//4

{

   rnt sum=n1+n2;//5

   return sum;//6

}

这段代码的执行，用图表示为：

上述的每个图片，基本对应程序中的每个步骤。在开始执行Method_1的时候，先把value1压入堆栈顶，然后是value2，接下来的是调用方法Add，因为方法有两个参数是n1和n2，所以把n1和n2分别压入堆栈，因为此处是调用了一个方法，并且方法有返回值，所以这里需要保存Add的返回地址，然后进入Add方法内部，在Add内部，首先是给sum赋值，所以把sum压入栈项，然后用return返回，此时，先前的返回地址就起到了作用，return会根据地址返回去的，在返回的过程中，把sum推出栈顶，找到了返回地址，但在Method_1方法中，我们希望把Add的返回值赋给value3，此时的返回地址也被推出堆栈，把value3压入堆栈。虽这个例子的结果在这里没有多大用途，但这个例子很好的说明了在方法被执行时，变量与进出堆栈的情况。这里也能看出为什么方法内部的局变量用过后，不能在其他方法中访问的原因。

其次来讨论一下类和对象在托管堆和堆栈中的情况。

先看一下代码：

    class Car

    {

        public void Run()

        {

            Console.WriteLine("一切正常");

        }

        public virtual double GetPrice()

        {

            return 0;

        }

        public static void Purpose()

        {

            Console.WriteLine("载人");

        }

    }

    class BMW : Car

    {

        public override double GetPrice()

        {

            return 800000;

        }

}

上面是两个类，一个Father一个Son，Son继承了Father，因为你类中有一个virtual的BuyHouse方法，所以Son类可以重写这个方法。

下面接着看调用代码。

        public void Method_A()

        {

            double CarPrice;//1

            Car car = new BMW();//2

            CarPrice = car.GetPrice();//调用虚方法（其实调用的是重写后的方法）

            car.Run();//调用实例化方法

            Car.Purpose();//调用静态方法

 }

这个方法也比较简单，就是定义一个变量用来获得价格，同时定义了一个父类的变量，用子类来实例化它。

接下来，我们分步来说明。

看一下运行时堆栈和托管堆的情部我：

这里需要说明的是，类是位于托管堆中的，每个类又分为四个类部，类指针，用来关联对象；同步索引，用来完成同步(比如线程的同步)需建立的；静态成员是属于类的，所以在类中出现，还有一个方法列表（这里的方法列表项与具体的方法对应）。

当Method_A方法的第一步执行时： 

 这时的CarPrice是没有值的

当Method_A方法执行到第二步，其实第二步又可以分成

Car car;

 car = new BMW();

先看Car car;

car在这里是一个方法内部的变量，所以被压到堆栈中。

 再看 car = new BMW();

这是一个实例化过程，car变成了一个对象

这里是用子类来实例化父类型。对象其实是子类的类型的，但变量的类型是父类的。

接下来，在Method_A中的调用的中调用car.GetPrice()，对于Car来说，这个方法是虚方法（并且子类重写了它），虚方法在调用是不会执行类型上的方法，即不会执行Car类中的虚方法，而是执行对象对应类上的方法，即　BMW中的GtPrice。

如果Method_A中执行方法Run()，因为Run是普通实例方法，所以会执行Car类中的Run方法。

如果调用了Method_A的Purpose方法，即不用变量car调用，也不用对象调用，而是用类名Car调用，因为静态方法会在类中分配内存的。如果用Car生成多个实例，静态成员只有一份，就是在类中，而不是在对象中。

操作系统上运行的都是进程，这进程是非托管的。现在。我们有一个Demo.exe，他是用.net写的（这里与语言无关了，因为编设成程序集后，都成为IL语言了），当然是一个托管理程序。这里的问题就是怎么把Demo.exe变成一个进程，运行在操作系统的进程中。这里就引出了应用程序域（Application Domain），应用程序域(Application Domain)是“托管理代码与非托管理代码之间的桥梁”（引自《.NET组件编程设计》），进程，应用程序域，.net程序集（这里是Demo.exe），之间的关系可以见下图：

应用程序域（Application Domain）的引入的好处在于，如果一个程序集出现错误，不会影响到别的应用程序域（Application Domain），同时他们又是一个进程中的。

在.net中，应用程序域（Application Domain）是用AppDomain类来表示的。

AppDomain CurrentAD=AppDomain.CurrentDomain;

上面的代码实现了获取当有程序集所在的应用程序域（Application Domain）。获取当前应用程序域（Application Domain）还可以通过当前线程来得到，如下：

AppDomain CurrentAD=Threed.GetDomain();

下面再看一下在当前应用程序域（Application Domain）中创建对象：

类：

Class Class1

{

   Public void FF()

{

  //实现功能

}

{

AppDomain CurrentAD=Threed.GetDomain();

Class1 C1=(Class1)CurrentAD.CreateInstanceAndUnwrap(“程序集名称”,”名命空间.类名”);

C1.FF();

这个是关于当前的应用程序域（Application Domain）的操作，怎么创建一个应用程序域（Application Domain）呢？看下面

AppDomain MyAppDomain=AppDomain.CreatDomain(“MyNewAD”);

Class1 C1=(Class1)MyAppDomain.CreateInstanceAndUnwrap(“程序集名称”,”名命空间.类名”);

C1.FF();

或

AppDomain MyAppDomain=AppDomain.CreatDomain(“MyNewAD”);

IObjectHandle handle=MyAppDomain.CreateInstance “程序集名称”,”名命空间.类名”);

Class1 C1=(Class1)handle.Unwrap();

C1.FF();

后都的好处在于用C1这个对象的时候才进处理。

 在大多数系统中，开发人员都是自己建立用户管理系统
在asp.net中，微软给了一套用户验证，权限，角色的控件和API，接下来的几往篇文单谈一下自己的浅薄认识。
引入数据库
把用户管理的数据库引入到自己的项目中，在装完Freamework2.0后，有如下文件，C:"Windows"Microsoft.NET"Framework"v2.0.50727"aspnet_regsql.exe（这是默认的安装目录）,这个文件是用来向用户的数据库添加用户管理的数据库表的。安装界面如下：

（一）

（二）

（三）

（四）

（五）

其中的第三步，用户可以选择自己的数据库把用户管理的数据表加载到自己的数据库中。

此时如果用用户登录控件做用户的操作时，用户的信息还是添加不到自己的数据中的，因为系统默认的用户数据库是一个位于本项目App_Data文件夹下的一个文件性SQL数据库，为了登录控件中用户管理的一些类能操作自己的数据库中的用户管理表，则需在配置文件作一下配置的修改，即在web.config中作修改。
修改如下：
在web.config的<system.web>中添加下列代码

 1 <!--添加成员管理-->
 2    <membership defaultProvider="SqlProvider" userIsOnlineTimeWindow="20">
 3      <providers>
 4        <add connectionStringName="ConString" enablePasswordRetrieval="false"
 5          enablePasswordReset="true" requiresQuestionAndAnswer="true"
 6          passwordFormat="Hashed" applicationName="/" name="SqlProvider"
 7          type="System.Web.Security.SqlMembershipProvider" />
 8      </providers>
 9    </membership>
10    <!--添加角色管理-->
11    <roleManager defaultProvider="SqlProvider"
12          enabled="true" cacheRolesInCookie="true"     cookieName=".ASPROLES"        cookieTimeout="30"     cookiePath="/"     cookieRequireSSL="true"        cookieSlidingExpiration="true"   cookieProtection="All" >
13      <providers>
14        <add name="SqlProvider" type="System.Web.Security.SqlRoleProvider"          connectionStringName="ConString"    applicationName="SampleApplication" />
15      </providers>
16    </roleManager>
17<!--配置连接字符串-->
18 <connectionStrings>
19    <add name="ConString" connectionString="Data Source=.;Initial Catalog=UserManage;Integrated Security=True"    providerName="System.Data.SqlClient" />
20 </connectionStrings>

本配置的意思是重新建立一个连接字符串，把用户管理和角色管理都指向这个连接字符串，也就是系统中有关用户角色类操作数据库时都依赖这个连接来完成。
成员管理和角色管理的配置中都有一个<providers>的标签，该标签的主要作用是配置成员类和角色类的一些属性，比如成员配置中<add connectionStringName="ConString" enablePasswordRetrieval="false"
          enablePasswordReset="true" requiresQuestionAndAnswer="true"
          passwordFormat="Hashed" applicationName="/" name="SqlProvider"
          type="System.Web.Security.SqlMembershipProvider" />
首先是个连接，指向ConString，密码回复功能，密码重设功能，是否要问题回答，密码的格式，应用程序的路径，本Provider的名称，以及本Provider的类型。
至此，我们就完成了把微软的用户管理的表导入自己的数据库，并且作了连接字符串的配置，如果我们现在操作成员类或角色类，成员和角色的变动就会在自己的数据表中得到体现。