VB6比VB.NET更容易？ [英] VB6 easier than VB.NET?

问题描述

在最近的一些帖子中，我看到的人似乎对易用性方面感到怀旧。 Visual Basic 6.我不能把手指放在它上面，但它们似乎暗示VB6比VB.NET更易于使用，

在VB6中编写程序比在VB.NET中编程更容易。我承认我很惊讶我对这种态度感到惊讶。我看不出任何合理性，总的来说，VB6比VB.NET更容易。


我*可以*看到在VB6语言中根深蒂固的人会发现转换到VB.NET令人生畏的事情。

（毕竟，VB.NET是一个重要的离开
来自VB6的
。）但我看不出是有人做出判断，从

客观的角度来看，VB6比VB.NET更容易。换句话说，只是

因为*你*碰巧更加熟悉那些被称为Visual
基本6，你可以在VB6中比VB.NET更快地编写应用程序，它

并不意味着VB6更容易。


我听说它认为.NET完全支持对象面向编程的一个缺点就是它使编码变得更加困难。 我只想要

进入那里并写一些代码;我不想担心那个OO垃圾的所有价值。也许这个原则适用于Hello World
类型的应用程序，但对于任何非平凡的应用程序，我只是没有看到

如何井OO原则的有序，干净和一致的实现
.NET框架中的
不能被视为一个更容易开发的环境。

开发。 >

我想我正在从教授某人的角度来看待它，这对于编程如何成为一名程序员来说是完全陌生的。在这种情况下，VB6或VB.NET会更容易吗？在我看来，毫无疑问VB.NET

会更容易。在我看来，在相对较短的时间内，我可以向某人传授面向对象编程的原理和.NET Framework的基本布局。但是，如果我将相同数量的时间用于从头开始教VB6，我会陷入困境，告诉他们关于所有怪癖，解决方法的问题。在我甚至可以通过基础知识之前，我将耗尽时间。 （我不会想要将这种类型的知识转移称为教学。）


重点是即使可能存在最初更陡峭的学习

曲线，以克服面向对象编程的原则，一旦你b
'具有OO顿悟。并且真正理解这些原则，其余的很顺利

航行。但是使用VB6，你可能会更快地启动和运行，但是你的每日编码过程都是通过找到一个看似无聊的b
$ b无穷无尽的古怪系列来解决的。那些只是你没有操作的行为或事物你认为他们会这样做，总体开发时间实际上要长得多。


所以，有没有那些人真的认为VB6比VB.NET更容易吗？

为什么？你认为这取决于项目的规模吗？还有其他

因素吗？帮助我理解，因为我只是没有这种态度。


- Mitchell S. Honnert

解决方案

< blockquote>在某些方面，VB6比.NET更简单，但.NET有更多的功能，你很多次不得不用你的方式克服你的方式

VB6 。


VB.NET对OO编程的支持，来自VB6背景，确实为非OO程序员提供了学习曲线。 ..和许多VB

程序员真正处于他们6的舒适区域。但转向OO

编程非常值得，大多数人可能会发现.NET

提供了很多很棒的新功能和改进一旦你停止

试图用VB6方式做事......


" Mitchell S. Honnert" < news@honnert~R~E~M~O~V~E~.com>在消息中写道

新闻：OA ************** @ TK2MSFTNGP09.phx.gbl ...

在最近的一些帖子中，在易用性方面，我看到过那些似乎在怀旧的人。我不能把手指放在它上面，但它们似乎暗示VB6比VB.NET更易于使用，它在某种程度上更容易编写程序在VB6中比在VB.NET中。我不得不承认我对这种态度感到惊讶。我看不出任何理由，总的来说，VB6比VB.NET更容易。

我*可以*看看哪里有人在VB6中根深蒂固语言会发现转向VB.NET令人生畏。 （VB.NET毕竟是VB6的主要出发点。）但是从目标角度来看，有人做出判断，认为VB6比VB更容易。净。换句话说，
只是因为*你*碰巧更加熟悉集体的怪癖，特性和不一致性，这些被称为可以写的Visual Basic 6 VB6中的应用程序比VB.NET更快，这并不意味着VB6更容易。

