.Net基础

 标题

 状态

 内容

 NET应用程序是如何执行的？ 

http://www.cnblogs.com/kingmoon/archive/2012/07/16/2594459.html

从汇编入手，探究泛型的性能问题

 汇编及IL

从这里我们可以看到，CLR为引用类型（string/object/Program）生成共享的机器码，它们都实际上在调用一个GenericMethod<System.__Canon>所生成的代码。而对于每个不同的值类型（int/DateTime/double），CLR则会为每种类型各生成一份

http://www.cnblogs.com/JeffreyZhao/archive/2009/06/03/my-view-of-il-2-il-shows-little-about-clr.html

 JIT

 JIT Compiler(Just-in-time Compiler) 即时编译

 。NET和C#各个版本的变迁

 已读

CLR是公共语言运行库(Common Language Runtime)  http://www.cnblogs.com/lufangtao/archive/2012/06/07/2539915.html

CLR 完全介绍 深入探讨 IDisposable  https://msdn.microsoft.com/zh-cn/magazine/cc163392.aspx

Net 版本和C#对应关系

.Net各版本差别 参考

http://blog.csdn.net/xjc1278003262/article/details/8605738?utm_source=tuicool

.Net1.0
.Net1.2
.Net2.0	1)泛型和可空类型 2)匿名方法 3)迭代 4) 部分类 5)本地应用托管.NET运行时实例的新API。 新的API提供比如多线程、内存分配，程序集加载等更细粒度上的运行时行为控制 。 6)许多新增和改进的ASP.NET Web控件 。 7) 新增ASP.NET个性化功能，如对主题、皮肤、母版页和WebParts 的支持。
.Net3.0	.NET 3.0有点奇特，因为它是一个在CLR、语言和已有库方面都没有改变的“主”版本，而 是由4个新的库组成。  WPF是下一代用户界面框架；它是一场革命，而不仅仅是对Windows Forms的革新，尽管 这两者可以共同存在。它跟Windows Forms是两种完全不同的模型，在本质上更倾向于组 装式。Silverlight的用户界面基于WPF。  WCF（Windows Communication Foundation）是构建面向服务的应用程序架构；它不会局限 于单个协议，而是可以进行扩展，并且致力于统一现有的RPC类的通信管道，如远程处理。  WF（Wondows Workflow Foundation）是用于构建工作流应用程序的系统。  Windows CardSpace是一个安全识别系统。
.Net3.5	1)Linq c#3.0 2)EF 3)新增两个Web开发程序集：System.Web.Abstraction和System.Web.Routing两个新组件。
.Net4.0
.Net4.5	1)异步

C#各版本差别

C#2.0	泛型 可空类型 匿名方法 委托的增强 迭代器块。 分部类型、静态类、包含不同访问修饰 符的属性的取值方法和赋值方法、命名空间别名、pragma指令以及固定大小的缓冲器，
C#3.0	LINQ而生 自动属性、数组和局部变量的隐式 类型、对象和集合的初始化程序以及匿名类型 Lambda表达式和表达式 扩展方法 分部方法仅出现在C# 3中
C#4.0	命名实参、可选参数、更好的COM交互、泛型可变性 动态类型
C#5.0	异步特性

HttpContext请求上下文对象

http://www.cnblogs.com/kissdodog/p/3360584.html

值类型和引用类型的区别

http://www.cnblogs.com/Autumoon/archive/2008/08/18/1270685.html

所有值类型都继承自System.ValueType，但是ValueType没有附加System.Object包含之外其它任何方法，不过它倒是改写了Equals和GetHashCode两个方法。引用类型变量的Equals比较的是二者的引用地址而不是内部的值，值类型变量的Equals方法比较的是二者的值而不是……哦对了，值类型压根儿没有引用地址；

c# ==和equals的区别

http://kb.cnblogs.com/page/206353/

http://stackoverflow.com/questions/21273890/what-is-the-difference-between-and-equals-for-primitives-in-c

