Visual Basic.Net (Bible Series)

Overview

Contributors Include: Jim Chandler, Jacob Grass, Kevin Grossnicklaus, Uday Kranti, NIIT, Rob Teixeira, and Yancey Jones.

Visual Basic .NET Bible covers everything you need to get up and runningwith this much changed version of Visual Basic and to begin creating applications for the new Microsoft.NET Platform.

Read More Show Less
... See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (21) from $1.99   
  • New (4) from $18.50   
  • Used (17) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$18.50
Seller since 2011

Feedback rating:

(3)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
new condition not used

Ships from: Murphy, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$28.79
Seller since 2013

Feedback rating:

(2)

Condition: New
New New. Cover is not perfect. Back cover has crease. The book is laminated by plastic paper. laminating has a little peel off.

Ships from: Scarborough, Canada

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$34.44
Seller since 2005

Feedback rating:

(115)

Condition: New
TIA Somerset, New Jersey, U.S. A 2001 Soft cover New NEW Book, Text & cover completely pristine, free of any wear. FREE TRACKING within the US (international tracking not ... currently available), and email notice when shipped. Your satisfaction guaranteed. Inquiries welcomed. Thanks. Read more Show Less

Ships from: Garland, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$70.00
Seller since 2014

Feedback rating:

(147)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Close
Sort by
Sending request ...

Overview

Contributors Include: Jim Chandler, Jacob Grass, Kevin Grossnicklaus, Uday Kranti, NIIT, Rob Teixeira, and Yancey Jones.

Visual Basic .NET Bible covers everything you need to get up and runningwith this much changed version of Visual Basic and to begin creating applications for the new Microsoft.NET Platform.

Read More Show Less

Product Details

  • ISBN-13: 9780764548260
  • Publisher: Wiley
  • Publication date: 12/1/1901
  • Series: Bible Series , #108
  • Edition description: Book with CD-ROM
  • Edition number: 1
  • Pages: 1272
  • Product dimensions: 7.42 (w) x 9.16 (h) x 2.36 (d)

Meet the Author

Bill Evjen has been programming in Web development since 1996. Though raised in Seattle, Bill is presently an Internet Applications developer in St. Louis, Missouri. His abilities in Microsoft-centric Web technologies have led him to develop a number of large Internet-based applications for Fortune 500 companies and others. Bill's love of the new .NET platform led him to be the Founder and President of the St. Louis .NET User Group (http://www.stlnet.org/), and has helped in bringing prominent .NET speakers to the Midwest. Bill graduated from Western Washington University in Bellingham, Washington with a Russian Linguistics degree, and when he isn't tinkering on the computer, he enjoys spending his free time in his summer place in Toivakka, Finland. You can reach Bill at evjen@yahoo.com.

Jason Beres has been a software developer for 10 years. He is currently a consultant in south Florida and works exclusively with Microsoft technologies. Jason holds the MCT, MCSD, and MCDBA certifications from Microsoft. When he is not teaching, consulting, or writing, he is formatting his hard drive and installing the latest beta products from Microsoft and keeping up with the latest episodes of Star Trek.

Read More Show Less

Read an Excerpt

In This Chapter

  • Intro to .NET
  • .NET Framework
  • CLR
  • BCL
  • VB .NET


Introduction to .NET

What is .NET? That is the question everyone has been asking since Microsoft announced this new idea at the PDC in 2000. If you were at Tech-Ed before the PDC, you might have heard about something called NGWS, or Next Generation Web Services. About year before that, there were rumors that Microsoft was inventing a new language called "Cool." Or was it a development platform? I am not sure; I didn't pay much attention to it way back then. I was more worried about how my Web sites were going to scale with COM components and ASP. Because Windows DNA was the end-all for building robust, n-tier, Web-based solutions, I figured that there would be nothing that revolutionary to replace all that amazing technology.

I was wrong.