我听说它认为.NET的全面支持是一个缺点对象面向对象编程是因为它使编码更加困难。 我只想要
进入并写下一些代码;我不想担心所有那些OO垃圾。也许这个原则适用于Hello
World。应用程序的类型，但对于任何非平凡的应用程序，我只是没有看到如何在.NET框架中有序，干净，一致地实现OO
原则无法实现被视为一个更容易开发的环境。

我想从教授对编程如何全新的人的角度来看它成为一名程序员。在这种情况下，哪个更容易，VB6还是VB.NET？在我看来，VB.NET
会更容易。在我看来，在相对较短的时间内，我可以教别人面向对象编程的原理和.NET Framework的基本布局。但是，如果我将相同数量的时间用于从头开始教VB6，我会陷入困境，告诉他们所有的怪癖，变通办法和
异常 - 在我甚至可以通过基础知识之前，我已经没有时间了。 （我甚至不想称这种类型的知识转移教学。）

关键是即使可能有一个最初更陡峭的学习
一旦你有OO顿悟，就可以通过面向对象编程的原则。并且真正理解了原则，其余的是顺利航行。但是使用VB6，你可能会更快地启动和运行，但是你的每日编码过程都是通过找到一些似乎无穷无尽的奇怪行为或者只是不做的事情来解决的。 t
按照你的想法操作，整体开发时间实际上要长得多。

那么，是否有人认为VB6比

- Mitchell S. Honnert

>很多VB程序员真的处于他们的舒适区域。

你已经找到了我对这个主题的一个主要观点。我认为，那些认为VB6比VB.NET更容易的人是/ b $ b那些在VB6区域的人。他们已经习惯了所有在VB6中完成所有工作所需的变通方法，所以他们错误地认为VB6更容易因为它更容易实现它们*。问题是，我不想被认为是一个优秀的程序员，因为我知道

神秘的技巧让我选择的语言来做事情它应该是开箱即用的
。我不想成为伏都教程序员。我会花很多时间来花时间学习更多关于语言的知识。即使这意味着一些额外的前期工作。


- Mitchell S. Honnert

" Michael C＃" < xy*@yomomma.com>在消息中写道

新闻：例如************* @ TK2MSFTNGP15.phx.gbl ...

在某些方面VB6比较简单比.NET更强大，但.NET中有很多功能，你很多时候不得不用VB6来克服自己的方式。

VB.NET的支持对于面向对象编程，当来自VB6背景时，
确实为非OO程序员提供了学习曲线......而且许多VB程序员确实在他们的舒适区域中使用了6.但是切换OO编程非常值得，大多数人可能会发现，一旦你停止尝试用VB6做事，.NET就会提供很多很棒的新功能和改进......

Mitchell S. Honnert < news@honnert~R~E~M~O~V~E~.com>在消息中写道
新闻：OA ************** @ TK2MSFTNGP09.phx.gbl ...

在最近的一些帖子中，我已经看到那些似乎在易用性方面打扮怀旧的人。我不能把手指放在它上面，但它们似乎暗示VB6比VB.NET更易于使用，它在某种程度上更容易编写程序在VB6中比在VB.NET中。我不得不承认我对这种态度感到惊讶。我看不出这个想法有什么合理性，总的来说，VB6比VB.NET更容易。

我*可以*看看有人在哪里根深蒂固的VB6语言将找到转向VB.NET的艰巨任务。 （毕竟，VB.NET远离VB6。）但是我看不到有人从客观的角度判断VB6比VB更容易。 NET。
换句话说，只是因为*你*碰巧更加熟悉了一系列怪癖，特点和
不一致的东西，你被称为Visual Basic 6可以在VB6中比VB.NET更快地编写应用程序，这并不意味着VB6更容易。

我听说它有一个缺点。 NET完全支持面向对象编程，这使得编码变得更加困难。 我只是想进去并写一些代码;我不想担心所有这些OO垃圾。也许这个原则适用于
Hello World。应用程序的类型，但对于任何非平凡的应用程序，我只是没有看到.NET框架中的OO原则的有序，干净和一致的实现如何无法实现被视为一个更容易开发的环境。

