class Sometype
   {

   }
class Sometype//这两种定义是相等的。
   {
public Sometype()
           : base()
       { 

       }
   }

 class Sometype
   {
public Sometype(int x)
       { 

       }
void DoSome()
       { }
   }
class Some : Sometype
   {
public Some()//编译出错
       { 

       }

　　　　public Some():base(5)//通过
　　　　{

　　　　}

   }

  sealed class Sometype
   {
private Int32 x = 5;//sometype的构造器把5储存在字段x，接着调用基类的构造函数。C#编译器提供了一个简化的语法。允许以内联的方式初始化实例字段。但在幕后

//它会将这工语法转换成构造器中的代码来执行初始化。
   }

  sealed class Some
   {
private Int32 x = 5;
private string s = "there";
private Int32 i;
public Some()
       { 

       }//编译器在为这3个构造器方法生成代码时，在每个方法开始的位置，都会包含用于初始化x，s，i的代码。在这些
//代码初始化之后，编译器会插入对基类构造函数的调用，然后在插入自己的构造器代码。
//在这里，即使没有显式的初始化i，也会保证i会被初始化为0.
       public Some(int x1) { x = 10; }
public Some(string s1) { s = s1; }
   }

  sealed class Some
   {
private Int32 x ;
private string s ;
private Int32 i;
//该构造器将所有的字段都设为默认值。
//其他的所有构造器都显示调用这个构造器
       public Some()
       {
           x = 30;
           s = "there";
           i = 300;
       }
//该构造器将所有的字段都设为默认值，然后修改x的默认值
       public Some(int x1)
           : this()
       {
           x = x1;
       }
//同上。。。
       public Some(string s1)
           : this()
       {
           s = s1;
       }

   }

  struct Point
  {
private int x, y;
public Point(int x1, int y1)//如果显式声明了构造函数，就必须要为值类型的所有字段赋值。这是因为为了生成“可验证”的代码，在访问值类型的任何一个字段之前，要对所有的字段进行赋值。
      {
          x = x1;
          y = y1;
      }
public Point()//结构体不能包含显式的无参构造函数，这里会编译出错！
      {//实际上，即使值类型提供哦你了无参构造器，许多编译器都不会去生成代码自动调用它，为了执行值类型的无参构造器，开发人员必须显式调用值类型的构造器。
          x = 20; y = 30;
      }//C#编译器故意不允许值类型定义无参构造器，就是为了避免开发人员对这种构造器在什么时候调用产生迷茫，由于不能定义无参构造器，所以编译器永远不会生成自动调用它的代码。
  }
sealed class Rectangle
  {
private Point p1, p2;//值类型的实例构造器只有在显式调用的时候才会执行，

public Rectangle()
      {
          p1 = new Point(100, 20);//如果没有用new操作符来调用Point的构造器，那么Point的字段x，y都将为0；这里p1的x=100，y=200.p2的都为0
      }
  }

struct Point
  {
public int x, y, z, q, n, m;
public Some some;
public Point(int x1, int y1)//允许为值类型定义有参的构造器
      {
//字段会将所有的字段初始化为0/null
          this = new Point();
          x = x1;//用x1的值覆盖x的0；
          y = y1;//用y1的值覆盖y的0；
      }
  }
class Program 
    {
public  const  Program p=null;
static void Main()
        {
            Point p = new Point(200, 100);
           Some som= p.some;//这里som为null
           int x= p.x;//200
            int y= p.y;//100
           int z= p.z;//0
         

            Console.ReadKey();          
        }
    }

  sealed class Some
  {
static Some()//可以看出，类型构造器类似于实例构造器，区别在于必须将它们标记为static。
//类型构造器没有访问你修饰符，总是私有的，但是如果显式的将类型标记为private 编译器会显示：静态构造函数不允许出现访问修饰符。
//之所以私有，是为了阻止任何用开发人员写的代码调用它，对类型构造器的调用总是由CLR负责的。
      { 

      }
  }

  sealed class Rectangle
  {
private static int i = 200;  
  }

  sealed class Rectangle
  {
private static int i;
static Rectangle()
      {
          i = 200;
      }
  }

  struct Point
  {
static Point()
      {

          Console.WriteLine("这句话永远都不会显示");//因为CLR不会调用值类型的静态构造器。
      }
  }

 class Program 
    {
static void Main()
        {

            PerfTest1(1000000000);
            PerfTest2(1000000000);

            Console.ReadKey();          
        }
//这个方法被jit编译时，BeforeFieldInit和Precise类的类型构造器还没被执行，所以对这些构造器的调用将嵌入这个方法的代码中，使它的运行变得较慢。
        private static void PerfTest1(int iterations)
        {
            Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
            {
//jit编译器优化调用BeforeFileldInit的类型构造器的代码，使它在循环之前执行。
                BeforefieldInit.s_x = 1;
            }
            Console.WriteLine("PerfTest1:{0} BeforeFileldInit", sw.Elapsed);
            sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
            {
//jit编译器在这里生成调用Precise类的类型构造器的代码，所以在每次循环迭代，都要核实一遍是否需要调用构造器。
                Precise.s_x = 1;
            }
            Console.WriteLine("PerfTest1:{0} Precise", sw.Elapsed);
        }
//这个方法被jit编译时，BeforeFieldInit和Precise类的类型构造器已经被执行，所以这个方法的代码中，不会在生成对这些构造器的调用，它运行的更快。

private static void PerfTest2(int iterations)
        {
            Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
            {
                BeforefieldInit.s_x = 1;
            }
            Console.WriteLine("PerfTest2:{0} BeforeFileldInit", sw.Elapsed);
            sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
            {
                Precise.s_x = 1;
            }
            Console.WriteLine("PerfTest2:{0} Precise", sw.Elapsed);
        }
    }
//由于这个类没有显示定义类型的构造器，所以在C#
//元数据中用BeforeFieldInit（字段初始化前）来标记定义
   internal sealed class BeforefieldInit
   {
public static int s_x = 123;
   }
//由于类中显式定义了类型的构造器，所以没有用BeforefieldInit来标记定义
   internal sealed class Precise
   {
public static int s_x;
static Precise()
       {
           s_x = 123;
       }
   }