Visual Basic .NET Tips & Techniques

Name: Visual Basic .NET Tips & Techniques
Brand: McGraw-Hill
Price: 85.89 EUR
Availability: OnlineOnly

Kris Jamsa(Autor*in)

McGraw-Hill (Verlag)

1. Auflage

Erschienen am 29. Mai 2002

706 Seiten

E-Book

PDF mit Adobe-DRM

Systemvoraussetzungen

978-0-07-222824-3 (ISBN)

85,89 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Intro
Copyright
Contents at a Glance
Contents
Acknowledgements
Introduction
Why You Should Read this Book
What this Book Covers
How to Use this Book
CHAPTER 1 Laying Your Visual Basic .NET Foundation
Creating Your First Console Application
Building a Windows-Based Application
Choosing the Correct Visual Basic Types
Declaring Variables in a Visual Basic .NET Program
Displaying Screen Output Using Console.Write and Console.WriteLine
Formatting Program Output Using Console.WriteLine
Concatenating Characters to the End of a String
Forcing Programs to Specify a Variable's Type
Beware of Variable Overflow and Precision
Performing Numeric Operations
Casting a Value of One Variable Type to Another
Making Decisions Using Conditional Operators
Taking a Closer Look at the Visual Basic .NET Relational and Logical Operators
Handling Multiple Conditions Using Select
Repeating a Series of Instructions
Avoiding Infinite Loops
Executing a Loop Prematurely
Visual Basic .NET Supports Lazy Evaluation to Improve Performance
Wrapping Long Statements
Taking Advantage of the Visual Basic Assignment Operators
Commenting Your Program Code
Reading Keyboard Input Using Console.Read and Console.ReadLine
Displaying a Message in a Message Box
Prompting the User for Input Using an Input Box
Breaking a Programming Task into Manageable Pieces
Passing Parameters to a Function or Subroutine
Declaring Local Variables in a Function or Subroutine
Changing a Parameter's Value in a Subroutine
Using Scope to Understand the Locations in a Program Where a Variable Has Meaning
Storing Multiple Values of the Same Type in a Single Variable
Grouping Values in a Structure
Improving Your Code's Readability Using Constants
Summarizing the Differences Between Visual Basic and Visual Basic .NET
CHAPTER 2 Exploiting the .NET Environment
Taking Advantage of the Common Language Runtime
Declaring Variables Based on Common Types
Migrating to ASP.NET
Exploiting Windows Forms
Making Sense of Metadata
Organizing Object Libraries Using Namespaces
Taking Advantage of Intermediate Language Code
Packaging .NET Solutions into Assemblies
Leveraging Managed Memory and Garbage Collection
Making Sense of .NET Versioning
Standardizing Error Handling
CHAPTER 3 Programming Visual Basic .NET Classes
Using Scope Attributes to Restrict Access to Class Members
Initializing Class Member Variables
Defining Multiple Constructors to Support Different Parameters
Simplifying Object Member References
Taking Advantage of Static Class Members
Taking Advantage of Properties to Control Values a Class Member Can Store
Avoiding Parameter Name and Class Member Variable Name Conflicts
Performing "Cleanup" Processing Using a Destructor Method
Mapping a Class Object to a Visual Basic .NET Form
Taking a Closer Look at .NET Garbage Collection
Forcing the Garbage Collector to Collect Unused Memory
Providing Destructor-like Support for Dispose Operations
Taking a Closer Look at Visual Basic .NET Forms
Taking a Closer Look at a Class Using the Visual Studio Class View
Sharing a Class Member Variable Among Class Instances
Inserting a Class Template Using Visual Studio
Researching Classes Using the Visual Studio Object Browser
CHAPTER 4 Object-Oriented Programming in Visual Basic .NET
Keeping Track of Constructor Methods
Passing Parameters to the Base-Class Constructor
Taking a Close Look at Inheritance and Destructor Methods
Method Overloading and Inheritance
Method Overriding and Inheritance
Shadowing a Base-Class Method
Forcing a Specific Method's Invocation Using MyClass
Preventing Class Inheritance
Implementing Polymorphic Objects that Change Form as Your Program Executes
Taking a Sneak Preview at Inheritance and Events
Restricting a Class for Use Only as a Base Class
Forcing a Derived Class to Override a Base-Class Method
Multiple Levels of Inheritance Differs from Multiple Inheritance
Creating an Interface
Implementing Multiple Interfaces Within a Class
Inheriting a Class that Implements an Interface
CHAPTER 5 Test Driving the Common Language Runtime and Base Class Library
Retrieving the Current System Date and Time
Taking a Closer Look at the DateTime Class
Taking a Closer Look at the String Class
Improving Performance Using a StringBuilder Object
Exploiting the Math Class
Sending E-mail Messages from Within a Visual Basic .NET Program
CHAPTER 6 Programming Visual Basic .NET File and Directory Operations
Getting Started with the Directory Class
Retrieving and Manipulating Directory Attributes
Creating a Unique Directory
Retrieving a Directory's Files and Subdirectories
Determining a System's Logical Disk Drives
Retrieving a Directory's Files and Subdirectories Using the DirectoryInfo Class
Retrieving a Directory's Parent or Root Directory
Manipulating a Directory Path
Performing Common File Operations
Taking Advantage of File Attributes
Starting with File Streams
Taking a Closer Look at the StreamWriter and StreamReader Classes
Reading and Writing Binary Data
Getting Started with File Locks
Responding to FileWatcher Events
CHAPTER 7 Leveraging the .NET Common Dialogs
Prompting the User for a File to Open
Fine-Tuning OpenFileDialog Operations
Saving Information in a User-Specified File
Fine-Tuning File Save Operations
Selecting Font Attributes
Putting a User's Font Selections to Use
Selecting a Color
Fine-Tuning Color Dialog Box Operations
Using the PrintDialog Class to Prompt the User for Printing Options
Determining Available Printers
Using the PageSetupDialog Class to Prompt the User for Page Settings
Performing Print Operations
CHAPTER 8 Exploiting Multiple Threads of Execution
Creating and Running Multiple Threads
Putting a Thread to Sleep
Suspending, Resuming, and Aborting a Thread
Taking a Closer Look at the Thread Class
Assigning Thread Names
Suspending One Thread's Execution Until a Specific Thread Completes Its Processing
Controlling Thread Priorities
Taking Advantage of the Thread Pool
Recognizing Potential Race Conditions Between Threads
Using SyncLock to Protect a Shared Resource
Synchronizing Thread Resource Access Using the Monitor Class
Preventing Thread Blocking with Monitor.TryEnter
Protecting Shared Variable Increment and Decrement Operations Using InterLocked
Taking a Closer Look at the Process Class
Launching a Program Using the Process Class
Terminating a Process
Preventing Two Copies of the Same Program from Executing at the Same Time
Displaying Information About Each Process in Your System
Displaying Information About a Process's Threads
CHAPTER 9 Taking Advantage of Structured Error Handling
Catching a Specific Exception
Testing for Different Exceptions
Handling Exceptions Using a Generic Catch Statement
Performing "Cleanup" Processing After an Exception Occurs
Taking a Closer Look at the System.Exception Class
Creating Your Own Custom Exceptions
Testing Your Exception Handling by Throwing an Exception
Chasing Down the Code Location that Caused an Exception
Taking a Closer Look at the Debug Class
Determining If the Debugger Is Active
Using Debug Class Assertions to Locate Program Errors
Using Event Logs to Track Program Operations
CHAPTER 10 Responding to and Handling Events
Defining and Raising an Event in a Class
Handling an Event Using the Handles Clause
Specifying an Event Handler Using AddHandler
Calling Multiple Handlers for an Event
Adding and Removing Event Handlers
Taking Advantage of Events and Class Inheritance
Using a .NET Delegate to Point to a Function
Taking Advantage of a Delegate in a Subroutine Call
Sorting Data Using Delegates
Assigning Multiple Methods to a Delegate
Viewing a Delegate's Invocation List
Responding to Timer Events
Taking a Closer Look at the EventArgs Class
CHAPTER 11 Programming Windows Forms
Programming the Form Control
Programming the Button Control
Programming the Label Control
Adding Images to a Form's Label
Programming the LinkLabel Class
Programming Menu Controls
Programming the PictureBox Control
Programming the NumericUpDown Control
Programming the ComboBox Control
Displaying an Operation's Status Using a ProgressBar and the StatusBar
Programming the TextBox Control
Programming the RichTextBox Control
Programming ScrollBar Controls
Programming the TrackBar Control
Programming the ToolBar Control
Programming the RadioButton Control
Using a GroupBox to Group Radio Buttons
Programming the CheckBox Control
Programming the DomainUpDown Control
Programming the ListBox Control
Programming the CheckedListBox Control
Programming the DateTimePicker Control
Programming the MonthCalendar Control
Programming a Tab Control
Using a Panel Control to Group Controls
Programming the TreeView Control
Programming the ListView Control
CHAPTER 12 Looking Closer at .NET Assemblies and Versioning
Revisiting .NET Assemblies
Creating a Class Library
Leveraging a Class Library's Programming-Language Independence
Taking a Closer Look at a Shared Assembly's Public Key
Installing a Shared Assembly into the Global Assembly Cache
Exploiting .NET Versioning
Precompiling a Shared Assembly to Reduce Load Time
Using the @Assembly Directive in an ASP.NET Page
Taking Advantage of the Microsoft .NET Framework Configuration
Viewing an Application's Assembly Specifics
CHAPTER 13 Programming ASP.NET Solutions
Creating and Running a Simple ASP.NET Page
Implementing a Simple ASP.NET Page Using C#and Visual Basic .NET
Creating and Running an ASP.NET Project in Visual Studio
Coding Changes You Must Make as You Migrate from ASP to ASP.NET
Taking Advantage of Cookies in an ASP.NET Page
Determining a Browser's Capabilities
Maintaining ASP and ASP.NET Pages Side by Side
ASP and ASP.NET Cannot Share Application and Session Objects
Viewing HTTP Header Information
Taking Advantage of Key ASP.NET Page-Based Methods
ASP and ASP.NET Treat Form.Request and Form.QueryString Differently
Handling Exceptions in ASP.NET Pages
Taking Advantage of ASP.NET Configuration Files
Implementing a Custom-Error Page
Improving Performance by Disabling Debug Operations
Specifying Application-and Session-Specific Processing
Taking a Closer Look at the Page Directive
Fine-Tuning ASP.NET Cache Attributes
Importing a Namespace Using the Imports Directive
CHAPTER 14 Programming Windows Services
Building a Simple Windows Service
Installing and Removing a Service in Windows 2000
Taking a Closer Look at the ServiceBase Class
Writing Service Events to the Windows Event Log
Directing a Service to Perform Operations at Specific Time Intervals
Taking Advantage of Threads to Process Service Operations
Notifying the Administrator of Critical System Events
Integrating a FileSystemWatcher into a Web Service
CHAPTER 15 Programming Web Forms
Programming the asp:Button Control
Programming the asp:Checkbox Control
Programming the asp:CheckboxList Controls
Programming the asp:RadioButton Control
Programming the asp:Hyperlink Control
Programming the asp:Image Control
Programming the asp:ImageButton Control
Programming the asp:Label Control
Programming the asp:TextBox Control
Programming the asp:Panel Control
Programmnig the asp:DropDownList Control
Programming the asp:ListBox
Programming the asp:RadioButtonList Control
Programming the asp:Literal Control
Programming the asp:PlaceHolder Control
Programming the asp:Calendar Control
Programming the asp:Rotator Control
Programming the asp:XML Control
Programming the asp:RequiredFieldValidator Control
Programming the asp:RangeValidator Control
Programming the asp:CompareValidator Control
Programming the asp:CustomValidator Control
Programming the asp:RegularExpressionValidator Control
Taking Advantage of HTML Server Controls
CHAPTER 16 Programming Web Services
Creating Your First Web Service
Creating a Simple Date/Time Web Service
Writing a Web Service that Uses Parameter-Based Methods
Using an HTML Form to Interact with a Web Service
Creating a Proxy for Your Web Service
Using a Web Service from Within an ASP.NET Page
Looking Behind the Scenes at Your Service's Web Service Description Language
Handling Exceptions in Web Services
Leveraging the Web Service Configuration Files
Looking Behind the Scenes at Your Web Service's SOAP
Building a Proxy Using WSDL.EXE
Changing the Web Service Namespace
Helping Others Discover Your Web Service
CHAPTER 17 Getting Started with ADO.NET
Specifying a Data Provider
Issuing a Query Using a DataReader Object
Issuing a Query Using a DataSet Object
Handling Data Set Updates Behind the Scenes
Querying a Database about Its Tables
Querying a Table about Its Columns
Viewing the Underlying XML Content
Building a Data Set from an XML File
Performing a Query Using an ASP.NET Page
Displaying a Database Table in a DataGrid Control
CHAPTER 18 Programming .NET Reflection and Program Attributes
Revisiting .NET Reflection
Viewing Class Information in ILDASM
Revisiting an Object's Methods
Taking a Closer Look at an Object's Methods
Contrasting Early and Late Binding
Invoking an Object Method Using Invoke
Taking a Closer Look at an Assembly
Making Sense of &Attributes&
Defining a Custom Attribute
Displaying an Assembly's Attributes
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken