vb.net.rar_Dot.资源-CSDN文库

共1个文件

doc：1个

版权申诉

173 浏览量 2022-09-22 20:33:33 上传评论收藏 64KB RAR 举报

资源推荐

资源详情

资源评论

收起资源包目录

vb.net.rar （1个子文件）

vb.net.doc 334KB

.Net (or VB7.0) is not an upgrade to VB 6.0; it is a completely new language written

from the ground up to be compatible with Microsofts "dotnet" Common Language

Runtime. The legacy VB language was used as a general guide for syntax but backwards

compatibility was sacrificed at so many points that there is little code that can be directly

ported. If you are looking at VB.Net as a potential upgrade path for current applications

or as a tool for current developers to move into and then learn new features you are

probably going to have significant problems. The Visual Basic 6.0 runtime is great at

simplifying many of the common programming tasks. But having this simplifying layer

has meant that you cant use a new operating system feature, such as DirectX, until there

is a Visual Basic-accessible wrapper around it. As a Visual Basic developer, the most

important benefit you get from the .NET Framework is direct and easy access to the

underlying .NET platform using a consistent programming model. This means you can

build applications with Visual Basic.NET that were not easy or not possible to build with

Visual Basic 6.0. As a Visual Basic 6.0 developer, you will appreciate now having access

to the same features and capabilities as other platform languages. For example, to create a

Windows Service, you no longer have to write it in Visual C++, nor will you have to

resort to hacks or kludges. You can do it all elegantly, cleanly, and easily using Visual

Basic.NET. To give you some examples of what you can do with the .NET Framework,

lets discuss four common tasks that you might need to perform in your applications:

tracing and event logging, multithreading, file system monitoring, and creating Windows

Services. Tracing and Event Logging When building a robust application, you must pay

careful attention to diagnostics and troubleshooting mechanisms. Typically, this involves

writing a tracing component, which handles opening the output destination (event log or

file), writing the trace message, and closing the output destination. You then call methods

on this component throughout your code, passing it the text to log. You invest all this

time and effort to build a tracing and logging subsystem, which ultimately does not

contribute to solving the business problem but is required to build the application. The

.NET Framework includes classes and other data types that make it easy to log trace

messages by providing the logging infrastructure for you. Multithreaded Applications

One of the great features of the .NET Framework is the ability to create multithreaded

applications in Visual Basic without having to use third-party tools or unsupported Visual

Basic tricks. The .NET Frameworks multithreading support is provided by classes and

interfaces in the System.Threading namespace, so all .NET languages can create and

manipulate threads in the same way. System.Threading.Thread is the core class and

provides support for creating and controlling threads. To create a thread, you create a new

System.Threading.Thread object that passes the constructor a ThreadStart delegate. This

delegate represents the method where the thread will begin its execution. When youre

ready to start the new thread, you call Thread.Start() (see Listing 1). As you start to build

multithreaded applications, youll quickly realize the need to control access to shared

resources, such as shared class variables. The .NET Framework also includes several

classes and data types that you can use to synchronize actions performed by two threads.

File System Monitoring Ive come across a few applications that are required to wait and

process files that show up in a particular directory—for example, an application that

imports data from a file into a database. Data files may be downloaded from a mainframe

or otherwise transferred into an input directory, from which the application imports them

into a database. Instead of constantly polling the directory for new files, you can wait for

notifications indicating that a new file has been created. You can do this in Visual Basic

6.0 by using Win32 APIs, and you can do it in Visual Basic.NET by using the .NET

Framework classes. However, implementation in .NET is more consistent with the way

you do everything else in .NET, so the learning curve is minimal. Creating Windows

Services When you want to create a Windows Service, you must use Visual C++ or resort

to using srvany.exe or third-party tools to create the service in Visual Basic. Either way,

you are not writing your service natively in Visual Basic, and you are adding more

dependencies outside the Visual Basic runtime. If you write a Windows Service from

scratch using C++ or C (without using the Active Template Library), youll have to write

quite a bit of code to coordinate communication back and forth between your service and

the Service Control Manager (SCM), which handles starting, pausing, continuing, and

stopping services. The .NET Framework makes it easy to implement a service by

providing the System.ServiceProcess.ServiceBase class. To write a service, you inherit

