VB 6和VB.NET之间的前五项变化

梦里梦外; 2022-12-07 12:10 140阅读 0赞

## VB 6和VB.NET之间的前五项变化 **(** The Top Five Changes between VB 6 and VB.NET **)** ##

![Top Five Changes][]

Visual Basic 1.0 was a major earthquake throughout programming. Before VB1, you had to use C, C++, or some other horrible development environment to create Windows applications. Programmers literally spent weeks just drawing windows on screens with picky, detailed, hard to debug code. (The same thing you can do by dragging a form from the toolbar in a few seconds.) VB1 was a hit and gazillions of programmers immediately started using it.

在整个编程过程中，Visual Basic 1.0都是一次重大地震。 在VB1之前，您必须使用C，C ++或其他可怕的开发环境来创建Windows应用程序。 程序员实际上花了数周的时间才在屏幕上绘制带有挑剔，详细，难以调试的代码的窗口。 (您可以通过在几秒钟内从工具栏拖动表单来执行相同的操作。)VB1非常受欢迎，成千上万的程序员立即开始使用它。

But to make the magic happen, Microsoft made some major architecture compromises. In particular, since VB1 created the forms and controls, they didn't allow the programmer access to the code that did it. You either let VB create everything, or you used C++.

但是要使魔术实现，微软做出了一些重大的架构折衷。 特别是，由于VB1创建了表单和控件，因此它们不允许程序员访问执行该操作的代码。 您要么让VB创建一切，要么使用C ++。

VB 2 through 6 maintained this same architecture. Microsoft made some very clever updates which gave programmers a lot more control, but in the final analysis programmers still couldn't integrate their code with the VB code. It was a black box - and not in the good OOP way either. Another way of saying this was that the programmer didn't have access to the internal VB "objects" and another way of saying that was that VB6 still wasn't fully "object oriented".

VB 2至6保持了相同的体系结构。 微软做了一些非常聪明的更新，使程序员拥有更多的控制权，但是归根结底，程序员仍然无法将他们的代码与VB代码集成在一起。 这是一个黑匣子-也不是良好的OOP方式。 另一种说法是程序员没有访问内部VB“对象”的权利，另一种说法是VB6仍然不是完全“面向对象的”。

## VB 6-落后于技术曲线 **(** VB 6 - Falling Behind the Technology Curve **)** ##

In the meantime, Java, Python, and a whole lot of other programming languages that WERE object oriented started to appear. Visual Basic was getting passed up - big time! This is a situation Microsoft does not tolerate ... and they resolved to solve the problem once and for all. The solution is .NET.

同时，Java，Python和WERE面向对象的许多其他编程语言开始出现。 Visual Basic渐行渐远-辛苦了！ 这是Microsoft不能容忍的情况，他们决心一劳永逸地解决问题。 解决方案是.NET。

But to do the things that .NET needed to do, Microsoft decided that they had to "break compatibility". That is, Visual Basic programs had been (with very minor exceptions) "upward compatible" from VB1 right up to VB6. A program written in that first version of VB would still compile and run in the next version. But with VB.NET, Microsoft found they just couldn't make the language completely OOP and maintain upward compatibily.

但是为了完成.NET需要做的事情，Microsoft决定他们必须“破坏兼容性”。 也就是说，从VB1到VB6，Visual Basic程序一直(“非常兼容”)是“向上兼容”的。 用第一个VB版本编写的程序仍然可以在下一个版本中编译并运行。 但是，通过VB.NET，Microsoft发现他们无法完全使该语言OOP并保持向上兼容。

Once they made this fundamental decision, the flood gates opened on ten years of accumulated "wish list" changes and ALL of them went into the new VB.NET. As they say in Britain, "In for a penny, in for a pound."

一旦他们做出了这一基本决定，就在十年的累积“愿望清单”更改中打开了闸门，所有这些都进入了新的VB.NET。 正如他们在英国所说的那样：“一分钱，一英镑。”

Without further delay, here's my very personal list of the top five changes from VB6 to VB.NET in reverse order.

不用再拖延了，这是我个人列出的从VB6到VB.NET的五个前反向更改。

*Wellllll* .... just one further delay. Since we're changing from VB6, where an array declared as Dim myArray(**5**) has **6** elements, We have six of 'em. It's only fitting ...

*Wellllll* ....再延迟一次。 由于我们要从VB6更改，在VB6中，声明为Dim myArray( **5** )的数组有**6个**元素，因此我们有6个'em。 这很合适...

(Drum roll please ...)

(请打鼓...)

## 奖(5)-类C语法更改 **(** Award(5) - C-like Syntax Changes **)** ##

