月度归档： 2019年11月

引用https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-iv/

本文中我们将研究垃圾收集（GC）以及保持应用程序有效运行的一些方法

标记

让我们从GC的角度来看这件事。如果我们负责“清除垃圾”，我们需要好好设计一个方案。首先，我们需要确定什么是垃圾，什么不是垃圾。
为了确定需要保留的内容，我们首先假设所有未使用的都是垃圾。想象一下，我们与两个好朋友住在一起， Joseph Ivan Thomas（JIT）和 Cindy Lorraine Richmond （CLR）。Joe和Cindy会跟踪他们在使用什么，并向我们提供他们需要保留的物品清单。我们将初始列表称为“root”列表，因为我们将其当成作用起点。我们将保留一个主列表，以图形化我们要保留的房间中所有物体的位置。使列表中的内容在正常工作时所需要的内容都添加到图表中。这也就是GC确定保留哪些内容的方式。它接受一个“Root”对象引用列表，以使其免受即时（JIT）编译器和公共语言运行时（CLR）的影响，然后递归搜索对象引用以构建应包含哪些内容的图形需要保留。
root包括：

• 全局/静态指针。通过在静态变量中保留对对象的引用来确保它不会被垃圾回收。
• 堆栈上的指针。我们不会想要去抛弃掉我们应用程序的线程仍然需要执行的东西。
• CPU寄存器指针。CPU中内存地址指向的托管堆中的所有内容都应该要保留下来。
  
  从上图我们可以看到，从roots直接引用了我们托管堆中的object1和object5，而我们的object1引用了我们的object3，所以在递归搜索中，我们roots也引用到了object3，现在我们知道所使用到的物体后，下一步进行压缩。

  压缩

  现在我们已经标识了需要保留的物体对象，我们现在只需要移动下需要保留的对象，即可压缩空间。
  
  在我们的内存中，我们还不需要放置一个对象之前，我们就先清理空间，由于不需要object2，因此作为GC，我们将object3往下移动，固定在object1的附近，把object2给清理掉。
  
  接下来我们按照和上面一样的方式，把object5给复制下来。
  
  现在我们已经清理了所有的内容了，我们只需要写一个便签并将其放置在压缩堆的顶部即可让Claire知道新的对象放在哪里。
  
  了解GC的本质可以帮助您理解，移动对象是非常消耗的。所以我们可以减少所要移动的内容的大小，那么我们将改善下GC流程，因为复制的内容将减少。

  处理托管堆之外的东西

  作为负责垃圾收集的人，我们在打扫房间的时候遇见一个问题是如何清理掉汽车中的物体。清洁时，我们需要清洁的所有东西，如果笔记本电脑在家而电池在车里该怎么办呢？
  在某些情况下，GC需要执行代码以清理非托管资源，例如文件，数据库连接，网络连接等等。一种解决方法是通过终结器

  class Sample{
  ~Sample(){
      //
  }
  }

  在对象创建期间，所有带有终结器的对象都将添加到终结队列中，假设object1,4,5都具有终结器的话，并且位于终结队列中。让我们看看当应用程序不再引用object2和4并且做垃圾回收时候会发生什么。
  
  object2以通常方法处理掉，但是，当我们处理到object4的时候，GC看到它在终结队列中，然后就先不回收掉object4的所拥有的内存，而是移动object4并把它的终结器添加到名为freachable的特殊队列中。
  
  有一个专用线程用于执行freachable队列中的对象。一档终结器由对象4上的该线程执行了，它将从freachable队列中删除。然后只有这样，object4才能准备好被GC；
  
  然后，object4会在下一个GC循环中被回收掉。
  因此在我们的类中添加终结器会为GC增加工作量，这个消耗是非常昂贵的，并且会对垃圾回收的性能和程序产生不利的影响，仅在绝对确定需要终结器的时候才使用它们。
  更好的做法是确保清理非托管资源。可以想象，最好是显式关闭链接并且使用IDisposable接口进行清理，而不是尽可能的用终结器。

  IDisposable

  实现IDisposable的类再Dispose（）方法（接口的唯一签名）中执行清除。因此如果我们有一个ResourceUser类而使用using来追踪finalizer，代码如下：

  public class ResourceUser{
  ~ResourceUser(){
      //
  }
  }

  我们可以用IDisposable作为实现相同功能的更好方法：

  public class ResourceUser:IDisposable{
  public void Dispose(){
      //
  }
  }

  IDisposable与using关键字集成在一起。在using块的末尾，对using（）中声明的对象调用Dispose（）。在using块之后不应引用该对象，因为该对象的本质上应被视为“已消失”并已准备好由GC清除。

  public static void DoSomething(){
  ResourceUser rec = new ResourceUser();
  using(rec){
      //
  }
  }

  还有一种写法是把对象放在using块中，这样从表面上看它更有意义，因为rec不在using块的范围以外可用。这种模式更符合IDisposible接口的意图

  public static void DoSomething(){
  using(ResourceUser rec = new ResourceUser()){
      //
  }
  }

  通过using（）和实现IDisposible的类一起使用，我们可以执行清理操作，而不会通过强制终结对象来增加GC的额外开销。

  静态变量：当心

  class Counter{
  private static int s_Number = 0;
  public static int GetNextNumber(){
      int newNumber = s_Number;
      s_Number = newNumber + 1;
      return newNumber;
  }
  }

  如果两个线程同时调用GetNextNumber(),并且在s_Number之前都为newNumber分配了相同的值。
  则他们将返回相同的结果。word是确保一次仅一个线程可以访问代码块的一种方法。最佳的做法是：您应锁定尽可能少的代码，因为线程必须在队列中等待才能执行lock（）块中的代码，并且效率低下。

  class Counter{
  private static int s_Number = 0;
  public static int GetNextNumber(){
      lock(typeof(Counter)){
          int newNumber = s_Number;
          newNumber += 1;
          s_Number = newNumber;
          return newNumber;
      }
  }
  }

  静态变量当心的第二种情况

  接下来，我们必须注意静态变量引用的对象。请记住，如何清理“roots”引用的任何内容。请看下面的例子：

  class Olympics{
  public static Collection<Runner> TryoutRunners;
  }
  class Runner{
  private string _fileName;
  private FileStream _fStream;
  public void GetStats(){
      FileInfo fInfo = new FileInfo(_fileName);
      _fStream = _fileName.OpenRead();
  }
  }

  因为Runner集合对于Olympics类是静态的，所以不仅将不释放集合中的对象让它们做垃圾回收（它们全部都是通过roots间接引用），并且您可能已经注意到，每次我们运行GetStats()时，Fileinfo都将打开文件。因为它没有关闭，也没有被GC释放，所以这段代码实际上的运行将是一场等待着发生的灾难。想象一下，我们有1000000个Runner在Olympics中。我们最终将会有许多不可收集的对象，每个对象都有一个开放的资源。

  单例模式

  保持现状不变的技巧是始终在内存中有一个使用程序类的实例。一种简单的方法就是使用GOF单例模式。应该谨慎的使用单例，因为它们确实是“全局变量”，并且在多线程应用程序中有很多让我们感到头疼和“奇怪”的行为，在这种情况下，不同的线程可能会改变对象的状态。如果我们使用单例模式（或任何全局变量），则我们应该能够证明其合理性。

  public class Earth{
  private static Earth _instance = new Earth();
  private Earth(){}
  public static Earth GetInstance(){return _instance;}
  }

  我们有一个私有的构造函数，因此只有Earth可以执行它的构造函数并制作一个Earth。我们有一个Earth的静态实例和一个获取实例的静态方法。该特定实现是线程安全的，因为CLR确保线程安全地创建静态变量。这是一种优雅的实现单例模式的方法。

  结论

  我们可以做以下的一些事情来提高GC性能：

  1. 清理。不要保留资源，确保关闭所有打开的链接，并尽快清理所有非托管对象。作为使用非托管对象的一般规则，请尽可能的延迟实例化并尽快清理。
  2. 不要过度引用。使用引用对象时候需要合理。请记住，我们的对象如果还活着，那它所引用的所有对象都不会被收集。当我们完成了类所引用的操作后，可以通过将引用设置为null来删除它。还有一个技巧是肩为使用的引用设置为自定义轻量级的NullObject，以避免获取空引用异常。启动GC时候引用到的文件越少，标记过程中的压力就越少。
  3. 使用finalizer很轻松，但是在GC时候代价却非常的大。我们只能在合理的情况下使用它们。如果我们使用IDisposible而不是finalizer，则效率是非常高的。因为可以通过一次GC就回收掉对象而不需要来两次GC。
  4. 把object和其子类放在一起。在GC上将大块内存复制到一起比较容易，而不是每次通过堆时都必须对堆进行碎片整理，因此我们声明一个由许多其他对象组成的对象时候，应该将他们尽可能的放在一起实例化。