我想我正在从教授一个对编程如何全新的人的角度来看待它成为一名程序员。在这种情况下，哪个更容易，VB6或VB.NET？在我看来，毫无疑问，VB.NET会更容易。在我看来，在相对较短的时间内，我可以教别人面向对象编程的原理和.NET Framework的基本布局。但是，如果我将相同的时间用于从头开始教VB6，那么我会陷入困境，告诉他们所有的怪癖，变通方法和
异常 - 在我甚至可以通过基础知识之前，我已经没有时间了。 （我甚至不想称这种类型的知识转移教学。）

关键是即使可能有一个最初更陡峭的学习曲线越过面向对象编程的原则，
一旦你有OO顿悟，并且真正了解原则，其余的一帆风顺。但是使用VB6，你可能会更快地启动和运行，但是你的日常编码过程是通过找到一系列看似无穷无尽的古怪行为或事物来解决的。
只是不按照你的想法操作，整个开发时间实际上要长得多。

那么，是否有人认为VB6比
- Mitchell S. Honnert

2005-03-24，Mitchell S. Honnert< news@honnert〜R〜E〜M〜O〜V〜E〜。>写道：

在最近的一些帖子中，我看到的人似乎对易用性方面怀有怀旧感。我不能完全把手指放在它上面，但它们似乎暗示VB6比VB.NET更易于使用，
它在某种程度上更容易编写程序在VB6中比在VB.NET中。我承认我对这种态度感到惊讶。我看不出任何合理性，总的来说，VB6比VB.NET更容易。


我不想概括别人所说的话，因为这个主题有很多意见，但我是说VB6是

肯定更容易学习，特别是初学者和

非程序员。

我听说过它有争议.NET完全支持面向对象编程的一个缺点是它使编码更加困难。 我只想要
进入并写下一些代码;我不想担心那些OO垃圾的所有问题。也许这个原则适用于Hello World类型的应用程序，但对于任何非平凡的应用程序，我只是没有看到
如何有序，干净和一致的实现.NET框架中的OO原则不能被视为一个更容易开发的环境。


非平凡是一个相对的术语。那里有很多小应用程序

对我来说似乎微不足道，但在小型的b
办公室中被视为圣杯。这些是非常有价值的提高生产力的b $ b应用程序，通常是由那些拿起一点VB的人写的。

这样的事情真的没有合理的顾问市场：如果我知道要写什么，我可以在不到一天的时间内编写应用程序，但是它需要花费六周的时间来学习需要的业务流程

自动化。


VB非常适合这类事情，因为它可能非常可靠。理解。考虑一些基本的东西，

类和类实例之间的区别。人们可以在没有理解这一点的情况下编写非常有用的应用程序，因为VB模糊了表单所涉及的区别。你可以将按钮拖到一个

表格上，写一些小事件处理程序，甚至可以做一些没有

的数据库工作，真正抓住大局。

这对.NET来说更加困难。 VB.Net仍然隐藏了一点复杂性，

但是类和实例以及范围和可见性以及其他东西的想法很快就出现了。

我想我正在教导一个对编程如何成为程序员完全陌生的人。在这种情况下，哪个更容易，VB6还是VB.NET？在我看来，VB.NET
会更容易。在我看来，在相对较短的时间内，我可以教别人面向对象编程的原理和.NET Framework的基本布局。但是，如果我将相同数量的时间用于从头开始教VB6，那么我就会陷入困境，告诉他们所有的怪癖，变通办法和例外情况。在我完成基本操作之前，我已经没有时间了。 （我甚至不想把这种类型的知识转移称为教学。）

另一方面，让我们说你确实写了这个为期一天的申请我上面提到的
。你在六个小时内写完了，现在你有两个小时

将它交给技术部门。办公室里的人正在进行

支持（因为他们不能再给你回电话来获取新功能）。

这个人可能已经完成了几个Word宏，可以在Excel等中做相当高级的

电子表格功能。


什么更容易解释，VB6表格背后的代码，或者完整的成熟的

.Net中的OOP应用程序？我认为VB6应用程序在限定时间内更容易解释

。

In some recent posts, I''ve seen people who seem to be waxing nostalgic with
respect to the "ease of use" of Visual Basic 6. I can''t quite put my finger
on it, but they seem to be implying that VB6 was simpler to use than VB.NET,
that it was somehow easier to write programs in VB6 than in VB.NET. I have
to admit I''m astonished by this attitude. I can''t see any rationality to
the idea that, on the whole, VB6 is easier than VB.NET.