from this class, override some of its methods, set its properties, and youre ready to go!

Creating custom events with Visual Basic .NET 2005

Visual Basic .NET is well known for its event-driven programming capabilities. VB.NET

2005 adds new functionality for custom events that provides flexibility in handling and

controlling events.

Events model in VB.NET

Events are defined as actions or occurances of interest. An interested object can subscribe

to an event and be notified when it happens. For example, a button on a form can

generate a click event and the form can subscribe and get notified when the event occurs.

This click event is processed through the form code.

VB.NET 2005 provides a range of flexible event models to address simple or very

complex events. Below is an example of a simple event using a Worker class with a

DoWork method:

Public Class Worker

Public Sub DoWork()

For completedWork As Integer = 1 To 100

System.Threading.Thread.Sleep(1000)

Console.WriteLine(completedWork)

End Sub

End Class

The DoWork method has a For loop repeating 100 times, waiting one second between

loops, and printing out the completed work to the console. But a client such as a form

using the object of the above class, for example, should provide visual feedback on how

much work has been completed when the DoWork method is called. Adding an event to

the Worker class and altering the DoWork method to call the event can provide this

information to the client.

Public Class Worker

Public Event WorkDone(ByVal completedWork As Integer)

Public Sub DoWork()

For completedWork As Integer = 1 To 100

System.Threading.Thread.Sleep(1000)

RaiseEvent WorkDone(completedWork)

Console.WriteLine(completedWork)

End Sub

End Class

An event called WorkDone has been identified with an integer argument through which

the amount of work completed can be passed. And in the DoWork method, the event

passing the actual amount of work completed is raised. Now the above class can be

consumed by a client by declaring and creating a Worker class object with events and

handling the WorkDone event to provide feedback on progress.

Private WithEvents mWorker As New Worker

Private Sub work_WorkDone(ByVal completedWork As Integer) Handles

mWorker.WorkDone

End Sub

In the above code, the work_WorkDone method will be called each time the WorkDone event is

raised. The Handles clause after the method signature links the event-handling code with the

actual event.

A method can also dynamically link to an event using the AddHandler method and be removed

from handling an event using the RemoveHandler method as seen below. This enables more

flexibility by relating a method to an event and removing the binding required at runtime. Even

when the Handles keyword is used to bind a method to an event internally, a call to the

AddHandler method is done to perform the actual binding.

‘We dont require to use WithEvents since we are binding to events dynamically

Private mWorker As New Worker

'Binds a method(handler) to an event

AddHandler mWorker.WorkDone, AddressOf work_WorkDone

'Unbinds a method(handler) from an event

RemoveHandler mWorker.WorkDone, AddressOf work_WorkDone

Delegates in .NET events

VB.NET implements events through a construct called delegates. Delegates point to a method

and can hold the address of a method, enabling a method to be invoked through an instance of

its delegate. The Worker class can be implemented without events using a delegate as follows:

Public Class Worker

Public Delegate Sub WorkDone(ByVal completedWork As Integer )

Public Handler As WorkDone

Public Sub DoWork()

For completedWork As Integer = 1 To 10

System.Threading.Thread.Sleep(1000)

If handler IsNot Nothing Then

handler(completedWork * 10)

End If

Console.WriteLine(completedWork)

End Sub

End Class

In the code above, a delegate named WorkDone that accepts an integer argument has been

defined. This delegate can point to any method with a similar signature (a sub-procedure that

accepts an integer). After the delegate is defined, a public variable delegate named Handler has

been defined, and instead of raising the event in the DoWork method, the delegate instance is

invoked.

In the Worker class client, the delegate instance is set to point to the method that will be called

when reporting the amount of work done.

Private mWorker As new Worker

'Sets the delegate instance to the method implementation

mWorker.Handler = AddressOf work_WorkDone

The above code uses delegates directly, not the event construct, so neither the

AddHandler nor RemoveHandler methods can be used. This exposes only one public

variable, so there can be only one method to handle the invocation of the delegate.

Directly using the delegates method eliminates the setting of multiple event handlers for

one event source, which would notify all handlers when the event occurs. But an event

type can be set as a delegate and use the event-handling mechanism, resulting in cleaner

code as follows:

Public Class Worker

Public Delegate Sub WorkDone(ByVal completedWork As Integer )