引用链接：https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-iii/

前言

在使用.NET框架的时候，我们可以不必主动担心内存管理和垃圾回收（GC），但是仍然要牢记内存管理和垃圾回收的机制，以优化应用程序的性能。另外，对内存管理的工作原理有一个基本的了解将有助于我们理解所编写程序中使用变量的行为。在这个文章中，我们将讨论堆中具有引用变量以及如何使用ICloneable修复引用变量引起的问题。

副本不是副本

为了清楚定义这个问题，我们来检查一下当堆上有一个值类型而不是堆上有一个引用类型的时候，会发生什么。首先，我们来定义一个值类型，采取一下的类和结构。我们有一个Dude类，其中包含Name元素和两个Shoe结构。我们有一个CopyDude（）方法，可以轻松的制作一个新的Dudes。

public struct Shoe{
public string Color;
}
public class Dude{
public string Name;
public Shoe RightShoe;
public Shoe LeftShoe;
public Dude CopyDude(){
Dude newPerson = new Dude();
newPerson.Name = Name;
newPerson.LeftShoe = LeftShoe;
newPerson.RightShoe = RightShoe;
return newPerson;
}
public override string ToString(){
return (Name + ": Dude!,I have a"+RightShoe.Color+" shoe on my right foot , and a" + LeftShoe.Color+"on my left foot");
}
}

