You are previewing Visual Basic 2010 Unleashed.
O'Reilly logo
Visual Basic 2010 Unleashed

Book Description

Foreword by Beth Massi
Senior Program Manager, Microsoft Visual Studio

Visual Basic 2010 Unleashed is the most comprehensive, practical reference to modern object-oriented programming with Visual Basic 2010. Written by Visual Basic MVP Alessandro Del Sole, a long-time leader of the global VB community, this book illuminates the core of the VB language and demonstrates its effective use in a wide variety of programming scenarios.

Del Sole covers both Visual Basic 2010 Professional Edition for professional developers and the Express Edition for hobbyists, novices, and students. Writing for VB programmers at all levels of experience, he walks through using VB 2010 for data access, user interface development, networking, communication, and many other tasks. For those moving from structured languages–including VB 6–he offers detailed guidance on building effective object-oriented code. He also demonstrates how to make the most of Microsoft’s underlying .NET platform to write more robust and powerful software.

This book’s broad coverage includes advanced features such as generics and collections; a thorough introduction to the Visual Studio 2010 IDE and Visual Studio Team System; a full section on data access with ADO.NET and LINQ; practical overviews of WPF and WCF; coverage of web and cloud development with Silverlight and Azure; and advanced topics such as multithreading, testing, and deployment.

  • Understand the Visual Studio 2010 IDE, .NET Framework 4.0, and the anatomy of a VB 2010 application

  • Debug VB applications and implement error handling and exceptions

  • Build efficient object-oriented software with classes, objects, namespaces, and inheritance

  • Work with advanced object-oriented features, including interfaces, generics, delegates, events, and collections

  • Organize, create, and improve classes with the Visual Studio Class Designer

  • Access data with LINQ–including LINQ to Objects, SQL, DataSets, Entities, XML, and Parallel LINQ

  • Build modern Windows applications with WPF controls, brushes, styles, and templates

  • Develop web-centric applications using ASP.NET, Silverlight, and Windows Azure Services cloud computing

  • Create and consume WCF services and WCF Data Services

  • Use advanced .NET 4.0 platform capabilities, including assemblies, multithreading, parallel programming, P/Invoke, and COM interoperability

  • Perform advanced compilations with MSBuild

  • Localize and globalize VB 2010 client applications

  • Alessandro Del Sole, Microsoft MVP for Visual Basic, is well-known throughout the global VB community. He is community leader on the Italian VB Tips and Tricks website that serves more than 41,000 developers and a frequent contributor and blogger at MSDN’s Visual Basic Developer Center. He is the author of three books about .NET development with Visual Basic.

    ON THE WEB:

    Download all examples and source code presented in this book from informit.com/title/9780672331008

    Category: Microsoft Programming

    Covers: Visual Basic 2010

    User Level: Intermediate

    Table of Contents

    1. Title Page
    2. Copyright Page
    3. Dedication
      1. Dedication
    4. Contents at a Glance
      1. Contents at a Glance
    5. Table of Contents
      1. Table of Contents
    6. Foreword
      1. Foreword
    7. About the Author
      1. About the Author
    8. Acknowledgments
      1. Acknowledgments
    9. We Want to Hear from You!
      1. We Want to Hear from You!
    10. Reader Services
      1. Reader Services
    11. Part I. Learning the Basics of VB
      1. Chapter 1. Introducing the .NET Framework 4.0
        1. Chapter 1. Introducing the .NET Framework 4.0
        2. What Is the .NET Framework?
          1. Where Is the .NET Framework
          2. The .NET Framework Architecture
        3. The Common Language Runtime
          1. Writing Managed Code
          2. .NET Assemblies
        4. The Base Class Library
        5. .NET Languages
        6. .NET Framework Tools
          1. Windows Software Development Kit
        7. What’s New in .NET Framework 4.0
      2. Chapter 2. Getting Started with the Visual Studio 2010 IDE
        1. Chapter 2. Getting Started with the Visual Studio 2010 IDE
        2. What’s New in Visual Studio 2010
        3. Start Page
          1. Get Started Tab
          2. The Guidance and Resources Tab
          3. The Latest News Tab
        4. Working with Projects and Solutions
          1. Creating Visual Basic Projects
          2. Multitargeting
          3. Accessing Recent and Online Templates
          4. Searching for Installed Templates
          5. Creating Reusable Projects and Items Templates
          6. Creating Your First Visual Basic 2010 Project
          7. Finding Visual Basic Projects
          8. Working with the Code Editor
        5. Working with Tool Windows
          1. The Solution Explorer Window
          2. Error List Window
          3. The Properties Window
          4. Output Window
        6. My Project
          1. Application Tab
        7. Compiling Projects
          1. Debug and Release Configurations
          2. Other Compile Options
          3. Advanced Compile Options
        8. Debugging Overview
          1. Debugging an Application
          2. Breakpoints and Data Tips
          3. About Runtime Errors
          4. Edit and Continue
        9. Browsing the Visual Basic and .NET Documentation
          1. Online Help and the MSDN Library
          2. Object Browser Window
      3. Chapter 3. The Anatomy of a Visual Basic Project
        1. Chapter 3. The Anatomy of a Visual Basic Project
        2. Brief Overview of Types and Members
          1. Classes
          2. Properties
          3. Methods
          4. Modules
          5. Structures
          6. Inheritance
          7. Namespaces
          8. Accessing Members
          9. Imports Directives
          10. #Region..#End Region Directives
          11. Attributes
          12. A New Feature: Implicit Line Continuation
        3. Visual Basic 2010 Reserved Keywords
        4. Understanding Project Files
          1. Dissecting My Project
          2. Application.MyApp
          3. AssemblyInfo.vb
          4. Resources and the Resources.resx File
          5. Application Settings
        5. Understanding References
          1. Adding References to COM Libraries
          2. Deploy Without PIAs
          3. Final Considerations
      4. Chapter 4. Data Types and Expressions
        1. Chapter 4. Data Types and Expressions
        2. Common Type System
          1. Everything Is an Object
          2. Introducing Value Types and Reference Types
          3. System.Object and System.ValueType
        3. Understanding Value Types
          1. .NET Framework Primitive Value Types
          2. Using Value Types
          3. Working with BigInteger
          4. Building Custom Value Types
        4. Understanding Reference Types
          1. .NET Framework Primitive Reference Types
        5. Differences Between Value Types and Reference Types
          1. Memory Allocation
          2. Object-Oriented Differences
          3. Performance Differences
          4. What Custom Type Should I Choose?
        6. Converting Between Value Types and Reference Types
          1. Understanding Implicit Conversions
          2. Boxing and Unboxing
          3. Deep Copy and Shallow Copy
          4. The GetType Keyword
        7. Conversion Operators
          1. Widening and Narrowing Conversions
        8. Working with .NET Fundamental Types
          1. Working with Strings
          2. Working with Dates
          3. Working with Time
          4. Working with TimeZone and TimeZoneInfo
          5. Working with GUIDs
          6. Working with Arrays
        9. Common Operators
          1. Arithmetic Operators
          2. Assignment Operators
          3. Logical, Bitwise and Shift Operators
          4. Concatenation Operators
          5. Comparison Operators
        10. Iterations, Loops, and Conditional Code Blocks
          1. Iterations
          2. Loops
          3. Conditional Code Blocks
          4. Constants
          5. With..End With statement
      5. Chapter 5. Debugging Visual Basic 2010 Applications
        1. Chapter 5. Debugging Visual Basic 2010 Applications
        2. Preparing an Example
        3. Debugging Instrumentation
          1. Debugging in Steps
          2. Mixed Mode Debugging
          3. “Just My Code” Debugging
          4. Working with Breakpoints and Trace Points
          5. Locals Window
          6. Command Window
          7. Call Stack Window
          8. Watch Windows
          9. Threads Window
          10. Autos Window
        4. Debugger Visualizers
        5. Debugging in Code
          1. The Debug Class
          2. The Trace Class
          3. Understanding Trace Listeners
          4. Using Debug Attributes in Your Code
      6. Chapter 6. Handling Errors and Exceptions
        1. Chapter 6. Handling Errors and Exceptions
        2. Introducing Exceptions
        3. Handling Exceptions
          1. Are You Upgrading from Visual Basic 6?
          2. System.Exception, Naming Conventions and Specialization
          3. Try..Catch..Finally
          4. The Throw Keyword
          5. The When Keyword
          6. Catching Exceptions Without a Variable
    12. Part II. Object-Oriented Programming with Visual Basic 2010
      1. Chapter 7. Class Fundamentals
        1. Chapter 7. Class Fundamentals
        2. Declaring Classes
          1. Nested Classes
        3. Fields
          1. Avoiding Ambiguities with Local Variables
        4. Properties
          1. Read-Only Properties
          2. Write-Only Properties
          3. Exposing Custom Types
          4. Accessing Properties
          5. Default Properties
        5. Scope
        6. Methods
          1. Invoking Methods
          2. Methods Arguments: ByVal and ByRef
          3. Overloading Methods
          4. Exit from Methods
        7. Partial Classes
        8. Partial Methods
        9. Constructors
          1. Overloading Constructors
          2. Object Initializers
        10. Shared Members
          1. Shared Classes
          2. Shared Fields
          3. Shared Properties
          4. Shared Methods
          5. Shared Constructors
        11. Common Language Specification
          1. Where Do I Need to Apply?
          2. Marking Assemblies and Types as CLS-Compliant
          3. Naming Conventions
          4. Rules About Classes
          5. Rules About Properties
          6. Rules About Methods
          7. Rules About Arrays
      2. Chapter 8. Managing an Object’s Lifetime
        1. Chapter 8. Managing an Object’s Lifetime
        2. Understanding Memory Allocation
        3. Understanding Garbage Collection
        4. Understanding the Finalize Method
        5. Understanding Dispose and the IDisposable Interface
          1. Using..End Using Statement
          2. Putting Dispose and Finalize Together
        6. Object Resurrection
        7. Advanced Garbage Collection
          1. Interacting with the Garbage Collector
          2. Understanding Generations and Operation Modes
      3. Chapter 9. Organizing Types Within Namespaces
        1. Chapter 9. Organizing Types Within Namespaces
        2. Understanding What Namespaces Are
        3. Organizing Types Within Namespaces
          1. Why Are Namespaces So Useful?
          2. Nested Namespaces
          3. Scope
          4. Root Namespace
          5. Global Keyword
          6. Imports Directives
          7. Namespaces and Common Language Specification
      4. Chapter 10. Modules
        1. Chapter 10. Modules
        2. Modules Overview
          1. Scope
        3. Differences Between Modules and Classes
          1. No Constructor
          2. No Inheritance Support
          3. No Interface Implementation
      5. Chapter 11. Structures and Enumerations
        1. Chapter 11. Structures and Enumerations
        2. Assignments
        3. Passing Structures to Methods
        4. Members’ Visibility
        5. Inheritance Limitations and Interfaces Implementation
        6. Memory Allocation
        7. Organizing Structures
        8. Overloading Operators
          1. Overloading CType
        9. Structures and Common Language Specification
        10. Enumerations
          1. Using Enumerations
          2. Useful Methods from System.Enum
          3. Using Enums As Return Values From Methods
          4. Enum Values As Bit Flags
          5. Enumerations and Common Language Specification
      6. Chapter 12. Inheritance
        1. Chapter 12. Inheritance
        2. Applying Inheritance
        3. Illustrating System.Object in Detail
        4. Introducing Polymorphism
        5. Overriding Members
          1. NotOverridable Keyword
          2. Overloading Derived Members
        6. Conditioning Inheritance
          1. NotInheritable Keyword
          2. MustInherit and MustOverride Keywords
        7. Accessing Base Classes Members
          1. MyBase Keyword
          2. MyClass Keyword
        8. Constructors’ Inheritance
        9. Shadowing
        10. Overriding Shared Members
        11. Practical Inheritance: Building Custom Exceptions
      7. Chapter 13. Interfaces
        1. Chapter 13. Interfaces
        2. Defining Interfaces
        3. Implementing and Accessing Interfaces
          1. Passing Interfaces As Method Arguments
        4. Interfaces and Polymorphism
        5. Interfaces Inheritance
        6. Defining CLS-Compliant Interfaces
        7. Most Common .NET Interfaces
          1. The IEnumerable Interface
          2. The IComparable Interface
          3. The IConvertible Interface
          4. The IFormattable Interface
      8. Chapter 14. Generics and Nullable Types
        1. Chapter 14. Generics and Nullable Types
        2. Introducing Generics
        3. Creating and Consuming Generics
          1. Consuming Generic Types
          2. Implementing Generic Methods
          3. Understanding Constraints
          4. Overloading Type Parameters
        4. Introducing Nullable Types
      9. Chapter 15. Delegates and Events
        1. Chapter 15. Delegates and Events
        2. Understanding Delegates
          1. Declaring Delegates
          2. Combining Delegates: Multicast Delegates
        3. Handling Events
          1. Registering for events: AddHandler and RemoveHandler
          2. Declaring Objects with the WithEvents Keyword
        4. Offering Events to the External World
          1. Raising Events
          2. Creating Custom Events
      10. Chapter 16. Working with Collections
        1. Chapter 16. Working with Collections
        2. Understanding Collections Architecture
        3. Working with Nongeneric Collections
          1. The ArrayList Collection
          2. The Queue Collection
          3. The Stack Collection
          4. The HashTable Collection
          5. The ListDictionary Collection
          6. The OrderedDictionary Collection
          7. The SortedList Collection
          8. The HybridDictionary Collection
          9. The StringCollection Collection
          10. The StringDictionary Collection
          11. The NameValueCollection Collection
          12. The BitArray Collection
          13. The Bitvector32 Collection
        4. Working with Generic Collections
          1. The List(Of T) Collection
          2. Working with Collection Initializers
          3. The ReadOnlyCollection(Of T) Collection
          4. The Dictionary(Of TKey, TValue) Collection
          5. The SortedDictionary(Of TKey, TValue) Collection
          6. The ObservableCollection(Of T) Collection
          7. The ReadonlyObservableCollection(Of T) Collection
          8. The LinkedList(Of T) Collection
          9. The Queue(Of T) and Stack(Of T) Collections
        5. Building Custom Collections
        6. Concurrent Collections
      11. Chapter 17. Visually Designing Objects
        1. Chapter 17. Visually Designing Objects
        2. Visual Studio Class Designer
          1. Enabling the Class Designer
          2. Adding and Designing Objects
          3. Implementing Derived Classes
          4. Creating Multiple Diagrams
          5. Exporting the Diagram
        3. Class View Window
        4. Class Details Window
      12. Chapter 18. “Generate From Usage” Coding Techniques
        1. Chapter 18. “Generate From Usage” Coding Techniques
        2. Coding New Types
          1. Generating Shared Members
          2. On-the-Fly Code and Object Initializers
        3. Generating Complex Objects
          1. Interfaces Additions
    13. Part III. Advanced VB Language features
      1. Chapter 19. Manipulating Files and Streams
        1. Chapter 19. Manipulating Files and Streams
        2. Manipulating Directories and Pathnames
          1. The System.IO.Path Class
          2. The System.IO.Directory Class
          3. The System.IO.DirectoryInfo Class
          4. The System.IO.DriveInfo Class
        3. Handling Exceptions for Directories and Pathnames
        4. Manipulating Files
          1. The System.IO.File Class
          2. The System.IO.FileInfo Class
          3. Handling File Exceptions
          4. Understanding Permissions
        5. Introducing Streams
          1. Reading and Writing Text Files
          2. Reading and Writing Binary Files
          3. Using Memory Streams
          4. Using Streams with Strings
          5. Compressing Data with Streams
          6. Networking with Streams
      2. Chapter 20. The My Namespace
        1. Chapter 20. The My Namespace
        2. Introducing My
        3. My.Application
          1. Retrieving Assembly Information
          2. Working with Cultures
          3. Deployment and Environment Information
        4. My.Computer
          1. Working with the File System
          2. Working with the Clipboard
          3. Playing Audio Files
          4. Managing the Keyboard
          5. Working with the Registry
          6. Accessing the Network
          7. Getting Computer Information
        5. My.Settings
          1. My.Settings Events
        6. My.Resources
          1. Getting Resources by Name in Code
        7. My.User
        8. My.WebServices
        9. Extending My
          1. Extending My.Application and My.Computer
          2. Extending My.Resources and My.Settings
        10. My in Different Applications
          1. Understanding Application Events
      3. Chapter 21. Advanced Language Features
        1. Chapter 21. Advanced Language Features
        2. Local Type Inference
          1. Option Infer Directive
          2. Local Type Inference Scope
        3. Array Literals
          1. Multidimensional and Jagged Arrays
        4. Extension Methods
          1. Coding Custom Extension Methods
          2. Exporting Extension Methods
        5. Anonymous Types
        6. Relaxed Delegates
        7. Lambda Expressions
          1. Type Inference and Lambda Expressions
          2. Multiline Lambdas
          3. Sub Lambdas
          4. Lexical Closures
        8. Ternary If Operator
        9. Generic Variance
          1. Covariance
          2. Contra Variance
    14. Part IV. Data Access with ADO.NET and LINQ
      1. Chapter 22. Introducing ADO.NET and DataSets
        1. Chapter 22. Introducing ADO.NET and DataSets
        2. Introducing ADO.NET
          1. Data Providers
          2. Connection Modes
          3. Understanding Connections and Data Readers
        3. Introducing DataSets
          1. Creating DataSets
      2. Chapter 23. Introducing LINQ
        1. Chapter 23. Introducing LINQ
        2. What Is LINQ?
        3. LINQ Examples
        4. Language Support
        5. Understanding Providers
        6. Overview of LINQ Architecture
      3. Chapter 24. LINQ to Objects
        1. Chapter 24. LINQ to Objects
        2. Introducing LINQ to Objects
        3. Querying in Memory Objects
          1. Understanding Deferred Execution
        4. Introducing Standard Query Operators
          1. Projection Operators
          2. Restriction Operators
          3. Aggregation Operators
          4. Understanding the Let Keyword
          5. Conversion Operators
          6. Generation Operators
          7. Ordering Operators
          8. Set Operators
          9. Grouping Operators
          10. Union Operators
          11. Equality Operators
          12. Quantifiers
          13. Concatenation Operators
          14. Elements Operators
          15. Partitioning Operators
      4. Chapter 25. LINQ to SQL
        1. Chapter 25. LINQ to SQL
        2. Introducing LINQ to SQL
          1. Prerequisites
          2. Understanding LINQ to SQL Classes
          3. Behind the Scenes of LINQ to SQL Classes
        3. Querying Data with LINQ to SQL
        4. Insert/Update/Delete Operations with LINQ
          1. Inserting Entities
          2. Updating Entities
          3. Deleting Entities
          4. Mapping Stored Procedures
          5. Using the Log
        5. Advanced LINQ to SQL
          1. Custom Validations
          2. Handling Optimistic Concurrency
          3. Using SQL Syntax Against Entities
        6. LINQ to SQL with SQL Server Compact Edition
          1. Writing the Connection String
      5. Chapter 26. LINQ to DataSets
        1. Chapter 26. LINQ to DataSets
        2. Querying Datasets with LINQ
          1. Building Complex Queries with Anonymous Types
        3. LINQ to DataSets’ Extension Methods
          1. Understanding CopyToDataTable
          2. Understanding Field(Of T) and SetField(Of T)
      6. Chapter 27. Introducing ADO.NET Entity Framework
        1. Chapter 27. Introducing ADO.NET Entity Framework
        2. Introducing Entity Framework
        3. Understanding Entity Data Models
          1. Understanding the ObjectContext class: The Visual Basic Mapping
          2. Entity Designer Tool Windows
        4. Insert/Update/Delete Operations for Entities
          1. Instantiating the ObjectContext
          2. Adding Entities
          3. Deleting Entities
          4. Updating Entities
          5. Handling Optimistic Concurrency
          6. Validating Data
        5. Querying EDMs with LINQ to Entities
        6. Querying EDMs with Entity SQL
        7. Mapping Stored Procedures
      7. Chapter 28. Manipulating Xml Documents with LINQ and Xml Literals
        1. Chapter 28. Manipulating Xml Documents with LINQ and Xml Literals
        2. Introducing LINQ to Xml
          1. The System.Xml.Linq Namespace
        3. Xml Literals
          1. LINQ Queries with Xml Literals
          2. Understanding Embedded Expressions
        4. Xml Schema Inference
      8. Chapter 29. Overview of Parallel LINQ
        1. Chapter 29. Overview of Parallel LINQ
        2. Introducing PLINQ
          1. Simulating an Intensive Work
          2. Measuring Performances of a Classic LINQ Query
          3. Measuring Performances of a PLINQ Query
          4. Ordering Sequences
          5. AsParallel and Binary Operators
          6. Using ParallelEnumerable
          7. Controlling PLINQ Queries
        3. Handling Exceptions
    15. Part V. Building Windows Applications
      1. Chapter 30. Creating Windows Forms 4.0 Applications
        1. Chapter 30. Creating Windows Forms 4.0 Applications
        2. What Windows Forms Is Today
        3. Creating Windows Forms Applications
          1. What’s New in Windows Forms 4.0
          2. Available Windows Forms Controls
        4. Building Windows Forms Applications with ADO.NET Entity Framework and Chart Control
          1. Providing Custom Validation
          2. Understanding Chart Control
          3. Populating the Chart Control
          4. Running the Sample Application
      2. Chapter 31. Creating WPF Applications
        1. Chapter 31. Creating WPF Applications
        2. What Is WPF?
          1. Improvements in WPF 4
        3. WPF Architecture
        4. Building WPF Applications with Visual Studio 2010
        5. Understanding the eXtensible Application Markup Language (XAML)
          1. Declaring and Using Controls with the Designer and XAML
        6. Understanding Visual Tree and Logical Tree
        7. Handling Events in WPF
          1. A More Thorough Discussion: Introducing the Routed Events
        8. Arranging Controls with Panels
          1. The Grid Panel
          2. The StackPanel Panel
          3. The WrapPanel Panel
          4. The Canvas Panel
          5. The DockPanel Panel
          6. The ViewBox Panel
        9. Managing Windows
          1. Instantiating Windows at Runtime
        10. Introducing the Application Object
        11. Brief Overview of WPF Browser Applications
      3. Chapter 32. WPF Common Controls
        1. Chapter 32. WPF Common Controls
        2. Introducing WPF Controls Features
        3. Understanding the ContentControl
        4. Understanding Common Controls
          1. Border
          2. Button
          3. Calendar
          4. CheckBox
          5. ComboBox
          6. DataGrid
          7. DatePicker
          8. DocumentViewer
          9. Ellipse
          10. Expander
          11. Frame
          12. GroupBox
          13. Image
          14. Label
          15. ListBox
          16. ListView
          17. MediaElement
          18. Menu
          19. PasswordBox
          20. ProgressBar
          21. RadioButton
          22. Rectangle
          23. RichTextBox
          24. ScrollBar
          25. ScrollViewer
          26. Separator
          27. Slider
          28. StatusBar
          29. TabControl
          30. TextBlock
          31. TextBox
          32. ToolBar
          33. TreeView
          34. WebBrowser
          35. WindowsFormsHost
        5. Using Common Dialogs
      4. Chapter 33. Brushes, Styles, Templates, and Animations in WPF
        1. Chapter 33. Brushes, Styles, Templates, and Animations in WPF
        2. Introducing Brushes
          1. Applying a SolidColorBrush
          2. Applying a LinearGradientBrush
          3. Applying a RadialGradientBrush
          4. Applying an ImageBrush
          5. Applying SelectionBrush and CaretBrush
          6. Applying a VisualBrush
          7. Applying a DrawingBrush
          8. Applying a BitmapCacheBrush
        3. Introducing Styles
          1. Styles Inheritance
          2. Understanding Triggers
        4. Introducing Control Templates
        5. Introducing Transformations
          1. Applying RotateTransform
          2. Applying ScaleTransform
          3. Applying SkewTransform
          4. Applying TranslateTransform
          5. Applying Multiple Transforms
        6. Introducing Animations
          1. Applying DoubleAnimation
          2. Applying ColorAnimation
          3. Working with Animation Events
          4. Creating Animations with Visual Basic
      5. Chapter 34. Manipulating Documents and Media
        1. Chapter 34. Manipulating Documents and Media
        2. Viewing Images
        3. Playing Media
        4. Manipulating Documents
          1. Understanding the RichTextBox Control
        5. Viewing XPS Documents
      6. Chapter 35. Introducing Data-Binding
        1. Chapter 35. Introducing Data-Binding
        2. Introducing the Data-Binding
          1. Binding UI Elements with the Binding Markup Extension
          2. Understanding the DataGrid and the ObservableCollection
        3. Discussing the New Drag’n’Drop Data-Binding
          1. Creating Tabular Data Forms
          2. Creating Master-Details Forms
          3. Understanding Views and Binding Lists
          4. Implementing String Formatters and Value Converters
      7. Chapter 36. Localizing Applications
        1. Chapter 36. Localizing Applications
        2. Introducing .NET Localization
        3. Windows Forms Localization
        4. WPF Localization
          1. Preparing the LocBaml tool
          2. Localizing a WPF Application
    16. Part VI. Building Web Applications
      1. Chapter 37. Building ASP.NET Web Applications
        1. Chapter 37. Building ASP.NET Web Applications
        2. Introducing the ASP.NET Model
          1. Understanding Page Requests
          2. Scalability and Performances
          3. Available Project Templates
        3. Web Forms and Master Pages
          1. Web Forms
        4. ASP.NET Controls
          1. Server Controls
          2. HTML Controls
        5. Handling Events
        6. Understanding State Management
          1. The Application State
          2. The Cache State
          3. The Context State
          4. Using Cookies for Saving Information
          5. The Session State
          6. The ViewState State
        7. Creating a Web Application with VB 2010 with Navigation and Data-Binding
          1. Master Pages
          2. Adding the Data Model
          3. Adding a New Web Form
          4. Adding Data Controls
          5. Adding Filtering Capabilities
          6. Adding Navigation Controls
          7. Running the Application
        8. Configuring a Web Application for Security
      2. Chapter 38. Publishing ASP.NET Web Applications
        1. Chapter 38. Publishing ASP.NET Web Applications
        2. Deployment Overview
          1. The 1-Click Deployment
        3. Classic Publishing
        4. MSDeploy Publish
          1. Understanding Packages
          2. Deploy with MSDeploy
      3. Chapter 39. Building Rich Internet Applications with Silverlight
        1. Chapter 39. Building Rich Internet Applications with Silverlight
        2. Introducing Silverlight
        3. Creating Silverlight Projects with Visual Basic 2010
        4. Adding Controls and Handling Events
          1. How Silverlight Applications Are Packaged
        5. Playing Media
        6. Animating UI Elements
        7. Introducing Navigation Applications
        8. Introducing WCF RIA Services
          1. Adding the Data Source
          2. Adding the Domain Service Class
          3. Data-Binding to Controls
          4. Running the Application
        9. “Out of Browser” Applications
      4. Chapter 40. Building and Deploying Applications for Windows Azure
        1. Chapter 40. Building and Deploying Applications for Windows Azure
        2. About Windows Azure Platform
        3. Registering for the Windows Azure Developer Portal
        4. Downloading and Installing Tools for Visual Studio
          1. Additional Tools
        5. Creating a Demo Project
          1. Understanding Web Roles and Web Configuration
          2. Adding a Silverlight 3 Project
          3. Testing the Application Locally
        6. Deploying Applications to Windows Azure
        7. Activating the Storage Account
          1. Using the Windows Azure Management Console Snap-In
    17. Part VII. Networking and Exposing Data Through Networks
      1. Chapter 41. Creating and Consuming WCF Services
        1. Chapter 41. Creating and Consuming WCF Services
        2. Introducing Windows Communication Foundation
          1. Understanding Endpoints
          2. Address, Binding, Contract: The ABC of WCF
        3. Implementing WCF Services
          1. Implementing Custom Logic for the WCF Service
        4. Consuming WCF Services
          1. Creating the Client and Adding a Service Reference
          2. Understanding the Proxy Class
          3. Invoking Members from the Service
        5. Handling Exceptions in WCF
        6. Hosting WCF Services in Internet Information Services
        7. Configuring Services with the Configuration Editor
      2. Chapter 42. Implementing and Consuming WCF Data Services
        1. Chapter 42. Implementing and Consuming WCF Data Services
        2. What Are Data Services?
          1. Querying Data via Http Requests
        3. Implementing WCF Data Services
          1. Deploying WCF Data Services to Internet Information Services
        4. Consuming WCF Data Services
          1. Creating a Client Application
          2. Querying Data
        5. Implementing Service Operations
        6. Implementing Query Interceptors
          1. Understanding Query Interceptors
          2. Understanding Change Interceptors
        7. Understanding Server-Driven Paging
    18. Part VIII. Advanced .NET Framework with VB 2010
      1. Chapter 43. Serialization
        1. Chapter 43. Serialization
        2. Objects Serialization
          1. Binary Serialization
          2. Soap Serialization
          3. Providing Serialization for Custom Objects
          4. NonSerialized events
        3. XML Serialization
          1. Customizing Xml Serialization
        4. Custom Serialization
          1. Serialization Events
        5. Serialization with XAML
        6. Serialization in Windows Communication Foundation
          1. JSON Serialization
        7. Serialization in the ADO.NET Entity Framework
      2. Chapter 44. Processes and Multithreading
        1. Chapter 44. Processes and Multithreading
        2. Managing Processes
          1. Querying Existing Processes
        3. Introducing Multithreading
          1. Creating Threads
          2. Passing Parameters
        4. Understanding the .NET Thread Pool
          1. Getting and Setting Information in the Thread Pool
        5. Threads Synchronization
          1. The SyncLock..End SyncLock Statement
          2. Synchronization with the Monitor Class
          3. Read/Write Locks
      3. Chapter 45. Parallel Programming
        1. Chapter 45. Parallel Programming
        2. Introducing Parallel Computing
          1. Introducing Parallel Classes
        3. Understanding and Using Tasks
          1. What Is a Task?
          2. Running Tasks with Parallel.Invoke
          3. Creating, Running, and Managing Tasks: The Task Class
          4. Creating Tasks That Return Values
          5. Exception Handling
          6. Cancelling Tasks
          7. The Barrier Class
        4. Parallel Loops
          1. Parallel.For Loop
          2. Parallel.ForEach Loop
        5. Debugging Tools For Parallel Tasks
        6. Concurrent Collections
          1. ConcurrentBag(Of T)
          2. ConcurrentQueue(Of T)
          3. ConcurrentStack(Of T)
          4. ConcurrentDictionary(Of TKey, TValue)
          5. BlockingCollection(Of T)
      4. Chapter 46. Working with Assemblies
        1. Chapter 46. Working with Assemblies
        2. Assembly Overview
          1. Information Stored Within Assemblies
          2. Assembly Location
          3. Signing Assemblies
          4. Assembly Information and Attributes
        3. Understanding Application Domains
          1. Creating Application Domains and Executing Assemblies
        4. Overview of Security Changes in .NET 4.0
          1. Permissions
          2. The Transparency Level 2
          3. Sandboxing
          4. Conditional APTCA
          5. Migrating from Old CAS-Based Code
      5. Chapter 47. Reflection
        1. Chapter 47. Reflection
        2. Introducing Reflection
        3. Understanding Assemblies’ Metadata
          1. Preparing a Sample Assembly
        4. Getting Assembly Information
        5. Reflecting Types
          1. Reflecting a Single Type
        6. Invoking Code Dynamically
        7. Generating Code at Runtime with Reflection.Emit
          1. Late Binding Concepts
      6. Chapter 48. Coding Attributes
        1. Chapter 48. Coding Attributes
        2. Applying Attributes
        3. Coding Custom Attributes
          1. Applying Custom Attributes
          2. Applying Attributes Multiple Times
          3. Defining Inheritance
        4. Reflecting Attributes
      7. Chapter 49. Platform Invokes and Interoperability with the COM Architecture
        1. Chapter 49. Platform Invokes and Interoperability with the COM Architecture
        2. Importing and Using COM Objects
          1. Importing COM Components into Visual Studio
          2. Using COM Objects in Code
          3. Catching Exceptions
          4. Releasing COM Objects
        3. Exposing .NET Objects to the COM World
        4. P/Invokes and Unmanaged Code
          1. Understanding P/Invokes
          2. Encapsulating P/Invokes
          3. Converting Types to Unmanaged
          4. The StructLayout Attribute
          5. The VBFixedString attribute
          6. Handling Exceptions
        5. References to the Win32 API calls
      8. Chapter 50. Documenting the Source Code
        1. Chapter 50. Documenting the Source Code
        2. Understanding XML Documents
          1. Enabling XML Comments
        3. Implementing XML Comments
          1. Defining Complex Code Documentation
        4. Generating Compiled Help Files
      9. Chapter 51. Advanced Compilations with MSBuild
        1. Chapter 51. Advanced Compilations with MSBuild
        2. Introducing MSBuild
          1. Introducing Projects
          2. Understanding Tasks and Creating Targets
        3. Advanced MSBuild Features
          1. Batching
          2. Logging
          3. Transformations
      10. Chapter 52. Building Customizations for Microsoft Office
        1. Chapter 52. Building Customizations for Microsoft Office
        2. Introducing the Visual Studio Tools for Office
          1. Understanding Application-Level Solutions and Document-Level Solutions
          2. What Are Office Business Applications?
        3. Creating an Application-Level Add-In for Microsoft Word
        4. Creating a Document-Level Add-In for Microsoft Excel
          1. Designing the Add-In
          2. Interacting with Documents via Visual Basic 2010 Code
          3. Running the Customized Document
        5. Deploying VSTO Add-Ins
    19. Part IX. Applications Deployment
      1. Chapter 53. Understanding the Global Assembly Cache
        1. Chapter 53. Understanding the Global Assembly Cache
        2. The Dll Hell Problem
          1. XCopy Deployment
        3. The Global Assembly Cache
          1. Installing and Uninstalling Assemblies
          2. Signing Assemblies with Strong Names
          3. Top Reasons for Installing (or Not) Assemblies to the GAC
          4. Adding References from Visual Studio to Your Own Assemblies
      2. Chapter 54. Setup & Deployment Projects for Windows Installer
        1. Chapter 54. Setup & Deployment Projects for Windows Installer
        2. Windows Installer Overview
        3. Creating a Setup Project
        4. Configuring the Setup Project
          1. Editing the File System
          2. Editing Registry Values
          3. Customizing Dialogs
          4. Creating File Types
          5. Providing Custom Actions
          6. Specifying Launch Conditions
          7. Package Configuration and Prerequisites
        5. Building and Deploying the Windows Installer Package
      3. Chapter 55. Deploying Applications with ClickOnce
        1. Chapter 55. Deploying Applications with ClickOnce
        2. Introducing ClickOnce
          1. How ClickOnce Handles Applications
          2. When Should I Use ClickOnce?
        3. Deploying Applications with ClickOnce
          1. Structure of a ClickOnce Deployment
        4. Configuring ClickOnce
          1. Application Files
          2. Prerequisites
          3. Updates
          4. Options
        5. Security Considerations
          1. Providing Certificates
        6. Programmatically Accessing ClickOnce
        7. Registration-Free COM
    20. Part X. Mastering the Visual Studio 2010 IDE
      1. Chapter 56. Advanced IDE Features
        1. Chapter 56. Advanced IDE Features
        2. Exporting Templates
          1. Exporting Project Templates
          2. Exporting Item Templates
        3. Customizing Visual Studio 2010
          1. Customizing the Tools Menu
          2. Customizing Commands and Toolbars
        4. Managing User Settings
          1. Exporting Settings
          2. Importing Settings
        5. Customizing the Toolbox
        6. Using, Creating, and Managing Reusable Code Snippets
          1. Consuming Code Snippets
          2. The Code Snippet Manager
          3. Creating and Consuming Custom Code Snippets
      2. Chapter 57. Introducing the Visual Studio Extensibility
        1. Chapter 57. Introducing the Visual Studio Extensibility
        2. Introducing Visual Studio Extensibility
          1. What’s New in the Extensibility with Visual Studio 2010
          2. The Visual Studio 2010 SDK
        3. Building a Visual Studio Package
        4. Deploying Visual Studio Extensions
        5. Managing Extensions with the Extension Manager
        6. Managing Add-Ins with the Add-In Manager
        7. Extending the Code Editor
      3. Chapter 58. Advanced Analysis Tools
        1. Chapter 58. Advanced Analysis Tools
        2. Introducing Analysis Tools
        3. Performing Code Analysis
        4. Calculating Code Metrics
        5. Profiling Applications
          1. Profiling External Executables
        6. IntelliTrace, the Historical Debugger
          1. IntelliTrace Options
          2. Creating a Sample Application
          3. Tracking Application Events and Exceptions with IntelliTrace
          4. Analyzing IntelliTrace Logs
          5. Using IntelliTrace for Unit Tests
        7. Generating Dependency Graphs
      4. Chapter 59. Testing Code with Unit Tests, Test-Driven Development, and Code Contracts
        1. Chapter 59. Testing Code with Unit Tests, Test-Driven Development, and Code Contracts
        2. Testing Code with Unit Tests
          1. Creating Unit Tests
          2. Running Unit Tests
          3. Enabling Code Coverage
          4. Unit Tests and IntelliTrace
        3. Introducing Test-Driven Development
          1. Creating a Test Project
          2. Creating Unit Tests
          3. Refactoring Code
        4. Understanding Code Contracts
          1. Setting Up the Environment
          2. Setting Contracts Properties
          3. Tools for Code Contracts
          4. Preconditions
          5. Post-Conditions
          6. Invariants
          7. Assertions and Assumptions
          8. Contract Events
    21. Appendixes
      1. Appendix A. Installing Visual Studio 2010
        1. Appendix A. Installing Visual Studio 2010
        2. Installing Visual Studio 2010
        3. Installing the Offline Documentation
          1. Finding Additional Contents Online
        4. Running Visual Studio 2010 for the First Time
      2. Appendix B. Useful Resources and Tools for Visual Basic
        1. Appendix B. Useful Resources and Tools for Visual Basic
        2. Visual Basic Resources in MSDN
        3. Useful Developer Tools for Visual Basic
        4. Coding Tools
        5. Networking
        6. Data Access
        7. Diagnostics and Performance
        8. Miscellaneous
        9. Where Do I Find Additional Tools?
    22. Index