VB.Net – 快速指南

VB.Net – 概述

Visual Basic .NET (VB.NET) 是一种在 .NET Framework 上实现的面向对象的计算机编程语言。虽然它是经典 Visual Basic 语言的演变，但它不向后兼容 VB6，并且任何用旧版本编写的代码都不能在 VB.NET 下编译。

与所有其他 .NET 语言一样，VB.NET 完全支持面向对象的概念。VB.NET 中的一切都是对象，包括所有原始类型（Short、Integer、Long、String、Boolean 等）和用户定义的类型、事件，甚至程序集。所有对象都继承自基类 Object。

VB.NET 是由微软的.NET 框架实现的。因此，它可以完全访问 .Net Framework 中的所有库。还可以在 Mono 上运行 VB.NET 程序，Mono 是 .NET 的开源替代品，不仅可以在 Windows 下运行，甚至可以在 Linux 或 Mac OSX 下运行。

以下原因使 VB.Net 成为广泛使用的专业语言 –

• 现代，通用。

• 面向对象。

• 面向组件。

• 简单易学。

• 结构化语言。

• 它产生高效的程序。

• 它可以在各种计算机平台上编译。

• .Net 框架的一部分。

强大的编程功能VB.Net

VB.Net 拥有众多强大的编程功能，深受全球众多程序员的喜爱。让我们提及其中一些功能 –

• 布尔条件

• 自动垃圾收集

• 标准库

• 程序集版本控制

• 属性和事件

• 代表和活动管理

• 易于使用的泛型

• 索引器

• 条件编译

• 简单的多线程

VB.Net – 环境设置

在本章中，我们将讨论可用于创建 VB.Net 应用程序的工具。

我们已经提到 VB.Net 是 .Net 框架的一部分，用于编写 .Net 应用程序。因此，在讨论运行 VB.Net 程序的可用工具之前，让我们了解 VB.Net 与 .Net 框架的关系。

.Net 框架

.Net 框架是一个革命性的平台，可帮助您编写以下类型的应用程序 –

• Windows 应用程序

• 网络应用程序

• 网页服务

.Net 框架应用程序是多平台应用程序。该框架的设计方式使其可以从以下任何一种语言中使用：Visual Basic、C#、C++、Jscript 和 COBOL 等。

所有这些语言都可以访问框架并相互通信。

.Net 框架由一个庞大的代码库组成，由客户端语言（如 VB.Net）使用。这些语言使用面向对象的方法。

以下是 .Net 框架的一些组件 –

• 公共语言运行时 (CLR)

• .Net 框架类库

• 通用语言规范

• 通用类型系统

• 元数据和程序集

• Windows 窗体

• ASP.Net 和 ASP.Net AJAX

• 网

• Windows 工作流基础 (WF)

• Windows 演示基础

• Windows 通信基础 (WCF)

• LINQ

对于每个组件执行的工作，请参阅ASP.Net – Introduction，有关每个组件的详细信息，请参阅 Microsoft 的文档。

用于 VB.Net 的集成开发环境 (IDE)

Microsoft 为 VB.Net 编程提供以下开发工具 –

• Visual Studio 2010 (VS)

• Visual Basic 2010 Express (VBE)

• 可视化网络开发人员

最后两个是免费的。使用这些工具，您可以编写从简单的命令行应用程序到更复杂的应用程序的各种 VB.Net 程序。Visual Basic Express 和 Visual Web Developer Express 版是 Visual Studio 的精简版，具有相同的外观和感觉。它们保留了 Visual Studio 的大部分功能。在本教程中，我们使用了 Visual Basic 2010 Express 和 Visual Web Developer（用于 Web 编程章节）。

你可以从这里下载。它会自动安装在您的机器中。请注意，您需要有效的互联网连接才能安装快速版。

在 Linux 或 Mac OS 上编写 VB.Net 程序

尽管 .NET Framework 在 Windows 操作系统上运行，但仍有一些替代版本可在其他操作系统上运行。Mono 是 .NET Framework 的一个开源版本，它包括一个 Visual Basic 编译器并在多种操作系统上运行，包括各种 Linux 和 Mac OS。最新版本是 VB 2012。

Mono 的既定目的不仅是能够跨平台运行 Microsoft .NET 应用程序，而且还为 Linux 开发人员带来更好的开发工具。Mono 可以在许多操作系统上运行，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。

VB.Net – 程序结构

在我们学习 VB.Net 编程语言的基本构建块之前，让我们先看一个最小的 VB.Net 程序结构，以便我们可以在接下来的章节中将其作为参考。

VB.Net Hello World 示例

VB.Net 程序基本上由以下部分组成 –

• 命名空间声明

• 一个类或模块

• 一项或多项程序

• 变量

• 主要程序

• 语句和表达式

• 评论

让我们看一个简单的代码，它会打印出“Hello World”字样 –

Imports System
Module Module1
   'This program will display Hello World 
   Sub Main()
      Console.WriteLine("Hello World")
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Hello, World!

让我们看看上述程序的各个部分 –

• 程序Imports System的第一行用于在程序中包含 System 命名空间。

• 下一行有一个模块声明，模块Module1。VB.Net 是完全面向对象的，因此每个程序都必须包含一个类的模块，该模块包含您的程序使用的数据和过程。

• 类或模块通常包含不止一个过程。过程包含可执行代码，或者换句话说，它们定义了类的行为。程序可以是以下任何一种 –

  • 功能

  • 子

  • 操作员

  • 得到

  • 放

  • 添加处理程序

  • 移除处理程序

  • 引发事件

• 下一行 (‘This program) 将被编译器忽略，并已在程序中添加附加注释。

• 下一行定义了 Main 过程，它是所有 VB.Net 程序的入口点。Main 过程说明模块或类在执行时将执行的操作。

• Main 过程用语句指定其行为

  Console.WriteLine(“Hello World”) WriteLine是System命名空间中定义的Console类的方法。此语句导致消息“Hello, World！” 以显示在屏幕上。

• 最后一行Console.ReadKey()是针对 VS.NET 用户的。当程序从 Visual Studio .NET 启动时，这将防止屏幕快速运行和关闭。

编译执行VB.Net程序

如果您使用的是 Visual Studio.Net IDE，请执行以下步骤 –

• 启动 Visual Studio。

• 在菜单栏上，选择文件 → 新建 → 项目。

• 从模板中选择 Visual Basic

• 选择控制台应用程序。

• 使用“浏览”按钮为您的项目指定名称和位置，然后选择“确定”按钮。

• 新项目出现在解决方案资源管理器中。

• 在代码编辑器中编写代码。

• 单击运行按钮或 F5 键以运行项目。将出现一个命令提示符窗口，其中包含一行 Hello World。

您可以使用命令行而不是 Visual Studio IDE 来编译 VB.Net 程序 –

• 打开文本编辑器并添加上述代码。

• 将文件另存为helloworld.vb

• 打开命令提示符工具并转到保存文件的目录。

• 键入VBC helloworld.vb，然后按回车编译代码。

• 如果您的代码中没有错误，命令提示符会将您带到下一行并生成helloworld.exe可执行文件。

• 接下来，输入helloworld来执行你的程序。

• 您将能够在屏幕上看到“Hello World”。

VB.Net – 基本语法

VB.Net 是一种面向对象的编程语言。在面向对象的编程方法中，程序由通过动作相互交互的各种对象组成。对象可能采取的操作称为方法。相同种类的对象被称为具有相同的类型，或者更常见的是，被称为在同一类中。

当我们考虑 VB.Net 程序时，它可以定义为通过调用彼此的方法进行通信的对象的集合。现在让我们简要地看看类、对象、方法和实例变量的含义。

• 对象– 对象具有状态和行为。例子：一只狗有状态——颜色、名字、品种以及行为——摇摆、吠叫、吃东西等。一个对象是一个类的实例。

• 类– 类可以定义为模板/蓝图，描述其类型的对象支持的行为/状态。

• 方法– 方法基本上是一种行为。一个类可以包含许多方法。在方法中编写逻辑、操作数据并执行所有操作。

• 实例变量– 每个对象都有其独特的实例变量集。对象的状态由分配给这些实例变量的值创建。

VB.Net 中的矩形类

例如，让我们考虑一个 Rectangle 对象。它具有长度和宽度等属性。根据设计，它可能需要接受这些属性的值、计算面积和显示细节的方法。

让我们看一下 Rectangle 类的实现，并根据我们在其中的观察来讨论 VB.Net 基本语法 –

Imports System
Public Class Rectangle
   Private length As Double
   Private width As Double

   'Public methods
   Public Sub AcceptDetails()
      length = 4.5
      width = 3.5
   End Sub

   Public Function GetArea() As Double
      GetArea = length * width
   End Function
   Public Sub Display()
      Console.WriteLine("Length: {0}", length)
      Console.WriteLine("Width: {0}", width)
      Console.WriteLine("Area: {0}", GetArea())

   End Sub

   Shared Sub Main()
      Dim r As New Rectangle()
      r.Acceptdetails()
      r.Display()
      Console.ReadLine()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Length: 4.5
Width: 3.5
Area: 15.75

在上一章中，我们创建了一个包含代码的 Visual Basic 模块。Sub Main 表示VB.Net 程序的入口点。在这里，我们使用包含代码和数据的类。您使用类来创建对象。例如，在代码中，r 是一个 Rectangle 对象。

对象是类的实例 –

Dim r As New Rectangle()

一个类可能有可以从外部类访问的成员，如果这样指定的话。数据成员称为字段，过程成员称为方法。

可以在不创建类的对象的情况下调用共享方法或静态方法。实例方法通过类的对象调用 –

Shared Sub Main()
   Dim r As New Rectangle()
   r.Acceptdetails()
   r.Display()
   Console.ReadLine()
End Sub

身份标识

标识符是用于标识类、变量、函数或任何其他用户定义项的名称。在 VB.Net 中命名类的基本规则如下 –

• 名称必须以字母开头，后面可以跟一系列字母、数字 (0 – 9) 或下划线。标识符中的第一个字符不能是数字。

• 它不能包含任何嵌入的空格或符号，如？– +！@#% ^ & * ( ) [ ] { } 。; :” ‘ / 和 \。但是，可以使用下划线 ( _ )。

• 它不应该是保留关键字。

VB.Net 关键词

下表列出了 VB.Net 保留关键字 –

VB.Net – 数据类型