对于值类型 对于不同的类型会强制转换成前面的类型。如果如short -》int 行   int=》short 不行

对于引用类型 ==比较的是引用地址是否相同（即栈中的内容是否相同），equal比较的是2个变量师傅是对同一个对象的引用，即堆中的内容是否相同。

值类型 类型不同的时候会调用不同的equal

Equals和GetHashcode http://blog.csdn.net/afgasdg/article/details/6889383

http://www.cnblogs.com/lwzz/archive/2012/02/26/2361843.html

ReferenceEquals是Object的静态方法，用于比较两个引用类型的对象是否是对于同一个对象的引用。

C#参考 ：ReferenceEquals, == , Equals  http://www.cnblogs.com/Dlonghow/archive/2008/08/04/1259732.html

默认情况下，对于引用类型，该方法对比的时引用的地址，对于值类型，对比的是值的二进制描述是否相同。100.0与100虽然都是100，但是它们的二进制分布是不一样的。

1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。

2 、要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。

1、equals方法用于比较对象的内容是否相等（覆盖以后）

2、hashcode方法只有在集合中用到

3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。

4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

5、将元素放入集合的流程图：

内存分配

C#中堆和栈的区别分析

http://www.cnblogs.com/aaa6818162/p/4644505.html

从内存分配看函数参数传递问题 http://blog.csdn.net/fmoonstar/article/details/6827030

变量、参数和内存分配 http://www.cnblogs.com/IOS-Developer/p/4117618.html

对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。

字符串的驻留（String Interning）

http://www.cnblogs.com/artech/archive/2007/03/04/663728.aspx

于String是我们做到频率最高的一种类型，CLR考虑性能的提升和内存节约上，对于相同的字符串，一般不会为他们分别分配内存块，相反地，他们会共享一块内存。CLR实际上采用这个的机制来实现的：CLR内部维护着一块特殊的数据结构——我们可以把它看成是一个Hash table，这个Hash table维护者大部分创建的string（我这里没有说全部，因为有特例）。这个Hash table的Key对应的相应的string本身，而Value则是分配给这个string的内存块的引用。当CLR初始化的时候创建这个Hash table。一般地，在程序运行过程中，如果需要的创建一个string，CLR会根据这个string的Hash Code试着在Hash table中找这个相同的string，如果找到，则直接把找到的string的地址赋给相应的变量，如果没有则在托管堆中创建一个string，CLR会先在managed heap中创建该strng，并在Hash table中创建一个Key-Value Pair——Key为这个string本身，Value位这个新创建的string的内存地址，这个地址最重被赋给响应的变量

深入理解string和如何高效地使用string  http://www.cnblogs.com/artech/archive/2007/05/06/737130.html

 C#中,String和string的区别

C#中，字符串的声明，你使用String还是string?
String? string? 只有一个大小写的问题，你习惯用哪个？知道具体的区别吗？
我是习惯了用string，区别也是最近才找到了权威的根据，'CLR via C#'。
其实，String是CLR的类型名称（也算是keyword），而string是C#中的keyword。在C#的编译时，默认会增加几行代码，看了你就会明白string和String的区别了！
using string = System.String;
using sbyte = System.SByte;
using byte = System.Byte;
using short = System.Int16;
using ushort = System.UInt16;
using int = System.Int32;
using uint = System.UInt32; ... ...
对了！ using string = System.String; C#编译器，会自动的把string转化为Sysem.string!
在CLR via C#中，Jeffrey Richter建议coding时，使用CLR默认的类型，也就是说，不要string，要String；不要int要Int32！至于为什么，还是大家自己看看这本书吧，very useful！

也可以这样理解：string是C#中字符串类型String的反射，一种简化的书写方式，就像int对应于Int32一样，二者在C#中可通用。

String，StringBuffer，StringBuilder

http://www.cnblogs.com/A_ming/archive/2010/04/13/1711395.html

我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　　　执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

　　　  而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

