VB 6.0到VB.NET转型指南：程序员入门

4星 · 超过85%的资源需积分: 9 48 浏览量更新于2024-07-27 1 收藏 4.13MB PDF 举报

"从VB 6.0进级到VB.NET Programmer's Introduction to Visual Basic.NET" 本书《从VB 6.0进级到VB.NET Programmer's Introduction to Visual Basic.NET》由VB和VB.NET领域的专家Craig Utley撰写，旨在帮助熟悉Visual Basic 6.0的开发者过渡到新的VB.NET平台。VB.NET是Microsoft .NET框架的一部分，它带来了许多新的特性和改进，包括更现代的编程范式、全面的类型系统和对.NET Framework的支持。 VB.NET的主要变化包括： 1. **语法更新**：VB.NET引入了更接近于标准.NET语法的改变，如“Option Strict”来确保类型安全，以及“Imports”语句来管理命名空间。 2. **面向对象编程强化**：VB.NET完全支持类、接口、继承、多态和抽象方法等面向对象概念，这在VB 6.0中不那么直观或完整。 3. **.NET Framework集成**：VB.NET开发者可以直接利用.NET Framework提供的大量类库，如System.Collections.Generic用于泛型集合，或者System.XML用于XML处理。 4. **事件处理**：VB.NET使用“AddHandler”和“RemoveHandler”关键字处理事件，比VB 6.0中的“WithEvents”更加灵活。 5. **异常处理**：VB.NET的错误处理机制采用了“Try...Catch...Finally”结构，与VB 6.0的"On Error"语句不同。 6. **Lambda表达式和 LINQ**：VB.NET支持Lambda表达式，使得匿名函数的使用更为简便。同时，语言集成查询（LINQ）允许开发者以更简洁的方式处理数据源。 7. **自动垃圾回收**：VB.NET使用.NET Framework的垃圾回收机制管理内存，开发者无需手动释放内存。 8. **泛型**：VB.NET引入了泛型，允许创建类型安全的集合和类，减少了类型转换的需要。 9. **Windows Forms和WPF**：VB.NET提供了更强大的Windows应用程序开发工具，如Windows Forms和Windows Presentation Foundation（WPF）。 10. **ASP.NET**：VB.NET可以用于构建Web应用程序，通过ASP.NET框架，开发者可以创建动态、数据驱动的网站。学习这本书，开发者将了解如何利用VB.NET的新特性提高代码质量、可维护性和性能，同时掌握如何迁移现有的VB 6.0代码到VB.NET平台。此外，书中可能还会涵盖调试技巧、单元测试、代码重构等实践方法，帮助读者全面升级他们的技能集，适应新的开发环境。虽然书中部分内容可能已过时（考虑到出版时间为2001年），但核心概念和技术对于理解VB.NET仍然是有价值的。

become quite versed in ADO as well. The needs for reusability and centralization (a

way to avoid distributing components to the desktop) have driven this move to the n-

tier model.

The move to the Web revealed some problems. Scalability was an issue, but more

complex applications had other requirements, such as transactions that spanned mul-

tiple components, multiple databases, or both. To address these issues, Microsoft cre-

ated Microsoft Transaction Services (MTS) and COM+ Component Services. MTS

(in Windows NT 4) and Component Services (an updated MTS in Windows 2000)

acted as an object-hosting environment, allowing you to gain scalability and distrib-

uted transactions with relative ease. However, VB components could not take full

advantage of all that Component Services had to offer, such as object pooling,

because VB did not support free threading.

In the ASP/VB6 model, Microsoft had developers building a component and then

calling it via an ASP. Microsoft realized that it would be a good idea to make the

component directly callable over HTTP, so that an application anywhere in the world

could use that component. Microsoft threw their support behind SOAP, Simple

Object Access Protocol, which allows developers to call a component over HTTP

using an XML string, with the data returning via HTTP in an XML string.

Components sport URLs, making them as easy to access as any other Web item.

SOAP has the advantage of having been a cross-industry standard, and not just a

Microsoft creation.

At this point, you might be tempted to think that SOAP is all you need, and that you

can just stick with VB6. Therefore it is important to understand what VB.NET gives

you, and why it makes sense for you, and many other developers, to upgrade to

.NET. For example, you create components and want them to be callable via SOAP,

but how do you let people know that those components exist? .NET includes a dis-

covery mechanism that allows you to find components that are available to you.

You ’ll find out more about this mechanism, including the “disco” file, in Chapter 8,

“Building Web Services with VB.NET.” .NET also provides many other features,

such as garbage collection for freeing up resources, true inheritance for the first time,

debugging that works across languages and against running applications, and the

ability to create Windows services and console applications.

Before proceeding, it’s important to understand a little bit more about what is meant

by “.NET.” There are many “.NETs” here. There is VB.NET, which is the new ver-

sion of Visual Basic. There is Visual Studio.NET, an Integrated Development

Environment that hosts VB.NET, C#, and C++.NET. Underlying all this is the . NET

Framework and its core execution engine, the Common Language Runtime.