我们的Dude类是一个引用类型，因此shoe结构是该类的成员元素，所以它们都最终出现在堆上。

当我们执行以下方法时候：

public static void Main(){
Dude bill = new Dude();
bill.Name = "Bill";
bill.LeftShoe = new Shoe();
bill.RightShoe = new Shoe();
bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";
Dude Ted = Bill.CopyDude();
Ted.Name = "Ted";
Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";
Console.WriteLine(Bill.ToString());
Console.WriteLine(Ted.ToString());
}

输出为：
Bill：Dude！I have a Blue shoe on my right foot, and a blue on my left foot.
Ted：Dude！I have a Red shoe on my right foot, and a Red on my left foot.

如果将Shoe设置为引用类型会怎样呢？

public class Shoe{
    public string Color;
}

并且在Main（）中运行完全相同的代码，看看我们的输入如何变化。
Bill：Dude！I have a Red shoe on my right foot, and a Red on my left foot.
Ted：Dude！I have a Red shoe on my right foot, and a Red on my left foot.
这显然是一个错误，但是你知道为什么会出现这样的错误吗？这就是我们最终在堆中得到的结果

因为我们使用的Shoe作为引用类型而不是值类型，并且在复制引用类型的内容时仅仅复制了指针（而不是实际对象），所以我们必须做一些额外的工作来制作Shoe引用类型的行为像值类型。
刚好我们有一个可以帮我们实现这个方案的接口：ICloneable。这个接口基本是是所有Dudes都会用到的方法，并且定义了如何复制引用类型，以避免我们的“鞋子共享”错误。我们所有需要“clone”的引用类型都应该使用ICloneable接口，包括Shoe类。
ICloneable包含一种方法：Clone（）

public object Clone(){
    //
}

这是我们在Shoe类中实现它的方式：

public class Shoe:ICloneable{
    public string Color;
    public object Clone(){
        Shoe newShoe = new Shoe();
        newShoe.Color = Color.Clone() as string;
        return newShoe;
    }
}

在clone（）方法内部，我们仅制作了一个新的Shoe，克隆所有引用类型并复制所有值类型，然后返回新对象。string类已经实现了ICloneable，因此我们可以调用Color.Clone()方法，由于Clone（）返回对象的引用，因此在设置鞋子颜色之前，我们必须“重新赋值”引用。
接下来我们的CooyDude（）方法中，我们需要克隆鞋子而不是复制它们：

public Dude CopyDude(){
    Dude newPerson = new Dude();
    newPerson.Name = Name;
    newPerson.LeftShoe = LeftShoe.Clone() as Shoe;
    newPerson.RightShoe = RightShoe.Clone() as Shoe;
    return newPerson;
}

现在，当我们运行Main时。

public static void Main(){
    Dude Bill = new Dude();
    Bill.Name = "Bill";
    Bill.LeftShoe = new Shoe();
    Bill.RightShoe = new Shoe();
    Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";
    Dude Ted = Bill.CopyDude();
    Ted.Name = "Ted";
    Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";
    Console.WriteLine(Bill.ToString());
    Console.WriteLine(Ted.ToString());
}

打印出来：
Bill : Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot
Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot
这才是我们需要输出的内容。

总结

因此，作为常规方法，我们总是希望克隆引用类型并复制值类型。因此，本着减少额外影响的原则，我们来更进一步的清理Dude类以实现ICloneable。使用CopyDude（）方法。

public class Dude:ICloneable{
    public string Name;
    public Shoe RightShoe;
    public Shoe LeftShoe;
    public override string ToString(){
        return(Name + ":Dude! I have a"+RightShoe.Color+" shoe on my right foot ,and a"+LeftShoe.Color+" on my left foot.");}
        public object Clone(){
            Dude newPerson = new Dude();
            newPerson.Name = Name.Clone() as string;
            newPerson.LeftShoe = LeftShoe.Clone() as Shoe;
            newPerson.RightShoe = RightShoe.Clone() as Shoe;
            return newPerson;
        }
}

然后我们在将Main（）中的方法改成Dude.Clone()

public static void Main(){
    Dude Bill = new Dude();
    Bill.Name = "Bill";
    Bill.LeftShoe = new Shoe();
    Bill.RightShoe = new Shoe();
    Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";
    Dude Ted = Bill.Clone() as Dude;
    Ted.Name = "Ted";
    Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";
    Console.WriteLine(Bill.ToString());
    Console.WriteLine(Ted.ToString());
}

输出如下：
Bill : Dude!, I have a Blue shoe on my right foot, and a Blue on my left foot.
Ted : Dude!, I have a Red shoe on my right foot, and a Red on my left foot.
输出的值如我们所预期的。
实际上，System.String类的赋值运算符（“=”符号）实际上就是克隆String,因此不必担心重复引用的问题，因此你必须主要到我们内存的膨胀。实际上由于字符串是引用类型，所以它实际上在图中应该指向堆中的另一个对象的指针，但是为了方便理解，我们把它显示成值类型