数据类型是指用于声明不同类型的变量或函数的扩展系统。变量的类型决定了它在存储中占用多少空间以及如何解释存储的位模式。

VB.Net 中可用的数据类型

VB.Net 提供了广泛的数据类型。下表显示了所有可用的数据类型 –

例子

以下示例演示了某些类型的使用 –

Module DataTypes
   Sub Main()
      Dim b As Byte
      Dim n As Integer
      Dim si As Single
      Dim d As Double
      Dim da As Date
      Dim c As Char
      Dim s As String
      Dim bl As Boolean
      
      b = 1
      n = 1234567
      si = 0.12345678901234566
      d = 0.12345678901234566
      da = Today
      c = "U"c
      s = "Me"
      
      If ScriptEngine = "VB" Then
         bl = True
      Else
         bl = False
      End If
      
      If bl Then
         'the oath taking
         Console.Write(c & " and," & s & vbCrLf)
         Console.WriteLine("declaring on the day of: {0}", da)
         Console.WriteLine("We will learn VB.Net seriously")
         Console.WriteLine("Lets see what happens to the floating point variables:")
         Console.WriteLine("The Single: {0}, The Double: {1}", si, d)
      End If
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

U and, Me
declaring on the day of: 12/4/2012 12:00:00 PM
We will learn VB.Net seriously
Lets see what happens to the floating point variables:
The Single:0.1234568, The Double: 0.123456789012346

VB.Net 中的类型转换函数

VB.Net 提供以下内联类型转换功能 –

例子

以下示例演示了其中一些功能 –

Module DataTypes
   Sub Main()
      Dim n As Integer
      Dim da As Date
      Dim bl As Boolean = True
      n = 1234567
      da = Today
      
      Console.WriteLine(bl)
      Console.WriteLine(CSByte(bl))
      Console.WriteLine(CStr(bl))
      Console.WriteLine(CStr(da))
      Console.WriteLine(CChar(CChar(CStr(n))))
      Console.WriteLine(CChar(CStr(da)))
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

True
-1
True
12/4/2012
1
1

VB.Net – 变量

变量只不过是给我们的程序可以操作的存储区域的名称。VB.Net 中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局；可以存储在该内存中的值范围；以及可以应用于变量的一组操作。

我们已经讨论了各种数据类型。VB.Net 中提供的基本值类型可以归类为 –

VB.Net 还允许定义其他值类型的变量（如Enum ）和变量的引用类型（如Class ）。我们将在后续章节中讨论日期类型和类。

VB.Net 中的变量声明

在昏暗的语句用于变量声明和存储分配的一个或多个变量。Dim 语句用于模块、类、结构、过程或块级别。

VB.Net 中变量声明的语法是 –

[ < attributelist > ] [ accessmodifier ] [[ Shared ] [ Shadows ] | [ Static ]]
[ ReadOnly ] Dim [ WithEvents ] variablelist

在哪里，

• attributelist是应用于变量的属性列表。可选的。

• accessmodifier定义了变量的访问级别，它的值有 – Public、Protected、Friend、Protected Friend 和 Private。可选的。

• Shared声明了一个共享变量，它不与类或结构的任何特定实例相关联，而是可用于类或结构的所有实例。可选的。

• 阴影表示该变量在基类中重新声明并隐藏了同名元素或重载元素集。可选的。

• 静态表示该变量将保留其值，即使在声明它的过程终止后也是如此。可选的。

• ReadOnly表示该变量可以读取，但不能写入。可选的。

• WithEvents指定该变量用于响应由分配给该变量的实例引发的事件。可选的。

• Variablelist提供声明的变量列表。

变量列表中的每个变量都具有以下语法和部分 –

variablename[ ( [ boundslist ] ) ] [ As [ New ] datatype ] [ = initializer ]

在哪里，

• variablename – 是变量的名称

• 边界列表– 可选。它提供数组变量每个维度的边界列表。

• 新– 可选。当 Dim 语句运行时，它会创建该类的一个新实例。

• 数据类型– 如果 Option Strict 为 On，则为必需。它指定变量的数据类型。

• 初始值设定项– 如果未指定 New 则可选。创建时计算并分配给变量的表达式。

此处显示了一些有效的变量声明及其定义 –

Dim StudentID As Integer
Dim StudentName As String
Dim Salary As Double
Dim count1, count2 As Integer
Dim status As Boolean
Dim exitButton As New System.Windows.Forms.Button
Dim lastTime, nextTime As Date

VB.Net中的变量初始化

变量用等号和常量表达式初始化（​​赋值）。初始化的一般形式是 –

variable_name = value;

例如，

Dim pi As Double
pi = 3.14159

您可以在声明时初始化一个变量，如下所示 –

Dim StudentID As Integer = 100
Dim StudentName As String = "Bill Smith"

例子

尝试以下使用各种类型变量的示例 –

Module variablesNdataypes
   Sub Main()
      Dim a As Short
      Dim b As Integer
      Dim c As Double
      
      a = 10
      b = 20
      c = a + b
      Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

a = 10, b = 20, c = 30

接受用户的价值

System 命名空间中的 Console 类提供了一个函数ReadLine，用于接受来自用户的输入并将其存储到变量中。例如，

Dim message As String
message = Console.ReadLine

以下示例演示了它 –

Module variablesNdataypes
   Sub Main()
      Dim message As String
      Console.Write("Enter message: ")
      message = Console.ReadLine
      Console.WriteLine()
      Console.WriteLine("Your Message: {0}", message)
      Console.ReadLine()
   End Sub
End Module

编译并执行上述代码时，会产生以下结果（假设用户输入 Hello World） –

Enter message: Hello World   
Your Message: Hello World

左值和右值

有两种表达方式 –

• lvalue – 作为左值的表达式可能出现在赋值的左侧或右侧。

• rvalue –右值表达式可能出现在赋值的右侧，但不会出现在左侧。

变量是左值，因此可能出现在赋值的左侧。数字文字是右值，因此可能不会被赋值，也不会出现在左侧。以下是一个有效的声明 –

Dim g As Integer = 20

但以下不是一个有效的语句，会产生编译时错误 –

20 = g

VB.Net – 常量和枚举

所述常量是指固定值，该程序可能无法在其执行期间改变。这些固定值也称为文字。

常量可以是任何基本数据类型，如整数常量、浮点常量、字符常量或字符串文字。还有枚举常量。

除了它们的值在定义后不能修改之外，常量被视为常规变量。

一个枚举是一组命名的整型常量。

声明常量

在 VB.Net 中，常量是使用Const语句声明的。Const 语句用于模块、类、结构、过程或块级别以代替文字值。

Const 语句的语法是 –

[ < attributelist > ] [ accessmodifier ] [ Shadows ] 
Const constantlist

在哪里，

• attributelist – 指定应用于常量的属性列表；您可以提供多个以逗号分隔的属性。可选的。

• accessmodifier – 指定哪些代码可以访问这些常量。可选的。值可以是以下之一：Public、Protected、Friend、Protected Friend 或 Private。

• Shadows – 这使得常量在基类中隐藏同名的编程元素。可选的。

• Constantlist – 给出声明的常量名称列表。必需的。

其中，每个常量名称具有以下语法和部分 –

constantname [ As datatype ] = initializer

• constantname – 指定常量的名称

• datatype – 指定常量的数据类型

• 初始值设定项 – 指定分配给常量的值

例如，

'The following statements declare constants.'
Const maxval As Long = 4999
Public Const message As String = "HELLO" 
Private Const piValue As Double = 3.1415

例子

以下示例演示了常量值的声明和使用 –

Module constantsNenum
   Sub Main()
      Const PI = 3.14149
      Dim radius, area As Single
      radius = 7
      area = PI * radius * radius
      Console.WriteLine("Area = " & Str(area))
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Area = 153.933

在 VB.Net 中打印和显示常量

VB.Net 提供以下打印和显示常量 –

声明枚举

枚举类型是使用Enum语句声明的。Enum 语句声明一个枚举并定义其成员的值。Enum 语句可用于模块、类、结构、过程或块级别。

Enum 语句的语法如下 –

[ < attributelist > ] [ accessmodifier ]  [ Shadows ] 
Enum enumerationname [ As datatype ] 
   memberlist
End Enum

在哪里，

• attributelist – 指应用于变量的属性列表。可选的。

• accessmodifier – 指定哪些代码可以访问这些枚举。可选的。值可以是以下之一：Public、Protected、Friend 或 Private。

• Shadows – 这使得枚举在基类中隐藏了相同名称的编程元素。可选的。

• enumerationname –枚举的名称。必需的

• datatype – 指定枚举及其所有成员的数据类型。

• memberlist – 指定在此语句中声明的成员常量列表。必需的。

memberlist 中的每个成员都具有以下语法和部分：

[< attribute list >] member name [ = initializer ]

在哪里，

• name – 指定成员的名称。必需的。

• 初始值设定项 – 分配给枚举成员的值。可选的。

例如，

Enum Colors
   red = 1
   orange = 2
   yellow = 3
   green = 4
   azure = 5
   blue = 6
   violet = 7
End Enum

例子

以下示例演示了 Enum 变量Colors 的声明和使用–

Module constantsNenum
   Enum Colors
      red = 1
      orange = 2
      yellow = 3
      green = 4
      azure = 5
      blue = 6
      violet = 7
   End Enum
   
   Sub Main()
      Console.WriteLine("The Color Red is : " & Colors.red)
      Console.WriteLine("The Color Yellow is : " & Colors.yellow)
      Console.WriteLine("The Color Blue is : " & Colors.blue)
      Console.WriteLine("The Color Green is : " & Colors.green)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

The Color Red is: 1
The Color Yellow is: 3
The Color Blue is: 6
The Color Green is: 4

VB.Net – 修饰符

修饰符是与任何编程元素一起添加的关键字，以特别强调编程元素在程序中的行为或访问方式。

例如，访问修饰符：Public、Private、Protected、Friend、Protected Friend 等，表示变量、常量、枚举或类等编程元素的访问级别。

VB.Net 中可用的修饰符列表

下表提供了 VB.Net 修饰符的完整列表 –

VB.Net – 语句

一个说法是在Visual Basic程序的完整指令。它可能包含关键字、运算符、变量、文字值、常量和表达式。

陈述可以归类为 –

• 声明语句– 这些是您命名变量、常量或过程的语句，也可以指定数据类型。

• 可执行语句– 这些是启动操作的语句。这些语句可以调用方法或函数、循环或通过代码块进行分支，或者将值或表达式分配给变量或常量。在最后一种情况下，它被称为赋值语句。