It became obvious to me that .NET was "the next big thing" when I received a book from a friend about something called ASP+. Although it would be at least 12 months before ASP+ was available to the public, there was already a book about it. As I read the foreword of the book, which was written by the developers of ASP .NET at Microsoft, it seemed they knew from the beginning that there had to be a better way to write Web-based applications.

So while the paint was still wet on the latest release of ASP more than three years ago, they started to work on the next version, which is today called ASP .NET. I thought that these guys were pretty smart because they listened to and understood all the things that developers complained about, and they decided to do something about it.

That may have been the beginning of .NET; I am not sure. It's hard to say where it all began, but one thing is for certain: .NET is a massive collaboration between many product groups at Microsoft. From the COM+ team to Windows 2000 to Developer Tools to SQL Server, everything is somehow tied together through .NET.

When you read about .NET, there are .NET servers, .NET languages, .NET specifications, .NET platforms, and probably more items suffixed with ".NET" than you could have ever imagined. In this chapter, you will learn exactly what .NET is, and what it means to you. In this book, you will learn about Visual Basic .NET, or VB .NET, how it fits into .NET, and how you can use this new language and the tools that come with it to transform the way you write applications today.

.NET Defined

There have been many articles, books, and conversations on what .NET really means, and depending on whom you talk to, the answer could be different every time. In reality, the answer is very simple:

.NET is Microsoft's platform for building XML Web Services.

More important, however, is what .NET does for you. No matter what your definition of .NET might be, or what you read about in magazines and on the Web, the end goal is to provide a platform for developing and deploying Web-based services, or Web Services, in a simple, secure, and consistent manner. This does not mean, however, that you will only be writing web services for all of your new .NET coding. There are great technological achievements in .NET that go far beyond the ability to create and consume web services, and throughout this chapter and throughout this book this will become very clear.

Software as a service

The software as a service paradigm has become more popular over the past few years. I saw an interview with CEO of Oracle on CNET sometime in 2000, and he mentioned that off-the-shelf software was a thing of the past. The only way to distribute software was through the Internet.

He was kind of right, but I wasn't really sure where he was coming from. The last time I tried to download the latest Oracle version from the Web, it took 27 hours, even on my high-speed 128KB Dual ISDN line. After the interview was finished, I realized that he was talking about selling services through the Internet, the types of services that portals offer. Yahoo, Excite, and the other major portal services all offer services for free, and eventually the technology will need to be in place so these companies can actually make money doing some of this cool stuff. I never understood how selling ads could generate profit on these huge sites, and in the end, that business model has proven not to work. So there needs to be a way to offer services and make money from those services.

The tools to develop for this type of technology may have existed years ago, but not in the mainstream. There needed to be a common method of communication between platforms and servers over the Internet, or the HTTP protocol, so that the consumer and the provider were not limited to what types of transactions could take place based on the type of hardware or operating system they were using. Or worse yet, what type of browser they were using.

Enter SOAP. The Simple Object Access Protocol, or SOAP, was the first effort in enabling a common and consistent mechanism for moving data over HTTP to any type of computer. SOAP is a set of XML specifications that describes how data can be sent and received over the Internet. A SOAP message contains information about itself. There are "parts" to a SOAP message that define the message content, the intent of the message, and how to send data back to the sender of the SOAP request.

In order to have a consistent and common platform for building Web Services, there needed to be a consistent and common way of communicating over the Internet. With SOAP, XML can be used to handle any request, and because XML is just a self-describing text file, any type of operating system or browser can consume SOAP-based Web Services.

The software as a service paradigm can be accomplished by using SOAP as the common protocol. Any Web site can offer a service, and the server on the back end can accept the request for that service through the standard port 80 that HTTP uses. It can then send the results back down to the client as XML, and the client can manipulate the data is it sees fit.

The .NET experience

While watching the marketing videos for .NET that Microsoft produces, you see a common message of the .NET experience: The .NET experience is from an end-user perspective. Granted, .NET experiences will be developed by people like you, but ultimately .NET is about getting information to the user in a cleaner, faster, more accessible fashion.