结论

通常我们计划复制对象，则应该实现（并使用）ICloneable这个接口，这使我们的引用类型可以在某种程度上模仿值类型的复制行为。由于值类型和引用类型分配内存的方式有所不同，因此跟踪我们要处理的变量类型非常重要。

引用 https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-ii/

前言

使用.NET框架，我们不必主动考虑内存管理和垃圾回收（GC），但仍必须牢记内存管理和垃圾回收，以优化应用程序的性能。另外，对内存管理的工作原理有一个基本的了解将有助于解释我们在编写的每个程序中使用的变量的行为。在本文中，我将介绍将参数传递给方法时需要注意的一些行为。

参数，重点

这是代码执行过程中发生的情况的详细视图。在第一部分中，我们介绍了进行方法调用时发生的情况。现在让我们更详细的介绍一下。。。
当我们进行方法调用时，会发生以下的情况：

1. 给堆栈上我们所执行的方法所需要的信息分配空间（称为堆栈框架）。这包括调用地址（指针），该地址基本上是GOTO指令，因此当线程完成运行我们的方法时，它知道要返回到哪里才能继续执行。
2. 我们的方法参数被复制。这是我们需要更仔细研究的地方。
3. 控制权传递给JIT'ted方法，线程开始执行代码，因此，我们有另外一种犯法，由“调用堆栈”上的堆栈帧表示。

public int AddFive(int pValue){
    int result;
    result = pValue + 5;
    return result;
}

使用的堆栈如下图所示

注意：这个方法不存在与堆栈中，在这里只作为参考来说明堆栈框架的开始。
和第一部分讨论的那样，根据参数的类型是引用类型还是值类型，对堆栈上的参数的处理方式将有所不同。值类型将被整体复制，引用类型将被复制引用。

传递值类型

这是传递值类型
首先，当我们传递值类型时，将分配空间，并将类型中的值复制到堆栈上的新空间。
示例代码：

class Class1
{
    public void Go(){
        int x = 5;
        AddFive(x);
        Console.WriteLine(x.ToString());
    }
    public int AddFive(int pValue){
        pValue += 5;
        return pValue;
    }
}

执行该方法时，将“x”的空间放置在堆栈上，其值为5。

接下来，将AddFive（）放置在堆栈上，并为其参数留出空间，并从x逐位复制值。

当AddFive（）完成执行后，线程将被传递回Go（），并且由于AddFive（）已经完成，因此pValue本质上是已经被抛弃了的数据：

因此，我们的代码输出的值为“5”，其中的关键点是：传递给方法的任何值类型参数都是复本，我们依靠原始变量的值来拷贝。
要记住的一件事：如果我们传递一个非常大的值类型（列如一个非常大的结构）并将其传递给堆栈，则每次复制它的空间和处理周期都会非常消耗。堆栈没有无限的空间，就像往一个杯子里一直倒水，最后它就可能会溢出。struct是一个可以变得非常大的值类型，我们必须了解我们如何处理它。
这是一个很大的结构：

public struct MyStruct{
    long a,b,c,d,e,f,g,h,i,j,k,l,m;
}

看一下我们执行Go（）并转到下面的DoSomething()方法时会发生什么：

public void Go(){
    MyStruct x = new MyStruct();
    DoSomething(x);
}
public void DoSomeThing(MyStruct pValue){
    //
}

这就能看到低效的地方了。想想一下，如果我们通过MyStruct数千次，你就可以知道它是怎么拖累你程序的效率了。
那我们改怎么改善上述问题呢？可以通过传递对原始值类型的引用，如下所示：

public void Go(){
    MyStruct x = new MyStruct();
    DoSomething(ref x);
}
public struct MyStruct{
    long a,b,c,d,e,f,g,h,i,j,k,l,m;
}
public void DoSomething(ref MyStruct pValue){
    //
}

这样，我们最终可以在内存中更加有效的分配对象。

通过引用传递值类型时，我们唯一需要注意的是，我们对值类型的值的访问。
pValue中的任何更改都将x中的值进行了修改。使用下面的示例代码

public void Go(){
    MyStruct x = new MyStruct();
    x.a = 5;
    DoSomething(ref x);
    Console.WriteLine(x.a.ToString());
}
public void DoSomething(ref MyStruct pValue){
    pValue.a = 12345;
}

上述代码的打印值为“12345”，因为pValue.a实际上使用的是原始数据x变量里的内存空间。

传递引用类型

作为引用类型的传递参数类似于在上一个示例中通过引用传递值类型。
如果我们需要使用值类型

public class MyInt{
    public int MyValue;
}

并且调用Go（）方法，因为MyInt是引用类型，所以它会出现在堆上。

如果按照以下代码来执行Go（）

