
At a Glance
708 Pages
23.5 x 19.1 x 3.5
Paperback
$103.75
or 4 interest-free payments of $25.94 with
 orÂShips in 15 to 25 business days
| Acknowledgments | p. xvii |
| Introduction | p. xix |
| Laying Your Visual Basic .NET Foundation | p. 1 |
| Creating Your First Console Application | p. 2 |
| Building a Windows-Based Application | p. 4 |
| Choosing the Correct Visual Basic Types | p. 6 |
| Declaring Variables in a Visual Basic .NET Program | p. 7 |
| Displaying Screen Output Using Console.Write and Console.WriteLine | p. 9 |
| Formatting Program Output Using Console.WriteLine | p. 11 |
| Concatenating Characters to the End of a String | p. 13 |
| Forcing Programs to Specify a Variable's Type | p. 15 |
| Beware of Variable Overflow and Precision | p. 17 |
| Performing Numeric Operations | p. 19 |
| Casting a Value of One Variable Type to Another | p. 22 |
| Making Decisions Using Conditional Operators | p. 24 |
| Taking a Closer Look at the Visual Basic .NET Relational and Logical Operators | p. 27 |
| Handling Multiple Conditions Using Select | p. 29 |
| Repeating a Series of Instructions | p. 31 |
| Avoiding Infinite Loops | p. 34 |
| Executing a Loop Prematurely | p. 34 |
| Visual Basic .NET Supports Lazy Evaluation to Improve Performance | p. 35 |
| Wrapping Long Statements | p. 36 |
| Taking Advantage of the Visual Basic Assignment Operators | p. 37 |
| Commenting Your Program Code | p. 38 |
| Reading Keyboard Input Using Console.Read and Console.ReadLine | p. 39 |
| Displaying a Message in a Message Box | p. 40 |
| Prompting the User for Input Using an Input Box | p. 41 |
| Breaking a Programming Task into Manageable Pieces | p. 43 |
| Passing Parameters to a Function or Subroutine | p. 47 |
| Declaring Local Variables in a Function or Subroutine | p. 49 |
| Changing a Parameter's Value in a Subroutine | p. 51 |
| Using Scope to Understand the Locations in a Program Where a Variable Has Meaning | p. 52 |
| Storing Multiple Values of the Same Type in a Single Variable | p. 55 |
| Grouping Values in a Structure | p. 58 |
| Improving Your Code's Readability Using Constants | p. 60 |
| Summarizing the Differences Between Visual Basic and Visual Basic .NET | p. 62 |
| Exploiting the .NET Environment | p. 64 |
| Taking Advantage of the Common Language Runtime | p. 65 |
| Declaring Variables Based on Common Types | p. 67 |
| Migrating to ASP.NET | p. 70 |
| Exploiting Windows Forms | p. 74 |
| Making Sense of Metadata | p. 76 |
| Organizing Object Libraries Using Namespaces | p. 79 |
| Taking Advantage of Intermediate Language Code | p. 82 |
| Packaging .NET Solutions into Assemblies | p. 84 |
| Leveraging Managed Memory and Garbage Collection | p. 86 |
| Making Sense of .NET Versioning | p. 89 |
| Standardizing Error Handling | p. 90 |
| Programming Visual Basic .NET Classes | p. 92 |
| Using Scope Attributes to Restrict Access to Class Members | p. 97 |
| Initializing Class Member Variables | p. 100 |
| Defining Multiple Constructors to Support Different Parameters | p. 102 |
| Simplifying Object Member References | p. 105 |
| Taking Advantage of Static Class Members | p. 107 |
| Taking Advantage of Properties to Control Values a Class Member Can Store | p. 109 |
| Avoiding Parameter Name and Class Member Variable Name Conflicts | p. 112 |
| Performing "Cleanup" Processing Using a Destructor Method | p. 112 |
| Mapping a Class Object to a Visual Basic .NET Form | p. 114 |
| Taking a Closer Look at .NET Garbage Collection | p. 115 |
| Forcing the Garbage Collector to Collect Unused Memory | p. 117 |
| Providing Destructor-like Support for Dispose Operations | p. 119 |
| Taking a Closer Look at Visual Basic .NET Forms | p. 120 |
| Taking a Closer Look at a Class Using the Visual Studio Class View | p. 123 |
| Sharing a Class Member Variable Among Class Instances | p. 124 |
| Inserting a Class Template Using Visual Studio | p. 125 |
| Researching Classes Using the Visual Studio Object Browser | p. 127 |
| Object-Oriented Programming in Visual Basic .NET | p. 128 |
| Keeping Track of Constructor Methods | p. 129 |
| Passing Parameters to the Base-Class Constructor | p. 131 |
| Taking a Close Look at Inheritance and Destructor Methods | p. 134 |
| Method Overloading and Inheritance | p. 137 |
| Method Overriding and Inheritance | p. 140 |
| Shadowing a Base-Class Method | p. 144 |
| Forcing a Specific Method's Invocation Using MyClass | p. 146 |
| Preventing Class Inheritance | p. 148 |
| Implementing Polymorphic Objects that Change Form as Your Program Executes | p. 149 |
| Taking a Sneak Preview at Inheritance and Events | p. 151 |
| Restricting a Class for Use Only as a Base Class | p. 152 |
| Forcing a Derived Class to Override a Base-Class Method | p. 152 |
| Multiple Levels of Inheritance Differs from Multiple Inheritance | p. 156 |
| Creating an Interface | p. 158 |
| Implementing Multiple Interfaces Within a Class | p. 162 |
| Inheriting a Class that Implements an Interface | p. 163 |
| Test Driving the Common Language Runtime and Base Class Library | p. 166 |
| Retrieving the Current System Date and Time | p. 167 |
| Taking a Closer Look at the DateTime Class | p. 169 |
| Taking a Closer Look at the String Class | p. 172 |
| Improving Performance Using a StringBuilder Object | p. 176 |
| Exploiting the Math Class | p. 179 |
| Sending E-mail Messages from Within a Visual Basic .NET Program | p. 181 |
| Programming Visual Basic .NET File and Directory Operations | p. 184 |
| Getting Started with the Directory Class | p. 185 |
| Retrieving and Manipulating Directory Attributes | p. 190 |
| Creating a Unique Directory | p. 193 |
| Retrieving a Directory's Files and Subdirectories | p. 194 |
| Determining a System's Logical Disk Drives | p. 196 |
| Retrieving a Directory's Files and Subdirectories Using the DirectoryInfo Class | p. 197 |
| Retrieving a Directory's Parent or Root Directory | p. 198 |
| Manipulating a Directory Path | p. 200 |
| Performing Common File Operations | p. 204 |
| Taking Advantage of File Attributes | p. 207 |
| Starting with File Streams | p. 213 |
| Taking a Closer Look at the StreamWriter and StreamReader Classes | p. 217 |
| Reading and Writing Binary Data | p. 221 |
| Getting Started with File Locks | p. 225 |
| Responding to FileWatcher Events | p. 227 |
| Leveraging the .NET Common Dialogs | p. 230 |
| Prompting the User for a File to Open | p. 232 |
| Fine-Tuning OpenFileDialog Operations | p. 235 |
| Saving Information in a User-Specified File | p. 239 |
| Fine-Tuning File Save Operations | p. 241 |
| Selecting Font Attributes | p. 244 |
| Putting a User's Font Selections to Use | p. 247 |
| Selecting a Color | p. 248 |
| Fine-Tuning Color Dialog Box Operations | p. 250 |
| Using the PrintDialog Class to Prompt the User for Printing Options | p. 252 |
| Determining Available Printers | p. 255 |
| Using the PageSetupDialog Class to Prompt the User for Page Settings | p. 256 |
| Performing Print Operations | p. 260 |
| Exploiting Multiple Threads of Execution | p. 264 |
| Creating and Running Multiple Threads | p. 267 |
| Putting a Thread to Sleep | p. 270 |
| Suspending, Resuming, and Aborting a Thread | p. 272 |
| Taking a Closer Look at the Thread Class | p. 275 |
| Assigning Thread Names | p. 277 |
| Suspending One Thread's Execution Until a Specific Thread Completes Its Processing | p. 280 |
| Controlling Thread Priorities | p. 283 |
| Taking Advantage of the Thread Pool | p. 286 |
| Recognizing Potential Race Conditions Between Threads | p. 288 |
| Using SyncLock to Protect a Shared Resource | p. 292 |
| Synchronizing Thread Resource Access Using the Monitor Class | p. 294 |
| Preventing Thread Blocking with Monitor.TryEnter | p. 298 |
| Protecting Shared Variable Increment and Decrement Operations Using InterLocked | p. 300 |
| Taking a Closer Look at the Process Class | p. 301 |
| Launching a Program Using the Process Class | p. 306 |
| Terminating a Process | p. 310 |
| Preventing Two Copies of the Same Program from Executing at the Same Time | p. 312 |
| Displaying Information About Each Process in Your System | p. 313 |
| Displaying Information About a Process's Threads | p. 314 |
| Taking Advantage of Structured Error Handling | p. 318 |
| Catching a Specific Exception | p. 324 |
| Testing for Different Exceptions | p. 327 |
| Handling Exceptions Using a Generic Catch Statement | p. 328 |
| Performing "Cleanup" Processing After an Exception Occurs | p. 330 |
| Taking a Closer Look at the System.Exception Class | p. 333 |
| Creating Your Own Custom Exceptions | p. 335 |
| Testing Your Exception Handling by Throwing an Exception | p. 336 |
| Chasing Down the Code Location that Caused an Exception | p. 339 |
| Taking a Closer Look at the Debug Class | p. 341 |
| Determining If the Debugger Is Active | p. 346 |
| Using Debug Class Assertions to Locate Program Errors | p. 347 |
| Using Event Logs to Track Program Operations | p. 348 |
| Responding to and Handling Events | p. 354 |
| Defining and Raising an Event in a Class | p. 355 |
| Handling an Event Using the Handles Clause | p. 358 |
| Specifying an Event Handler Using AddHandler | p. 361 |
| Calling Multiple Handlers for an Event | p. 363 |
| Adding and Removing Event Handlers | p. 365 |
| Taking Advantage of Events and Class Inheritance | p. 366 |
| Using a .NET Delegate to Point to a Function | p. 367 |
| Taking Advantage of a Delegate in a Subroutine Call | p. 370 |
| Sorting Data Using Delegates | p. 373 |
| Assigning Multiple Methods to a Delegate | p. 377 |
| Viewing a Delegate's Invocation List | p. 378 |
| Responding to Timer Events | p. 379 |
| Taking a Closer Look at the EventArgs Class | p. 381 |
| Programming Windows Forms | p. 384 |
| Programming the Form Control | p. 388 |
| Programming the Button Control | p. 390 |
| Programming the Label Control | p. 392 |
| Adding Images to a Form's Label | p. 395 |
| Programming the LinkLabel Class | p. 396 |
| Programming Menu Controls | p. 398 |
| Programming the PictureBox Control | p. 399 |
| Programming the NumericUpDown Control | p. 402 |
| Programming the ComboBox Control | p. 404 |
| Displaying an Operation's Status Using a ProgressBar and the StatusBar | p. 405 |
| Programming the TextBox Control | p. 407 |
| Programming the RichTextBox Control | p. 409 |
| Programming ScrollBar Controls | p. 411 |
| Programming the TrackBar Control | p. 412 |
| Programming the ToolBar Control | p. 414 |
| Programming the RadioButton Control | p. 416 |
| Using a GroupBox to Group Radio Buttons | p. 417 |
| Programming the CheckBox Control | p. 419 |
| Programming the DomainUpDown Control | p. 421 |
| Programming the ListBox Control | p. 422 |
| Programming the CheckedListBox Control | p. 424 |
| Programming the DateTimePicker Control | p. 425 |
| Programming the MonthCalendar Control | p. 427 |
| Programming a Tab Control | p. 428 |
| Using a Panel Control to Group Controls | p. 430 |
| Programming the TreeView Control | p. 431 |
| Programming the ListView Control | p. 433 |
| Looking Closer at .NET Assemblies and Versioning | p. 436 |
| Revisiting .NET Assemblies | p. 437 |
| Creating a Class Library | p. 439 |
| Leveraging a Class Library's Programming-Language Independence | p. 441 |
| Taking a Closer Look at a Shared Assembly's Public Key | p. 443 |
| Installing a Shared Assembly into the Global Assembly Cache | p. 444 |
| Exploiting .NET Versioning | p. 444 |
| Precompiling a Shared Assembly to Reduce Load Time | p. 446 |
| Using the @Assembly Directive in an ASP.NET Page | p. 447 |
| Taking Advantage of the Microsoft .NET Framework Configuration | p. 449 |
| Viewing an Application's Assembly Specifics | p. 451 |
| Programming ASP.NET Solutions | p. 454 |
| Creating and Running a Simple ASP.NET Page | p. 456 |
| Implementing a Simple ASP.NET Page Using C# and Visual Basic .NET | p. 458 |
| Creating and Running an ASP.NET Project in Visual Studio | p. 460 |
| Coding Changes You Must Make as You Migrate from ASP to ASP.NET | p. 463 |
| Taking Advantage of Cookies in an ASP.NET Page | p. 465 |
| Determining a Browser's Capabilities | p. 467 |
| Maintaining ASP and ASP.NET Pages Side by Side | p. 469 |
| ASP and ASP.NET Cannot Share Application and Session Objects | p. 471 |
| Viewing HTTP Header Information | p. 476 |
| Taking Advantage of Key ASP.NET Page-Based Methods | p. 479 |
| ASP and ASP.NET Treat Form.Request and Form.QueryString Differently | p. 480 |
| Handling Exceptions in ASP.NET Pages | p. 484 |
| Taking Advantage of ASP.NET Configuration Files | p. 488 |
| Implementing a Custom-Error Page | p. 489 |
| Improving Performance by Disabling Debug Operations | p. 490 |
| Specifying Application- and Session-Specific Processing | p. 492 |
| Taking a Closer Look at the Page Directive | p. 492 |
| Fine-Tuning ASP.NET Cache Attributes | p. 494 |
| Importing a Namespace Using the Imports Directive | p. 495 |
| Programming Windows Services | p. 500 |
| Building a Simple Windows Service | p. 502 |
| Installing and Removing a Service in Windows 2000 | p. 509 |
| Taking a Closer Look at the ServiceBase Class | p. 511 |
| Writing Service Events to the Windows Event Log | p. 514 |
| Directing a Service to Perform Operations at Specific Time Intervals | p. 516 |
| Taking Advantage of Threads to Process Service Operations | p. 519 |
| Notifying the Administrator of Critical System Events | p. 522 |
| Integrating a FileSystemWatcher into a Web Service | p. 526 |
| Programming Web Forms | p. 530 |
| Programming the asp:Button Control | p. 533 |
| Programming the asp:Checkbox Control | p. 536 |
| Programming the asp:CheckboxList Controls | p. 539 |
| Programming the asp:RadioButton Control | p. 541 |
| Programming the asp:Hyperlink Control | p. 543 |
| Programming the asp:Image Control | p. 545 |
| Programming the asp:ImageButton Control | p. 548 |
| Programming the asp:Label Control | p. 550 |
| Programming the asp:TextBox Control | p. 552 |
| Programming the asp:Panel Control | p. 555 |
| Programming the asp:DropDownList Control | p. 557 |
| Programming the asp:ListBox | p. 559 |
| Programming the asp:RadioButtonList Control | p. 561 |
| Programming the asp:Literal Control | p. 563 |
| Programming the asp:PlaceHolder Control | p. 564 |
| Programming the asp:Calendar Control | p. 566 |
| Programming the asp:Rotator Control | p. 567 |
| Programming the asp:XML Control | p. 569 |
| Programming the asp:RequiredFieldValidator Control | p. 570 |
| Programming the asp:RangeValidator Control | p. 573 |
| Programming the asp:CompareValidator Control | p. 576 |
| Programming the asp:CustomValidator Control | p. 578 |
| Programming the asp:RegularExpressionValidator Control | p. 580 |
| Taking Advantage of HTML Server Controls | p. 582 |
| Programming Web Services | p. 586 |
| Creating Your First Web Service | p. 588 |
| Creating a Simple Date/Time Web Service | p. 593 |
| Writing a Web Service that Uses Parameter-Based Methods | p. 595 |
| Using an HTML Form to Interact with a Web Service | p. 597 |
| Creating a Proxy for Your Web Service | p. 598 |
| Using a Web Service from Within an ASP.NET Page | p. 601 |
| Looking Behind the Scenes at Your Service's Web Service Description Language | p. 602 |
| Handling Exceptions in Web Services | p. 604 |
| Leveraging the Web Service Configuration Files | p. 605 |
| Looking Behind the Scenes at Your Web Service's SOAP | p. 606 |
| Building a Proxy Using WSDL.EXE | p. 606 |
| Changing the Web Service Namespace | p. 609 |
| Helping Others Discover Your Web Service | p. 609 |
| Getting Started with ADO.NET | p. 612 |
| Specifying a Data Provider | p. 613 |
| Issuing a Query Using a DataReader Object | p. 615 |
| Issuing a Query Using a DataSet Object | p. 617 |
| Handling Data Set Updates Behind the Scenes | p. 618 |
| Querying a Database about Its Tables | p. 620 |
| Querying a Table about Its Columns | p. 622 |
| Viewing the Underlying XML Content | p. 623 |
| Building a Data Set from an XML File | p. 625 |
| Performing a Query Using an ASP.NET Page | p. 628 |
| Displaying a Database Table in a DataGrid Control | p. 631 |
| Programming .NET Reflection and Program Attributes | p. 634 |
| Revisiting .NET Reflection | p. 635 |
| Viewing Class Information in ILDASM | p. 638 |
| Revisiting an Object's Methods | p. 640 |
| Taking a Closer Look at an Object's Methods | p. 644 |
| Contrasting Early and Late Binding | p. 646 |
| Invoking an Object Method Using Invoke | p. 649 |
| Taking a Closer Look at an Assembly | p. 652 |
| Making Sense of [left angle bracket]Attributes[right angle bracket] | p. 653 |
| Defining a Custom Attribute | p. 654 |
| Displaying an Assembly's Attributes | p. 656 |
| Index | p. 657 |
| Table of Contents provided by Syndetics. All Rights Reserved. |
ISBN: 9780072223187
ISBN-10: 0072223189
Series: Tips & Techniques
Published: 29th May 2002
Format: Paperback
Language: English
Number of Pages: 708
Audience: Professional and Scholarly
Publisher: McGraw-Hill Education - Europe
Country of Publication: US
Dimensions (cm): 23.5 x 19.1 x 3.5
Weight (kg): 1.23
Shipping
| Standard Shipping | Express Shipping | |
|---|---|---|
| Metro postcodes: | $9.99 | $14.95 |
| Regional postcodes: | $9.99 | $14.95 |
| Rural postcodes: | $9.99 | $14.95 |
Orders over $79.00 qualify for free shipping.
How to return your order
At Booktopia, we offer hassle-free returns in accordance with our returns policy. If you wish to return an item, please get in touch with Booktopia Customer Care.
Additional postage charges may be applicable.
Defective items
If there is a problem with any of the items received for your order then the Booktopia Customer Care team is ready to assist you.
For more info please visit our Help Centre.
