声明声明

声明语句用于命名和定义过程、变量、属性、数组和常量。声明编程元素时，还可以定义其数据类型、访问级别和范围。

您可以声明的编程元素包括变量、常量、枚举、类、结构、模块、接口、过程、过程参数、函数返回、外部过程引用、运算符、属性、事件和委托。

以下是 VB.Net 中的声明语句 –

Dim number As Integer
Dim quantity As Integer = 100
Dim message As String = "Hello!"

Const maximum As Long = 1000
Const naturalLogBase As Object 
= CDec(2.7182818284)

Enum CoffeeMugSize
   Jumbo
   ExtraLarge
   Large
   Medium
   Small
End Enum 

Class Box
Public length As Double
Public breadth As Double   
Public height As Double
End Class

Structure Box
Public length As Double           
Public breadth As Double   
Public height As Double
End Structure

Public Module myModule
Sub Main()
Dim user As String = 
InputBox("What is your name?") 
MsgBox("User name is" & user)
End Sub 
End Module

Public Interface MyInterface
   Sub doSomething()
End Interface 

Function myFunction
(ByVal n As Integer) As Double 
   Return 5.87 * n
End Function

Sub mySub(ByVal s As String)
   Return
End Sub 

Declare Function getUserName
Lib "advapi32.dll" 
Alias "GetUserNameA" 
(
   ByVal lpBuffer As String, 
   ByRef nSize As Integer) As Integer 

Public Shared Operator +
(ByVal x As obj, ByVal y As obj) As obj
   Dim r As New obj
' implemention code for r = x + y
   Return r
End Operator 

ReadOnly Property quote() As String 
   Get 
      Return quoteString
   End Get 
End Property

Public Event Finished()

Delegate Function MathOperator( 
   ByVal x As Double, 
   ByVal y As Double 
) As Double 

可执行语句

一个可执行语句执行一个动作。调用过程、分支到代码中的另一个位置、循环访问多个语句或计算表达式的语句都是可执行语句。赋值语句是可执行语句的特例。

例子

以下示例演示了决策声明 –

Module decisions
   Sub Main()
      'local variable definition '
      Dim a As Integer = 10

      ' check the boolean condition using if statement '
      If (a < 20) Then
         ' if condition is true then print the following '
         Console.WriteLine("a is less than 20")
      End If
      Console.WriteLine("value of a is : {0}", a)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

a is less than 20;
value of a is : 10

VB.Net – 指令

VB.Net 编译器指令向编译器提供指令以在实际编译开始之前对信息进行预处理。所有这些指令都以 # 开头，并且在一行中的指令之前只能出现空白字符。这些指令不是语句。

VB.Net 编译器没有单独的预处理器；然而，指令的处理就像有一个指令一样。在 VB.Net 中，编译器指令用于帮助条件编译。与 C 和 C++ 指令不同，它们不用于创建宏。

VB.Net 中的编译器指令

VB.Net 提供以下一组编译器指令 –

• #Const 指令

• #ExternalSource 指令

• #If…Then…#Else 指令

• #Region 指令

#Const 指令

该指令定义了条件编译器常量。该指令的语法是 –

#Const constname = expression

在哪里，

• constname – 指定常量的名称。必需的。

• 表达式– 它可以是文字或其他条件编译器常量，也可以是包括除Is之外的任何或所有算术或逻辑运算符的组合。

例如，

#Const state = "WEST BENGAL"

例子

以下代码演示了该指令的假设用法 –

Module mydirectives
#Const age = True
Sub Main()
   #If age Then
      Console.WriteLine("You are welcome to the Robotics Club")
   #End If
   Console.ReadKey()
End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

You are welcome to the Robotics Club

#ExternalSource 指令

该指令用于指示特定源代码行与源外部文本之间的映射。它仅供编译器使用，调试器对代码编译没有影响。

该指令允许将外部代码文件中的外部代码包含到源代码文件中。

该指令的语法是 –

#ExternalSource( StringLiteral , IntLiteral )
   [ LogicalLine ]
#End ExternalSource

#ExternalSource 指令的参数是外部文件的路径、第一行的行号和发生错误的行。

例子

以下代码演示了该指令的假设用法 –

Module mydirectives
   Public Class ExternalSourceTester

      Sub TestExternalSource()

      #ExternalSource("c:\vbprogs\directives.vb", 5)
         Console.WriteLine("This is External Code. ")
      #End ExternalSource

      End Sub
   End Class

   Sub Main()
      Dim t As New ExternalSourceTester()
      t.TestExternalSource()
      Console.WriteLine("In Main.")
      Console.ReadKey()

   End Sub

当上面的代码被编译和执行时，它会产生以下结果 –

This is External Code.
In Main.

#If…Then…#Else 指令

该指令有条件地编译所选的 Visual Basic 代码块。

该指令的语法是 –

#If expression Then
   statements
[ #ElseIf expression Then
   [ statements ]
...
#ElseIf expression Then
   [ statements ] ]
[ #Else
   [ statements ] ]
#End If

例如，

#Const TargetOS = "Linux"
#If TargetOS = "Windows 7" Then
   ' Windows 7 specific code
#ElseIf TargetOS = "WinXP" Then
   ' Windows XP specific code
#Else
   ' Code for other OS
#End if

例子

以下代码演示了该指令的假设用法 –

Module mydirectives
#Const classCode = 8

   Sub Main()
   #If classCode = 7 Then
      Console.WriteLine("Exam Questions for Class VII")
   #ElseIf classCode = 8 Then
      Console.WriteLine("Exam Questions for Class VIII")
   #Else
      Console.WriteLine("Exam Questions for Higher Classes")
   #End If
      Console.ReadKey()

   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Exam Questions for Class VIII

#Region 指令

该指令有助于折叠和隐藏 Visual Basic 文件中的代码段。

该指令的语法是 –

#Region "identifier_string" 
#End Region

例如，

#Region "StatsFunctions" 
   ' Insert code for the Statistical functions here.
#End Region

VB.Net – 运营商

运算符是一个符号，它告诉编译器执行特定的数学或逻辑操作。VB.Net 内置丰富的运算符，并提供以下常用运算符类型 –

• 算术运算符

• 比较运算符

• 逻辑/位运算符

• 位移运算符

• 赋值运算符

• 杂项运算符

本教程将解释最常用的运算符。

算术运算符

下表显示了 VB.Net 支持的所有算术运算符。假设变量A 为2，变量B 为7，然后 –

显示示例

比较运算符

下表显示了 VB.Net 支持的所有比较运算符。假设变量A 为10，变量B 为20，然后 –

显示示例

除了上述之外，VB.Net 还提供了另外三个比较运算符，我们将在接下来的章节中使用它们；但是，我们在此进行简要说明。

• Is Operator – 它比较两个对象引用变量并确定两个对象引用是否引用同一个对象而不执行值比较。如果 object1 和 object2 都引用完全相同的对象实例，则结果为True；否则，结果为假。

• IsNot Operator – 它还比较两个对象引用变量并确定两个对象引用是否引用不同的对象。如果 object1 和 object2 都引用完全相同的对象实例，则结果为False；否则，结果为真。

• Like Operator – 将字符串与模式进行比较。

逻辑/位运算符

下表显示了 VB.Net 支持的所有逻辑运算符。假设变量 A 保存布尔值 True，变量 B 保存布尔值 False，然后 –

显示示例

位移运算符

我们已经讨论了按位运算符。移位运算符对二进制值执行移位操作。在进入移位运算符之前，让我们了解位操作。

按位运算符处理位并执行逐位运算。&、| 和 ^ 的真值表如下 –

假设如果 A = 60; B = 13；现在以二进制格式，它们将如下 –

A = 0011 1100

乙 = 0000 1101

—————–

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

我们已经看到，VB.Net 支持的 Bitwise 运算符是 And、Or、Xor 和 Not。位移运算符是 >> 和 << 分别用于左移和右移。

假设变量 A 为 60，变量 B 为 13，然后 –

显示示例

赋值运算符

VB.Net 支持以下赋值运算符 –

显示示例

杂项运算符

VB.Net 支持的其他重要运算符很少。

显示示例

AddHandler Button1.Click,
AddressOf Button1_Click

 
Dim result As res
= Await AsyncMethodThatReturnsResult()
Await AsyncMethod()

MsgBox(GetType(Integer).ToString())

Dim add5 = Function(num As
   Integer) num + 5
'prints 10
Console.WriteLine(add5(5))

Dim num = 5
Console.WriteLine(If(num >= 0,
"Positive", "Negative"))

VB.Net 中的运算符优先级

运算符优先级确定表达式中术语的分组。这会影响表达式的计算方式。某些运算符的优先级高于其他运算符；例如，乘法运算符的优先级高于加法运算符 –

例如，x = 7 + 3 * 2；在这里，x 被赋值为 13，而不是 20，因为运算符 * 的优先级高于 +，所以它首先乘以 3*2，然后加到 7。

在这里，具有最高优先级的运算符出现在表格的顶部，具有最低优先级的运算符出现在底部。在表达式中，优先级更高的运算符将首先被评估。

显示示例

VB.Net – 决策

决策结构要求程序员指定要由程序评估或测试的一个或多个条件，以及如果确定条件为真则要执行的一条或多条语句，以及可选地，如果条件成立则要执行的其他语句确定为假。

以下是在大多数编程语言中发现的典型决策结构的一般形式 –

VB.Net 提供以下类型的决策声明。单击以下链接以查看其详细信息。

VB.Net – 循环

可能存在需要多次执行代码块的情况。通常，语句是按顺序执行的：首先执行函数中的第一条语句，然后是第二条，依此类推。

编程语言提供了允许更复杂的执行路径的各种控制结构。

循环语句允许我们多次执行一个语句或一组语句，以下是大多数编程语言中循环语句的一般形式 –

VB.Net 提供以下类型的循环来处理循环需求。单击以下链接以查看其详细信息。

循环控制语句

循环控制语句改变其正常顺序的执行。当执行离开范围时，在该范围内创建的所有自动对象都将被销毁。

VB.Net 提供了以下控制语句。单击以下链接以查看其详细信息。

VB.Net – 字符串

在 VB.Net 中，您可以使用字符串作为字符数组，但是，更常见的做法是使用 String 关键字来声明字符串变量。string 关键字是System.String类的别名。

创建字符串对象