对于三者使用的总结： 1.如果要操作少量的数据用 = String

　　　　　　　　　　              2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

　　　　　　　　　　              3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

 参数的类型

  实参和形参:形参就是函数定义时候用的，实参是在函数调用时候用的。

1. 比如你定义一个函数void add（int a, int b），这里的a和b就是形参。

2. 当你进行函数调用的时候，add（1, 2），这里的1和2就是实参。

 变量和参数

  http://www.cnblogs.com/lanxiazhi/archive/2009/03/19/1417161.html

局部变量是指在函数型成员如方法、属性、索引器中声明的变量

声明时指定了static修饰符的字段就是静态变量

C#中一共有四种类型的参数：值参数，引用参数，输出参数，参数数组。

 C# const, readonly, static readonly 

 http://www.cnblogs.com/qingxia/archive/2011/02/10/1950741.html

Const 定义的是静态常在对象初始化的时候赋值.以后不能改变它的值.属于编译时常量。不能用new初始化。

Readonly 是只读变量.属于运行时变量.可以在类constructor里改变它的值.不能作用于局部变量。

const 和 static 不能在一起用，它已经是静态的了。

我们都知道，const和static readonly的确非常像：通过类名而不是对象名进行访问，在程式中只读等等。在多数情况下能混用。
二者本质的差别在于，const的值是在编译期间确定的，因此只能在声明时通过常量表达式指定其值。

而static readonly,在程式中只读, 不过它是在运行时计算出其值的，所以还能通过静态构造函数来对它赋值,

readonly只能用来修饰类的field，不能修饰局部变量，也不能修饰property等其他类成员

 委托 事件

什么是委托？

委托和事件的关系？

 http://www.cnblogs.com/chengzish/p/4559268.html

http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx

委托 是存放方法的指针的清单，也就是装方法的容器

事件是委托对象，事件自身实现了对委托对象的保护

所以event关键字本质就是做了两个事情，从而实现对委托对象的保护：

　　　 1，创建了一个对应的Private委托对象

　　　2，然后添加Add和Remove方法访问、操作这个Private委托对象。

　　

Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，

其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

<SPAN style="FONT-SIZE: 13px">using System;
using System.Collections.Generic;
using System.Text; 

namespace Delegate {
     // 热水器
    public class Heater {
        private int temperature;
        public delegate void BoilHandler(int param);   //声明委托
       public event BoilHandler BoilEvent;        //声明事件 

       // 烧水
       public void BoilWater() {
            for (int i = ; i <= ; i++) {
               temperature = i; 

               if (temperature > ) {
                   if (BoilEvent != null) { //如果有对象注册
                      BoilEvent(temperature);  //调用所有注册对象的方法
                  }
               }
            }
        }
     } 

     // 警报器
    public class Alarm {
        public void MakeAlert(int param) {
            Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", param);
        }
     } 

     // 显示器
    public class Display {
        public static void ShowMsg(int param) { //静态方法
           Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", param);
        }
     } 

     class Program {
        static void Main() {
            Heater heater = new Heater();
            Alarm alarm = new Alarm(); 

            heater.BoilEvent += alarm.MakeAlert;    //注册方法
           heater.BoilEvent += (new Alarm()).MakeAlert;   //给匿名对象注册方法
           heater.BoilEvent += Display.ShowMsg;       //注册静态方法 

           heater.BoilWater();   //烧水，会自动调用注册过对象的方法
       }
     }
 }
输出为：
Alarm：嘀嘀嘀，水已经  度了：
Alarm：嘀嘀嘀，水已经  度了：
Display：水快烧开了，当前温度：96度。
// 省略...
</SPAN>

多线程

static

单例

 线程上下文切换的性能损耗测试  http://www.cnblogs.com/EthanCai/p/3705834.html

static 在多线程的情况

Static与线程安全 http://yinlei555.iteye.com/blog/707986

静态方法是否有线程安全问题?要看在静态方法中是否使用了静态成员。