public void Go(){
    MyInt x = new MyInt();
    x.MyValue = 2;
    DoSomething(x);
    Console.WriteLine(x.MyValue.ToString());
}
public void DoSomething(MyInt pValue){
    pValue.MyValue = 12345;
}

这个时候发生了以下的事情。

1. 从对Go（）的调用开始，变量x进入堆栈。
2. 从对DoSomething()的调用开始，参数pValue进入堆栈。
3. x的值（堆栈上MyInt的地址）被复制到pValue

因此，当我们使用pValue更改堆中MyInt对象的MyValue属性并稍后使用x引用堆上对象时，我们得到的值是“12345”。
所以有一个有趣的地方，当我们通过引用传递引用类型的时候会发生什么呢？
看看这个。如果我们有Thing类，Animal和Vegetable继承自它

public class Thing{

}
public class Animal:Thing{
    public int Weight;
}
public class Vegetable:Thing{
    public int Length;
}

然后再执行下面Go（）方法：

public void Go(){
    Thing x = new Animal();
    Switcharoo(ref x);
    Console.WriteLine("x is Animal : "+(x is Animal).ToString());
    Console.WriteLine("x is Vegetable : "+(x is Vegetable).ToString());
}
public void Switcharoo(ref Thing pValue){
    pValue = new Vegetable();
}

我们的x就变成的Vegetable。
如果不加ref那x还是Animal
让我们看看发生了什么；

1. 从Go（）方法调用开始，x指针进入堆栈
2. Animal对象在堆上
3. 对Switcharoo方法调用开始，pValue进入堆栈并指向x

4. Vegetable在堆上
5. x的值通过pValue更改为Vegetable的地址。

如果不通过ref传递Thing，则保留对Animal引用的并从代码获得相反的结果。

引用

https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net-part-i/

前言

这段时间在巩固c#基础的时候，发现有些基础性的东西在以前是没有仔细去想过的，比如值类型，和引用类型的区分，究竟值类型保存在哪里，引用类型保存在哪里，两个究竟是啥区别。在说到这个问题的时候，我们需要巩固一下堆和堆栈的信息。这个知识点在前面讲GC的时候有带过一点，但是没有详细去了解过，所以现在开始做一次总结。

Stack 和 Heap 有什么区别

堆栈（stack）一般来负责跟踪代码中正在执行的内容（即所谓的“调用”）。而堆（Heap）一般来说负责跟踪我们的对象。
可以将堆栈想想成一系列盒子堆叠在一起。每次调用方法的时候，都是从顶部叠放一个盒子，从而跟踪应用程序中发生的事情。我们只能使用堆栈顶部盒子里面的内容。当我们完成顶部盒子里的后，我们就把这个盒子给丢掉并继续使用推上来的顶部盒子里的内容。堆是类似的，它的主要用途是保存信息，以便可以随时随地的访问堆中的任何内容。和堆栈相比堆没有任何访问限制
堆栈是自我维护的，这就意味着我们可以不用去管理它的内存情况，顶部的数据不再使用就丢弃掉。堆就必须去考虑垃圾回收的情况（GC）。
。
以上图片并不是内存中真实的表现形式，但是能够帮助我们区分堆栈和堆。

堆栈和堆上发生了什么

我们将在执行代码时将四种主要类型的东西放入堆栈和堆中：值类型，引用类型，指针和指令。

值类型

在c#中，使用以下类型声明列表表明的所有“事物”均为值类型（因为它们来自System.ValueType）：

• bool
• byte
• char
• decimal
• double
• enum
• float
• int
• long
• sbyte
• short
• stuct
• uint
• ulong
• ushort
  

  引用类型

  所有被声明为以下类型的事物都被称为引用类型：