您可以使用以下方法之一创建字符串对象 –

• 通过将字符串文字分配给 String 变量

• 通过使用 String 类构造函数

• 通过使用字符串连接运算符 (+)

• 通过检索属性或调用返回字符串的方法

• 通过调用格式化方法将值或对象转换为其字符串表示

以下示例演示了这一点 –

Module strings
   Sub Main()
      Dim fname, lname, fullname, greetings As String
      fname = "Rowan"
      lname = "Atkinson"
      fullname = fname + " " + lname
      Console.WriteLine("Full Name: {0}", fullname)

      'by using string constructor
      Dim letters As Char() = {"H", "e", "l", "l", "o"}
      greetings = New String(letters)
      Console.WriteLine("Greetings: {0}", greetings)

      'methods returning String
      Dim sarray() As String = {"Hello", "From", "Tutorials", "Point"}
      Dim message As String = String.Join(" ", sarray)
      Console.WriteLine("Message: {0}", message)

      'formatting method to convert a value 
      Dim waiting As DateTime = New DateTime(2012, 12, 12, 17, 58, 1)
      Dim chat As String = String.Format("Message sent at {0:t} on {0:D}", waiting)
      Console.WriteLine("Message: {0}", chat)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Full Name: Rowan Atkinson
Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 5:58 PM on Wednesday, December 12, 2012

字符串类的属性

String 类具有以下两个属性 –

String 类的方法

String 类有许多方法可以帮助您处理字符串对象。下表提供了一些最常用的方法 –

上面的方法列表并不详尽，请访问 MSDN 库以获取完整的方法列表和 String 类构造函数。

例子

以下示例演示了上面提到的一些方法 –

比较字符串

Module strings
   Sub Main()
      Dim str1, str2 As String
      str1 = "This is test"
      str2 = "This is text"
      
      If (String.Compare(str1, str2) = 0) Then
         Console.WriteLine(str1 + " and " + str2 + " are equal.")
      Else
         Console.WriteLine(str1 + " and " + str2 + " are not equal.")
      End If
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

This is test and This is text are not equal.

字符串包含字符串

Module strings
   Sub Main()
      Dim str1 As String
      str1 = "This is test"
      
      If (str1.Contains("test")) Then
         Console.WriteLine("The sequence 'test' was found.")
      End If
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

The sequence 'test' was found.

获取子串：

Module strings
   Sub Main()
      Dim str As String
      str = "Last night I dreamt of San Pedro"
      Console.WriteLine(str)
      
      Dim substr As String = str.Substring(23)
      Console.WriteLine(substr)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Last night I dreamt of San Pedro
San Pedro.

连接字符串

Module strings
   Sub Main()
      Dim strarray As String() = {
         "Down the way where the nights are gay",
         "And the sun shines daily on the mountain top",
         "I took a trip on a sailing ship",
         "And when I reached Jamaica",
         "I made a stop"
      }
      Dim str As String = String.Join(vbCrLf, strarray)
      Console.WriteLine(str)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Down the way where the nights are gay
And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

VB.Net – 日期和时间

您编写的大多数软件都需要实现某种形式的返回当前日期和时间的日期函数。日期是日常生活的重要组成部分，因此无需思考就可以轻松地与它们一起工作。VB.Net 还提供了强大的日期算术工具，使操作日期变得容易。

的日期数据类型包含日期值，时间值或日期和时间值。Date 的默认值是 0001 年 1 月 1 日的 0:00:00（午夜）。等效的 .NET 数据类型是System.DateTime。

的日期时间的结构表示的时间瞬间，通常表示为一个日期和一天中的时间

'Declaration
<SerializableAttribute> _
Public Structure DateTime _
   Implements IComparable, IFormattable, IConvertible, ISerializable,  
   IComparable(Of DateTime), IEquatable(Of DateTime)

您还可以从 DateAndTime 类中获取当前日期和时间。

该DateAndTime模块包含日期和时间的操作使用的程序和属性。

'Declaration
<StandardModuleAttribute> _
Public NotInheritable Class DateAndTime

DateTime 结构的属性和方法

下表列出了DateTime结构的一些常用属性–

下表列出了DateTime结构的一些常用方法–

上面的方法列表并不详尽，请访问Microsoft 文档以获取 DateTime 结构的方法和属性的完整列表。

创建日期时间对象

您可以通过以下方式之一创建 DateTime 对象 –

• 通过从任何重载的 DateTime 构造函数调用 DateTime 构造函数。

• 通过为 DateTime 对象分配一个由属性或方法返回的日期和时间值。

• 通过解析日期和时间值的字符串表示。

• 通过调用 DateTime 结构的隐式默认构造函数。

以下示例演示了这一点 –

Module Module1
   Sub Main()
      'DateTime constructor: parameters year, month, day, hour, min, sec
      Dim date1 As New Date(2012, 12, 16, 12, 0, 0)
      'initializes a new DateTime value
      Dim date2 As Date = #12/16/2012 12:00:52 AM#
      'using properties
      Dim date3 As Date = Date.Now
      Dim date4 As Date = Date.UtcNow
      Dim date5 As Date = Date.Today
      
      Console.WriteLine(date1)
      Console.WriteLine(date2)
      Console.WriteLine(date3)
      Console.WriteLine(date4)
      Console.WriteLine(date5)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

12/16/2012 12:00:00 PM
12/16/2012 12:00:52 PM
12/12/2012 10:22:50 PM
12/12/2012 12:00:00 PM

获取当前日期和时间

以下程序演示了如何在 VB.Net 中获取当前日期和时间 –

模块日期时间
   子主（）
      Console.Write("当前时间：")
      Console.WriteLine(Now.ToLongTimeString)
      Console.ReadKey()
   结束子
终端模块

当上面的代码被编译和执行时，它会产生以下结果 –

Current Time: 11 :05 :32 AM

当前日期 –

Module dateNtime
   Sub Main()
      Console.WriteLine("Current Date: ")
      Dim dt As Date = Today
      Console.WriteLine("Today is: {0}", dt)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Today is: 12/11/2012 12:00:00 AM

格式化日期

日期文字应包含在井号 (##) 内，并以 M/d/yyyy 格式指定，例如 #12/16/2012#。否则，您的代码可能会根据您的应用程序运行所在的区域设置而改变。

例如，您为 2012 年 2 月 6 日的日期指定了 #2/6/2012# 的日期文字。对于使用 mm/dd/yyyy 格式的语言环境来说是可以的。但是，在使用 dd/mm/yyyy 格式的语言环境中，您的文字将编译为 2012 年 6 月 2 日。如果语言环境使用另一种格式，例如 yyyy/mm/dd，文字将无效并导致编译器错误。

要将日期文字转换为您的语言环境格式或自定义格式，请使用String 类的Format函数，指定预定义或用户定义的日期格式。

以下示例演示了这一点。

Module dateNtime
   Sub Main()
      Console.WriteLine("India Wins Freedom: ")
      Dim independenceDay As New Date(1947, 8, 15, 0, 0, 0)
      ' Use format specifiers to control the date display.
      Console.WriteLine(" Format 'd:' " & independenceDay.ToString("d"))
      Console.WriteLine(" Format 'D:' " & independenceDay.ToString("D"))
      Console.WriteLine(" Format 't:' " & independenceDay.ToString("t"))
      Console.WriteLine(" Format 'T:' " & independenceDay.ToString("T"))
      Console.WriteLine(" Format 'f:' " & independenceDay.ToString("f"))
      Console.WriteLine(" Format 'F:' " & independenceDay.ToString("F"))
      Console.WriteLine(" Format 'g:' " & independenceDay.ToString("g"))
      Console.WriteLine(" Format 'G:' " & independenceDay.ToString("G"))
      Console.WriteLine(" Format 'M:' " & independenceDay.ToString("M"))
      Console.WriteLine(" Format 'R:' " & independenceDay.ToString("R"))
      Console.WriteLine(" Format 'y:' " & independenceDay.ToString("y"))
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

India Wins Freedom:
Format 'd:' 8/15/1947
Format 'D:' Friday, August 15, 1947
Format 't:' 12:00 AM
Format 'T:' 12:00:00 AM
Format 'f:' Friday, August 15, 1947 12:00 AM
Format 'F:' Friday, August 15, 1947 12:00:00 AM
Format 'g:' 8/15/1947 12:00 AM
Format 'G:' 8/15/1947 12:00:00 AM
Format 'M:' 8/15/1947 August 15
Format 'R:' Fri, 15 August 1947 00:00:00 GMT
Format 'y:' August, 1947

预定义的日期/时间格式

下表标识了预定义的日期和时间格式名称。这些可以按名称用作Format函数的样式参数–

对于其他格式（如用户定义格式），请参阅Microsoft 文档。

DateAndTime 类的属性和方法

下表列出了DateAndTime类的一些常用属性–

下表列出了DateAndTime类的一些常用方法–

上面的列表并不详尽。有关 DateAndTime 类的属性和方法的完整列表，请参阅Microsoft 文档。

以下程序演示了其中的一些和方法 –

Module Module1
   Sub Main()
      Dim birthday As Date
      Dim bday As Integer
      Dim month As Integer
      Dim monthname As String
      ' Assign a date using standard short format.
      birthday = #7/27/1998#
      bday = Microsoft.VisualBasic.DateAndTime.Day(birthday)
      month = Microsoft.VisualBasic.DateAndTime.Month(birthday)
      monthname = Microsoft.VisualBasic.DateAndTime.MonthName(month)
      
      Console.WriteLine(birthday)
      Console.WriteLine(bday)
      Console.WriteLine(month)
      Console.WriteLine(monthname)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

7/27/1998 12:00:00 AM
27
7
July

VB.Net – 数组

数组存储相同类型元素的固定大小的顺序集合。数组用于存储数据的集合，但将数组视为相同类型变量的集合通常更有用。

所有数组都由连续的内存位置组成。最低地址对应第一个元素，最高地址对应最后一个元素。

在 VB.Net 中创建数组

要在 VB.Net 中声明数组，请使用 Dim 语句。例如，

Dim intData(30)	  ' an array of 31 elements
Dim strData(20) As String	' an array of 21 strings
Dim twoDarray(10, 20) As Integer	'a two dimensional array of integers
Dim ranges(10, 100)	 'a two dimensional array

您还可以在声明数组时初始化数组元素。例如，

Dim intData() As Integer = {12, 16, 20, 24, 28, 32}
Dim names() As String = {"Karthik", "Sandhya", _
"Shivangi", "Ashwitha", "Somnath"}
Dim miscData() As Object = {"Hello World", 12d, 16ui, "A"c}

可以使用数组的索引来存储和访问数组中的元素。以下程序演示了这一点 –

Module arrayApl
   Sub Main()
      Dim n(10) As Integer ' n is an array of 11 integers '
      Dim i, j As Integer
      ' initialize elements of array n '         
      
      For i = 0 To 10
          n(i) = i + 100 ' set element at location i to i + 100 
      Next i
      ' output each array element's value '
      
      For j = 0 To 10
          Console.WriteLine("Element({0}) = {1}", j, n(j))
      Next j
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Element(0) = 100
Element(1) = 101
Element(2) = 102
Element(3) = 103
Element(4) = 104
Element(5) = 105
Element(6) = 106
Element(7) = 107
Element(8) = 108
Element(9) = 109
Element(10) = 110

动态数组

动态数组是可以根据程序的需要进行维度和重新维度的数组。您可以使用ReDim语句声明动态数组。

ReDim 语句的语法 –

ReDim [Preserve] arrayname(subscripts)

在哪里，

• 当您调整现有数组的大小时，Preserve关键字有助于将数据保留在现有数组中。

• arrayname是要重新维度的数组的名称。

• 下标指定新维度。

Module arrayApl
   Sub Main()
      Dim marks() As Integer
      ReDim marks(2)
      marks(0) = 85
      marks(1) = 75
      marks(2) = 90
     
      ReDim Preserve marks(10)
      marks(3) = 80
      marks(4) = 76
      marks(5) = 92
      marks(6) = 99
      marks(7) = 79
      marks(8) = 75
      
      For i = 0 To 10
         Console.WriteLine(i & vbTab & marks(i))
      Next i
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

0	85
1	75
2	90
3	80
4	76
5	92
6	99
7	79
8	75
9	0
10	0

多维数组

VB.Net 允许多维数组。多维数组也称为矩形数组。

您可以将一个二维字符串数组声明为 –

Dim twoDStringArray(10, 20) As String

或者，整数变量的 3 维数组 –

Dim threeDIntArray(10, 10, 10) As Integer

以下程序演示了创建和使用二维数组 –

Module arrayApl
   Sub Main()
      ' an array with 5 rows and 2 columns
      Dim a(,) As Integer = {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}}
      Dim i, j As Integer
      ' output each array element's value '
      
      For i = 0 To 4
          For j = 0 To 1
              Console.WriteLine("a[{0},{1}] = {2}", i, j, a(i, j))
          Next j
      Next i
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8