When the PocketPC was released, I thought it was the coolest thing on earth. The advertisements had visions of wireless access to the Internet, downloading movies, viewing contact information from my Outlook at the office, and all kinds of cool things that were so new and exciting I was amazed they were ready for prime time. In the end, it has taken about two years for any of those things to be ready for pre-game, let alone prime time; but with .NET, it is more evident that devices like the PocketPC can be useful devices. Up until now, I have used my PocketPC for reading e-Books. But with Web Services and the ASP .NET Mobile SDK, the Web sites that are being developed for full-scale browsers can now be scaled down to devices like the PocketPC and even the cell phone with little or no change to the underlying source code. Figure 1-1 gives you a visual representation of what the .NET experience could mean to you.

Figure 1-1: The .NET experience

Once useful services can be consumed from many devices, the typical end user will find them more useful, and their acceptance will become more widespread. If you can offer customers the same solution that can be used in the office or on the cell phone when they are away from the office, I think the selling part will not be how much, but when.

From the developer viewpoint, the .NET experience is equally as important as the end user. If this stuff is going to be a pain in the neck to develop, you will never use it. The good news is that Microsoft realized that, and created the tools that developers like yourself need to create great Web- and Windows-based applications faster and easier than you have ever developed applications before.

With Visual Studio .NET, you have the tools you need to leverage your existing knowledge to create applications for .NET. Visual Basic has always been known for providing the developer with the most efficient IDE for developing Windows-based applications. With the introduction of Visual InterDev, Microsoft tried to create the same ease-of-use GUI for creating Web-based applications. If you have ever used InterDev, you know that it fell short in being the Rapid Application Development (RAD) tool for the Internet it was promised to be. Visual Studio .NET is truly RAD for the Internet. With the best of all worlds, from Visual Basic to InterDev to FrontPage to any other GUI tool you have ever used, Visual Studio .NET is a combination of everything great Microsoft has ever produced in a development environment.

If you are like me, you do not have time to learn brand new stuff. You have enough to do at work as it is, let alone learn about SOAP and how to make it work with .NET. With Visual Studio .NET, XML is "baked" in; it is everywhere, and you do not have to know where or how. Everything to the developer is transparent; all you need to worry about is coding. The plumbing that goes into marshalling XML from client to server is not an issue. I mentioned RAD for the Internet, but VS .NET is also RAD for the server. It is a unified environment for developing client- and server-based applications and services, in just about any language you choose to use, faster and easier than ever. And best of all, it is based on standards that are in place today, such as XML, SOAP, HTTP, and HTML.

Let's get into some details about what makes up .NET and how you can actually use it.

The .NET Framework

The .NET Framework is the plumbing of .NET. The framework provides the services necessary to develop and deploy applications for the loosely coupled, disconnected Internet environment. Figure 1-2 shows the key components of the framework.

Figure 1-2: The .NET Framework

The two main components that make up the framework are the Common Language Runtime (CLR) and the Base Class Libraries (BCL). Everything in this book relates to the BCL. As a developer, you are coding against class libraries, which are all derived from the BCL. In the future, you may be using third-party class libraries that are not part of the base classes, but they must still be based on the CLR specifications. Other core services include cross-language interoperability, security, managed execution, and the Common Type System (CTS). Together, these services make up the .NET Framework.

Common Language Runtime

The CLR is the foundation of the framework. The goals of the CLR are as follows:

  • Secure and Robust execution environment

  • Simplified development process

  • Multilanguage support

  • Simplified management and simplified deployment

As I mentioned earlier, I always thought Windows DNA was the end-all to programming concepts. In my world of Windows only, I never ran into any interoperability issues, but in reality, that was a major drawback of the COM technology. COM provided a great way for applications to integrate, but each application had to supply the underlying infrastructure, and the objects had no direct interaction. This does not make for a very global concept. In order for any application to consume any type of service, there needed to be a better way to handle cross-process and cross-platform communication.

Secure and robust execution environment