I *can* see where someone who is entrenched in the VB6 language would find
the switch to VB.NET daunting. (VB.NET is, after all, a major departure
from VB6.) But what I can''t see is someone making the judgment, from an
objective standpoint, that VB6 is easier than VB.NET. In other words, just
because *you* happen to be so much more familiar with the collective set of
eccentricities, peculiarities, and inconsistencies that is known as Visual
Basic 6 that you can write applications faster in VB6 than VB.NET, it
doesn''t mean that VB6 is easier.

I''ve heard it argued that a drawback to .NET''s full support of object
oriented programming is that it makes coding more difficult. "I just want
to get in there and write some code; I don''t want to have to worry about all
of that OO crap." Perhaps the principle holds true for the "Hello World"
type of application, but for any non-trivial application, I just don''t see
how the well-ordered, clean, and consistent implementation of OO principles
in the .NET framework couldn''t be seen as an easier environment in which to
develop.

I guess I''m looking at it from the perspective of teaching someone who is
completely new to programming how to be a programmer. In this case, which
would be easier, VB6 or VB.NET? There''s not doubt in my mind that VB.NET
would be easier. In my opinion, in a relatively short period of time, I
could teach someone the principles of object oriented programming and the
basic layout of the .NET Framework. But if I applied this same amount of
time to teaching someone VB6 from scratch, I''d get so bogged down in telling
them about all of the quirks, workarounds, and exceptions-to-the-rule that
I''d run out of time before I could even get through the basics. (I wouldn''t
even want to call this type of knowledge transfer "teaching".)

The point is that even though there might be an initially steeper learning
curve to get past the principles of object oriented programming, once you
have the "OO epiphany" and truly grok the principles, the rest is smooth
sailing. But with VB6, you may get up and running a bit faster, but your
daily process of coding is so taken up by finding workarounds to a seemingly
endless series of quirky behaviors or things that just don''t operate how you
think they would, that the overall development time is actually much longer.

So, are there people out there that really think VB6 is easier than VB.NET?
Why? Do you think it depends on the size of the project? Are there other
factors? Help me understand because I just don''t get this attitude.

- Mitchell S. Honnert

解决方案

In some respects VB6 was simpler than .NET, but .NET has a lot more
functionality in it that you many times had to kludge your way through with
VB6.

VB.NET''s support for OO programming, when coming from a VB6 background, does
provide a learning curve to non-OO programmers... and a lot of VB
programmers were really in their comfort zone with 6. But the switch to OO
programming is well worth it, and most people probably discover that .NET
provides a lot of great new functionality and improvements once you stop
trying to do things the VB6 way...

"Mitchell S. Honnert" <news@honnert~R~E~M~O~V~E~.com> wrote in message
news:OA**************@TK2MSFTNGP09.phx.gbl...

In some recent posts, I''ve seen people who seem to be waxing nostalgic
with respect to the "ease of use" of Visual Basic 6. I can''t quite put my
finger on it, but they seem to be implying that VB6 was simpler to use
than VB.NET, that it was somehow easier to write programs in VB6 than in
VB.NET. I have to admit I''m astonished by this attitude. I can''t see any
rationality to the idea that, on the whole, VB6 is easier than VB.NET.

I *can* see where someone who is entrenched in the VB6 language would find
the switch to VB.NET daunting. (VB.NET is, after all, a major departure
from VB6.) But what I can''t see is someone making the judgment, from an
objective standpoint, that VB6 is easier than VB.NET. In other words,
just because *you* happen to be so much more familiar with the collective
set of eccentricities, peculiarities, and inconsistencies that is known as
Visual Basic 6 that you can write applications faster in VB6 than VB.NET,
it doesn''t mean that VB6 is easier.

I''ve heard it argued that a drawback to .NET''s full support of object
oriented programming is that it makes coding more difficult. "I just want
to get in there and write some code; I don''t want to have to worry about
all of that OO crap." Perhaps the principle holds true for the "Hello
World" type of application, but for any non-trivial application, I just
don''t see how the well-ordered, clean, and consistent implementation of OO
principles in the .NET framework couldn''t be seen as an easier environment
in which to develop.