锯齿状阵列

锯齿状数组是数组的数组。以下代码显示了声明一个名为score of Integers的锯齿状数组–

Dim scores As Integer()() = New Integer(5)(){}

以下示例说明了使用锯齿状数组 –

Module arrayApl
   Sub Main()
      'a jagged array of 5 array of integers
      Dim a As Integer()() = New Integer(4)() {}
      a(0) = New Integer() {0, 0}
      a(1) = New Integer() {1, 2}
      a(2) = New Integer() {2, 4}
      a(3) = New Integer() {3, 6}
      a(4) = New Integer() {4, 8}
      Dim i, j As Integer
      ' output each array element's value 
      
      For i = 0 To 4
         For j = 0 To 1
            Console.WriteLine("a[{0},{1}] = {2}", i, j, a(i)(j))
         Next j
      Next i
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8

数组类

Array 类是 VB.Net 中所有数组的基类。它在 System 命名空间中定义。Array 类提供各种属性和方法来处理数组。

数组类的属性

下表提供了Array类的一些最常用的属性–

Array 类的方法

下表提供了Array类的一些最常用的方法–

有关 Array 类属性和方法的完整列表，请参阅 Microsoft 文档。

例子

以下程序演示了 Array 类的一些方法的使用：

Module arrayApl
   Sub Main()
      Dim list As Integer() = {34, 72, 13, 44, 25, 30, 10}
      Dim temp As Integer() = list
      Dim i As Integer
      Console.Write("Original Array: ")
      
      For Each i In list
         Console.Write("{0} ", i)
      Next i
      Console.WriteLine()
      ' reverse the array
      Array.Reverse(temp)
      Console.Write("Reversed Array: ")
      
      For Each i In temp
         Console.Write("{0} ", i)
      Next i
      Console.WriteLine()
      'sort the array
      Array.Sort(list)
      Console.Write("Sorted Array: ")
      
      For Each i In list
         Console.Write("{0} ", i)
      Next i
      Console.WriteLine()
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Original Array: 34 72 13 44 25 30 10
Reversed Array: 10 30 25 44 13 72 34
Sorted Array: 10 13 25 30 34 44 72

VB.Net – 集合

集合类是用于数据存储和检索的专门类。这些类提供对堆栈、队列、列表和哈希表的支持。大多数集合类实现相同的接口。

集合类有多种用途，例如为元素动态分配内存和根据索引访问项目列表等。这些类创建 Object 类的对象集合，Object 类是 VB 中所有数据类型的基类。网。

各种集合类及其用法

以下是System.Collection命名空间的各种常用类。单击以下链接以查看其详细信息。

VB.Net – 函数

过程是一组在调用时共同执行任务的语句。过程执行后，控制返回到调用过程的语句。VB.Net 有两种类型的程序 –

• 功能

• 子程序或子程序

函数返回一个值，而 Sub 不返回一个值。

定义函数

Function 语句用于声明函数的名称、参数和主体。Function 语句的语法是 –

[Modifiers] Function FunctionName [(ParameterList)] As ReturnType
   [Statements]
End Function

在哪里，

• 修饰符– 指定函数的访问级别；可能的值有：Public、Private、Protected、Friend、Protected Friend 和有关重载、覆盖、共享和隐藏的信息。

• FunctionName – 表示函数的名称

• ParameterList – 指定参数列表

• ReturnType – 指定函数返回的变量的数据类型

例子

下面的代码片段显示了一个函数FindMax，它接受两个整数值并返回两者中较大的一个。

Function FindMax(ByVal num1 As Integer, ByVal num2 As Integer) As Integer
   ' local variable declaration */
   Dim result As Integer
   
   If (num1 > num2) Then
      result = num1
   Else
      result = num2
   End If
   FindMax = result
End Function

返回值的函数

在 VB.Net 中，函数可以通过两种方式向调用代码返回一个值 –

• 通过使用 return 语句

• 通过将值分配给函数名称

以下示例演示使用FindMax函数 –

Module myfunctions
   Function FindMax(ByVal num1 As Integer, ByVal num2 As Integer) As Integer
      ' local variable declaration */
      Dim result As Integer
      
      If (num1 > num2) Then
         result = num1
      Else
         result = num2
      End If
      FindMax = result
   End Function
   Sub Main()
      Dim a As Integer = 100
      Dim b As Integer = 200
      Dim res As Integer
      
      res = FindMax(a, b)
      Console.WriteLine("Max value is : {0}", res)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Max value is : 200

递归函数

函数可以调用自身。这称为递归。以下是使用递归函数计算给定数字的阶乘的示例 –

Module myfunctions
   Function factorial(ByVal num As Integer) As Integer
      ' local variable declaration */
      Dim result As Integer
      
      If (num = 1) Then
         Return 1
      Else
         result = factorial(num - 1) * num
         Return result
      End If
   End Function
   Sub Main()
      'calling the factorial method
      Console.WriteLine("Factorial of 6 is : {0}", factorial(6))
      Console.WriteLine("Factorial of 7 is : {0}", factorial(7))
      Console.WriteLine("Factorial of 8 is : {0}", factorial(8))
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Factorial of 6 is: 720
Factorial of 7 is: 5040
Factorial of 8 is: 40320

参数数组

有时，在声明函数或子过程时，您不确定作为参数传递的参数数量。VB.Net 参数数组（或参数数组）在这些时候会派上用场。

以下示例演示了这一点 –

Module myparamfunc
   Function AddElements(ParamArray arr As Integer()) As Integer
      Dim sum As Integer = 0
      Dim i As Integer = 0
      
      For Each i In arr
         sum += i
      Next i
      Return sum
   End Function
   Sub Main()
      Dim sum As Integer
      sum = AddElements(512, 720, 250, 567, 889)
      Console.WriteLine("The sum is: {0}", sum)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

The sum is: 2938

将数组作为函数参数传递

您可以在 VB.Net 中将数组作为函数参数传递。以下示例演示了这一点 –

Module arrayParameter
   Function getAverage(ByVal arr As Integer(), ByVal size As Integer) As Double
      'local variables
      Dim i As Integer
      Dim avg As Double
      Dim sum As Integer = 0
      
      For i = 0 To size - 1
         sum += arr(i)
      Next i
      avg = sum / size
      Return avg
   End Function
   Sub Main()
      ' an int array with 5 elements '
      Dim balance As Integer() = {1000, 2, 3, 17, 50}
      Dim avg As Double
      'pass pointer to the array as an argument 
      avg = getAverage(balance, 5)
      ' output the returned value '
      Console.WriteLine("Average value is: {0} ", avg)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Average value is: 214.4

VB.Net – 子程序

正如我们在前一章中提到的，Sub 过程是不返回任何值的过程。我们在所有示例中都使用了 Sub 过程 Main。到目前为止，我们一直在这些教程中编写控制台应用程序。当这些应用程序启动时，控制转到 Main Sub 过程，它依次运行构成程序主体的任何其他语句。

定义子过程

该子语句用来声明名称，参数和子过程的主体。Sub 语句的语法是 –

[Modifiers] Sub SubName [(ParameterList)] 
   [Statements]
End Sub

在哪里，

• 修饰符– 指定程序的访问级别；可能的值有 – Public、Private、Protected、Friend、Protected Friend 和有关重载、覆盖、共享和隐藏的信息。

• SubName – 表示子的名称

• ParameterList – 指定参数列表

例子

以下示例演示了一个 Sub 过程CalculatePay，它采用两个参数小时和工资，并显示员工的总工资 –

Module mysub
   Sub CalculatePay(ByRef hours As Double, ByRef wage As Decimal)
      'local variable declaration
      Dim pay As Double
      pay = hours * wage
      Console.WriteLine("Total Pay: {0:C}", pay)
   End Sub
   Sub Main()
      'calling the CalculatePay Sub Procedure
      CalculatePay(25, 10)
      CalculatePay(40, 20)
      CalculatePay(30, 27.5)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Total Pay: $250.00