对于ASP.NET, 多个客户端访问服务器端, 这是一个多线程的例子

c#创建带参数的线程

、无参数线程的创建
Thread thread = new Thread(new ThreadStart(getpic));
thread.Start();
 private void showmessage()
{
     Console.WriteLine("hello world");
}
、带一个参数的线程
使用ParameterizedThreadStart，调用 System.Threading.Thread.Start(System.Object) 重载方法时将包含数据的对象传递给线程。
注意传递的参数只能是object类型，不过可以进行强制类型转换。
Thread thread = new Thread(new ParameterizedThreadStart(showmessage));
string o = "hello";
thread.Start((object)o);
private static void showmessage(object message)
{
     string temp = (string)message;
     Console.WriteLine(message);
}
、带两个及以上参数的线程
这时候可以将线程执行的方法和参数都封装到一个类里边，通过实例化该类，方法就可以调用属性来尽享传递参数。
例如如下程序，想传入两个string变量，然后打印输出。
public class ThreadTest
    {
        private string str1;
        private string str2;

        public ThreadTest(string a, string b)
        {
            str1 = a;
            str2 = b;
        }
        public void ThreadProc()
        {
            Console.WriteLine(str1 + str2);
        }
    }
public class Example {
    public static void Main()
    {
       ThreadTest tt = new ThreadTest("hello ", "world");
       Thread thread = new Thread(new ThreadStart(tt.ThreadProc));
            thread.Start();
    }
} 

http://www.cnblogs.com/aaa6818162/p/4516940.html

/// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            // 双重锁定只需要一句判断就可以了
            if (uniqueInstance == null)
            {
                lock (locker)
                {
                    // 如果类的实例不存在则创建，否则直接返回
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }

 Dispose(); .Clear(); = null

 DataTable的 .Dispose(); .Clear(); = null; 三个有何区别,?http://zhidao.baidu.com/link?url=HE1FqLFeui856OhD7i3n4aKEicDJh42GaRm0EuLGvJC9xPIwQCmWM99D_iEmv3d035-8Td8hcIcJD-qIgXnz8_

 深拷贝浅拷贝

 ICloneable

浅拷贝就比如像引用类型，而深拷贝就比如值类型。

浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，

可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。

深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，

叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

 Lambda表达式详解

http://www.cnblogs.com/aaa6818162/p/4677140.html

           //传入参数类型
            Action<string> action = s =>
            {
                Console.WriteLine(s);
            };

            //传入参数类型 返回参数类型
            Func<int,int> gwl = p =>
            {
                return p + ;
            };       

 c#扩展方法

 async and await 简单的入门

http://www.cnblogs.com/LoveJenny/archive/2011/11/01/2230933.html

http://blog.csdn.net/tianmuxia/article/details/17675681

http://www.cnblogs.com/jesse2013/p/async-and-await.html

线程的创建是比较占用资源的一件事情，.NET 为我们提供了线程池来帮助我们创建和管理线程。Task是默认会直接使用线程池，但是Thread不会。如果我们不使用Task，又想用线程池的话，可以使用ThreadPool类。

await并不是针对于async的方法，而是针对async方法所返回给我们的Task，这也是为什么所有的async方法都必须返回给我们Task。所以我们同样可以在Task前面也加上await关键字，这样做实际上是告诉编译器我需要等这个Task的返回值或者等这个Task执行完毕之后才能继续往下走。

 迭代器

http://www.cnblogs.com/yangecnu/archive/2012/03/17/2402432.html

foreach编译来调用GetEnumerator和MoveNext方法以及Current属性

http://dotnet.9sssd.com/csbase/art/794

考虑这样一种情况。假设数组是靠链表实现的（实际上是线性表，但是我们这里假设）。
当你使用arr[i]访问数组的一个元素的时候，它必须从数组的开头开始找起。
我们假设访问一个节点需要1毫秒。
那么我们写
for (i = 1; i < 5; i++)
{
    arr[i]
}
需要1+2+3+4+5=15毫秒。
但是如果我们使用迭代器，在内部始终保持着最后一个访问的节点，那么我们遍历同样的数组，只要1+1+1+1+1=5毫秒。

http://bbs.csdn.net/topics/390525082

for和foreach

http://m.blog.csdn.net/blog/sansan52048/9159941

 在foreach循环中，迭代集合collectionObject的过程如下：
 （）调用collectionObject.GetEnumerator(),返回一个IEnumerator引用。这个方法可以通过IEnumerable接口的实现代码来获得。但这是可选的。
 （）调用返回的IEnumerator接口的MoveNext()方法。
 （）如果MoveNext()方法返回true,就使用IEnumerator接口的Current属性获取对象的一个引用，用于foreach循环。
 （）重复前面两步，直到MoveNext()方法返回false为止，此时循环停止。

 替代foreach实现：
 foreach (XXX a in b){
 ...
 } 

 等同于

 XXX a;
 IEnumerator ie = (IEnumable)b.GetEnumerator();
 while (ie.MoveNext) {
 a = (XXX)ie.Current;
 ...
 }

foreach是取只读的，在取的时候数据队列不能变（包括修改，删除，添加等）。要避免这个问题，就应该使用for循环。

             IList<Person> iList = new List<Person>();

            iList.Add( new Person("david",));
            iList.Add(new Person("bob", ));
            iList.Add(new Person("justin",));

        // 用linq重新排序 

            var textList = (from c in iList
                orderby c.age
                    select c);

            int iPerson =;
            foreach (Person p in textList)
            {
                // 这时候在immediate Window里面输入iList.RemoveAt(2)，程序会抛出异常
                Console.WriteLine(p.name + ":" + p.age);
                iList[iPerson] = p; // 排序后修改原来的队列！！！
                iPerson++;
            }
            for (int ii = ; ii < iList.Count; ii++)
            {
                // 这时候在immediate Window里面输入iList.RemoveAt(2)，程序不会抛出异常
                Console.WriteLine(iList[ii].name);
            }

 状态机

 http://www.cnblogs.com/TianFang/archive/2007/12/27/1017665.html

 线程静态字段 System.ThreadStaticAttribute

http://www.cnblogs.com/SkylineSoft/articles/1726232.html

ThreadStaticAttribute 的作用是告诉CLR，它标记的静态字段的存取是依赖当前线程，而独立于其他线程的。

例如：

class MyClass{
    [ThreadStatic] static public string threadvalue;
}

MyClass 中的threadvalue就是一个线程静态字段 。 如果一个程序中同时有多个线程同时访问这个字段，则每个线程访问的都是独立的threadvalue 。例如线程1设置它为”hello”,然后线程2设置它为”world”，最后线程1读取它的时候，得到的是”hello”。

基于这个，线程静态字段有以下特征：

• 它是静态的字段。所以不需要MyClass的实例，直接用 MyClass.threadvalue的形式来访问就可以了。
• 它的存取是根据线程来指定内存位置的，所以它的存取速度较慢。
• 访问线程静态字段不可能发生线程不同步问题。因为虽然语意上不同线程访问的是同一字段，但实际上不同线程访问的是不同的内存块。
• 一条线程不可能访问到另外一条线程上的线程静态字段。就算你得到另外一条线程的System.Threading.Thread 对象的引用也不行。

但是，使用线程静态字段要注意：

• 字段上的初始化语句在类的静态构造方法中执行。所以语句只执行一句。其他线程再访问这个字段时，为字段的类型的默认值。
• 如果不同线程上的字段都引用同一对象，那么不代表该对象是线程同步的。因为[ThreadStatic]指的是字段是隔离的。但是它引用的对象则不被[ThreadStatic]控制。

如果你知道 System.Runtime.Remoting.Messaging.Context (以下简称MContext)
那么MContext和线程静态字段有什么不同呢？

• 他们可以说都是与当前线程相关的。但是他们不是同一个东西。
• MContext是基于名称的，可以根据名称储存不同的数据。而ThreadStatic不会有名称冲突。
• ThreadStatic 是CLR内部实现的。而 MContext 是附属在 System.Threading.Thread 对象的一个字典。
• 线程静态字段的存取速度比MContext的快
• MContext被叫做逻辑线程上下文数据。它的数据会在异步调用的时候复制到另外一条线程中。而线程静态字段是不会被复制的。(例如 eventHandlerInst.BeginInvoke(...)时，在新的线程中，就拥有原线程上MContext的数据。在eventHandlerInst.EndInvoke执行时，新线程上的MContext上的数据就会还原到调用EndInvoke的线程上.这个在以后讲到Remoting时会详细说)
• System.Web.HttpContext.Current 是用 MContext 实现的。

http://www.cnblogs.com/lori/archive/2013/04/17/3026061.html

 List<T>传值

 [__DynamicallyInvokable]
    public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
    {
      if (source == null)
        throw Error.ArgumentNull("source");
      return new List<TSource>(source);
    }

  /// <summary>
    /// 初始化 <see cref="T:System.Collections.Generic.List`1"/> 类的新实例，该实例包含从指定集合复制的元素并且具有足够的容量来容纳所复制的元素。
    /// </summary>
    /// <param name="collection">一个集合，其元素被复制到新列表中。</param><exception cref="T:System.ArgumentNullException"><paramref name="collection"/> 为 null。</exception>
    [__DynamicallyInvokable]
    public List(IEnumerable<T> collection)
    {
      if (collection == null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
      ICollection<T> collection1 = collection as ICollection<T>;
      if (collection1 != null)
      {
        int count = collection1.Count;
        if (count == )
        {
          this._items = List<T>._emptyArray;
        }
        else
        {
          this._items = new T[count];
          collection1.CopyTo(this._items, );
          this._size = count;
        }
      }
      else
      {
        this._size = ;
        this._items = List<T>._emptyArray;
        foreach (T obj in collection)
          this.Add(obj);
      }
    }

   [TestMethod]
        public void TestMethod2()
        {
            IList<PostData> list = new List<PostData>();
            list.Add(new PostData() { id = "", startId = "" });
           list.Add(new PostData() { id = "", startId = "" });
            file(list);
            Assert.IsTrue(list.Count==);//
        }

        public void file(IList<PostData> list)
        {
            list = list.Where(p => p.id == "").ToList();
        }

 终结器

 http://blog.csdn.net/fxqcn/article/details/6717426

托管代码和非托管代码

http://www.cnblogs.com/muzhiye/archive/2012/02/23/2365556.html

net托管代码是运行在.NET FRAMEWORK上的，类似于JAVA虚拟机

托管代码：属安全代码，因为不涉及指针，但相对性能上较低，C#写出来的东西就可以认为是托管代码

非托管代码：非安全的，可以使用指针，性能较高，C++那是写出来的东西就可以认为是非托管代码，还有比如MFC等等

一般地，项目开发用托管代码即可。

简单来说：
托管代码就是把有关内存管理的操作全都由CLR来管理，也就是把底层的一些操作全都封装起来了（安全性上就相对高点，因为不能直接进行内存读取，不会出现内存溢出之类的问题，但相对的，性能会有损失，使用起来也会不够灵活）；
非托管代码，可以直接进行硬件操作，性能比较好；
比较直观的例子就是：C#使用垃圾回收，而C++需要手动释放
-------------------------------------------
CLI的定义：Common Language Infrastructure公共语言基础结构
C#生成的不是处理器能直接解释的指令，而是一种中间语言指令，即CIL：Common Intermediate Language，第二个编译步骤通常在执行时发生，在这个过程中，CIL被转换成处理器能理解的机内码，但要想执行，仅仅转换为机内码还是不行的，C#程序还需要在一个代理的上下文中执行，负责管理C#程序执行的这个代理就是虚拟执行系统Virtual Execution System,VES，又称为“运行时”，运行时负责加载和运行程序，并在程序执行时提供额外的服务（比如安全、垃圾回收等）。
也就是说“运行时”：runtime它不是指一个时间，而是特指“虚拟执行系统”这个代理，负责管理C#程序的执行

 C#编译器  JIT编译器

从C#的源代码到机器代码，中间要经过两个编译器。一个就是把C#源代码编译成托管模块的C#编译器。另一个就是作为CLR一个组件的JIT编译器。每经过一次编译，程序的语言就更低级一步。

C#编译器生成的是IL语言和元数据

C#编译器是用来生成包含IL和元数据的模块的，一旦编译完成，东西基本就是定下来了的。而JIT编译器会根据元数据和情况来做一些改变。比如泛型中的类型参数的填入和生成相应的机器代码，都是JIT编译器做的，而不是C#编译器。C#编译器的工作就是生成相应的IL和元数据告诉JIT这是一个泛型类型，有类型实参。编译好的程序集，放在那里不动，程序集里的IL和元数据当然不会发生变化。而同一个程序集，在不同CLR版本中的行为和性能就有可能不同，也是一样的道理。

http://www.cnblogs.com/lwzz/archive/2011/06/08/2075757.html

http://www.cnblogs.com/lwzz/archive/2011/06/11/2078576.html

 CLR VIA

 http://www.cnblogs.com/janes/category/308324.html

.Net 托管模块与程序集的关系

 http://blog.csdn.net/kmguo/article/details/17055065

.NET概念：.NET程序编译和运行

http://blog.csdn.net/yysyangyangyangshan/article/details/7306346

 浅谈.NET中泛型的基本原理

http://www.cnblogs.com/DebugLZQ/archive/2012/09/03/2669383.html

 NET PDB文件到底是什么？

http://www.cnblogs.com/imjustice/archive/2013/06/07/note_about_dot_net_pdb_file.html

这个文件会在我们调试的时候被使用到，这个东西可以理解为调试的时候应用程序和源文件之间的一个桥梁。正是归功于这个文件，我们才能在debug的时候看到程序当前执行相对应的代码和监视到一些变量

主要远程调试可以用

 汇编

 类型参数

尖括号中的T是不确定的数据类型，叫做类型参数，一般规定以字母T开头，可以是TKey, TValue都可以。而调用时指定的具体类型叫做类型实参。

 开放类型与封闭类型

开放类型：具有泛型参数的类型是开放类型，如List<T>，CLR不允许构造开放类型的实例；

封闭类型：在实际调用代码时，如果所有类型实参都已经指定了实际数据类型，如List<string>，则该类型为封闭类型。CLR允许构造封闭类型的实例。

正确实现 IDisposable 接口

http://www.cnblogs.com/xlshcn/archive/2007/01/16/idisposable.html

在.NET的对象中实际上有两个用于释放资源的函数：Dispose和Finalize。Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的。

Dispose和Finalize。Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的。

 C# 托管资源和非托管资源

那么对于非托管的资源，这里再重申一下，就是Stream，数据库的连接，GDI+的相关对象，还有Com对象等等这些资源

最常见的一类非托管资源就是包装操作系统资源的对象，例如文件，窗口或网络连接，对于这类资源虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它不了解具体如何清理这些资源。还好.net Framework提供了Finalize()方法，它允许在垃圾回收器回收该类资源时，适当的清理非托管资源。如果在MSDN Library 中搜索Finalize将会发现很多类似的主题，这里列举几种常见的非托管资源：ApplicationContext,Brush,Component,ComponentDesigner,Container,

Context,Cursor,FileStream,Font,Icon,Image,Matrix,Object,OdbcDataReader,OleDBDataReader,Pen,Regex,Socket,StreamWriter,Timer,Tooltip 等等资源。

http://blog.csdn.net/liangjin1126/article/details/2660946