The CLR provides the environment that manages code when it is executed. Code that runs inside the framework is known as managed code, which runs under certain rules provided by the CLR. Managed code supplies the Metadata (data about data) necessary for the CLR to provide services such as memory management, cross-language integration, code access security, and automatic lifetime control of objects. Code based on Microsoft Intermediate Language (MSIL) executes as managed code. Managed code is the core concept of the framework. With managed code, CPU-specific compilers can be built to handle the intermediate language's request. In this type of scenario, the COM model is outdated.

The MSIL is the output produced when .NET applications are compiled. This is a semi-new concept for VB developers. In the past, you could either compile to "native" code (which wasn't really native at all), or you could compile to P-Code, which was interpreted by the VB runtime when your application executed. The MSIL is the language that all of the .NET languages compile down to. After they are in this intermediate language, a process called Just-In-Time (JIT) compilation occurs when resources are used from your application at runtime. JIT allows "parts" of your application to execute when they are needed, which means that if something is never needed, it will never compile down to the PE (portable executable) file that is the native code. By using JIT, the CLR can cache the code that is used more than once and reuse it for subsequent calls, without going through the compilation process again. Figure 1-3 describes the JIT process.

Figure 1-3: JIT compilation process

The JIT process enables a secure environment by making certain assumptions:

  • Type references are compatible with the type being referenced.

  • Operations are invoked on an object only if they are within the execution parameters for that object.

  • Identities within the application are accurate.

By following these rules, the managed execution can guarantee that code being executed is type safe; the execution will only take place in memory that it is allowed to access. This is possible by the verification process that occurs when the MSIL is converted into CPU-specific code. During this verification, the code is examined to ensure it is not corrupt, it is type safe, and the code does not interfere with existing security policies that are in place on the system.

Exception handling

The framework supports Structured Exception Handling (SEH) across languages and processes. When you compile you applications, tables are created based on the methods in the classes and the errors that can occur are mapped to handlers in your method calls. In an unmanaged environment, errors were passed through HRESULTs and Boolean return values, and there was no common way to handle an error if it did occur. In .NET, error handing is integrated with the framework; it is not an afterthought.

Garbage collection

Object lifetime is managed through a process called garbage collection (GC). Through GC, released object references are automatically reclaimed by the operating system. In VB6, you had to explicitly set objects equal to nothing to ensure that memory was regained, and in C++, overlooking the release of objects caused nasty memory leaks. In .NET, memory management is automatic, and memory is reclaimed when the runtime decides that the object references are no longer in use.

Simplified development

Simplified development could mean a lot of different things to a lot of different people. In some cases, it could mean the computer reading your mind, saving you a lot of typing. In other cases, it could mean winning the lottery and retiring to a beach somewhere in the South Pacific, or maybe even a 20-million-dollar (586,440,010.07 Russian rubles) ride to Alpha, that cool space station circling the earth. In .NET, simplified development means more than any of that.

One of the biggest changes in the framework is the elimination of the registry. The registry is the enemy of all developers. GUIDs, IDL files, HRESULTs, and all other COM-related nightmares go away in .NET.

The good news is that you can still use your COM components in .NET.

Just like adding a reference to a DLL in VB6, you can add a reference to a COM DLL in .NET, and it will create a wrapper for the DLL that .NET can use to access the members in the DLL in a managed environment. You can also call .NET assemblies from an unmanaged environment, such as VB6. Both of these features require no additional work on your part, so you have a very flexible environment to use your existing code in a .NET application, or to use .NET assemblies in a VB6 environment.

Object-oriented features

A new concept to VB developers is object-oriented programming. OO simplifies the reuse and interoperability between components. The classes in the framework are all 100% object-oriented. The nice thing about the BCL being 100% OO is that you can implement OO features across languages, such as inheritance and polymorphism. This is a key factor to simplified development in large shops where some programmers might be using VB .NET, whereas other developers could be using COBOL .NET or C#. No matter what your language choice, the same features are available to everyone.

Visual Studio .NET

The Visual Studio .NET IDE is the best part of simplified development. The tools available in VS .NET allow you to quickly and easily develop large-scale, distributed applications. Chapter 17 delves into the features of the VS .NET IDE, and I am sure you will be very impressed as you start to use it in the real world to develop applications.

Multilanguage support

As of today, there are roughly 18 languages that the framework supports. From Pascal to COBOL to JScript, you have complete freedom over the tool you use to develop your applications. As the CLR gains more acceptance, there are sure to be additional languages added by other companies besides Microsoft.

Out of the VS .NET box, Microsoft ships with compilers for JScript .NET, Visual Basic .NET, C#, and Managed C++. .All of these languages are fully supported in the VS .NET IDE, and there are command-line compilers for each of these languages. The other 15 or so languages are coming from third parties, and they will either have their own IDE or they will hook into the VS .NET IDE.

How is this possible? The .NET Framework defines a subset of rules that defines how a language can be consumed by the CLR. The set of rules is called the Common Language Specification (CLS). The CLS allows any third party to create a language that can target the .NET Framework, as long as the specifications laid out in the CLS are followed.

Because of the CLS, language interoperability is possible. Components written in VB .NET can be consumed from C# or Managed C++, no extra code required. Passing strings from Managed C++ to VB .NET does not require strange conversion functions that will allow VB .NET to use the data. In .NET, a string is a string, the same in all languages. This is possible by the Common Type System employed by the framework, defined in the CLS.

The CTS defines what types are allowed to run inside the framework. A type can be defined as a value type or a reference type. Value types are stored as a representation of their value, such as data types. Reference types are stored as a reference to a type, such as an object. Reference types in .NET are based on the System.Object type, and they can be further broken down into classes that derive from the System.Object type. Figure 1-4 describes the CTS as implemented in the .NET Framework.

Figure 1-4: Common Type System

Debugging, tracing, and profiling are available across languages and across machines. Since these processes are based on what occurs at runtime, a single debugger can be used across all languages because it is interacting with the MSIL, not the specifics of a particular language.

All languages, no matter what developer-specific features the language offers, still have to compile down to the MSIL, and then get interpreted by the CPU-specific execution engine. This means that all languages are on a level playing field. All languages support the features of the .NET Framework, or else they would not be considered a .NET language.

There are language-specific features based on your language choice, which could include built-in functions, keywords, or language semantics, but when the file is built, it is built to the MSIL. The language-specific compiler will ensure that the code is type safe and will pass the MSIL verification process. This is not to say that certain rules cannot be broken, so you should investigate the CLS and CTS to make sure you are using CLS-compliant types.

VB .NET is an example of a language that has special features that other languages do not. Because there are roughly 12 million VB developers who have 10,000 times that in lines of code written, Microsoft has included an upgrade path for existing applications. This upgrade path uses a compatibility library that contains many of the same keywords and functions you are used to using in VB6. When you are coding in VB .NET, functions such as MsgBox are still valid, even though the BCL has a MessageBox class that is more robust and should be used. Essentially, the Msgbox function has a compatibility wrapper that actually calls the native BCL MessageBox class members.

Simplified deployment and management

The main unit of deployment in .NET is an assembly. Although assemblies can have a .dll extension (they can also have the .exe extension), they are not traditional COM DLLs. Assemblies contain a manifest, which is Metadata that is "emitted" to the callers of the assembly.

The Metadata contains the name of the assembly, the version, the culture, and optionally the public key for the assembly. Other information in the assembly includes what types are exported, what types are referenced, and the security permissions for each type.

Assemblies come in two flavors: private or shared.

Private assemblies are deployed through a "zero impact install" process. Zero impact install means that you no longer have to cross your fingers when you deploy an application, because the application installation is not affecting the state of the machine. Because the registry is not involved, you simply copy the files that your application needs to execute to the directory in which it will run. This process is called XCopy deployment. That's right, XCopy from the old DOS days. You are just copying files, and it all just works.

Shared assemblies are copied to the Global Assembly Cache (GAC). The GAC is a repository for files that can be shared across multiple processes. When assemblies are installed to the GAC, they are bound by version and policies defined by the publisher of the assembly.

Side-by-side DLLs, introduced with the release of Windows 2000, have come full circle in .NET. On the same machine, in the same exact process, DLLs with the same name but different versions can be executing at the same time.

Base class libraries

The .NET Framework provides a set of hierarchical objects, broken down by functionality, called the Base Class Libraries (BCL). The classes provide a set of common, object-oriented interfaces that can be accessed from any .NET language.

The BCL is divided into namespaces, which define a naming scheme for classes, such as webclasses, Data classes, Windows Forms, XML classes, Enterprise services, and System classes. By implementing a naming scheme, it is easy to categorize what functionality the classes are actually going to provide. For example, the Data classes provide the following top-level namespaces:

  • System.Data

  • System.Data.Common

  • System.Data.OLEDB

  • System.Data.SQLClient

  • System.Data.SQLTypes

Each one of the data namespaces is broken down further into more granular classes, which define the methods, fields, structures, enumerations, and interfaces that are provided by each type.

The System class provides the base services that all languages would include, such as IO, arrays, collections, security, and globalization.

Because the class system is unified for all languages, it is not important what language is attempting to access the base classes, all of the features are available to all languages, and the way in which the code is implemented is the same. This actually makes it very easy to understand code written in other languages. Because the class libraries in use are the same, the only difference in the code is the semantics of each specific language. After you figure out those semantics, you can fully understand what is going on in other languages. Consider the differences in the following VB .NET and C# code.

' VB.NET CodePublic Sub ReadMyData(strCN As String)
    Dim strQuery As String = "SELECT * FROM Orders"
    Dim cn As New SqlConnection(strCN)
    Dim cmd As New SqlCommand(strQuery, cn)
    cn.Open()
    Dim rdr As SqlDataReader
    rdr = cmd.ExecuteReader()
    While rdr.Read()
        Console.WriteLine(rdr.GetString(1))
    End While
    rdr.Close()
    cn.Close()
End Sub 'ReadMyData
// C# Codepublic void ReadMyData(string strCN) {
    string strQuery = "SELECT * FROM Orders";
    SqlConnection cn = new SqlConnection(strCN);
    SqlCommand cmd = new SqlCommand(strQuery,cn);
    cn.Open();
    SqlDataReader rdr;
    rdr = cmd.ExecuteReader();
    while (rdr.Read()) {
       Console.WriteLine(rdr.GetString(1));
    }
    rdr.Close();
    cn.Close();

}