Total Pay: $800.00
Total Pay: $825.00

按值传递参数

这是将参数传递给方法的默认机制。在这种机制中，当调用一个方法时，会为每个值参数创建一个新的存储位置。实际参数的值被复制到其中。因此，对方法内部参数所做的更改对参数没有影响。

在 VB.Net 中，您使用ByVal关键字声明引用参数。以下示例演示了该概念 –

Module paramByval
   Sub swap(ByVal x As Integer, ByVal y As Integer)
      Dim temp As Integer
      temp = x ' save the value of x 
      x = y    ' put y into x 
      y = temp 'put temp into y 
   End Sub
   Sub Main()
      ' local variable definition 
      Dim a As Integer = 100
      Dim b As Integer = 200
      Console.WriteLine("Before swap, value of a : {0}", a)
      Console.WriteLine("Before swap, value of b : {0}", b)
      ' calling a function to swap the values '
      swap(a, b)
      Console.WriteLine("After swap, value of a : {0}", a)
      Console.WriteLine("After swap, value of b : {0}", b)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200

它表明尽管它们在函数内部发生了变化，但值没有变化。

通过引用传递参数

引用参数是对变量内存位置的引用。当您通过引用传递参数时，与值参数不同，不会为这些参数创建新的存储位置。引用参数表示与提供给方法的实际参数相同的内存位置。

在 VB.Net 中，您使用ByRef关键字声明引用参数。以下示例演示了这一点 –

Module paramByref
   Sub swap(ByRef x As Integer, ByRef y As Integer)
      Dim temp As Integer
      temp = x ' save the value of x 
      x = y    ' put y into x 
      y = temp 'put temp into y 
   End Sub
   Sub Main()
      ' local variable definition 
      Dim a As Integer = 100
      Dim b As Integer = 200
      Console.WriteLine("Before swap, value of a : {0}", a)
      Console.WriteLine("Before swap, value of b : {0}", b)
      ' calling a function to swap the values '
      swap(a, b)
      Console.WriteLine("After swap, value of a : {0}", a)
      Console.WriteLine("After swap, value of b : {0}", b)
      Console.ReadLine()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Before swap, value of a : 100
Before swap, value of b : 200
After swap, value of a : 200
After swap, value of b : 100

VB.Net – 类和对象

当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何数据，但它确实定义了类名的含义，即类的对象将包含什么以及可以对这样的对象执行哪些操作。

对象是类的实例。构成类的方法和变量称为类的成员。

类定义

类定义以关键字Class开头，后跟类名；和类主体，以 End Class 语句结束。以下是类定义的一般形式 –

[ <attributelist> ] [ accessmodifier ] [ Shadows ] [ MustInherit | NotInheritable ] [ Partial ] _
Class name [ ( Of typelist ) ]
   [ Inherits classname ]
   [ Implements interfacenames ]
   [ statements ]
End Class

在哪里，

• attributelist是适用于类的属性列表。可选的。

• accessmodifier定义了类的访问级别，它具有以下值：Public、Protected、Friend、Protected Friend 和 Private。可选的。

• 阴影表示该变量在基类中重新声明并隐藏了同名元素或重载元素集。可选的。

• MustInherit指定该类只能用作基类，不能直接从它创建对象，即抽象类。可选的。

• NotInheritable指定该类不能用作基类。

• Partial表示类的部分定义。

• Inherits指定它继承的基类。

• 实现指定类继承自的接口。

以下示例演示了一个 Box 类，具有三个数据成员，长度、宽度和高度 –

Module mybox
   Class Box
      Public length As Double   ' Length of a box
      Public breadth As Double  ' Breadth of a box
      Public height As Double   ' Height of a box
   End Class
   Sub Main()
      Dim Box1 As Box = New Box()        ' Declare Box1 of type Box
      Dim Box2 As Box = New Box()        ' Declare Box2 of type Box
      Dim volume As Double = 0.0         ' Store the volume of a box here
      
      ' box 1 specification
      Box1.height = 5.0
      Box1.length = 6.0
      Box1.breadth = 7.0
      
      ' box 2 specification
      Box2.height = 10.0
      Box2.length = 12.0	
      Box2.breadth = 13.0
      
      'volume of box 1
      volume = Box1.height * Box1.length * Box1.breadth
      Console.WriteLine("Volume of Box1 : {0}", volume)
      
      'volume of box 2
      volume = Box2.height * Box2.length * Box2.breadth
      Console.WriteLine("Volume of Box2 : {0}", volume)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Volume of Box1 : 210
Volume of Box2 : 1560

成员函数和封装

类的成员函数是在类定义中具有其定义或原型的函数，就像任何其他变量一样。它对它所属的类的任何对象进行操作，并且可以访问该对象的类的所有成员。

成员变量是对象的属性（从设计角度来看），它们是私有的以实现封装。这些变量只能使用公共成员函数访问。

让我们把上面的概念放在一个类中设置和获取不同类成员的值 –

Module mybox
   Class Box
      Public length As Double    ' Length of a box
      Public breadth As Double   ' Breadth of a box
      Public height As Double    ' Height of a box
      Public Sub setLength(ByVal len As Double)
         length = len
      End Sub
      
      Public Sub setBreadth(ByVal bre As Double)
         breadth = bre
      End Sub
      
      Public Sub setHeight(ByVal hei As Double)
         height = hei
      End Sub
      
      Public Function getVolume() As Double
         Return length * breadth * height
      End Function
   End Class
   Sub Main()
      Dim Box1 As Box = New Box()        ' Declare Box1 of type Box
      Dim Box2 As Box = New Box()        ' Declare Box2 of type Box
      Dim volume As Double = 0.0         ' Store the volume of a box here

      ' box 1 specification
      Box1.setLength(6.0)
      Box1.setBreadth(7.0)
      Box1.setHeight(5.0)
      
      'box 2 specification
      Box2.setLength(12.0)
      Box2.setBreadth(13.0)
      Box2.setHeight(10.0)
      
      ' volume of box 1
      volume = Box1.getVolume()
      Console.WriteLine("Volume of Box1 : {0}", volume)

      'volume of box 2
      volume = Box2.getVolume()
      Console.WriteLine("Volume of Box2 : {0}", volume)
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Volume of Box1 : 210
Volume of Box2 : 1560

构造函数和析构函数

类构造函数是类的特殊成员 Sub，每当我们创建该类的新对象时都会执行该成员。构造函数的名称为New，它没有任何返回类型。

以下程序解释了构造函数的概念 –

Class Line
   Private length As Double    ' Length of a line
   Public Sub New()   'constructor
      Console.WriteLine("Object is being created")
   End Sub
   
   Public Sub setLength(ByVal len As Double)
      length = len
   End Sub
     
   Public Function getLength() As Double
      Return length
   End Function
   Shared Sub Main()
      Dim line As Line = New Line()
      'set line length
      line.setLength(6.0)
      Console.WriteLine("Length of line : {0}", line.getLength())
      Console.ReadKey()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Object is being created
Length of line : 6

默认构造函数没有任何参数，但如果需要，构造函数可以有参数。这种构造函数称为参数化构造函数。此技术可帮助您在创建对象时为其分配初始值，如下例所示 –

Class Line
   Private length As Double    ' Length of a line
   Public Sub New(ByVal len As Double)   'parameterised constructor
      Console.WriteLine("Object is being created, length = {0}", len)
      length = len
   End Sub
   Public Sub setLength(ByVal len As Double)
      length = len
   End Sub
       
   Public Function getLength() As Double
      Return length
   End Function
   Shared Sub Main()
      Dim line As Line = New Line(10.0)
      Console.WriteLine("Length of line set by constructor : {0}", line.getLength())
      'set line length
      line.setLength(6.0)
      Console.WriteLine("Length of line set by setLength : {0}", line.getLength())
      Console.ReadKey()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Object is being created, length = 10
Length of line set by constructor : 10
Length of line set by setLength : 6

甲析构函数是每当它的类的对象进入的范围之时执行的类的特殊成员子。

一个析构函数的名称为最终确定，它可以既不返回一个值，也不能采取任何参数。析构函数对于在退出程序之前释放资源非常有用，例如关闭文件、释放内存等。

析构函数不能被继承或重载。

以下示例解释了析构函数的概念 –

Class Line
   Private length As Double    ' Length of a line
   Public Sub New()   'parameterised constructor
      Console.WriteLine("Object is being created")
   End Sub
   
   Protected Overrides Sub Finalize()  ' destructor
      Console.WriteLine("Object is being deleted")
   End Sub
   
   Public Sub setLength(ByVal len As Double)
      length = len
   End Sub
   
   Public Function getLength() As Double
      Return length
   End Function
   
   Shared Sub Main()
      Dim line As Line = New Line()
      'set line length
      line.setLength(6.0)
      Console.WriteLine("Length of line : {0}", line.getLength())
      Console.ReadKey()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Object is being created
Length of line : 6
Object is being deleted

VB.Net 类的共享成员

我们可以使用 Shared 关键字将类成员定义为静态成员。当我们将类的成员声明为 Shared 时，意味着无论创建了多少个类的对象，该成员都只有一个副本。

关键字Shared意味着一个类只存在成员的一个实例。共享变量用于定义常量，因为它们的值可以通过调用类而不创建它的实例来检索。

共享变量可以在成员函数或类定义之外初始化。您还可以在类定义中初始化共享变量。

您还可以将成员函数声明为 Shared。此类函数只能访问共享变量。共享函数甚至在创建对象之前就存在。

以下示例演示了共享成员的使用 –

Class StaticVar
   Public Shared num As Integer
   Public Sub count()
      num = num + 1
   End Sub
   Public Shared Function getNum() As Integer
      Return num
   End Function
   Shared Sub Main()
      Dim s As StaticVar = New StaticVar()
      s.count()
      s.count()
      s.count()
      Console.WriteLine("Value of variable num: {0}", StaticVar.getNum())
      Console.ReadKey()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Value of variable num: 3

遗产

面向对象编程中最重要的概念之一是继承。继承允许我们根据另一个类来定义一个类，这使得创建和维护应用程序更容易。这也提供了重用代码功能和快速实现时间的机会。

创建类时，程序员可以指定新类应继承现有类的成员，而不是编写全新的数据成员和成员函数。这个现有类称为基类，新类称为派生类。

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

VB.Net 中用于创建派生类的语法如下 –