In the .NET model, you write applications that target the .NET Framework. This

gives them automatic access to such benefits as garbage collection (which destroys

4 Chapter 1: Why Should You Move to Visual Basic.NET?

02 2203-x CH01 5/1/01 12:53 PM Page 4

objects and reclaims memory for you), debugging, security services, inheritance, and

more. When you compile the code from any language that supports the .NET

Framework, it compiles into something called MSIL, or Microsoft Intermediate

Language. This MSIL file is binary, but it is not machine code; instead, it is a format

that is platform independent and can be placed on any machine running the .NET

Framework. Within the .NET Framework is a compiler called the Just-In-Time, or

JIT, compiler. It compiles the MSIL down to machine code specific to that hardware

and operating system.

In looking at the fundamental changes, it’s important to understand that the number-

one feature request from Visual Basic developers, for years, has been inheritance. VB

has had interface inheritance since VB4, but developers wanted real or implementa-

tion inheritance. Why? What are the benefits? The main benefit of inheritance is the

ability to create applications more quickly. This is an extension of the promise of

component design and reusability. With implementation inheritance, you build a base

class and can inherit from it, using it as the basis for new classes. For example, you

could create a Vehicle class that provides basic functionality that could be inherited

in both a Bicycle class and a Car class. The important point here is that Bicycle and

Car inherit the functionality, or the actual code, from the Vehicle class. In VB4, the

best you could do was inherit the structure, minus any implementation code. In

VB.NET, the functionality in that base class is available to your other classes as is, or

you can extend and modify it as necessary.

.NET provides you with integrated debugging tools. If you’ve ever debugged an ASP

application that had VB COM components, you know that you had to use Visual

InterDev to debug the ASPs and VB to debug the components. If you also had C++

components in the mix, you had to use the C++ debugger on those components. With

.NET, there is one debugger. Any language that targets the .NET Framework can be

debugged with that single debugger, even if one part of your application is written in

VB.NET and calls another part written in C# (pronounced “C-Sharp”), or any other

language built to target the .NET Framework.

.NET supplies a standard security mechanism, available to all parts of your application.

.NET provides a possible solution to DLL Hell, and removes much of the complexity

of dealing with COM and the registry. .NET allows you to run components locally,

without requiring the calling application to go to the registry to find components.

There are also things that VB.NET can do that you cannot do today in VB. For exam-

ple, Web Applications are a new form of project. Gone is Visual InterDev with its

interpreted VBScript code. Instead, you now build your ASP.NET pages with

