Visual Basic .NET编程指南：从入门到.NET框架应用

需积分: 0 61 浏览量更新于2024-07-17 收藏 2.51MB PDF 举报

"《Programming Visual Basic .NET》是一本由Dave Grundgeiger所著，O'Reilly出版社于2002年1月首次出版的专业编程指南，旨在帮助读者全面了解Visual Basic .NET。该书恰好在Visual Basic Studio .NET的初次发布之际发行，内容涵盖了.NET框架与Visual Basic .NET的结合，包括了CLR（Common Language Runtime）、Windows Forms、ASP.NET、Web Forms、Web Services和ADO.NET等关键技术。在本书中，首先通过一个示例应用程序和对.NET架构的高屋建瓴的介绍，引导读者进入Visual Basic .NET的世界。第一章"Introduction"深入探讨了Microsoft .NET框架的本质，以及Visual Basic .NET的角色。1.1节解释了.NET框架作为跨平台的开发平台，它提供了统一的基础结构和服务，使得程序可以在多个操作系统上运行。1.2节则介绍了Visual Basic .NET，作为.NET框架中的一个重要语言，它以其易学性和灵活性而备受青睐。第二章"Visual Basic .NET Language"详细解析了编程语言的核心概念。章节中，作者阐述了源代码文件的组织、标识符的使用规则、关键字的作用、常量和变量的定义、数据类型、命名空间的管理、符号常量、变量作用域和访问修饰符等基础知识。此外，还涵盖了赋值操作、算术和逻辑运算、语句结构、类和对象、接口、结构体、枚举、异常处理、委托、事件、标准模块以及属性和条件编译等高级主题。对于初学者来说，这本书不仅提供了丰富的理论知识，还有实际项目示例，使读者能够快速掌握Visual Basic .NET的编程技巧。而对于已经熟悉VB的开发者，它则是一个深入了解.NET框架并提升技能的实用手册。无论是为了学习还是职业发展，这都是一本不可多得的参考资源。"

In Visual Basic 6, various program objects were defined by placing source code in files having various

filename extensions. For example, code that defined classes was placed in .cls files, code that defined

standard modules was placed in .bas files, and so on. In Visual Basic .NET, all source files have .vb

filename extensions, and program objects are defined with explicit syntax. For example, classes are

defined with the Class...End Class construct, and standard modules are defined with the

Module...End Module construct. Any particular .vb file can contain as many of these declarations

as desired.

The purpose of standard modules in Visual Basic 6 was to hold code that was outside of any class

definition. For example, global constants, global variables, and procedure libraries were often placed

in standard modules. Standard modules in Visual Basic .NET serve a similar purpose and can be used

in much the same way. However, in Visual Basic .NET they define datatypes that cannot be

instantiated and whose members are all static. This will be discussed in more detail in Chapter 2.

The next line in the example begins the definition of a subroutine named Main:

Public Sub Main( )

It ends with:

End Sub

This syntax is similar to Visual Basic 6. The Sub statement begins the definition of a subroutine -- a

method that has no return value.

The Main subroutine is the entry point for the application. When the Visual Basic .NET compiler is

invoked, it looks for a subroutine named Main in one of the classes or standard modules exposed by

the application. If Main is declared in a class rather than in a standard module, the subroutine must be

declared with the Shared modifier. This modifier indicates that the class does not need to be

instantiated for the subroutine to be invoked. In either case, the Main subroutine must be Public. An

example of enclosing the Main subroutine in a class rather than in a standard module is given at the

end of this section.

If no Main subroutine is found, or if more than one is found, a compiler error is generated. The

command-line compiler has a switch (/main:location) that allows you to specify which class or

standard module contains the Main subroutine that is to be used, in the case that there is more than

one.

Lastly, there's the line that does the work:

Console.WriteLine("hello, world")

This code invokes the Console class's WriteLine method, which outputs the argument to the console.

The WriteLine method is defined as a shared (also known as a static) method. Shared methods don't

require an object instance in order to be invoked; nonshared methods do. Shared methods are

invoked by qualifying them with their class name (in this case, Console).

Here is a program that uses a class instead of a standard module to house its Main subroutine. Note

that Main is declared with the Shared modifier. It is compiled and run in the same way as the

standard module example, and it produces the same output. There is no technical reason to choose

one implementation over the other.

Imports System

Public Class Hello

Public Shared Sub Main( )

Console.WriteLine("hello, world")

The next line declares a label control that will be used for displaying the text Hello, Windows:

Private lblHelloWindows As Label

The Label class is defined in the System.Windows.Forms namespace.

As is the case with console applications, GUI applications must have a shared subroutine called Main:

Public Shared Sub Main( )

Application.Run(New HelloWindows( ))

End Sub