<access-specifier> Class <base_class>
...
End Class
Class <derived_class>: Inherits <base_class>
...
End Class

考虑一个基类 Shape 及其派生类 Rectangle –

' Base class
Class Shape
   Protected width As Integer
   Protected height As Integer
   Public Sub setWidth(ByVal w As Integer)
      width = w
   End Sub
   Public Sub setHeight(ByVal h As Integer)
      height = h
   End Sub
End Class
' Derived class
Class Rectangle : Inherits Shape
   Public Function getArea() As Integer
      Return (width * height)
   End Function
End Class
Class RectangleTester
   Shared Sub Main()
      Dim rect As Rectangle = New Rectangle()
      rect.setWidth(5)
      rect.setHeight(7)
      ' Print the area of the object.
      Console.WriteLine("Total area: {0}", rect.getArea())
      Console.ReadKey()
   End Sub	
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Total area: 35

基类初始化

派生类继承了基类的成员变量和成员方法。因此，应在创建子类之前创建超类对象。超类或基类在 VB.Net 中隐式称为MyBase

以下程序演示了这一点 –

' Base class
Class Rectangle
   Protected width As Double
   Protected length As Double
   Public Sub New(ByVal l As Double, ByVal w As Double)
      length = l
      width = w
   End Sub
   Public Function GetArea() As Double
      Return (width * length)
   End Function
   Public Overridable Sub Display()
      Console.WriteLine("Length: {0}", length)
      Console.WriteLine("Width: {0}", width)
      Console.WriteLine("Area: {0}", GetArea())
   End Sub
   'end class Rectangle  
End Class

'Derived class
Class Tabletop : Inherits Rectangle
   Private cost As Double
   Public Sub New(ByVal l As Double, ByVal w As Double)
      MyBase.New(l, w)
   End Sub
   Public Function GetCost() As Double
      Dim cost As Double
      cost = GetArea() * 70
      Return cost
   End Function
   Public Overrides Sub Display()
      MyBase.Display()
      Console.WriteLine("Cost: {0}", GetCost())
   End Sub
    'end class Tabletop
End Class
Class RectangleTester
   Shared Sub Main()
      Dim t As Tabletop = New Tabletop(4.5, 7.5)
      t.Display()
      Console.ReadKey()
   End Sub
End Class

当上面的代码被编译和执行时，它会产生以下结果 –

Length: 4.5
Width: 7.5
Area: 33.75
Cost: 2362.5

VB.Net 支持多重继承。

VB.Net – 异常处理

异常是在程序执行过程中出现的问题。异常是对程序运行时出现的异常情况的响应，例如试图除以零。

异常提供了一种将控制从程序的一个部分转移到另一个部分的方法。VB.Net 异常处理建立在四个关键字之上 – Try、Catch、Finally和Throw。

• Try – Try 块标识将激活特定异常的代码块。后面跟着一个或多个 Catch 块。

• Catch – 程序在程序中要处理问题的位置使用异常处理程序捕获异常。Catch 关键字表示捕获异常。

• 最后– 最后块用于执行一组给定的语句，无论是否抛出异常。例如，如果您打开一个文件，无论是否引发异常，它都必须关闭。

• Throw – 出现问题时程序抛出异常。这是使用 Throw 关键字完成的。

句法

假设一个块将引发异常，一个方法使用 Try 和 Catch 关键字的组合来捕获异常。Try/Catch 块放置在可能生成异常的代码周围。Try/Catch 块中的代码称为受保护代码，使用 Try/Catch 的语法如下所示 –

Try
   [ tryStatements ]
   [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
   [ catchStatements ]
   [ Exit Try ] ]
[ Catch ... ]
[ Finally
   [ finallyStatements ] ]
End Try

您可以列出多个 catch 语句来捕获不同类型的异常，以防您的 try 块在不同情况下引发多个异常。

.Net Framework 中的异常类

在 .Net Framework 中，异常由类表示。.Net Framework 中的异常类主要是直接或间接派生自System.Exception类。从 System.Exception 类派生的一些异常类是System.ApplicationException和System.SystemException类。

该System.ApplicationException类支持异常，由应用程序产生的。所以程序员定义的异常应该从这个类派生出来。

该System.SystemException类是所有预定义的系统异常的基类。

下表提供了一些从 Sytem.SystemException 类派生的预定义异常类 –

处理异常

VB.Net 以 try 和 catch 块的形式为异常处理问题提供了结构化的解决方案。使用这些块，核心程序语句与错误处理语句分开。

这些错误处理块是使用Try、Catch和finally关键字实现的。以下是发生除以零条件时抛出异常的示例 –

Module exceptionProg
   Sub division(ByVal num1 As Integer, ByVal num2 As Integer)
      Dim result As Integer
      Try
         result = num1 \ num2
      Catch e As DivideByZeroException
         Console.WriteLine("Exception caught: {0}", e)
      Finally
         Console.WriteLine("Result: {0}", result)
      End Try
   End Sub
   Sub Main()
      division(25, 0)
      Console.ReadKey()
  End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

Exception caught: System.DivideByZeroException: Attempted to divide by zero. 
at ...
Result: 0

创建用户定义的例外

您还可以定义自己的异常。用户定义的异常类派生自ApplicationException类。以下示例演示了这一点 –

Module exceptionProg
   Public Class TempIsZeroException : Inherits ApplicationException
      Public Sub New(ByVal message As String)
         MyBase.New(message)
      End Sub
   End Class
   Public Class Temperature
      Dim temperature As Integer = 0
      Sub showTemp()
         If (temperature = 0) Then
            Throw (New TempIsZeroException("Zero Temperature found"))
         Else
            Console.WriteLine("Temperature: {0}", temperature)
         End If
      End Sub
   End Class
   Sub Main()
      Dim temp As Temperature = New Temperature()
      Try
         temp.showTemp()
      Catch e As TempIsZeroException
         Console.WriteLine("TempIsZeroException: {0}", e.Message)
      End Try
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

TempIsZeroException: Zero Temperature found

投掷物体

如果对象直接或间接派生自 System.Exception 类，则可以抛出该对象。

您可以在 catch 块中使用 throw 语句将当前对象作为 –

Throw [ expression ]

以下程序演示了这一点 –

Module exceptionProg
   Sub Main()
      Try
         Throw New ApplicationException("A custom exception _ is being thrown here...")
      Catch e As Exception
         Console.WriteLine(e.Message)
      Finally
         Console.WriteLine("Now inside the Finally Block")
      End Try
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

A custom exception is being thrown here...
Now inside the Finally Block

VB.Net – 文件处理

一个文件是存储在一个特定的名称和目录路径的磁盘数据的集合。当一个文件被打开进行读或写时，它就变成了一个流。

流基本上是通过通信路径的字节序列。有两个主要流：输入流和输出流。该输入流用于从文件（读操作）读取数据和所述输出数据流是用于写入到该文件中（写操作）。

VB.Net I/O 类

System.IO 命名空间具有各种类，用于对文件执行各种操作，例如创建和删除文件、读取或写入文件、关闭文件等。

下表显示了 System.IO 命名空间中一些常用的非抽象类 –

FileStream 类

System.IO 命名空间中的FileStream类有助于读取、写入和关闭文件。这个类派生自抽象类Stream。

您需要创建一个FileStream对象来创建新文件或打开现有文件。创建FileStream对象的语法如下 –

Dim <object_name> As FileStream = New FileStream(<file_name>, <FileMode Enumerator>, <FileAccess Enumerator>, <FileShare Enumerator>)

例如，创建 FileStream 对象F以读取名为sample.txt的文件–

Dim f1 As FileStream = New FileStream("sample.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite)

例子

以下程序演示了FileStream类的使用 –

Imports System.IO
Module fileProg
   Sub Main()
      Dim f1 As FileStream = New FileStream("sample.txt", _ FileMode.OpenOrCreate, FileAccess.ReadWrite)
      Dim i As Integer
      
      For i = 0 To 20
         f1.WriteByte(CByte(i))
      Next i
      f1.Position = 0
      
      For i = 0 To 20
         Console.Write("{0} ", f1.ReadByte())
      Next i
      f1.Close()
      Console.ReadKey()
   End Sub
End Module

当上面的代码被编译和执行时，它会产生以下结果 –

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 -1

VB.Net 中的高级文件操作

前面的示例提供了 VB.Net 中的简单文件操作。但是，要利用 System.IO 类的强大功能，您需要了解这些类的常用属性和方法。

我们将在以下部分讨论这些类及其执行的操作。请单击提供的链接以访问各个部分 –

VB.Net – 基本控件

对象是您使用工具箱控件在 Visual Basic 窗体上创建的一种用户界面元素。事实上，在 Visual Basic 中，窗体本身就是一个对象。每个 Visual Basic 控件都包含三个重要元素 –

• 描述对象的属性，

• 方法使对象做某事并且

• 事件是对象做某事时发生的事情。

控件属性

所有 Visual Basic 对象都可以通过设置其属性来移动、调整大小或自定义。属性是 Visual Basic 对象拥有的值或特征，例如 Caption 或 Fore Color。

可以在设计时使用“属性”窗口或在运行时使用程序代码中的语句设置属性。

Object. Property = Value

在哪里

• Object是您正在自定义的对象的名称。

• 属性是您要更改的特征。

• 值是新的属性设置。

例如，

Form1.Caption = "Hello"

您可以使用属性窗口设置任何表单属性。大多数属性可以在应用程序执行期间设置或读取。您可以参考 Microsoft 文档以获取与应用于它们的不同控件和限制相关联的属性的完整列表。

控制方法

方法是作为类成员创建的过程，它们使对象执行某些操作。方法用于访问或操作对象或变量的特征。您将在课程中使用主要有两类方法 –

• 如果您使用的是诸如工具箱提供的控件之类的控件，则可以调用其任何公共方法。这种方法的要求取决于所使用的类。

• 如果现有方法都不能执行您想要的任务，您可以向类添加一个方法。

例如，MessageBox控件有一个名为Show的方法，它在下面的代码片段中被调用 –

Public Class Form1
   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) 
   Handles Button1.Click
      MessageBox.Show("Hello, World")
   End Sub
End Class

控制事件

事件是通知应用程序发生了重要事件的信号。例如，当用户单击窗体上的控件时，该窗体可以引发Click事件并调用处理该事件的过程。有各种类型的与表单相关的事件，如单击、双击、关闭、加载、调整大小等。