"Award(5)", our **6th Place** award goes to the C groupies choice: **C-like Syntax Changes!**

“ Award(5)”，我们的**第六名**奖归C组选择：类**C语法更改！**

Now you can code a += 1 instead of a = a + 1, saving THREE WHOLE KEYSTROKES!

现在，您可以用+ = 1而不是a = a + 1进行编码，从而节省了三个按键！

Programmers of the World, Rejoice! VB has been raised up to C level, and a whole new generation trying to learn VB will get a little closer to the mass confusion that confronts students of C++.

世界程序员，欢呼！ VB已提高到C水平，并且新一代尝试学习VB的人将与C ++学生所面临的大量困惑更加接近。

But wait! There's more!

可是等等！ 还有更多！

VB.NET now features "short circuit logic" that has introduced subtle bugs into C++ code for years to save precious nano-seconds of processor time. Short circuit logic only evaluates multiple conditions in a logical statement if necessary. For example:

VB.NET现在具有“短路逻辑”功能，该功能多年来在C ++代码中引入了细微的错误，以节省宝贵的纳秒级处理器时间。 必要时，短路逻辑仅在逻辑语句中评估多个条件。 例如：

Dim R As BooleanR = Function1() And Function2()

Dim R为BooleanR = Function1()和Function2()

In VB6, both functions are evaluated whether they need it or not. With VB.NET, if Function1() is false, Function2() is ignored since "R" can't be True. But, what if a global variable is changed in Function2() - just by chance (C++ programmers would say, "by poor programming".) Why does my code produce the wrong answer some of the time when it's translated to VB.NET? This might be it!

在VB6中，是否需要评估两个函数。 在VB.NET中，如果Function1()为false，则将忽略Function2()，因为“ R”不能为True。 但是，如果在Function2()中更改了全局变量，该怎么办-只是偶然(C ++程序员会说“由于编程不当”。)为什么在将我的代码翻译成VB.NET时有时会产生错误的答案？ 可能就是这样！

For **Try**ing harder, VB.NET will **Catch** a little luck and **Finally** get recognized for "exceptional" error handling.

对于**尝试**荷兰国际集团更难，VB.NET会**抓住**一点点运气， **最后**得到认可的“例外”的错误处理。

VB6 had the last holdout GoTo: "On Error GoTo". Even I have to admit that the C++ style "Try-Catch-Finally" structured exception handling is a vast improvement, not just a half vast improvement.

VB6具有最后一个保留GoTo：“错误时转到”。 甚至我不得不承认，C ++样式的“ Try-Catch-Finally”结构化异常处理是一个巨大的进步，而不仅仅是一半的巨大进步。

What, you say "On Error GoTo" is still in VB.NET? Wellll ... We try not to talk about that too much.

什么，您说“ On Error GoTo”仍在VB.NET中？ Wellll ...我们尽量不要谈论太多。

## 第五名-其他命令更改 **(** 5th Place - The Miscellaneous Command Changes **)** ##

**5th Place** selection is a group award: **The Miscellaneous Command Changes!** They have to share this award and there's a gazillion of 'em. Microsoft has been saving up for ten years and they really cut loose.

**第五名的**选择是团体奖项： **杂项命令更改！** 他们必须分享这个奖项，并且有大量的“ em”。 微软已经节省了十年的时间，而且他们真的松了一口气。

VB.NET no longer supports VarPtr, ObjPtr and StrPtr functions which retrieved the memory address of variables. And it doesn't support VB6 LSet which was used to convert one user defined type to another. (Not to be confused with VB6 LSet which does something completely different - see below.)

VB.NET不再支持VarPtr，ObjPtr和StrPtr函数，这些函数检索变量的内存地址。 而且它不支持用于将一种用户定义的类型转换为另一种类型的VB6 LSet。 (不要与功能完全不同的VB6 LSet混淆-参见下文。)

We also bid fond adieu to Let, Is Missing, DefBool, DefByte, DefLng, DefCur, DefSng, DefDbl, DefDec, DefDate, DefStr, DefObj, DefVar, and (my personal favorite!) GoSub.

我们也对Let，Missing，DefBool，DefByte，DefLng，DefCur，DefSng，DefDbl，DefDec，DefDate，DefStr，DefObj，DefVar和(我个人最喜欢的)GoSub表示深深的兴趣。

Circle has morphed into GDI+ DrawEllipse. The same goes for Line to DrawLine. In calculation we now have Atan instead of Atn, Sign goes in for Sgn, and Sqrt suits up for the big game instead of Sqr.

圆已变形为GDI + DrawEllipse。 Line to DrawLine也是一样。 在计算中，我们现在有Atan而不是Atn，Sign进入了Sgn，而Sqrt适合大型游戏而不是Sqr。