• class
• interface
• delegate
• object
• string
  

  指针

  放在内存管理方案“事件”的第三种类型是对类型的引用。引用通常被称为指针。在c#中尽量不要明确使用指针，他们是由公共语言运行时（CLR）管理的。指针（或引用）与引用类型的不同之处在于，当我们说某个对象是引用类型时，意味着我们能够通过指针访问它。指针是内存中的一大块空间，指向内存中的另一个空间。指针占用的空间与我们放入堆栈和堆中的其他任何东西一样。其值可以是内存地址或null。
  
  指针是可以在堆栈中也可以在堆中的。

  如何决定是放在哪里的

  这是我们的两个黄金法则：

  1. 引用类型总放在堆上。
  2. 值类型和指针总是放在声明它们的地方。
     正如我们前面提到的，堆栈（stack）负责跟踪代码执行过程中每个线程的位置。您可以将其视为线程“状态”，并且每个线程都有自己的堆栈。当我们的代码调用执行一个方法时，线程开始执行经过JIT编译并存放在于方法表中的指令，它还将方法的参数放在线程堆栈中。然后当我们遍历代码并在方法中遇到变量时，将它们放置在堆栈的顶部。

     public int AddFive(int pValue){
     int result;
     result = pValue + 5;
     return result;
     }

     这是堆栈顶部的情况。在查看的内容已经位于堆栈的的其他项目之上了。
     一旦执行executin ghte方法，该方法的参数将被放置在堆栈上。
     注意
     该方法不存在与堆栈中，仅作参考说明
     
     首先入栈的是方法体，然后入栈我们方法的参数。
     将控制（执行该方法的线程）传递给位于我们类型方法表中的AddFive（）方法的指令，如果这是我们第一次点击该方法，将执行JIT编译
     
     该方法执行时，我们使用一些内存来存储“结果”变量，并将其分配在堆栈上。
     
     该方法完成执行并返回我们的结果。
     
     通过将指针移到AddFive()开始的可用内存地址来清理堆栈上分配的所有内存，然后我们转到堆栈上的上一个方法。
     
     在此实例中，我们的“结果”变量被放置在堆栈上。事实上，每次在方法主体中声明值类型时，它将被放置在堆栈中。
     现在，值类型有时也放置在堆上。在规则中：值类型总是去声明它们的地方。所以，如果在方法外部但是在引用类型内部声明了值类型，那么将其放置在堆的引用类型内。
     现在来看另一个例子：
     如果我们定义以下的MyInt类：

     public class MyInt{
     public int MyValue;
     }

     并且正在执行以下方法：

     public MyInt AddFive（int pValue）{
     MyInt result = new MyInt();
     result.MyValue = pValue + 5;
     return result;
     }

     与之前一样，线程开始执行该方法，并且其参数被放置在该线程的堆栈中。
     
     现在开始变得有趣了。
     由于MyInt是引用类型，因此将其放置在堆上，并且由堆栈上的指针引用。
     
     在AddFive()完成执行之后,我们正在清理
     
     我们在堆中只剩下一个孤零零的MyInt(堆栈中不再有任何人指向MyInt)
     
     这个时候就是垃圾回收集（GC）发挥作用的地方。一单程序达到一定内存阈值并且需要更多的堆空间时候，便会启动GC。GC将停止所有正在运行的线程（FULL STOP），在堆中找到主程序未访问的所有对象并将其删除。然后，GC将压缩堆中剩余的所有对象以腾出空间，并调整指针指向堆栈和堆中的这些对象。可以想象，这在性能方面可能是非常昂贵的。因此现在您可以了解为什么在尝试编写高性能代码时，注意堆栈和堆中内容是很重要。
     那这是怎么影响我的呢？
     当使用引用类型时，我们要处理类型的指针，而不是该类型本身。当我们使用值类型时，我们使用的是值类型本身。这是不是十分明确呢？
     那我们看下实例代码
     如果我们执行以下方法：

     public int ReturnValue(){
     int x = new int();
     x = 3;
     int y = new int();
     y = x;
     y = 4;
     return x;
     }

     这上面返回的值是3，这个很简单对吧。
     但是我们如果使用的是MyInt类：

     public class MyInt{
     public int MyValue;
     }

     并且我们正在执行以下方法：

     public int ReturnValue2(){
     MyInt x = new MyInt();
     x.MyValue = 3;
     MyInt y = new MyInt();
     y = x;
     y.MyValue = 4;
     return x.MyValue;
     }

     现在我们得到的返回值是几呢：是4。
     可能有人想不通为啥这个值是4
     我们先来先第一个例子中的内存图
     
     后面我们看下第二个例子的内存图，因为x，y都是指向堆中的同一个对象，所以我们就没办法获得3
     
     希望以上内容能使您更好的了解c#中“值类型”和“引用类型”变量之间的基本区别，以及对什么是指针以及何时使用它的基本理解。

委托

委托是一种引用类型，标识对具有特定参数列表和返回类型的方法的引用。在实例化委托时，可以将其实例与任何具有兼容签名和返回类型的方法相关联。通过委托实例调用方法。
委托用于将方法作为参数传递给其它方法。可将任何可访问类或结构中与委托类型匹配的任何方法分配给委托。该方法可以是静态方法，也可以是实例方法。
将方法作为参数进行引用的能力使委托成为定义回调方法的理想选择。
委托有以下属性：

• 委托类似于c++的函数指针，但委托完全面向对象，不像c++指针会记住函数，委托会同时封装对象实例和方法。
• 委托允许将方法作为参数进行传递。
• 委托可用于定义回调方法。
• 委托可以链接在一起
• 方法不必与委托类型完全匹配
• 可使用匿名方法或lambda表达式内联代码块
• 可以使用？.Invoke()来调用委托方法
  匿名函数和函数实例的问题
  在研究逆变和协变的时候发现一段官方代码

  public delegate R SampleGenericDelegate<A, R>(A a);
  public static Second AFristRSecond(First first)
  {
  return new Second();
  }
  SampleGenericDelegate<Second, First> fse = AFirstRSecond;

  这段代码里，返回值是定义委托的子类，参数是定义委托的父类，所以这个逆变，又是协变，但是我用匿名函数写的时候却没办法成功
  SampleGenericDelegate<Second, First> fse3 = delegate (First a)
  {
  return new Second();
  };
  没有搞明白这个原因，只能归结于是匿名函数和函数实例的不一致。

  .NET包含的委托类型