以下是表单Load事件处理程序子例程的默认结构。您可以通过双击代码来查看此代码，该代码将为您提供与表单控件关联的所有事件的完整列表 –

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
   'event handler code goes here
End Sub

这里，Handles MyBase.Load表示Form1_Load()子程序处理Load事件。类似的，你可以检查存根代码的点击，双击。如果您想初始化一些变量，如属性等，那么您将这些代码保留在 Form1_Load() 子程序中。在这里，需要注意的重要一点是事件处理程序的名称，默认情况下它是 Form1_Load，但您可以根据您在应用程序编程中使用的命名约定更改此名称。

基本控制

VB.Net 提供了种类繁多的控件，可帮助您创建丰富的用户界面。所有这些控件的功能都在各自的控件类中定义。控件类在System.Windows.Forms命名空间中定义。

下表列出了一些常用的控件 –

VB.Net – 对话框

有许多内置对话框可在 Windows 窗体中用于各种任务，例如打开和保存文件、打印页面、为应用程序用户提供颜色、字体、页面设置等选项。这些内置对话框减少了开发人员的时间和工作量。

所有这些对话框控件类都继承自CommonDialog类并覆盖基类的RunDialog()函数以创建特定对话框。

当对话框的用户调用其ShowDialog()函数时，会自动调用 RunDialog ()函数。

所述的ShowDialog方法用于显示所有在运行时对话框控件。它返回DialogResult枚举类型的值。DialogResult 枚举的值是 –

• Abort – 当用户单击 Abort 按钮时，返回 DialogResult.Abort 值。

• 取消– 当用户单击取消按钮时，返回 DialogResult.Cancel。

• 忽略– 当用户单击忽略按钮时，返回 DialogResult.Ignore。

• No – 返回 DialogResult.No，当用户单击 No 按钮时。

• None – 不返回任何内容，对话框继续运行。

• OK – 返回 DialogResult.OK，当用户点击 OK 按钮时

• 重试– 返回 DialogResult.Retry ，当用户单击重试按钮时

• Yes – 返回 DialogResult.Yes，当用户单击 Yes 按钮时

下图显示了通用对话框类继承 –

上述所有这些类都有相应的控件，可以在设计时从工具箱中添加这些控件。您可以通过以编程方式实例化类或使用相关控件将这些类的相关功能包含到您的应用程序中。

当您双击工具箱中的任何对话框控件或将控件拖到窗体上时，它会出现在 Windows 窗体设计器底部的组件托盘中，它们不会直接显示在窗体上。

下表列出了常用的对话框控件。单击以下链接以检查其详细信息 –

VB.Net – 高级表格

在本章中，让我们研究以下概念 –

• 在应用程序中添加菜单和子菜单

• 在表单中添加剪切、复制和粘贴功能

• 在表单中锚定和停靠控件

• 模态形式

在应用程序中添加菜单和子菜单

传统上，Menu、MainMenu、ContextMenu和MenuItem类用于在 Windows 应用程序中添加菜单、子菜单和上下文菜单。

现在，MenuStrip、ToolStripMenuItem、ToolStripDropDown和ToolStripDropDownMenu控件替换了以前版本的与菜单相关的控件并为其添加了功能。但是，为了向后兼容和将来使用，旧的控件类被保留。

让我们首先使用旧版本控件创建一个典型的 windows 主菜单栏和子菜单，因为这些控件仍然在旧应用程序中大量使用。

下面是一个例子，它展示了我们如何创建一个带有菜单项的菜单栏：文件、编辑、查看和项目。文件菜单有子菜单新建、打开和保存。

让我们双击 Form 并将以下代码放入打开的窗口中。

Public Class Form1
   Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
      'defining the main menu bar
      Dim mnuBar As New MainMenu()
      'defining the menu items for the main menu bar
      Dim myMenuItemFile As New MenuItem("&File")
      Dim myMenuItemEdit As New MenuItem("&Edit")
      Dim myMenuItemView As New MenuItem("&View")
      Dim myMenuItemProject As New MenuItem("&Project")

      'adding the menu items to the main menu bar
      mnuBar.MenuItems.Add(myMenuItemFile)
      mnuBar.MenuItems.Add(myMenuItemEdit)
      mnuBar.MenuItems.Add(myMenuItemView)
      mnuBar.MenuItems.Add(myMenuItemProject)

     ' defining some sub menus
      Dim myMenuItemNew As New MenuItem("&New")
      Dim myMenuItemOpen As New MenuItem("&Open")
      Dim myMenuItemSave As New MenuItem("&Save")

      'add sub menus to the File menu
      myMenuItemFile.MenuItems.Add(myMenuItemNew)
      myMenuItemFile.MenuItems.Add(myMenuItemOpen)
      myMenuItemFile.MenuItems.Add(myMenuItemSave)

      'add the main menu to the form
      Me.Menu = mnuBar
     
      ' Set the caption bar text of the form.  
      Me.Text = "tutorialspoint.com"
   End Sub
End Class

当使用 Microsoft Visual Studio 工具栏上提供的开始按钮执行并运行上述代码时，它将显示以下窗口 –

Windows 窗体包含一组丰富的类，用于创建您自己的具有现代外观、外观和感觉的自定义菜单。在MenuStrip中，ToolStripMenuItem，的ContextMenuStrip控件用于高效地创建菜单栏和上下文菜单。

单击以下链接以检查其详细信息 –

在表单中添加剪切、复制和粘贴功能

ClipBoard类公开的方法用于在应用程序中添加剪切、复制和粘贴功能。ClipBoard 类提供在系统剪贴板上放置数据和从系统剪贴板上检索数据的方法。

它有以下常用方法 –

下面是一个示例，它展示了我们如何使用 Clipboard 类的方法剪切、复制和粘贴数据。采取以下步骤 –

• 在窗体上添加一个富文本框控件和三个按钮控件。

• 将按钮的文本属性分别更改为剪切、复制和粘贴。

• 双击按钮在代码编辑器中添加以下代码 –

Public Class Form1
   Private Sub Form1_Load(sender As Object, e As EventArgs) _ 
    Handles MyBase.Load
      ' Set the caption bar text of the form.  
      Me.Text = "tutorialspoint.com"
   End Sub
   
   Private Sub Button1_Click(sender As Object, e As EventArgs) _ 
      Handles Button1.Click
      Clipboard.SetDataObject(RichTextBox1.SelectedText)
      RichTextBox1.SelectedText = ""
   End Sub
   
   Private Sub Button2_Click(sender As Object, e As EventArgs) _
       Handles Button2.Click
      Clipboard.SetDataObject(RichTextBox1.SelectedText)
   End Sub
   
   Private Sub Button3_Click(sender As Object, e As EventArgs) _
    Handles Button3.Click
      Dim iData As IDataObject
      iData = Clipboard.GetDataObject()
      If (iData.GetDataPresent(DataFormats.Text)) Then
         RichTextBox1.SelectedText = iData.GetData(DataFormats.Text)
      Else
         RichTextBox1.SelectedText = " "
      End If
   End Sub
End Class

当使用Microsoft Visual Studio 工具栏上提供的开始按钮执行并运行上述代码时，它将显示以下窗口 –

输入一些文本并检查按钮的工作方式。

在表单中锚定和停靠控件

锚定允许您将控件的锚位置设置为其容器控件的边缘，例如窗体。Control 类的Anchor属性允许您设置此属性的值。Anchor 属性获取或设置控件绑定到的容器的边缘，并确定控件如何与其父控件一起调整大小。

当您将控件锚定到窗体时，在调整窗体大小时，控件会保持与窗体边缘的距离及其锚定位置。

您可以从“属性”窗口设置控件的 Anchor 属性值 –

例如，让我们在窗体上添加一个 Button 控件并将其锚点属性设置为底部、右侧。运行此窗体以查看 Button 控件相对于窗体的原始位置。

现在，当您拉伸窗体时，按钮和窗体右下角之间的距离保持不变。

对接的控制装置其对接至其容器的边缘中的一个的。在对接时，控件完全填充容器的特定区域。

Control 类的Dock属性执行此操作。Dock 属性获取或设置哪些控件边框停靠到其父控件，并确定控件如何与其父控件一起调整大小。

您可以从“属性”窗口设置控件的 Dock 属性值 –

例如，让我们在窗体上添加一个 Button 控件并将其 Dock 属性设置为底部。运行此窗体以查看 Button 控件相对于窗体的原始位置。

现在，当您拉伸表单时，按钮会随着表单调整自身大小。

模态形式

模态表单是那些在您可以继续使用应用程序的其余部分之前需要关闭或隐藏的表单。所有对话框都是模态形式。MessageBox 也是一种模态形式。

您可以通过两种方式调用模态表单 –

• 调用ShowDialog方法

• 调用Show方法

让我们举一个例子，在这个例子中我们将创建一个模态窗体，一个对话框。采取以下步骤 –

• 向您的应用程序添加一个表单 Form1，并向 Form1 添加两个标签和一个按钮控件

• 将第一个标签和按钮的文本属性分别更改为“欢迎使用教程点”和“输入您的姓名”。将第二个标签的文本属性保留为空白。

  

• 添加一个新的 Windows 窗体 Form2，并向 Form2 添加两个按钮、一个标签和一个文本框。

• 将按钮的文本属性分别更改为 OK 和 Cancel。将标签的文本属性更改为“输入您的姓名：”。

• 将Form2的FormBorderStyle属性设置为FixedDialog，为它提供一个对话框边框。

• 将Form2的ControlBox属性设置为 False。

• 将Form2的ShowInTaskbar属性设置为 False。

• 将OK 按钮的DialogResult属性设置为 OK，将 Cancel 按钮设置为 Cancel。

在 Form2 的 Form2_Load 方法中添加以下代码片段 –

Private Sub Form2_Load(sender As Object, e As EventArgs) _
   Handles MyBase.Load
   AcceptButton = Button1
   CancelButton = Button2
End Sub

在 Form1 的 Button1_Click 方法中添加以下代码片段 –

Private Sub Button1_Click(sender As Object, e As EventArgs) _
   Handles Button1.Click
   Dim frmSecond As Form2 = New Form2()
   
   If frmSecond.ShowDialog() = DialogResult.OK Then
      Label2.Text = frmSecond.TextBox1.Text
   End If
End Sub

当使用Microsoft Visual Studio 工具栏上提供的开始按钮执行并运行上述代码时，它将显示以下窗口 –

单击“输入您的姓名”按钮显示第二种形式 –