In string processing, even though they're still available if you reference a Microsoft compatibility namespace, we have PadRight for VB6's LSet (again, totally different than VB6's LSet, of course) and PadLeft for RSet. (There goes the three keystrokes we saved with "+="!)

在字符串处理中，即使您引用了Microsoft兼容性名称空间，即使它们仍然可用，对于VB6的LSet，我们也有PadRight(同样，与VB6的LSet完全不同)，对于RSet，则有PadLeft。 (接着我们用“ + =”保存了三个击键！)

And of course, since we're OOP now, don't fret if Property Set, Property Let, and Property Get are not met in VB.NET, you bet!

当然，由于我们现在是OOP，所以如果您在VB.NET中未满足Property Set，Property Let和Property Get，请不要担心！

Finally, Debug.Print becomes either Debug.Write or Debug.WriteLine. Only nerds print everything anyway.

最后，Debug.Print成为Debug.Write或Debug.WriteLine。 无论如何，只有书呆子才能打印所有内容。

This doesn't even touch all the NEW commands in VB.NET, but we've got to stop this nonsense somewhere.

这甚至不涉及VB.NET中的所有NEW命令，但是我们必须在某些地方停止这种废话。

## 第四名-程序调用的更改 **(** 4th Place - Changes to Procedure Calls **)** ##

In **4th Place**, we have **Changes to Procedure Calls!**

在**第四位** ，我们**对过程调用**进行了**更改！**

This is the "goodness, purity, and wholesome virtue" award and represents a lot of hard campaigning by the "no more sloppy code" faction.

这是“善良，纯洁和有益健康的美德”奖，代表着“不再草率的代码”派系进行的艰苦奋斗。

In VB6, if a procedure parameter variable is an intrinsic type, then it's ByRef, unless you have coded it ByVal explicitly, but if it's not coded ByRef or ByVal and it's not an intrinsic variable then it's ByVal. ... Got that?

在VB6中，如果过程参数变量是内在类型，则其为ByRef，除非您已对其明确编码为ByVal，但如果未对ByRef或ByVal进行编码并且不是内在变量，则为ByVal。 ... 了解？

In VB.NET, it's ByVal unless it's coded ByRef.

在VB.NET中，除非编码为ByRef，否则为ByVal。

The ByVal VB.NET default, by the way, also prevents changes to parameter variables in procedures from being unintentionally propagated back into the calling code - a key part of good OOP programming.

顺便说一句，ByVal VB.NET的默认设置还可以防止过程中对参数变量的更改无意间传播回调用代码中-这是良好的OOP编程的关键部分。

Microsoft also "overloads" VB.NET with a change in the requirements for parentheses in procedure calls.

Microsoft还通过更改过程调用括号中的要求来“重载” VB.NET。

In VB6, parentheses are required around arguments when making function calls, but not when calling a subroutine when not using the Call statement but they are required when the Call statement is used.

在VB6中，在进行函数调用时，参数周围必须带有括号，但在不使用Call语句时调用子例程时则不需要，但是在使用Call语句时，则需要在括号中添加括号。

In VB.NET, parentheses are always required around a nonempty argument list.

在VB.NET中，始终必须在非空参数列表周围加上括号。

## 第三名-数组从0开始而不是从1开始 **(** 3rd Place - Arrays are 0 based instead of 1 based **)** ##

The Bronze Award - **3rd Place**, goes to **Arrays are 0 based instead of 1 based!**

铜奖- **第三名** ，去**数组是从0开始，而不是从1开始！**

It's just one syntax change, but this change gets "medal podium" status because it is voted, "most likely to screw up your program logic". Remember, 3rd place *IS* "Award(2)" in our list. If you have counters and arrays in your VB6 program (and how many don't), this one will MESS YOU UP.

这只是语法上的一项更改，但是此更改获得“金牌领奖台”状态，因为它被投票通过，“最有可能破坏您的程序逻辑”。 请记住，第三名*是* “ Award(2)”在我们的列表中。 如果您的VB6程序中有计数器和数组(以及没有的计数器和数组)，则此命令将使您满意。

For ten years, People have been asking, "What was Microsoft smoking when they did it this way?" And for ten years, programmers have sort of universally ignored the fact that there was a myArray(0) element that just took up space and didn't get used for anything ... Except for those programmers who DID use it and their programs looked, I mean, just "weird".

十年来，人们一直在问：“当他们这样做时，Microsoft在抽烟是什么？” 十年来，程序员普遍忽略了一个事实：存在一个myArray(0)元素只是占用了空间并且没有被用于任何东西的事实……除了那些使用DID且其程序看上去很简单的程序员，我的意思是，只是“怪异”。

