NO STARCH PRESS
"the finest in geek entertainment"™
"the finest in geek entertainment"™
book main | contents |
reviews | updates
|
Introduction Who should read this book What you will learn Code samples Complaints, adulation, and everything in between Chapter overview Chapter 1: The .NET Revolution A brief history of Visual Basic Modern-day problems Visual Basic's quirky mix Isolated languages Enterprise development headaches DLL Hell Incomplete support for object-oriented programming The .NET Vision The ingredients of .NET The Common Language Runtime (CLR) The .NET classes Speaking the same language Deep language integration Pre-built infrastructure Web Services and the next-generation Internet Open standards: XML, SOAP, WSDL and other letters from the alphabet Metadata: The end of DLL Hell? Still want more details? Is VB.NET still VB? Ten enhancements you can't live without Ten changes that may frustrate you The dark side of .NET What about COM? Chapter 2: The Design Environment New in .NET Starting out in the IDE The start page What's New Online Community Headlines Search Online Downloads Web Hosting My Profile Get Started Manipulating IDE windows Window navigation Basic facts about the IDE Docking and tabbing Auto hiding and push pins Splitting windows Windows in Visual Studio .NET The Solution Explorer The Class View The Toolbox The Properties window The Output window The task list The code display The Dynamic Help window Using macros The Macro IDE The temporary macro Macros with intelligence Configuring IDE settings The Options window Personalizing your environment Summary Chapter 3: VB.NET Basics New in .NET Namespaces, Types, and the Class Library Introducing the class library Adding references What exactly is in the class library? Using the objects in a namespace Exploring namespaces The new file format Class and Module blocks Changing and extending your project's namespace The simplest possible .NET program Other resources Data types The System types Arrays Data types "under the hood" It's all objects Changes to operations Syntax changes Converting variables Math Some new rules for scope Enhanced functions Optional parameters and defaults Default values Procedure overloading Calling a procedure Delegates Summary Chapter 4: Windows Forms New in .NET Getting started Designing forms The component tray Custom designers Locking controls Basic form properties Anchoring Docking Making docking work Splitting windows Form oddities Exploring .NET forms The .NET way: forms as classes Form inheritance Modal forms Under the hood with Visual Basic 6 forms Under the hood with .NET forms Stepping through the "muck and goo" What about binary information? Control events Handling more than one event Dynamically adding controls Dynamic event hook up Interacting between forms Dialog windows Owner forms MDI interfaces A Control Gallery List controls Organizing controls Menu controls Modern controls The NotifyIcon control Providers Dialog box controls What comes next? Chapter 5: Object-Oriented Programming New in .NET Introducing OOP! What is object-oriented programming? The problems with traditional structured programming First there were structures… A very simple person structure Making a structure with brains Instantiating an object What is an object, really? Enhancing a class with properties Enhancing a class with a constructor Constructors that accept parameters Multiple constructors The default constructor Destructors Garbage collection Enhancing a class with events An event in action Events with different signatures Summary What comes next? Chapter 6: Mastering Objects New in .NET The philosophy of OOP The "black box" idea Loose coupling Cohesion Types in .NET Enumerations Creating an enumeration Enumerations "under the hood" Organizing enumerations Shared members Shared methods Shared properties Modules "under the hood" Inheritance Constructors in inherited classes Protected members Overriding methods Overridden methods in action Casting MustOverride and MustInherit Multiple inheritance Is inheritance a good idea? Inheriting to extend .NET classes Interfaces Using interfaces Interfaces and backward compatibility COM and interface-based programming Other reasons to use interfaces Collection classes A basic collection A NuclearFamily class Creating a custom collection class What comes next? Chapter 7: Bug Proofing New in .NET Anatomy of an error The principles of bug proofing How Visual Basic.NET treats errors Option Explicit and Option Strict Line Numbers Visual Studio.NET's debugging tools Watching your program in action Commands available in break mode Customizing breakpoints Breakpoint window The Autos, Locals, and Watch windows The Call Stack window Structured exception handling Understanding the error Call stack The evolution from On Error Goto The Exception object Filtering by exception Filtering by conditions Throwing your own exceptions Defensive coding The principles of defensive coding Testing assumptions with Assertions Using logging and traces Putting it all together Chapter 8: Dealing With Data: Files, Printing, and XML New in .NET Interacting with Files Creating a FileStream Writing text to a file Writing binary information Visual Basic-style file access Managing files and folders The File class The FileInfo class Printing and previewing Printing data from an array Printing pictures Print settings Print preview Parsing information Working with the registry XML files What is XML anyway? Writing a simple XML document Reading XML Advanced XML What's next? Chapter 9: Databases and ADO.NET New in .NET Introducing ADO.NET Using relational data SQL Server and OLE DB The Basic ADO.NET Objects ADO.NET object relations Connection objects Command objects Data reader objects Updating Data with the Command Object Why use a Command? A data update example A transaction example A stored procedure example Using DataSets When should I use a DataSet? Filling a DataSet with a data adapter Accessing information in a DataSet Deleting records Adding information to a DataSet Working with multiple tables DataTable relations Updating Data Using a DataSet Using the CommandBuilder object Updating the data source Reporting concurrency problems Updating in stages Creating a DataSet by hand Storing a DataSet in XML Data binding What Comes Next? Chapter 10: Threading New in .NET An introduction to threading Under the hood with threads Comparing single-threading and multithreading Scalability and simplicity Timers versus threads Creating a simple multithreaded application Wrapping a thread in a class Basic thread management Thread methods Thread priorities Background threads When is too much not enough Retrieving information from a thread Using callbacks Synchronizing Potential thread problems Basic synchronization A sample synchronization problem Fixing our problem with SyncLock What comes next? Chapter 11: Setup and Deployment New in .NET Introducing Assemblies Assemblies vs. Components That Use COM Why haven't we seen these features before? Looking at your program as an assembly Setting assembly information Retrieving assembly information Creating a .NET Component Creating a class library project Creating a client Other .NET requirements The Global Assembly Cache The GAC "under the hood" Creating a shared assembly Advanced Policy Files Specifying a version for a shared assembly Specifying a search path for a private assembly Introducing The Windows Installer Creating a Windows Installer setup The Windows Installer project Basic setup project options File System Registry File Types User Interface Choice windows Conditions Custom Actions Launch Conditions Summary Chapter 12: Web Forms and ASP.NET New in .NET A Web Development Outline What was wrong with ASP? Starting a Web Application Ingredients of an ASP.NET project Designing with Web Forms Adding controls to a Web Form How does it work? The AutoPostback property Web Control events View state Under the hood with a Web Form Other controls Thinking About State Anatomy of a web request Witnessing the problem Using the State Bag Transferring Information Passing information in the query string Using session state Using Application state A summary of different types of state management What comes next? Chapter 13: Web Services New in .NET The vision of the interactive Web Web Services: COM for the Internet? Web Services today Creating your first Web Service Touching up your Web Service Testing your Web Service Your Web Service in action The open standards plumbing XML and WSDL SOAP Accessing a Web Service directly Consuming a Web Service The proxy class Adding a web reference Inspecting the proxy class Using the proxy class Dynamic discovery What comes next? Chapter 14: Migrating To Visual Basic.NET Introducing .NET Migration Visual Basic 6 in the .NET world File compatibility The migration wizard Migrating a simple project Importing the project Forms and the "default instance" Other changes COM components in .NET ActiveX components in .NET Migrating a sophisticated project Showstoppers Common migration errors Arrays Variants Default properties Load statement Printing Clipboard Context-sensitive help Menu controls Control arrays Automatic re-initialization GDI Class_Terminate code VarPtr, StrPtr, ObjPtr Memory storage for user-defined types Optional parameters Goto and Gosub Other new behaviors Preparing for VB.NET Summary |
book main | contents | reviews | updates
Copyright 2010 by No Starch Press