• Func<> 通常用于现有转换的请款，也就是说需要将委托参数转换为其他结果时。必须且只有一个返回值的时候用这个，返回值有协变，如果传入参数的话是带有逆变。
• Action<> 用于需要使用委托参数执行操作的情况。简而言之，无返回值的用这个，如果有传入参数的定义，这个是有逆变out关键词的。
• Predicate<> 用于需要确定参数是否满足委托条件的情况，必须且只有一个bool值的返回值，必须且只有一个传入参数，传入参数带有逆变。
  

  委托中的变体

  
  public class First { }
  public class Second : First { }
  public delegate First SampleDelegate(Second a);
  public delegate Second SampleDelegateSecond(Second a);
  public First ASecondRFirst(Second first)
  { return new First(); }
  public Second AsecondRsecond(Second second)
  {return new Second();}
  public First AFirstRFirst(First first)
  {return new First();}
  public Second AFirstRSecond(First first)
  {return new Second();}

- 协变
定义：将返回派生程度较大的派生类型的方法分配给委托（就是把子类返回出来）
在上述代码中体现为：SampleDelegate sa = AsecondRsecond 这个就表现为协变
- 逆变
定义：方法所接受参数的派生类型所具有的派生程度小于委托类型指定的程度（就是传参传父类）
在上述代码中表现为：SampleDelegate sa = AFirstRFirst 这个就表现为逆变