The code is almost identical, except for the squiggly braces at the end of the lines of code in C#, and the way that variables are declared.

Visual Basic .NET

Now that you have an idea of what the .NET Framework is and the features it provides, what does this mean to you as a VB .NET developer? The key components to VB .NET that will make your life as a developer easier are the language innovations, RAD features, the new forms models for the Web-based applications and Windows-based applications, and most importantly the ability to create Web Services.

Language innovations

VB .NET is finally a first-class language. Every feature that is provided by the framework is available in VB .NET. VB .NET is a fully object-oriented language, providing inheritance, polymorphism, encapsulation, overloading, and overriding. With structured exception handling, there is a clean and consistent method of handling errors not only within a method, but also in a calling chain of multiple methods, and even across components written in other languages.

RAD features

The VS .NET tool provides the most RAD tool ever developed to assist you in every possible way while writing code. With improved designers, server explorers, data designers, and XML designers, you have all the external tools at your fingertips to write client- and server-based applications. All of this without having to learn anything new, because the VS .NET IDE will be familiar to you if you have used any of the previous VB versions, or even Visual InterDev. IDE features such as auto complete and auto-list members have been improved to make is easier than ever to verify your code as you are developing.

Web Forms

Web Forms allow the development of scalable Web-based applications in a familiar VB-like IDE. Features such as code behind minimize the spaghetti code produced by Visual InterDev, and with down-level browser support, no special code is needed to target specific browser types or versions. The IDE is the same for Windows-based applications, so all of the features available to developing Windows-based applications are available when building Web-based applications.

