using System;

 namespace ILLearn

 {

     class Program

     {

         const int WEIGHT = ;

         static void Main(string[] args)

         {

             var height = ;

             People people = new Developer("*");

             var vocation = people.GetVocation();

             var healthStatus = People.IsHealthyWeight(height, WEIGHT) ? "healthy" : "not healthy";

             Console.WriteLine($"{vocation} is {healthStatus}");

             Console.ReadLine();

         }

     }

     abstract class People

     {

         public string Name { get; set; }

         public abstract string GetVocation();

         public static bool IsHealthyWeight(int height, int weight)

         {

             var healthyWeight = (height - ) * 0.7;

             return weight <= healthyWeight * 1.1 && weight >= healthyWeight * 0.9; //标准体重是 (身高-80) *  0.7，区间在10%内都是正常范围

         }

     }

     class Developer : People

     {

         public Developer(string name)

         {

             Name = name;

         }

         public override string GetVocation()

         {

             return "Developer";

         }

     }

 }

 .method public hidebysig specialname rtspecialname

         instance void  .ctor(string name) cil managed

 {

   // 代码大小       14 (0xe)

   .maxstack

   IL_0000:  ldarg.  //加载第1个参数，因为是实例，而实例的第1个参数始终是this

   IL_0001:  call       instance void ILLearn.People::.ctor()  //调用基类People的构造函数，而People也会调用Object的构造函数

   IL_0006:  ldarg.  //加载this

   IL_0007:  ldarg.  //加载第二个参数也就是name

   IL_0008:  call       instance void ILLearn.People::set_Name(string)  //调用this的 set_Name， set_Name这个函数是编译时为属性生成的

   IL_000d:  ret  //return

 } // end of method Developer::.ctor

 .method public hidebysig virtual instance string //虚函数

         GetVocation() cil managed

 {

   // 代码大小       6 (0x6)

   .maxstack    //最大计算栈，默认是8

   IL_0000:  ldstr      "Developer"  //加载string "Developer"

   IL_0005:  ret //return

 } // end of method Developer::GetVocation

 .method public hidebysig static bool  IsHealthyWeight(int32 height,  //静态函数

                                                       int32 weight) cil managed

 {

   // 代码大小       52 (0x34)

   .maxstack    //最大计算栈大小

   .locals init ([] float64 healthyWeight) //局部变量

   IL_0000:  ldarg.  //加载第1个参数，因为是静态函数，所以第1个参数就是height

   IL_0001:  ldc.i4.s     //ldc 加载数值， 加载80

   IL_0003:  sub  //做减法，也就是 height-80，把结果放到计算栈上，前面两个已经移除了

   IL_0004:  conv.r8  //转换成double，因为下面计算用到了double，所以要先转换

   IL_0005:  ldc.r8     0.69999999999999996  //加载double数值 0.7， 为什么是0.69999999999999996呢, 二进制存不了0.7，只能找个最相近的数

   IL_000e:  mul  //计算栈上的两个相乘，也就是(height - 80) * 0.7

   IL_000f:  stloc.  //存到索引为0的局部变量(healthyWeight)

   IL_0010:  ldarg.  //加载第1个参数 weight

   IL_0011:  conv.r8  //转换成double

   IL_0012:  ldloc.  //加载索引为0的局部变量(healthyWeight)

   IL_0013:  ldc.r8     1.1000000000000001  //加载double数值 1.1， 看IL_0010到IL_0013，加载了3次，这个函数最多也是加载3次，所以maxstack为3

   IL_001c:  mul  //计算栈上的两个相乘，也就是 healthyWeight * 1.1, 这时计算栈上还有两个，第一个是weight，第二个就是这个计算结果

   IL_001d:  bgt.un.s   IL_0032  //比较这两个值，第一个大于第二个就跳转到 IL_0032，因为第一个大于第二个表示第一个条件weight <= healthyWeight * 1.1就是false，也操作符是&&，后面没必要再算，直接return 0

   IL_001f:  ldarg.  //加载第1个参数 weight

   IL_0020:  conv.r8  //转换成double

   IL_0021:  ldloc.  //加载索引为0的局部变量(healthyWeight)

   IL_0022:  ldc.r8     0.90000000000000002  //加载double数值 0.9

   IL_002b:  mul  //计算栈上的两个相乘，也就是 healthyWeight * 0.9, 这时计算栈上还有两个，第一个是weight，第二个就是这个计算结果

   IL_002c:  clt.un  //比较大小，第一个小于第二个则把1放上去，否则放0上去

   IL_002e:  ldc.i4. //加载数值0

   IL_002f:  ceq  //比较大小，相等则把1放上去，否则放0上去

   IL_0031:  ret  //return 栈顶的数，为什么没用blt.un.s，因为IL_0033返回的是false

   IL_0032:  ldc.i4.  //加载数值0

   IL_0033:  ret  //return 栈顶的数

 } // end of method People::IsHealthyWeight

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

 {

   .entrypoint  //这是入口

   // 代码大小       67 (0x43)

   .maxstack    //大小为3的计算栈

   .locals init (string V_0,

            string V_1)  //两个string类型的局部变量，本来还有个people的局部变量，被release方式优化掉了，因为只是调用了people的GetVocation，后面没用，所以可以不存

   IL_0000:  ldc.i4     0xaa  //加载int型170

   IL_0005:  ldstr      "*"  //加载string "*"

   IL_000a:  newobj     instance void ILLearn.Developer::.ctor(string)  //new一个Developer并把栈上的*给构造函数

   IL_000f:  callvirt   instance string ILLearn.People::GetVocation()  //调用GetVocation

   IL_0014:  stloc.  //把上面计算的结果存到第1个局部变量中，也就是V_0

   IL_0015:  ldc.i4.s     //加载int型60

   IL_0017:  call       bool ILLearn.People::IsHealthyWeight(int32,  //调用IsHealthyWeight，因为是静态函数，所以用call

                                                             int32)

   IL_001c:  brtrue.s   IL_0025  //如果上面返回true的话就跳转到IL_0025

   IL_001e:  ldstr      "not healthy"  //加载string "not healthy"

   IL_0023:  br.s       IL_002a  //跳转到IL_002a

   IL_0025:  ldstr      "healthy"  //加载string "healthy"

   IL_002a:  stloc.  //把结果存到第2个局部变量中，也就是V_1, IL_0017到IL_002a这几个指令加在一起用来计算三元表达式

   IL_002b:  ldstr      "{0} is {1}"  //加载string "{0} is {1}"

   IL_0030:  ldloc.  //加载第1个局部变量

   IL_0031:  ldloc.  //加载第2个局部变量

   IL_0032:  call       string [mscorlib]System.String::Format(string,  //调用string.Format，这里也可以看到C# 6.0的语法糖 $"{vocation} is {healthStatus}"，编译后的结果和以前的用法一样

                                                               object,

                                                               object)

   IL_0037:  call       void [mscorlib]System.Console::WriteLine(string)  //调用WriteLine

   IL_003c:  call       string [mscorlib]System.Console::ReadLine()  //调用ReadLine

   IL_0041:  pop

   IL_0042:  ret

 } // end of method Program::Main