SampleDelegate sa = AFirstRSecond 这个应该是既满足协变，又满足逆变。
- 泛型委托
public delegate R SampleGenericDelegate(A a);
SampleGenericDelegatedGeneric = ASecondRFirst
上述代码为正常的泛型委托
dGeneric = AFirstRSecond;
上述即是协变也是逆变的隐式转换。
- 泛型类型参数中的变体
泛型委托之间的隐式转换，要求类型继承自对方，才可以将泛型委托分配给对方。
泛型类型参数的变体仅支持引用类型
合并委托的时候要求类型完全相同，所以变体委托不应该合并。
泛型委托的协变需要使用关键词out，协变类型只能用作方法返回类型，不能用作方法参数类型；逆变使用关键词in，逆变类型只能用作方法参数类型，不能用作方法返回类型。
可以在同一个委托中支持变体和协变，单这只适用于不同类型的参数。
在做协变和逆变的时候，写不写关键词，协变是可以支持函数实例和匿名函数的委托，逆变可以支持函数实例的的委托，匿名函数的委托就不能支持；这块的文档官方只说了可能会发现可以使用，所以就当一种奇巧淫技使用了。
当不是用关键字来进行逆变和协变的时候，就不能将一个委托分配给另外一个委托了。
```csharp
public delegate R SampleGenericDelegate<out R>();
SampleGenericDelegate1<String> dobject = () => "";
SampleGenericDelegate1<Object> dobject1 = dobject;
//错误
public delegate R SampleGenericDelegate<R>();
SampleGenericDelegate1<String> dobject = () => "";
SampleGenericDelegate1<Object> dobject1 = dobject;</code></pre>
<p>上述代码就体现了这个问题。</p>
<ul>
<li>合并委托（多播委托）
可以通过使用+运算符将多个对象分配到一个委托实例上。多播委托包含已分配委托列表。此多播委托被调用时会依次调用列表中的委托。仅可合并类型相同的委托。对象必须是已经初始化过。当使用匿名函数合并委托的时候，取消是很麻烦的。
<pre><code class="language-csharp">delegate void CustomDel(string s);
void Hello(string s){Console.WriteLine("Hello" + s);}
//错误1
CustomDel c += Hello;
//错误2
CustomDel c = Hello;
CustomDel d;
c += d;</code></pre>
<p>这两个委托都是没有初始化的。所以在合并的时候就不对。</p>
<pre><code class="language-csharp">CustomDel c = Hello;
c += (string s)=> { Console.WriteLine("niming" + s); };
c -= Hello;
c("aaaaa");</code></pre>
<p>上述代码你如果想在多播委托中删除掉匿名函数的委托，你只能再定义一个委托实例，把匿名函数赋值给给委托实例，然后再添加到多播委托上。</p>
<h3>闭包</h3>
<p>委托还能增加一种闭包的概念，这个概念在前面有分析过。</p>
<h2>匿名函数</h2>
<p>在说委托的时候，已经用到了匿名函数，现在具体说下匿名函数的内容
匿名函数是一个“内联”语句或表达式，可在需要委托类型的任何地方使用。可以使用匿名函数来初始化命名委托，或传递命名委托作为方法参数。
可以使用lambda表达式或匿名方法来创建匿名函数。某些类型的lambda表达式可以转换为表达式树类型</p>
<h3>匿名方法</h3>
<p>delegate 运算符创建一个可以转换为委托类型的匿名方法。</p>
<h3>lambda表达式</h3>
<p>只是使用委托的更方便的语法，将声明签名和方法正文，但是在分配到委托之前没有自己的正式标识。</p></li>
<li>表达式lambda，表达式为其主体：
<pre><code class="language-csharp">（input-parameters）=>expression</code></pre>
<p>使用=>从其主体分离lambda参数列表。在左侧指定输入参数，在另一侧输入表达式或语句块。
lambda广泛用于表达式树的构造。
只有当lambda只有一个输入参数的时候，小括号才是可选的；否则括号是必须的。
输入参数类型必须全部为显式或者全部为隐式；否者会编译出错。
表达式lambda的主体可以包含方法调用。不过若要创建在.NET公共语言运行时的上下文之外计算的表达式树，不得在lambda表达式中使用方法调用。在.NET公共语言运行时上下文之外，方法将没有任何意义。</p></li>
<li>语句lambda，语句块作为其主体：
<pre><code class="language-csharp">(inpput-parameters) => {<sequence-of-statements>}</code></pre>
<p>语句lambda与表达式lambda表达式类似，只是语句括在大括号中。
语句lambda的主体可以包含任意数量的语句；但是实际上通常不会多于两个或者三个。
语句 lambda 也不能用于创建表达式目录树。</p>
<h3>异步lambda</h3>
<p>使用关键词async和await。</p>
<h3>lambda 表达式和元组</h3>
<p>c# 7.0起，c#语言提供了对元组的内置支持。可以提供一个元组作为Lambda表达式的参数，同时Lambda表达式也可以返回元组。可通过用括号括住用逗号分隔的组件列表来定义元组。</p>
<pre><code class="language-csharp">Func<Tuple<int, int, int>, Tuple<int, int, int> > doubleThem = ns => (new Tuple<int, int, int> (2 * ns.Item1, 2 * ns.Item2, 2 * ns.Item3));
var numbers = new Tuple<int, int, int>(2, 3, 4);
var doublednumbers = doubleThem(numbers);</code></pre>
<p>元组类型关键词是Tuple，通常是item1，item2这样的字段命名。但是也可以使用命名组件定义元组。</p>
<pre><code class="language-csharp">Func<(int n1, int n2, int n3), (int, int, int)> doublethem = ns => (2 * ns.n1, 2 * ns.n2, 3 * ns.n3);
var numbers = (2, 3, 4);
var doubledNumbers = doublethem(numbers);</code></pre>
<p>上述是使用命名组件定义元组的示例代码。</p>
<h3>捕获lambda表达式中的外部变量和变量范围</h3>
<p>lambda可以引用外部变量。这些变量在定义lambda表达式的方法中或包含lambda表达式的类型中的范围内变量。以这种方式捕获的变量将进行存储以备在lambda表达式中使用，即使在其他情况下，这些变量将超出范围并进行垃圾回收。必须明确地分配外部变量，然后才能将lambda表达式中使用该变量。</p></li>
<li>捕获的变量将不会被作为垃圾回收，直至引用变量的委托符合垃圾回收的条件。</li>
<li>在封闭方法中看不到lambda表达式内引入的变量。</li>
<li>lambda表达式无法从封闭方法中直接捕获in，ref或out参数。</li>
<li>lambda表达式中的return语句不会导致封闭方法返回。</li>
<li>如果相应跳转语句的目标位于lambda表达式块之外，lambda表达式不得包含goto，break或continue语句。同样，如果目标在块内部，在lambda表达式块外部使用跳转语句也是错误的。
<h2>事件</h2>
<p>要定义一个事件，可以在事件类的签名中使用event关键字，并制定事件的委托类型。
还能显式创建包含添加或删除处理程序的属性，创建方法和属性的语法类似，只是替换关键词为add,remove。</p>
<h3>使用委托添加事件</h3>
<pre><code class="language-csharp">
delegate void CustomDel(string s);
event CustomDel cusevnet;
void funcust(string s){</code></pre></li>
</ul>
<p>}
cusevnet += funcust;</p>
<pre><code>### .NET支持事件的委托
```csharp
private EventHandler<T> directoryChanged;
event EventHandler<T> DirectoryChanged
{
    add{ directoryChanged += value;}
    remove{directoryChanged -= value;}
}

EventHandler

是一个预定义的委托，当不生成数据的时候用EventHandler,但是当有数据产生的时候用泛型EventHandler&lt TEventArgs &gtTEventArgs是继承EventArgs的类型。

事件委托的签名

void OnEventRaised(object sender,EventArgs args)

上述代码为.NET事件委托的标准签名。返回类型为void，参数列表包含两个参数：发件人和事件参数。sender的编译类型为system.object，第二个参数通常派生自system.EventArgs的类型，即使事件类型不需要任何参数，你仍要提供者两个参数。应使用特殊值EventArgs.Empty来表示事件不包含任何附加信息。在.NET Core版本中对TEventArgs的定义不再要求必须派生自System.EventArgs的类。

两种事件对比

EventHandler事件是不带返回值的，传入参数只能为固定的两个，而委托事件是可以自定义参数和返回值的。