VB.NET是怎样做到的

vb.net能够实现非常多c#不能做到的功能，如when语句、optional参数、局部static变量、对象实例访问静态方法、handles绑定事件、on error处理异常、object直接后期绑定等等。vb和c#同属.net的语言，编译出来的是同样的cil，但为什么vb支持非常多有趣的特性呢。我们一起来探究一下。

• （一）局部静态变量

  vb支持用static关键字声明局部变量，这样在过程结束的时候能保持变量的数值：

  public sub test1()

      static i as integer

      i += 1 实现一个过程调用计数器

  end sub

  我们实现了一个简单的过程计数器。每调用一次test，计数器的数值就增加1。其实更有非常多情况我们希望保持变量的数值。而c#的static是不能用在过程内部的。因此要实现过程计数器，我们必须声明一个类级别的变量。这样做明显不如vb好。因为无法防止其他过程修改计数器变量。这就和对象封装一个道理，本来应该是个方法的局部变量，目前我要被迫把他独立出来，显然是不好的设计。那么vb是怎么生成局部静态变量的呢？将上述代码返汇编，我们能清晰地看到在vb生成的cil中，i不是作为局部变量，而是作为类的field出现的：

  .field private specialname int32 $static$test1$2001$i

  也就是说，i被改名作为一个类的字段，但被冠以specialname。在代码中试图访问$static$test1$2001$i是不可能的，因为他不是个有效的标识符。不过在il中，将这个变量加一的代码却和一般的类字段完全相同，是通过ldfld加载的。我觉得这个方法十分聪明，把静态变量变成生命周期相同的类字段，不过又由编译器来控制访问的权限，让他成为一个局部变量。同时也解释了vb为什么要用两个不同的关键字来声明静态变量??static和shared。

  由于局部静态变量的实质是类的字段，所以他和真正的局部变量还是有所不同的。比如在多线程条件下，对局部静态变量的访问就和访问字段相同。

  （二）myclass关键字

  vb.net支持一项非常有意思的功能??myclass。大部分人使用myclass可能仅限于调用本类其他构造函数时。其实myclass能产生一些非常独特的用法。myclass永远按类的成员为不可重写的状态进行调用，即当类的方法被重写后，用myclass仍能得到自身的版本。下面这个例子和vb帮助中所举的例子非常相似

  public class myclassbase
      protected overridable sub greeting()
          console.writeline("hello form base")
      end sub

      public sub useme()
          me.greeting()
      end sub

      public sub usemyclass()
          myclass.greeting()
      end sub
  end class

  public class myclasssub
      inherits myclassbase

      protected overrides sub greeting()
          console.writeline("hello form sub")
      end sub
  end class

  我们用一段代码来测试：

  dim o as myclassbase = new myclasssub()

  o.useme()
  o.usemyclass()

  结果是useme执行了子类的版本，而usemyclass还是执行了基类本身的版本，尽管这是个虚拟方法。观其il，能看到其简单的实现原理：

  me用的调用指令是callvirt

  il_0001: callvirt   instance void app1.myclassbase::greeting()

  而myclass调用的是call

  il_0001:  call       instance void app1.myclassbase::greeting()

  奇怪的是，如此简单的一个功能，我竟然无法用c#实现，c#怎样也不允许我按非虚函数的方式调用一个虚函数。c++能用类名::方法名的方式访问自身版本的函数，但c#的类名只能用来访问静态的成员。这真是c#一个奇怪的限制。

  （三）handles和withevents

  vb除了能用c#那样的方法来处理事件响应以外，更有从vb5继承下来的独特的事件处理方式??withevents。

  我喜欢称这种事件处理方式为静态的事件处理，书写响应事件的方法时就已决定该方法响应的是哪一个事件，而c#则是在代码中绑定事件的。比如下面这个最简单的例子：

  public class handlerclass
      public withevents myobj as eventclass

  
      private sub myobj_myevent(byval sender as object, byval e as system.eventargs) handles myobj.myevent
          msgbox("hello")
      end sub

      public sub new()
          myobj = new eventclass
      end sub
  end class

  代码中用到的eventclass是这样的：

  public class eventclass
      public event myevent as eventhandler

      protected overridable sub onmyevent(byval e as eventargs)
          raiseevent myevent(me, e)
      end sub

      public sub test()
          onmyevent(new eventargs)
      end sub
  end class

  我们来复习一下，这段代码隐式地给eventclass编写了两个方法??add_myevent(eventhandler)和remove_myevent(eventhandler)，实际上所有使用事件的上下文都是通过调用这两个方法来绑定事件和解除绑定的。c#还允许你书写自己的事件绑定/解除绑定的代码。

  那么withevents是怎么工作的呢？vb.net的编译器在编译时自动将

  public withevents myobj as eventclass

  翻译成下面这个过程：

      private _myobj as eventclass

      public property myobj() as eventclass
          get
              return _myobj
          end get
          set(byval value as eventclass)

              if not (me._myobj is nothing) then
                  removehandler _myobj.myevent, addressof myobj_myevent
              end if

              me._myobj = value

              if me._myobj is nothing then exit property

              addhandler _myobj.myevent, addressof myobj_myevent

          end set
      end property

  由此可见，当对withevents变量赋值的时候，会自动触发这个属性以绑定事件。我们所用的大部分事件响应都是1对1的，即一个过程响应一个事件，所以这种withevents静态方法是非常有用的，他能显著增强代码可读性，同时也让vb.net中的事件处理非常方便，不像c#那样离开了窗体设计器就必须手工绑定事件。

  不过在分析这段il的时候，我也发现了vb.net在翻译时小小的问题，就是ldarg.0出现得过多，这是频繁使用me或this的表现，所以我们在编码过程中一定要注意，除了使用到me/this本身引用以外，使用他的成员时不要带上me/this，比如me.myint = 1就改成myint = 1，这样的小习惯会为你带来非常大的性能收益。

  （四）类型转换运算符

  在visual basic 2005中将加入一个新的运算符??trycast，相当于c#的as运算符。我一直希望vb有这样一个运算符。vb目前的类型转换运算符主要有ctype和directcast。他们的用法几乎相同。我周详比较了一下这两个运算符，得出以下结论：

  1、在转换成引用类型时，两者没有什么差别，都是直接调用castclass指令，除非重载了类型转换运算符ctype。directcast运算符是不能重载的。

  2、转换成值类型时，ctype会调用vb指定的类型转换函数（如果有的话），比如将string转换为int32时，就会自动调用visualbasic.compilerservices.integertype.fromstring，而将object转换为int32则会调用fromobject。其他数值类型转换为int32时，ctype也会调用类型本身的转换方法实施转换。directcast运算符则非常简单，直接将对象拆箱成所需类型。

  所以在用于值类型时，ctype没有directcast快速但能支持更多的转换。在c#中，类型转换则为（type)运算符和as运算符。(type)运算符的工作方式和vb的directcast非常相似，也是直接拆箱或castclass的，不过如果遇见支持的类型转换（如long到int），(type)运算符也会调用相应的转换方法，但不支持从string到int的转换。c#另一个运算符as则更加智能，他只要判断对象的运行实例能否转成目标类型，然后就能省略castclass指令，直接按已知类型进行操作，而且编译器还能自动对as进行优化，比如节省一个对象引用等。所以在将object转换成所需的类型时，as是最佳选择。

  由于as有非常多好处，visual basic 2005将这一特性吸收了过来，用trycast运算符就能获得和as相同的效果，而且语法和directcast或ctype相同。

  （五）实现接口

  vb.net采用的实现接口的语法是vb5发明的implements，这个实现接口的语法在当今主流语言中独一无二。比如我有两个接口：

  interface interface1
      sub test()
  end interface

  interface interface2
      sub test()
  end interface

  这两个接口有一个完全相同的成员test。假设我需要用一个类同时实现两个接口会怎么样呢？先想想看，如果是java，jscrip.net这样的语言就只能用一个test函数实现两个接口的test成员。如果两个test只是偶然重名，其内容必须要分别实现怎么办，于是一些解决接口重名的设计出现了……。在vb中，独特的implements语句能让你想怎么实现接口就怎么实现，比如下面的类implementation用两个名字根本不相同的方法实现了两个接口。

  public class implementation
      implements interface1, interface2

      public sub hello() implements interface1.test

      end sub

      private sub hi() implements interface2.test

      end sub
  end class

  也就是说，vb允许用任意名字的函数实现接口中的成员，而且访问器能是任意的，比如想用public还是private都能。

  c#在处理重名成员上提供了显式实现（explicit implementation）的语法，其实现上述两个接口的语法为

   public class class1 : interface1, interface2
   {
        public class1()
        {
        }
        void interface1.test()
        {
        }

        void interface2.test()
        {
        }

   }

  注意这里，c#只能用接口名.成员名的名字来命名实现方法，而且访问器只能是private，不能公开显式实现的方法。

  在考察了il以后，我发现.net支持隐式实现和显式实现两种方式。其中隐式实现只要在类里面放一个和接口成员方法名字相同的方法即可??这一种vb不支持。而显式实现则在方法的描述信息里加入：

  .override testapp.interface1::test

  无论是c#的显式实现还是vb的implements语句都是这样的原理。也就是说.net提供了换名实现接口成员的功能，不过只有vb将这个自由让给了用户，而其他语言还是采用了经典的语法。

  （六）默认属性和属性参数

  在原先的vb6里，有一项奇特的功能??默认属性。在vb6中，对象的名称能直接表示该对象的默认属性。比如textbox的默认属性是text，所以下面的代码

  text1.text = "hello"

  就能简化为

  text1 = "hello"

  这种简化给vb带来了非常多麻烦，赋值运算就需要两个关键字??let和set，结果属性过程也需要let和set两种。而且这种特征在后期绑定的时候仍能工作。到了vb.net，这项功能被大大限制了，目前只有带参数的属性才能作为默认属性。如

  list1.item(0) = "hello"

  能简化为

  list1(0) = "hello"

  这种语法让有默认属性的对象看起来像是个数组。那么vb怎么判断一个属性是否是默认属性呢？看下列代码

  public class proptest
      public property p1(byval index as integer) as string
          get
  
          end get
          set(byval value as string)
  
          end set
      end property
  
      default public property p2(byval index as integer) as string
          get
  
          end get
          set(byval value as string)
  
          end set
      end property
  end class

  p1和p2两个属性基本上完全相同，唯一的不同是p2带有一个default修饰符。反汇编这个类以后，能发现两个属性完全相同，没有所有差异。不过proptest类却被增加了一个自定义元属性system.reflection.defaultmemberattribute。这个元属性指定的成员是invokemember所使用默认类型，也就是说后期绑定也能使用默认属性。可是我试验将defaultmember元属性手工添加到类型上却不能达到让某属性成为默认属性的功能。看来这项功能又是vb的一项“语法甜头”。不过，vb或c#的编译器对别人生成的类的默认属性应该只能通过defaultmemberattribute来判断，所以我将一个vb类只用defaultmemberattribute指定一个默认方法，不使用default，然后将他编译以后给c#用，果然，c#将他识别为一个索引器（indexer）！

  既然说到了c#的索引器，我们就顺便来研究一下vb和c#属性方面的不同。刚才的实验结果是vb的默认属性在c#中就是索引器。不过vb仍然能用属性的语法来访问默认属性，而c#只能用数组的语法访问索引器。更特别的是，vb能创建不是默认属性，不过带有参数的属性，如上面例子里的p1，而c#则不支持带参数的属性，如果将vb编写的，含有带参数属性的类给c#用，c#会提示“属性不受该语言支持，请用get_xxx和set_xxx的语法访问”。也就是说，带参数的属性是clr的一项功能，但不符合cls（通用语言规范），因此就会出现跨语言的障碍。这也更加深了我们对cls的认识??如果你希望让你的代码跨语言工作，请一定要注意符合cls。

  （七）可选参数和按名传递

  vb从4.0开始支持“可选参数”这一特性。就是说，函数或子程式的参数有些是可选的，调用的时候能不输入。其实vb从1.0开始就有一些函数带有可选参数，只不过到了4.0才让用户自己研发这样的过程。在vb4里，可选参数能不带默认值，而在vb.net里，如果使用可选参数，则必须带有默认值。如

  public sub testoptional(optional i as integer = 1)

  end sub

  调用的时候，既能写成testoptional(2)，也能写成testoptional()，这种情况参数i自动等于1。如果过程有不止一个可选参数，则vb还提供一种简化操作的方法??按名传递参数。比如过程

  public sub testoptional(optional i as int32 = 1, optional j as int32 = 1, optional k as int32 = 1)

  end sub

  如果只想指定k，让i和j使用默认值，就能使用按名传递，如下

  testoptional(k := 2)

  而且这种方式不受参数表顺序的限制

  testoptional(k := 2, i := 3, j := 5)

  这些的确是相当方便的功能，c#就不支持上述两个特性。我们看看他是怎样在il级别实现的。上述第一个方法在il中的定义为

  .method public instance void testoptional([opt] int32 i) cil managed
  {
  .param [1] = int32(0x00000001)
  .maxstack 8

  可见，参数被加上了[opt]修饰符，而且.param指定了参数的默认值。这是只有vb能识别的内容，c#会跳过他们。在调用的时候，vb若发现参数被省略，则自动读取.param部分的默认值，并显式传递给过程。这一部分完全由编译器处理，而且没有所有性能损失，和手工传递所有参数是完全相同的。至于按名传递，vb会自动调整参数的顺序，其结果和传统方式的传递也没有所有的不同。这说明我们能放心地使用这项便利。而且带有可选参数的过程拿到c#中，顶多变成不可选参数，也不会造成什么其他的麻烦。

  ps.非常多com组件都使用了默认参数，而且有些过程的参数列表非常长，在vb里能轻松地处理他们，而在c#中经常让研发者传参数传到吐血。

  （八）on error语句和when语句

  本次讨论的是异常处理语句。vb.net推荐使用try...end try块来进行结构化的异常处理，不过为了确保兼容性，他也从以前版本的basic中借鉴了on error语句。其实on error并不能算是vb的好处，因为使用他会破坏程式的结构，让带有异常处理的程式难以看懂和调试。不过我一直非常惊叹于vb的工程师是怎样实现他的，因为on error能让异常的跳转变得非常灵活，不像try那样受到限制。首先看看try是怎样实现的：

  public function f1() as integer
      try
          dim n as integer = 2 ＼ n
      catch ex as exception
          msgbox(ex.message)
      end try
  end function

  这是最简单的异常处理程式，通过reflector反汇编（如果用ildasm，不要选择“展开try-catch”），能发现整个过程被翻译成19条指令。留意这一句：

  .try l_0000 to l_0006 catch exception l_0006 to l_0022

  这就是典型的try块，在catch处直接指定要捕捉的异常，然后指定catch区的位置，非常清晰。还要留意这两句：

  l_0007: call projectdata.setprojecterror

  l_001b: call projectdata.clearprojecterror

  能看出，这两句是在catch块的开头和末尾。深入这两个过程我发现他是在为err对象记录异常。看来使用err也是语法甜头，性能苦头，凭空添加了这两句（幸好都不太复杂）。

  接下来我编写了一个和此功能类似的函数，用的是on语句处理异常：

  public function f2() as integer
      on error goto catchblock
      dim n as integer = 2 ＼ n
      exit function
  catchblock:

      msgbox(err.description)

  end function

  这不比上一个过程复杂，不过反汇编以后，他的il代码竟然有47条指令，刚才才19条啊！最主要的改动是try部分，目前他是这样：

  .try l_0000 to l_0022 filter l_0022 l_0036 to l_0060

  注意，catch不见了，而出现了filter。我从没在c#生成的il中见过filter。我查询了meta data一节的文件，filter大概能够进行一些过滤，满足一定条件才进入处理异常的块中，本例来说，l_0022指令开始就是过滤器，他是：

  l_0022: isinst exception
  l_0027: brfalse.s l_0033
  l_0029: ldloc.s v_4
  l_002b: brfalse.s l_0033
  l_002d: ldloc.3
  l_002e: brtrue.s l_0033
  l_0030: ldc.i4.1
  l_0031: br.s l_0034
  l_0033: ldc.i4.0
  l_0034: endfilter

  endfilter就是异常处理部分代码的开始。而l0030之前的代码是过滤器的判断部分，v_4和v_3是vb自己加入保存错误代码的变量。在整个反汇编中，我发现设计成处理异常部分的代码在il里其实也是在try块中，也就是说程式的结构已不是规整的try...catch块，产生异常的语句和处理异常的语句在一起，而真正处理异常的指令是一大堆繁冗拖沓的跳转语句。

  下面看看我编写的第三个例子：

  public function f3() as integer
      on error resume next
      dim n as integer = 2 ＼ n
  end function

  这个值有2行的过程动用了vb强大的语法杀手??on error resume next，他将忽略所有异常，让代码紧接产生异常的语句继续执行下去，猜猜这个功能产生了多少il指令？答案是50条！比普通的on error还要长。其实现我就不多说了，和前面的on语句差不多。不过50这个数字似乎提醒了大家，不要在程式里偷懒使用on error处理异常，这样产生的代价是不可接受的。

  最后一个例子是vb.net的when语句，他能实现对catch部分的过滤：

  public function f1() as integer
      dim n as integer = 0
      try
          dim m as integer = 2 ＼ n
      catch ex as exception when n = 0
          msgbox(ex.message)
      end try
  end function

  里面的when语句进行了对变量n的判断，仅当n = 0的时候才进入处理部分。听到“过滤”两个字，我们已猜出，他是用try...filter来实现的。没错。这里的filter主要是进行ex是否是exception型，n是否等于零等，当过滤成功，就会转移到异常处理段进行处理。这次vb生成的代码要比on error语句规则得多，结构相当清晰。

  本次我们还借助on error语句和when语句了解到try filter结构，他是c#不能生成的，因此，我发现他不能被常见的反编译器反编译（因为反编译器的编写者只知道c#，呵呵）。而且用了on error后程式结构变得异常混乱，这在产生负面作用的时候，是不是能够变相起到保护我们代码的作用呢？

  （九）实例访问共享成员

  大家都知道静态成员在vb中叫做共享成员，虽然刚接受起来有点别扭，但“共享成员”的确是名副其实的：

  public class class1
      public shared i as integer
      other none-shared members
  end class

  不仅像在c#中那样，能用class1.i访问共享成员i，还能用实例变量来访问:

  dim c1 as new class1
  c1.i = 100

  就像i是c1的成员相同！当然只有一个i，所有实例去修改i的值都将导致所有i的值改动（因为其实只有一个）。甚至me和myclass也能访问共享成员。

  me.i = 100
  myclass.i = 100

  这在c#中是不可能做到的，一个纯正的c#程式员看到这些代码一定会觉得匪夷所思。为了揭示他的工作原理，我们能做下列实验：

  dim c1 as class1
  c1.i = 100

  注意，这里的c1为nothing!，即使是nothing的变量也能访问共享成员，而且不会出错。接下来我们实验更极端的情况：

  dim o as object = new class1
  o.i = 100

  结果??失败，不能通过后期绑定访问共享成员。目前结果已非常明显，只有在vb明确了解对象类型的情况下，才能使用实例访问共享成员，vb会自动判断类型，然后将所有对共享成员访问的语句改写成

  class1.i = 100

  这样的语法。delphi也支持这一有趣的特征，而且李维在《inside vcl》中将此说成delphi.net相对于.net的扩展之一。
  
  出处：https://www.cnblogs.com/gmtyt/archive/2010/11/09/1872947.html