Web Services

By prefixing a method with the identifier, which is an example of attribute-based programming, you have just created a Web Service callable method. The underlying plumbing is handled by the IDE, and deployment is as easy as copying a file to the Web server. Creating a Web Service is as easy as creating any other type of application.

Windows Forms

Windows Forms are a rewritten forms engine targeted specifically for the .NET platform. The same classes that are used in VB .NET are shared across all languages, and Windows Forms can even run as a semi-trusted or fully trusted browser component. So who needs applets!

Summary

As you can see, .NET has a lot to offer, not only from a framework standpoint, but also from a tools standpoint. By taking advantage of features of the Common Language Runtime, you have the ability to write applications that are object-oriented to the core, and that can interact with any other .NET application, written in any of the 18 or so .NET languages. .NET is truly a revolution in the way VB developers like you can write code, not only in a "Next Generation" fashion, but also faster than before because of the robust toolset provided by Microsoft. It is a very exciting time, and by reading this book, you will have a solid foundation on which to proceed in your next .NET application....

Read More Show Less

Table of Contents

Preface.

Acknowledgments.

PART I: Introduction.

Chapter 1: Introduction to .NET.

Chapter 2: VB6 and VB .NET Differences.

PART II: The VB .NET Programming Language.

Chapter 3: Object-Oriented Programming and VB .NET.