Public Handler As WorkDone

Public Sub DoWork()

For completedWork As Integer = 1 To 10

System.Threading.Thread.Sleep(1000)

RaiseEvent WorkEvent(completedWork * 10)

Console.WriteLine(completedWork)

End Sub

End Class

Custom events in VB.NET 8.0

Custom events provide flexibility and control in creating and managing events. When using

custom events, it is the responsibility of the developer to bind and unbind handlers, as well as to

specify the actual calls to raise the events. Although this requires a bit more code than the earlier

implementations, it provides more control over the handlers and the invocation.

A custom event is defined by using the Custom keyword in front of the event declaration, and by

providing the delegate type for the event. The custom event has three sections: The AddHandler

section, which is invoked whenever a handler is added using the Handles keyword or the

AddHandler method; RemoveHandler section, which is called whenever a handler is removed

using the RemoveHandler method; and the RaiseEvent section that will be invoked whenever an

event is requested. The developer should write the necessary code in each of these sections to

manage the handlers, as well as specify how handlers will be notified when an event is

requested.

Below, the Worker class is implemented using the custom event construct in VB.NET

2005.

Public Class Worker

Public Delegate Sub WorkDone(ByVal completedWork As Integer )

Private handlers As New ArrayList()

Public Custom Event WorkCompleted As WorkDone

AddHandler (ByVal value As WorkDone)

If handlers.Count <= 5 Then

handlers.Add(value)

End If

End AddHandler

RemoveHandler(ByVal value As WorkDone)

handlers.Remove(value)

End RemoveHandler

RaiseEvent (ByVal completedWork >As Integer)

If completedWork > 50 Then

For Each handler As WorkDone In handlers

handler.Invoke(completedWork)

End If

End RaiseEvent

End Event

Public Sub DoWork()

For completedWork As Integer = 1 To 10

评论收藏

内容反馈

版权申诉

小贝德罗

粉丝: 65
资源: 1万+

vb.net.rar_Dot.

轻量级的Dot Net编译器支持C#和VB.NET_.net 静态编译器.rar

Advanced Address Book_Dot._vb.net_piecehk1_

F:\dotNet\asp.net\[原版计算机类书籍]DotNET(3-29)DotNET Oreilly.Dot.NET.And.XML.rar

Dot_net_study3.rar_Dot._asp.net

vb.net-serialport.rar_VB .net 源代码_serialport_vb.net_vb.net串口_数据采

SciTech.NET.Memory.Profiler.v4.0.114.安装_注册机

SQL and VB.NET.rar

VB.NET2010_MODBUS.zip_VB MODBUS_modbus vb_vb modbus_vb.net RS4

Apress.The.Ultimate.VB.Dot.NET.and.ASP.Dot.NET.Code.Book

VB.NET_OPC_NetClientDemo.rar_opc.net_vb.net opc

tcp_TCP/IP_tcp_vb.net_VB.NET.tcp_

VB.Net写的简单论坛.rar_VB.net asp_asp.net vb_vb.net winsock_vb.net贴吧_w

Beginning.Object.Oriented.ASP.NET.2.0.with.VB.NET.From.Novice.to.Professional

VB.net 计算器.rar_VB.net计算器_vb.net_计算器VB.net

Form1_vb.net_vb.net串口_vb.net串口_源码（有注释）.rar

TVideoGrabber_10.6.2.2_CSharp-VB.NET_Downloadly.ir.rar

vb.net.rar_.net_vb_net_vb.net_vb.net.

VBNET.rar_This Is It_login_vb.net_vb.net login_vb.net program

vb.net开发实例_VB.net教程_VB.NET系统_vb.net_

VB.NET.Essentials.information.rar_.net_BASIC Essentials_vb.net_v

Vb.net.rar_.NET登录_vb.net_vb.net SQL_vb.net sql数据库

VB.NET object-oriented.rar_VB .net_net_vb.net_vb.net excel

冰河的渗透实战笔记-冰河.pdf

大灰狼远控2021最新版，解压密码222

J-LINK V10 V11固件.rar

ISO21434.pdf

Web安全漏洞扫描工具-AWVS14

CTF 竞赛入门指南（ctf-all-in-one）.pdf

Web中间件常见漏洞总结.pdf

最新资源