For I = 1 to 5   MyArray(I - 1) = WhateverNext

对于I = 1至5 MyArray(I-1)=什么

I mean, *REALLY*! ...

我的意思是， *真的* ！ ...

## 第二名-Variant数据类型 **(** 2nd Place - The Variant Datatype **)** ##

The Silver Medal of **2nd Place** goes to honor an old friend that was dropped into the bit bucket of programming with the passing of VB6! I speak of none other than, **The Variant Datatype**.

**第二名**的银牌是为了纪念一个老朋友，随着VB6的加入，他被丢进了编程的小桶中！ 我只说**The Variant Datatype** 。

Probably no other single feature of Visual Basic "notNet" better represents the philosophy of "fast, cheap, and loose". This image dogged VB right up to the introduction of VB.NET. I'm old enough to remember the introduction of Visual Basic 3.0 by Microsoft: "Oh Wow! Lookee here! With the new, improved Variant data type, you don't have to declare variables or nothin'. You can just think 'em up and code 'em."

也许Visual Basic的“ notNet”没有其他单一功能可以更好地代表“快速，廉价和宽松”的理念。 这个图像一直困扰着VB，直到引入VB.NET。 我年纪大了，还记得微软对Visual Basic 3.0的介绍：“哦，哇！在这里，Lookee！有了经过改进的新的Variant数据类型，您不必声明变量也没必要了。并编码它们。”

Microsoft changed their tune pretty fast on that one and recommended declaring variables with a specific datatype almost immediately, leaving many of us to wonder, "If you can't use Variants, why have them?"

微软很快就改变了他们的调子，并建议几乎立即声明具有特定数据类型的变量，这让我们许多人感到疑惑，“如果您不能使用Variants，为什么要使用它们？”

But while we're on the subject of datatypes, I should mention that a lot of datatypes have changed in addition to dropping Variant into wet cement. There's a new Char datatype and a Long datatype that is 64 bits. Decimal is way different. Short and Integer aren't the same length anymore.

但是，当我们讨论数据类型时，我应该提到，除了将Variant放入湿水泥之外，许多数据类型都发生了变化。 有一个新的Char数据类型和一个64位的Long数据类型。 小数则有所不同。 Short和Integer的长度不再相同。

And there is a new "Object" datatype that can be *anything*. Did I hear someone say, "**Son of Variant**"?

并且有一个新的“ Object”数据类型，可以是*任何东西* 。 我听到有人说“ **变种之子** ”吗？

## 第一名-VB.NET最终完全面向对象 **(** 1st Place - VB.NET is finally completely Object Oriented **)** ##

Finally! The Gold Medal, **1st Place**, the highest award I can bestow goes to ...

最后！ 金奖， **第一名** ，我可以授予的最高奖项是...

TA DAH!

塔达！

**VB.NET is finally completely Object Oriented!**

**VB.NET最终完全是面向对象的！**

Now when you go to the beach, the C++ programmers won't kick sand in your face and steal your (girlfriend/boyfriend - pick one). And you can **still** code a complete General Ledger Trial Balance while they're trying to figure out which header files to include.

现在，当您去海滩时，C ++程序员不会在您的脸上踢沙，也不会偷走您的(女友/男友-选择一个)。 而且，当他们试图找出要包括的头文件时，您**仍然**可以编写完整的总帐试用余额。

For the first time, you can code as close to the chip as you need to and access all the system internals your heart desires *without* having to resort to those nasty Win32 API calls. You've got inheritance, function overloading, asynchronous multithreading, garbage collection, and *everything* is an object. Can life get any better?

第一次，您可以根据需要在尽可能接近的芯片上进行编码，并访问您内心所希望的所有系统内部， *而*不必诉诸那些讨厌的Win32 API调用。 您已经有了继承，函数重载，异步多线程，垃圾回收，并且*一切*都是对象。 生活会更好吗？

Did I hear someone say C++ has multiple inheritance and .NET still doesn't?

我是否听说有人说C ++具有多重继承而.NET仍然没有？

***Burn the heretic!***

***燃烧异端！***

> 翻译自: [https://www.thoughtco.com/top-changes-between-vb6-and-vbnet-3424025][https_www.thoughtco.com_top-changes-between-vb6-and-vbnet-3424025]

[Top Five Changes]: /images/20221123/1004984d31d14136a3b7480f1ce7877d.png
[https_www.thoughtco.com_top-changes-between-vb6-and-vbnet-3424025]: https://www.thoughtco.com/top-changes-between-vb6-and-vbnet-3424025