Chapter 4: Hello World.

Chapter 5: Data Types, Variables, and Operators.

Chapter 6: Arrays.

Chapter 7: Conditional Logic.

Chapter 8: Procedures.

Chapter 9: Dialog Boxes.

Chapter 10: File IO and System Objects.

Chapter 11: Dictionary Object.

Chapter 12: Error Handling.

Chapter 13: Namespaces.

Chapter 14: Classes and Objects.

Chapter 15: Multithreading.

Chapter 16: COM Interop and MSMQ.

PART III: Visual Studio .NET: The IDE for VB .NET.

Chapter 17: Visual Basic .NET IDE.

Chapter 18: Compiling and Debugging.

Chapter 19: Customizing.

Chapter 20: Source Control.

PART IV: Data Access.

Chapter 21: Introduction to Data Access in .NET.

Chapter 22: ADO.NET.

Chapter 23: Data Access in Visual Studio .NET.

Chapter 24: Introduction to XML in .NET.

PART V: Windows Forms.

Chapter 25: Introduction to System.Windows.Forms.

Chapter 26: Controls.

Chapter 27: Specific Controls.

Chapter 28: Visual: Inheritance.

Chapter 29: Irregular Forms.

Chapter 30: Other Namespaces and Objects in the Catalog.

PART VI: VB .NET and the Web.

Chapter 31: Introduction to Web Development.

Chapter 32: Introduction to ASP.NET.

Chapter 33: Page Framework.

Chapter 34: HTML Server Controls.

Chapter 35: Web Controls.

Chapter 36: Validation Controls.

Chapter 37: User Controls.

Chapter 38: Events.

Chapter 39: Cascading Style Sheets.

Chapter 40: State Management.

Chapter 41: ASP.NET Applications.

Chapter 42: Tracing.

Chapter 43: Security.

PART VII: Web Services.

Chapter 44: Introduction to Web Services.

Chapter 45: Web Services Infrastructure.

Chapter 46: SOAP.

Chapter 47: Building a Web Service.

Chapter 48: Deploying and Publishing Web Services.

Chapter 49: Finding Web Services.

Chapter 50: Consuming Web Services.

Appendix A: Globalization.

Globalizing Applications.

Localization.

Resource Files.

CultureInfo Class.

ResourceManager Class.

Windows Forms Designer Globalization.

Appendix B: VB6 Upgrade Wizard.

Why You Should Not Upgrade.

The Upgrade Wizard.

SimpleClient.VBP.

SimpleClient.NET.

Index.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)