VB.NET (or C# or C++), and they are truly compiled for better performance.

VB.NET lets you create Windows services natively for the first time by providing a

Windows Services project type. And yes, VB.NET lets VB developers build truly

free-threaded components and applications for the first time.

Visual Basic.NET: A New Framework 5

02 2203-x CH01 5/1/01 12:53 PM Page 5

Finally, you need to realize that the new language is actually going to have a version

number on it, although the final name is undecided. It might well be called VB.NET

2002. This implies that at some point, there will be new versions of VB.NET, just as

there were new versions of VB. In this book, references to previous versions of VB

will be either VB or VB6. References to VB.NET 2002 will be just VB.NET.

You have decided you need to move from Visual Basic 6 to VB.NET, and you picked

up this book to find out about the changes. Yet, the first thing you see is a chapter

about the .NET Framework. Why start with the .NET Framework? The truth is that

you cannot understand VB.NET until you understand the .NET Framework. You see,

the .NET Framework and VB.NET are tightly intertwined; many of the services you

will build into your applications are actually provided by the .NET Framework and

are merely called into action by your application.

The .NET Framework is a collection of services and classes. It exists as a layer

between the applications you write and the underlying operating system. This is a

powerful concept: The .NET Framework need not be a Windows-only solution. The

.NET Framework could be moved to any operating system, meaning your .NET

applications could be run on any operating system hosting the .NET Framework. This

means that you could achieve true cross-platform capabilities simply by creating

VB.NET applications, provided the .NET Framework was available for other plat-

forms. Although this promise of cross-platform capability is a strong selling point to

.NET, there has not yet been any official announcement about .NET being moved to

other operating systems.

In addition, the .NET Framework is exciting because it encapsulates much of the

basic functionality that used to have to be built into various programming languages.

The .NET Framework has the code that makes Windows Forms work, so any lan-

guage can use the built-in code in order to create and use standard Windows forms.

In addition, Web Forms are part of the framework, so any .NET language could be

used to create Web Applications. Additionally, this means that various programming

elements will be the same across all languages; a Long data type will be the same

size in all .NET languages. This is even more important when it comes to strings and

arrays. No longer will you have to worry about whether or not a string is a BStr or a

CStr before you pass it to a component written in another language.

The Common Language Runtime

One of the major components of the .NET Framework is the Common Language

Runtime, or CLR. The CLR provides a number of benefits to the developer, such as

exception handling, security, debugging, and versioning, and these benefits are avail-

able to any language built for the CLR. This means that the CLR can host a variety

of languages, and can offer a common set of tools across those languages. Microsoft

6 Chapter 1: Why Should You Move to Visual Basic.NET?

02 2203-x CH01 5/1/01 12:53 PM Page 6

has made VB, C++, and C# ”premier” languages for the CLR, which means that

these three languages fully support the CLR. In addition, other vendors have signed

up to provide implementations of other languages, such as Perl, Python, and even

COBOL.

When a compiler compiles for the CLR, this code is said to be managed code.

Managed code is simply code that takes advantage of the services offered by the

CLR. For the runtime to work with managed code, that code must contain metadata.

This metadata is created during the compilation process by compilers targeting the

CLR. The metadata is stored with the compiled code and contains information about

the types, members, and references in the code. Among other things, the CLR uses

this metadata to

• Locate classes

• Load classes

• Generate native code

• Provide security

The runtime also handles object lifetimes. Just as COM/COM+ provided reference

counting for objects, the CLR manages references to objects and removes them from

memory when all the references are gone, through the process known as garbage col-

lection. Although garbage collection actually gives you slightly less control than you

had in VB, you gain some important benefits. For example, your errors should

decrease because the number of objects that end up hanging around due to circular

references should be reduced or completely eliminated. In addition, garbage collec-

tion ends up being much faster than the old way of destroying objects in VB.

Instances of objects you create that are managed by the runtime are called managed

data. You can interact with both managed and unmanaged data in the same applica-

tion, although managed data gives you all the benefits of the runtime.

The CLR defines a standard type system to be used by all CLR languages. This

means that all CLR languages will have the same size integers and longs, and they

will all have the same type of string—no more worrying about BStrs and CStrs! This

standard type system opens up the door for some powerful language interoperability.

For example, you can pass a reference of a class from one component to another,

even if those components are written in different languages. You also can derive a

class in C# from a base class written in VB.NET, or any other combination of lan-

guages targeted to the runtime. Don’t forget that COM had a set of standard types as

well, but they were binary standards. This meant that with COM, you had language

interoperability at run time. With .NET’s type standard, you have language interoper-

ability at design time.

The Common Language Runtime 7

02 2203-x CH01 5/1/01 12:53 PM Page 7

After it is compiled, managed code includes metadata, which contains information

about the component itself, and the components used to create the code. The runtime

can check to make sure that resources on which you depend are available. The meta-

data removes the need to store component information in the registry. That means

moving a component to a new machine does not require registration (unless it will be

a global assembly, which is described in Chapter 4, “Building Classes and

Assemblies with VB.NET”), and removing components is as simple as deleting them.

As you can see, the Common Language Runtime provides a number of benefits that are

not only new, but should enhance the experience of building applications. Other bene-

fits that you will see in more detail include some of the new object-oriented features to

VB.NET. Many of these new features are not so much additions to the language as they

are features of the runtime that are simply being exposed to the VB.NET.

Managed Execution

To understand how your VB.NET applications work, and just how much the code dif-

fers from the VB code that Dorothy wrote in Kansas, it’s important to understand

managed code and how it works. To use managed execution and get the benefits of

the CLR, you must use a language that was built for, or targets, the runtime.

Fortunately for you, this includes VB.NET. In fact, Microsoft wanted to make sure

that VB.NET was a premier language on the .NET platform, meaning that Visual

Basic could no longer be accused of being a “toy” language.

The runtime is a language-neutral environment, which means that any vendor can

create a language that takes advantage of the runtime’s features. Different compilers

can expose different amounts of the runtime to the developer, so the tool you use and

the language in which you write might still appear to work somewhat differently. The

syntax of each language is different, of course, but when the compilation process

occurs, all code should be compiled into something understandable to the runtime.

NOTE

Just because a language targets the runtime doesn’t mean that the language can’t

add features that are not understood by other languages. To make sure that your

components are completely usable by components written in other languages, you

must use only types that are specified by the Common Language Specification. The

Common Language Specification elements will be examined in Appendix A, “The

Common Language Specification.”

Microsoft Intermediate Language (MSIL)

One of the more interesting aspects of .NET is that when you compile your code, you

do not compile to native code. Before you VB developers panic and fear that you are

8 Chapter 1: Why Should You Move to Visual Basic.NET?

02 2203-x CH01 5/1/01 12:53 PM Page 8

剩余221页未读，继续阅读

sunnyyang4330123

粉丝: 0
资源: 3

VB 6.0到VB.NET转型指南：程序员入门

Visual Basic.NET程序员查询辞典

Sybex - Mastering Visual Basic .NET (VBL).pdf

Visual Basic 2012 Programmer's Reference VB2012程序员参考手册

MS VSUAL BASIC 6.0 PROGRAMMER`S GUIDE 程序员指南.WDL

A Programmer's Introduction to CSharp

A Programmer_s Introduction to C#.pdf

Professional Refactoring in C# & ASP.NET (Wrox Programmer to Programmer)

Exploring C++ The Programmer's Introduction to C++.

ASP.NET AJAX Programmer's Reference

Microsoft visual c++ 6.0 programmer's Guide 程序员指南

最新资源