I guess I''m looking at it from the perspective of teaching someone who is
completely new to programming how to be a programmer. In this case, which
would be easier, VB6 or VB.NET? There''s not doubt in my mind that VB.NET
would be easier. In my opinion, in a relatively short period of time, I
could teach someone the principles of object oriented programming and the
basic layout of the .NET Framework. But if I applied this same amount of
time to teaching someone VB6 from scratch, I''d get so bogged down in
telling them about all of the quirks, workarounds, and
exceptions-to-the-rule that I''d run out of time before I could even get
through the basics. (I wouldn''t even want to call this type of knowledge
transfer "teaching".)

The point is that even though there might be an initially steeper learning
curve to get past the principles of object oriented programming, once you
have the "OO epiphany" and truly grok the principles, the rest is smooth
sailing. But with VB6, you may get up and running a bit faster, but your
daily process of coding is so taken up by finding workarounds to a
seemingly endless series of quirky behaviors or things that just don''t
operate how you think they would, that the overall development time is
actually much longer.

So, are there people out there that really think VB6 is easier than
VB.NET? Why? Do you think it depends on the size of the project? Are
there other factors? Help me understand because I just don''t get this
attitude.

- Mitchell S. Honnert

> a lot of VB programmers were really in their comfort zone with 6.
You''ve hit on one of main points of my thoughts on this topic. I
hypothesize that the people who think that VB6 is easier than VB.NET are
those who were/are "in the VB6 zone". They had become accustomed to all of
the workarounds necessary to get anything done in VB6, so they mistakenly
believe that VB6 is easier because it''s easier for *them*. The thing is, I
wouldn''t want to be thought of as a good programmer because I know the
mystical tricks to get my language of choice to do the things it''s supposed
to do out of the box. I don''t want to be a voodoo programmer. I''d much
rather spend that time learning more about the language. Even if it means
some additional up-front work.

- Mitchell S. Honnert
"Michael C#" <xy*@yomomma.com> wrote in message
news:eg*************@TK2MSFTNGP15.phx.gbl...

In some respects VB6 was simpler than .NET, but .NET has a lot more
functionality in it that you many times had to kludge your way through
with VB6.

VB.NET''s support for OO programming, when coming from a VB6 background,
does provide a learning curve to non-OO programmers... and a lot of VB
programmers were really in their comfort zone with 6. But the switch to
OO programming is well worth it, and most people probably discover that
.NET provides a lot of great new functionality and improvements once you
stop trying to do things the VB6 way...

"Mitchell S. Honnert" <news@honnert~R~E~M~O~V~E~.com> wrote in message
news:OA**************@TK2MSFTNGP09.phx.gbl...

In some recent posts, I''ve seen people who seem to be waxing nostalgic
with respect to the "ease of use" of Visual Basic 6. I can''t quite put
my finger on it, but they seem to be implying that VB6 was simpler to use
than VB.NET, that it was somehow easier to write programs in VB6 than in
VB.NET. I have to admit I''m astonished by this attitude. I can''t see
any rationality to the idea that, on the whole, VB6 is easier than
VB.NET.

I *can* see where someone who is entrenched in the VB6 language would
find the switch to VB.NET daunting. (VB.NET is, after all, a major
departure from VB6.) But what I can''t see is someone making the
judgment, from an objective standpoint, that VB6 is easier than VB.NET.
In other words, just because *you* happen to be so much more familiar
with the collective set of eccentricities, peculiarities, and
inconsistencies that is known as Visual Basic 6 that you can write
applications faster in VB6 than VB.NET, it doesn''t mean that VB6 is
easier.

I''ve heard it argued that a drawback to .NET''s full support of object
oriented programming is that it makes coding more difficult. "I just
want to get in there and write some code; I don''t want to have to worry
about all of that OO crap." Perhaps the principle holds true for the
"Hello World" type of application, but for any non-trivial application, I
just don''t see how the well-ordered, clean, and consistent implementation
of OO principles in the .NET framework couldn''t be seen as an easier
environment in which to develop.