This Main method creates an instance of the HelloWindows class and passes it to the Run method of

the Application class (defined in the System.Windows.Forms namespace). The Run method takes

care of the housekeeping of setting up a Windows message loop and hooking the HelloWindows form

into it.

Next is another special method:

Public Sub New( )

Like Main, New has special meaning to the Visual Basic .NET compiler. Subroutines named New are

compiled into constructors. A constructor is a method that has no return value (but can have

arguments) and is automatically called whenever a new object of the given type is instantiated.

Constructors are explained further in Chapter 2.

The constructor in the HelloWindows class instantiates a Label object, sets some of its properties, sets

some properties of the form, and then adds the Label object to the form's Controls collection. The

interesting thing to note is how different this is from how Visual Basic 6 represented form design. In

Visual Basic 6, form layout was represented by data in .frm files. This data was not code, but rather a

listing of the properties and values of the various elements on the form. In Visual Basic .NET, this

approach is gone. Instead, Visual Basic .NET statements must explicitly instantiate visual objects and

set their properties. When forms are designed in Visual Studio .NET using its drag-and-drop designer,

Visual Studio .NET creates this code on your behalf.

The command line to compile the Hello, Windows program is:

vbc HelloWindows.vb

/reference:System.dll,System.Drawing.dll,System.Windows.Forms.dll

/target:winexe

(Note that there is no break in this line.)

The command line for compiling the Hello, Windows program has more stuff in it than the one for the

console-based hello, world program. In addition to specifying the name of the .vb file, this command

line uses the /references switch to specify three .dlls that contain the implementations of library

classes used in the program (Form, Label, Point, etc.). The hello, world console application didn't

require references when being compiled because all it used was the Console class, defined in the

System namespace. The Visual Basic .NET command-line compiler includes two references implicitly:

mscorlib.dll (which contains the System namespace) and Microsoft.VisualBasic.dll (which contains

helper classes used for implementing some of the features of Visual Basic .NET).

Besides the /references switch, the command line for compiling the Hello, Windows program

includes the /target switch. The /target switch controls what kind of executable code file is

produced. The possible values of the /target switch are:

exe

<p>

<asp:button type="submit" id="btnBlack" text="Black"

OnClick="btnBlack_Click" runat="server"/>

<asp:button id="btnBlue" text="Blue"

OnClick="btnBlue_Click" runat="server"/>

<asp:button id="btnGreen" text="Green"

OnClick="btnGreen_Click" runat="server"/>

</p>

</form>

</body>

</html>

To run this program, enter it using a text editor and save it in a file named HelloBrowser.aspx.

Because the application is a web page that is meant to be delivered by a web server, it must be saved

onto a machine that is running IIS and has the .NET Framework installed. Set up a virtual folder in IIS

to point to the folder containing HelloBrowser.aspx. Finally, point a web browser to HelloBrowser.aspx.

The output of the Hello, Browser application is shown in Figure 1-3.

Figure 1-3. Hello, Browser!

Be sure to reference the file through the web server machine

name or localhost (if the web server is on your local machine), so

that the web server is invoked. For example, if the file is in a

virtual directory called Test on your local machine, point your

browser to http://localhost/Test/HelloBrowser.aspx. If you point

your browser directly to the file using a filesystem path, the web

server will not be invoked.

Going into detail on the Hello, Browser code would be too much for an introduction. However, I'd like

to draw your attention to the <asp:label> and <asp:button> tags. These tags represent server-

side controls. A server-side control is a class that is instantiated on the web server and generates

appropriate output to represent itself on the browser. These classes have rich, consistent sets of

properties and methods and can be referenced in code like controls on forms are referenced in GUI

applications.

ASP.NET has many other nifty features, some of which are:

• Web pages are compiled, resulting in far better performance over classic ASP.

• Code can be pulled out of web pages entirely and placed in .vb files (called code-behind files)

that are referenced by the web pages. This separation of web page layout from code results in

pages that are easier to develop and maintain.

剩余397页未读，继续阅读

drjiachen

粉丝: 172
资源: 2138

Visual Basic .NET编程指南：从入门到.NET框架应用

ZPL打印机编程指南：Visual Basic实现

"Visual Basic语言和算法翻译及文献综述PDF文件

深入探索Visual Basic.NET编程指南

Visual_Basic_NET_Programming_Sybex (VBL).pdf

Programming.in.Visual.Basic.2010

ZPL_ZHCN.rar_打印编程_Visual_Basic_

LabVIEW-.rar_LabView编程_Visual_Basic_

Visual Basic Programming.pdf

Microsoft_Excel_2013_Programming_by_Example_with_VBA，_XML_and_ASP.pdf

Computer Programming Concepts and Visual Basic.pdf

最新资源