I guess I''m looking at it from the perspective of teaching someone who is
completely new to programming how to be a programmer. In this case,
which would be easier, VB6 or VB.NET? There''s not doubt in my mind that
VB.NET would be easier. In my opinion, in a relatively short period of
time, I could teach someone the principles of object oriented programming
and the basic layout of the .NET Framework. But if I applied this same
amount of time to teaching someone VB6 from scratch, I''d get so bogged
down in telling them about all of the quirks, workarounds, and
exceptions-to-the-rule that I''d run out of time before I could even get
through the basics. (I wouldn''t even want to call this type of knowledge
transfer "teaching".)

The point is that even though there might be an initially steeper
learning curve to get past the principles of object oriented programming,
once you have the "OO epiphany" and truly grok the principles, the rest
is smooth sailing. But with VB6, you may get up and running a bit
faster, but your daily process of coding is so taken up by finding
workarounds to a seemingly endless series of quirky behaviors or things
that just don''t operate how you think they would, that the overall
development time is actually much longer.

So, are there people out there that really think VB6 is easier than
VB.NET? Why? Do you think it depends on the size of the project? Are
there other factors? Help me understand because I just don''t get this
attitude.

- Mitchell S. Honnert

On 2005-03-24, Mitchell S. Honnert <news@honnert~R~E~M~O~V~E~.com> wrote:

In some recent posts, I''ve seen people who seem to be waxing nostalgic with
respect to the "ease of use" of Visual Basic 6. I can''t quite put my finger
on it, but they seem to be implying that VB6 was simpler to use than VB.NET,
that it was somehow easier to write programs in VB6 than in VB.NET. I have
to admit I''m astonished by this attitude. I can''t see any rationality to
the idea that, on the whole, VB6 is easier than VB.NET.
I don''t want to generalize about what others have said, because there''s
a very wide range of opinions on this subject, but I''d say VB6 was
definitely easier to learn, especially for beginners and
non-programmers.
I''ve heard it argued that a drawback to .NET''s full support of object
oriented programming is that it makes coding more difficult. "I just want
to get in there and write some code; I don''t want to have to worry about all
of that OO crap." Perhaps the principle holds true for the "Hello World"
type of application, but for any non-trivial application, I just don''t see
how the well-ordered, clean, and consistent implementation of OO principles
in the .NET framework couldn''t be seen as an easier environment in which to
develop.
"Non-trivial" is a relative term. There''s lots of small apps out there
that seem trivial to me, but are treated like the Holy Grail in small
offices. And these are very valuable productivity-enhancing
applications, usually written by somebody who picked up a little VB.
There''s really no reasonable consultant market for things like this: I
could write the app in less than a day if I knew what to write, but it
would take me six weeks to learn the business process that needs to be
automated.

VB was perfect for these kinds of things, because it could be very
forgiving of a certain lack of understanding. Consider something basic,
the difference between a class and an instance of a class. People could
write very useful apps without understanding this because VB blurred the
distinction where forms were concerned. You could drag buttons onto a
form, write little event handlers, maybe even do some DB work without
ever really grasping the big picture.

That''s much tougher in .NET. VB.Net still hides complexity a little,
but the idea of class and instances and scope and visibility and stuff
like that pops up pretty quickly.
I guess I''m looking at it from the perspective of teaching someone who is
completely new to programming how to be a programmer. In this case, which
would be easier, VB6 or VB.NET? There''s not doubt in my mind that VB.NET
would be easier. In my opinion, in a relatively short period of time, I
could teach someone the principles of object oriented programming and the
basic layout of the .NET Framework. But if I applied this same amount of
time to teaching someone VB6 from scratch, I''d get so bogged down in telling
them about all of the quirks, workarounds, and exceptions-to-the-rule that
I''d run out of time before I could even get through the basics. (I wouldn''t
even want to call this type of knowledge transfer "teaching".)

On the flipside, let''s say you did write this one-day application I
mentioned above. You wrote it in six hours and now you have two hours
to hand it over to the "technical" person in the office for ongoing
support (because they can''t afford to call you back for new features).
This person has maybe done a few Word macros, can do fairly advanced
spreadsheet functions in Excel, etc.

What''s easier to explain, the code behind a VB6 form, or a full-fledged
OOP app in .Net? I think the VB6 app would be much easier to explain
in a limited time.

这篇关于VB6比VB.NET更容易？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！