You are previewing Visual Studio® 2010 and .NET 4, Six-in-one.
O'Reilly logo
Visual Studio® 2010 and .NET 4, Six-in-one

Book Description

Complete coverage of all key .NET 4 and Visual Studio 2010 languages and technologies

.NET 4 is Microsoft's latest version of their core programming platform, and Visual Studio 2010 is the toolset that helps write .NET 4 applications. This comprehensive resource offers one-stop shopping for all you need to know to get productive with .NET 4. Experienced author and .NET guru Mitchel Sellers reviews all the important new features of .NET 4, including .NET charting and ASP.NET charting, ASP.NET dynamic data and jQuery, and the addition of F# as a supported package language.

The expansive coverage is divided into six distinctive parts for easy navigation, and addresses: Visual Studio 2010, .NET 4, ASP.NET, the C# language, the VB.NET language, and the new F# language. A practical approach and complete examples round out this much-needed reference.

  • Focuses on the new and important features of the latest version Microsoft's core programming platform-.NET 4-as well as Visual Studio 2010, which allows you to write .NET 4 applications

  • Provides comprehensive coverage divided into six parts: Visual Studio 2010, .NET 4, ASP.NET, the C# language, the VB.NET language, and the new F# language

  • Discusses Visual Studio snippets and templates, .NET charting components, the .NET framework and WPF, LINQ, and the Entity framework

  • Explores various aspects of Visual Basic 2010, such as multi-line lambdas, auto-implemented properties, nullable optional parameters, and more

This investigative look at .NET 4 and Visual Studio 2010 will help you identify and isolate key elements that can benefit you immediately.

Table of Contents

  1. Copyright
  2. ABOUT THE AUTHORS
  3. ABOUT THE TECHNICAL EDITOR
  4. CREDITS
  5. ACKNOWLEDGMENTS
  6. INTRODUCTION
    1. WHO THIS BOOK IS FOR
    2. WHAT THIS BOOK COVERS
    3. HOW THIS BOOK IS STRUCTURED
      1. Part I: Visual Studio
      2. Part II: .NET 4
      3. Part III: ASP.NET 4.0
      4. Part IV: VB.NET
      5. Part V: C#
      6. Part VI: F# and Other .NET Languages
    4. WHAT YOU NEED TO USE THIS BOOK
    5. CONVENTIONS
    6. SOURCE CODE
    7. ERRATA
    8. P2P.WROX.COM
  7. I. Visual Studio
    1. 1. History of Visual Studio
      1. 1.1. ROOTS
        1. 1.1.1. The First Breakthrough: Visual Basic
        2. 1.1.2. Other Languages and Tools
        3. 1.1.3. Visual Studio 97 and 6.0
      2. 1.2. VISUAL STUDIO.NET 2002 AND 2003
      3. 1.3. VISUAL STUDIO 2005
      4. 1.4. VISUAL STUDIO 2008
      5. 1.5. VISUAL STUDIO 2010
        1. 1.5.1. Changes in Editions
        2. 1.5.2. What's New in Visual Studio 2010
        3. 1.5.3. Shift to WPF
      6. 1.6. SUMMARY
    2. 2. Visual Studio UI Enhancements
      1. 2.1. BASIC IDE OVERVIEW
        1. 2.1.1. Exploring the Start Page
        2. 2.1.2. Understanding Window Management
        3. 2.1.3. New Project Dialog Window
        4. 2.1.4. Creating New Projects in a New Way
        5. 2.1.5. Using the Add Reference Dialog Window
        6. 2.1.6. Using the Extension Manager
      2. 2.2. EXPLORING NEW DAILY DEVELOPMENT FEATURES
        1. 2.2.1. Exploring the Code Editor Window
        2. 2.2.2. Code Navigation
          1. 2.2.2.1. Reference Highlighting
          2. 2.2.2.2. Search and Replace
          3. 2.2.2.3. Call Hierarchy
          4. 2.2.2.4. Code Definition
          5. 2.2.2.5. Debugging
        3. 2.2.3. Generate From Usage
      3. 2.3. EXPLORING THE VISUAL DESIGNERS
        1. 2.3.1. WPF Designer
        2. 2.3.2. XML Schema Designer
      4. 2.4. NEW TOOLS FOR ARCHITECTS
      5. 2.5. SUMMARY
    3. 3. Visual Studio Code Snippets
      1. 3.1. UNDERSTANDING CODE SNIPPETS
        1. 3.1.1. Using Code Snippets
          1. 3.1.1.1. Inserting a Snippet
          2. 3.1.1.2. Surrounding the Selected Code with a Snippet
          3. 3.1.1.3. Visual Basic Specific Features
        2. 3.1.2. HTML, SQL, and JScript Code Snippets
      2. 3.2. CREATING CODE SNIPPETS
        1. 3.2.1. Creating a Simple Code Snippet
          1. 3.2.1.1. Writing the Code Snippet Definition
          2. 3.2.1.2. Importing the Code Snippet
          3. 3.2.1.3. Accessing and Using the New Snippet
        2. 3.2.2. The Code Snippet File Structure
          1. 3.2.2.1. The <Header> Element
          2. 3.2.2.2. The <Snippet> Element
            1. 3.2.2.2.1. Defining the Code
            2. 3.2.2.2.2. Declaring Literals and Objects
          3. 3.2.2.3. Language-Dependent Features
            1. 3.2.2.3.1. <Imports> and <References>
            2. 3.2.2.3.2. Code Snippet Functions
      3. 3.3. MANAGING CODE SNIPPETS
        1. 3.3.1. The Code Snippet Manager
        2. 3.3.2. Code Snippet Storage
        3. 3.3.3. Adding and Removing Snippets
        4. 3.3.4. Importing Snippets
      4. 3.4. ADVANCED CODE SNIPPET FEATURES
        1. 3.4.1. Multiple Snippets in a File
        2. 3.4.2. Code Snippets in Other Languages
        3. 3.4.3. Building Online Code Snippet Providers
      5. 3.5. SNIPPET EDITORS
        1. 3.5.1. Export as Code Snippet Add-In
        2. 3.5.2. Snippet Designer
        3. 3.5.3. Snippet Editor
      6. 3.6. SUMMARY
    4. 4. Visual Studio Templates
      1. 4.1. THE ROLE OF TEMPLATES
        1. 4.1.1. Project Templates
        2. 4.1.2. Item Templates
      2. 4.2. CREATING TEMPLATES
        1. 4.2.1. Creating a Simple Project Template
          1. 4.2.1.1. Creating the Startup Project
          2. 4.2.1.2. Adding a Small Customization
        2. 4.2.2. Creating a Simple Item Template
      3. 4.3. TEMPLATE STORAGE STRUCTURE
        1. 4.3.1. Template Folders
          1. 4.3.1.1. Understanding the Project Template Hierarchy
          2. 4.3.1.2. Understanding the Item Template Hierarchy
        2. 4.3.2. The Template Manifest File
          1. 4.3.2.1. The General Structure of the Manifest File
          2. 4.3.2.2. The <TemplateData> Element
          3. 4.3.2.3. The <TemplateContent> Element
            1. 4.3.2.3.1. Defining Files and Folders in Project Templates
            2. 4.3.2.3.2. Defining Files and Referenced Assemblies in Item Templates
          4. 4.3.2.4. Advanced Features
      4. 4.4. CUSTOMIZING TEMPLATES
        1. 4.4.1. Template Parameters
        2. 4.4.2. Custom Template Parameters
        3. 4.4.3. Wizards
          1. 4.4.3.1. Comment Selector Sample
          2. 4.4.3.2. Implementing IWizard
          3. 4.4.3.3. Integrating the Wizard with the Template
      5. 4.5. DEPLOYING TEMPLATES
        1. 4.5.1. Exporting and Importing Templates
          1. 4.5.1.1. Manual Export
          2. 4.5.1.2. Using the Export Template Wizard
          3. 4.5.1.3. Deploying the Template Files
        2. 4.5.2. Creating a Template Installation Kit
          1. 4.5.2.1. Creating the VSIX Installation Kit
          2. 4.5.2.2. Uploading Templates to the Visual Studio Gallery
          3. 4.5.2.3. Installing Templates with the Extension Manager
      6. 4.6. SUMMARY
    5. 5. Getting the Most Out of the IDE
      1. 5.1. WINDOW MANAGEMENT
        1. 5.1.1. Visual Studio Window Architecture
        2. 5.1.2. Tool Windows
        3. 5.1.3. Document Windows
        4. 5.1.4. Arranging Windows
          1. 5.1.4.1. Floating Windows
          2. 5.1.4.2. Docking Tool Windows
          3. 5.1.4.3. Docking Document Windows
          4. 5.1.4.4. Auto-hiding Tool Windows
          5. 5.1.4.5. Organizing Document Tab Groups
          6. 5.1.4.6. Splitting and Duplicating Document Windows
          7. 5.1.4.7. Setting the Position of New Document Windows
      2. 5.2. CUSTOMIZING MENUS AND TOOLBARS
        1. 5.2.1. The Customize Dialog
        2. 5.2.2. Adding Menus and Commands
          1. 5.2.2.1. Adding a Menu to the Main Menu Bar
          2. 5.2.2.2. Adding Commands to a Menu
          3. 5.2.2.3. Removing Menus and Commands
          4. 5.2.2.4. Adding Menus and Commands to Toolbars
        3. 5.2.3. Creating and Rearranging Toolbars
        4. 5.2.4. Context Sensitivity
      3. 5.3. IDE CONFIGURATION
        1. 5.3.1. The Options Dialog
        2. 5.3.2. Changes in Option Pages
          1. 5.3.2.1. Visual Experience Options
          2. 5.3.2.2. Extension Manager Page
          3. 5.3.2.3. Projects and Solutions
          4. 5.3.2.4. Text Editor
        3. 5.3.3. Visual Studio Settings
          1. 5.3.3.1. The Export and Import Settings Wizard
          2. 5.3.3.2. Exporting Settings
          3. 5.3.3.3. Importing Settings
          4. 5.3.3.4. Reset All Settings
          5. 5.3.3.5. Export and Import Options
          6. 5.3.3.6. Looking into the .vssettings Files
      4. 5.4. REDUCING EFFORTS WITH KEYBOARD SHORTCUTS
        1. 5.4.1. Command Routing and Command Contexts
        2. 5.4.2. Working with Keyboard Shortcuts
          1. 5.4.2.1. Determine the Shortcut Key Assigned to a Command
          2. 5.4.2.2. Removing a Shortcut
          3. 5.4.2.3. Creating a New Keyboard Shortcut
          4. 5.4.2.4. Using the Keyboard Exclusively
        3. 5.4.3. Working with Keyboard Mapping Schemes
          1. 5.4.3.1. Exporting and Importing Keyboard Mapping Schemes
          2. 5.4.3.2. Keyboard Shortcuts in the Settings File
      5. 5.5. CUSTOM START PAGES
        1. 5.5.1. Creating Your First Custom Start Page
          1. 5.5.1.1. The Structure of the Start Page Solution
          2. 5.5.1.2. The Definition of the Start Page
          3. 5.5.1.3. Command Button Definitions
          4. 5.5.1.4. The Recent Projects Definition
          5. 5.5.1.5. The MyControl User Control
        2. 5.5.2. Changing the StartPage.xaml File
        3. 5.5.3. Accessing the Visual Studio Context
        4. 5.5.4. Accessing the Visual Studio Object Model
        5. 5.5.5. A Few More Points About Start Pages
      6. 5.6. CUSTOMIZING THE TOOLBOX
        1. 5.6.1. A Lap Around the Toolbox
          1. 5.6.1.1. Components in the Toolbox
          2. 5.6.1.2. Using the Keyboard to Access Toolbox Functions
        2. 5.6.2. Customizing Toolbox Tabs
          1. 5.6.2.1. Working with Tabs
          2. 5.6.2.2. Rearranging Tab Items
          3. 5.6.2.3. Resetting the Toolbox
        3. 5.6.3. Adding Items to the Toolbox
          1. 5.6.3.1. Selecting a Component to Add
          2. 5.6.3.2. Blocked Components
          3. 5.6.3.3. Adding Text Snippets to the Toolbox
        4. 5.6.4. A Few More Points About Toolbox Customization
      7. 5.7. VISUAL STUDIO GALLERY
        1. 5.7.1. Browsing the Visual Studio Gallery
        2. 5.7.2. Downloading and Installing Components
        3. 5.7.3. Adding Your Own Contributions to the Gallery
        4. 5.7.4. Working Together with the Community
      8. 5.8. SUMMARY
    6. 6. Visual Studio Extensibility
      1. 6.1. THE VISUAL STUDIO SHELL AND PACKAGES
        1. 6.1.1. Package Integration
      2. 6.2. EXTENSIBILITY OUT OF THE BOX
        1. 6.2.1. Extending Visual Studio by Customization
          1. 6.2.1.1. Code Snippets Sample
          2. 6.2.1.2. GhostDoc Sample
        2. 6.2.2. Using Macros to Automate Common Tasks
        3. 6.2.3. Visual Studio Add-Ins
      3. 6.3. EXTENSIONS WITH VISUAL STUDIO SDK
        1. 6.3.1. The Full Power of Extensibility
        2. 6.3.2. Visual Studio Package Development
        3. 6.3.3. Editor Extensibility
      4. 6.4. CREATING VISUAL STUDIO MACROS
        1. 6.4.1. Understanding the Structure of Macros
          1. 6.4.1.1. Using the Macro Explorer
        2. 6.4.2. Using the Macros IDE
          1. 6.4.2.1. Using the Project Explorer and the Class View
          2. 6.4.2.2. Editing Projects and Macros
        3. 6.4.3. Recording and Developing Macros
          1. 6.4.3.1. Learning by Macro Recording
          2. 6.4.3.2. A Few Points About Macro Development
            1. 6.4.3.2.1. Building and Running Macros
            2. 6.4.3.2.2. Debugging a Macro
            3. 6.4.3.2.3. Macro Deployment
            4. 6.4.3.2.4. Responding IDE Events
        4. 6.4.4. Macro Samples
          1. 6.4.4.1. Accessing IDE Options
          2. 6.4.4.2. Writing Output Messages
          3. 6.4.4.3. Traversing the Solution Hierarchy
          4. 6.4.4.4. Dealing with User Input
      5. 6.5. CREATING VISUAL STUDIO ADD-INS
        1. 6.5.1. Add-In Architecture
        2. 6.5.2. Creating a Simple Add-In
          1. 6.5.2.1. Using the Visual Studio Add-In Wizard
          2. 6.5.2.2. The Connect Class
          3. 6.5.2.3. Managing and Loading Add-Ins
        3. 6.5.3. Using the Automation Model
        4. 6.5.4. Going on with Add-In Development
      6. 6.6. VISUAL STUDIO PACKAGES IN A NUTSHELL
        1. 6.6.1. Creating a Package with a Simple Menu Command
          1. 6.6.1.1. Using the VSPackage Wizard
          2. 6.6.1.2. Source Code Structure
          3. 6.6.1.3. Package Type Definition
          4. 6.6.1.4. The Command Table
        2. 6.6.2. Debugging the Package
      7. 6.7. EXTENDING THE NEW EDITOR
        1. 6.7.1. Extending the Editor with the Managed Extensibility Framework
          1. 6.7.1.1. Using Export Attributes
          2. 6.7.1.2. Accessing Services with Import Attribute
          3. 6.7.1.3. Metadata Attributes
        2. 6.7.2. Editor Extensibility Points
        3. 6.7.3. Creating a Simple Classifier
          1. 6.7.3.1. The Classification Type
          2. 6.7.3.2. The Classifier Provider and the Classifier
          3. 6.7.3.3. The Classification Format
          4. 6.7.3.4. Playing with the Classification
      8. 6.8. SUMMARY
  8. II. .NET 4
    1. 7. .NET Framework Version History
      1. 7.1. BEFORE THE .NET FRAMEWORK
        1. 7.1.1. Win/Win32 Programming in C
        2. 7.1.2. C++ Programming
        3. 7.1.3. Programming in Visual Basic
        4. 7.1.4. Programming in Delphi
        5. 7.1.5. COM Programming
      2. 7.2. THE ORIGIN AND GOALS OF THE .NET FRAMEWORK
      3. 7.3. EVOLUTION OF THE .NET FRAMEWORK
        1. 7.3.1. .NET Framework 1.0
        2. 7.3.2. .NET Framework 1.1
        3. 7.3.3. .NET Framework 2.0
        4. 7.3.4. .NET Framework 3.0
        5. 7.3.5. .NET Framework 3.5
        6. 7.3.6. .NET Framework 4.0
        7. 7.3.7. .NET Compact Framework
        8. 7.3.8. .NET Micro Framework
      4. 7.4. .NET FRAMEWORK ARCHITECTURE
        1. 7.4.1. Common Language Run-time (CLR)
        2. 7.4.2. Base Class Library
        3. 7.4.3. Services of the .NET Architecture
          1. 7.4.3.1. ASP.NET
          2. 7.4.3.2. Windows Forms
          3. 7.4.3.3. Web Services
          4. 7.4.3.4. ADO.NET
          5. 7.4.3.5. Workflow Foundation (WF)
          6. 7.4.3.6. Windows Communication Framework (WCF)
          7. 7.4.3.7. Windows Presentation Framework (WPF)
          8. 7.4.3.8. CardSpace
          9. 7.4.3.9. Entity Framework
      5. 7.5. MAIN BENEFITS OF THE .NET FRAMEWORK
      6. 7.6. SUMMARY
    2. 8. Modern UI Frameworks (WPF and Silverlight)
      1. 8.1. THE IMPORTANCE OF USER EXPERIENCE
      2. 8.2. DEVELOPERS ARE FROM VULCAN, DESIGNERS ARE FROM VENUS
      3. 8.3. A NEW GENERATION OF PRESENTATION FRAMEWORKS
      4. 8.4. THE TEN PILLARS OF SILVERLIGHT
        1. 8.4.1. XAML
          1. 8.4.1.1. Silverlight Hello World Application
          2. 8.4.1.2. Adding Event Handlers
          3. 8.4.1.3. Code Versus XAML
        2. 8.4.2. Tools for Working with Silverlight (and WPF)
        3. 8.4.3. Layout
          1. 8.4.3.1. Layout Containers in Silverlight
            1. 8.4.3.1.1. Border
            2. 8.4.3.1.2. Canvas
            3. 8.4.3.1.3. StackPanel
            4. 8.4.3.1.4. Grid
            5. 8.4.3.1.5. Viewbox
          2. 8.4.3.2. Custom Layout Panels
        4. 8.4.4. Data Binding
          1. 8.4.4.1. Simple Data Binding
          2. 8.4.4.2. Data Binding Between Two UI Elements
          3. 8.4.4.3. Data Binding to a List of Objects
          4. 8.4.4.4. Master-Detail Data Binding
        5. 8.4.5. Styles
        6. 8.4.6. Templates
          1. 8.4.6.1. Control Templates
          2. 8.4.6.2. Templates for Data Binding
        7. 8.4.7. Animations
          1. 8.4.7.1. Storyboards and Animations
          2. 8.4.7.2. Transformations
        8. 8.4.8. Media
          1. 8.4.8.1. Audio and Video Playback
          2. 8.4.8.2. Deep Zoom
          3. 8.4.8.3. Smooth Streaming
          4. 8.4.8.4. Webcam and Microphone Access
        9. 8.4.9. Networking
          1. 8.4.9.1. Communicating via HTTP
          2. 8.4.9.2. WCF
          3. 8.4.9.3. WCF RIA Services
        10. 8.4.10. Other Features
          1. 8.4.10.1. Out-of-Browser (OOB) Applications
          2. 8.4.10.2. Printing
          3. 8.4.10.3. Bitmap Effects
          4. 8.4.10.4. Local Messaging
          5. 8.4.10.5. GPU Acceleration
          6. 8.4.10.6. Isolated Storage
          7. 8.4.10.7. Navigation and Search Engine Optimization
      5. 8.5. WINDOWS PRESENTATION FOUNDATION
        1. 8.5.1. WPF Features not Available in Silverlight
          1. 8.5.1.1. Rich Document Presentation with Flow Documents
          2. 8.5.1.2. Additional Layout Containers and Controls
          3. 8.5.1.3. Windows 7 integration
            1. 8.5.1.3.1. Aero Glass
            2. 8.5.1.3.2. Touch
            3. 8.5.1.3.3. Taskbar Integration
          4. 8.5.1.4. A Different Control Templating Model
          5. 8.5.1.5. VisualBrush
          6. 8.5.1.6. WPF 3D
      6. 8.6. CHOOSING BETWEEN WPF AND SILVERLIGHT
      7. 8.7. DESIGNER - DEVELOPER COOPERATION IN SILVERLIGHT AND WPF
        1. 8.7.1. A Common Solution Format
        2. 8.7.2. Blendability
        3. 8.7.3. Design Time Sample Data in Blend
        4. 8.7.4. SketchFlow
        5. 8.7.5. Triggers, Actions, and Behaviors
        6. 8.7.6. Model-View-ViewModel Pattern
      8. 8.8. SUMMARY
    3. 9. Windows Communication Foundation (WCF)
      1. 9.1. WCF VERSUS ASMX WEB SERVICES
      2. 9.2. A QUICK LOOK AT SOA
        1. 9.2.1. Service
        2. 9.2.2. Service Provider
        3. 9.2.3. Service Consumer(s)
        4. 9.2.4. Service Registry
        5. 9.2.5. Service Contract
        6. 9.2.6. Service Proxy
        7. 9.2.7. Service Lease
        8. 9.2.8. Message
        9. 9.2.9. Service Description
        10. 9.2.10. Advertising and Discovery
      3. 9.3. BUILDING BLOCKS OF THE WCF ARCHITECTURE
      4. 9.4. GETTING STARTED WITH WCF
        1. 9.4.1. Creating the WCF Service
          1. 9.4.1.1. Creating the Service Interface
          2. 9.4.1.2. Creating the Service Class
        2. 9.4.2. Defining Data Contracts
        3. 9.4.3. Specifying the Binding Information
        4. 9.4.4. Hosting the WCF Service
        5. 9.4.5. Creating the Service Proxy
        6. 9.4.6. Creating the Service Client — The Service Consumer
      5. 9.5. WORKING WITH AN AJAX-ENABLED WCF SERVICE
      6. 9.6. REST AND WCF
      7. 9.7. IMPLEMENTING A WCF SERVICE DECLARATIVELY
        1. 9.7.1. Defining the Service Contract
        2. 9.7.2. Hosting the Service
        3. 9.7.3. Implementing the Service Logic Declaratively
      8. 9.8. SUMMARY
    4. 10. Enhancements to the .NET Core Framework
      1. 10.1. CHANGES IN COMMON LANGUAGE RUN-TIME
        1. 10.1.1. In-Process Side-By-Side Execution
          1. 10.1.1.1. Understanding Side-By-Side Execution
          2. 10.1.1.2. Issues Before CLR 4.0
          3. 10.1.1.3. .NET 4 Changes in CLR Hosting
        2. 10.1.2. DLR Integration
          1. 10.1.2.1. Expression Trees in .NET 3.5
          2. 10.1.2.2. DLR to the Rescue
          3. 10.1.2.3. Invoking IronPython Code Example
          4. 10.1.2.4. ExpandoObject Example
          5. 10.1.2.5. DynamicObject Example
        3. 10.1.3. Type Equivalence
          1. 10.1.3.1. No-PIA Example Featuring Type Equivalence
          2. 10.1.3.2. Equivalence Instead of Equality
          3. 10.1.3.3. Equivalence in the CLR
      2. 10.2. PARALLEL COMPUTING
        1. 10.2.1. The Challenge of Many-core Shift
          1. 10.2.1.1. Software: The Weakest Link
          2. 10.2.1.2. Issues with Multi-Threading
        2. 10.2.2. The Microsoft Approach
          1. 10.2.2.1. Tools, Programming Models, Run-times
          2. 10.2.2.2. Overview of Parallel Programming Architecture
        3. 10.2.3. Parallel LINQ
          1. 10.2.3.1. The LoremIpsumQuery Example
          2. 10.2.3.2. Comparing LoremIpsumQuery Implementations
          3. 10.2.3.3. Influencing PLINQ Behavior
        4. 10.2.4. Task Parallel Library
          1. 10.2.4.1. The Parallel Class
            1. 10.2.4.1.1. Parallel.Invoke
            2. 10.2.4.1.2. Parallel.For
            3. 10.2.4.1.3. Parallel.For<TLocal>
            4. 10.2.4.1.4. Parallel.ForEach
          2. 10.2.4.2. Working with Tasks
            1. 10.2.4.2.1. Creating and Starting Tasks
            2. 10.2.4.2.2. Defining Control Flow
            3. 10.2.4.2.3. Tasks with Results
            4. 10.2.4.2.4. Executing Tasks
            5. 10.2.4.2.5. Task-Related Types
          3. 10.2.4.3. Coordination Data Structures
            1. 10.2.4.3.1. Concurrent Collection classes
            2. 10.2.4.3.2. Synchronization Primitives
            3. 10.2.4.3.3. Lazy Initialization Classes
            4. 10.2.4.3.4. Cancellation Primitives
      3. 10.3. CODE CONTRACTS
        1. 10.3.1.
          1. 10.3.1.1. Understanding the Code Contracts System
          2. 10.3.1.2. Declaring Code Contracts
            1. 10.3.1.2.1. Preconditions
            2. 10.3.1.2.2. Postconditions
            3. 10.3.1.2.3. Object Invariants
            4. 10.3.1.2.4. Interface Contracts
          3. 10.3.1.3. Code Contract Tools in Visual Studio
          4. 10.3.1.4. Run-time Behavior
      4. 10.4. MANAGED EXTENSIBILITY FRAMEWORK
        1. 10.4.1. The Challenge
          1. 10.4.1.1. Dynamic Composition
          2. 10.4.1.2. The Open/Closed Principle
        2. 10.4.2. A Simple MEF Example
          1. 10.4.2.1. Getting MEF into the Game
          2. 10.4.2.2. Multiple Parts
          3. 10.4.2.3. Using Host Services
        3. 10.4.3. Basic MEF Concepts
          1. 10.4.3.1. Parts and Contracts
          2. 10.4.3.2. Exports and Imports
          3. 10.4.3.3. Composition Containers and Catalogs
          4. 10.4.3.4. Parts and Metadata
        4. 10.4.4. Composition
          1. 10.4.4.1. Explicit and Implicit Composition
          2. 10.4.4.2. Part Instantiation
          3. 10.4.4.3. Lazy Instantiation
          4. 10.4.4.4. Import Notification
          5. 10.4.4.5. Recomposition
          6. 10.4.4.6. Part lifetime
          7. 10.4.4.7. Accessing Metadata
        5. 10.4.5. A Few More Points on MEF
      5. 10.5. SUMMARY
    5. 11. Enhancements to the .NET Workflow Framework
      1. 11.1. AN INTRODUCTION TO WF 4.0
        1. 11.1.1. The Workflow Design Surface
        2. 11.1.2. The Hello Workflow Application
          1. 11.1.2.1. Adding an Input Argument
          2. 11.1.2.2. Adding Activities to the Workflow
          3. 11.1.2.3. Passing Input Arguments to the Workflow
          4. 11.1.2.4. Adding an Output Argument
          5. 11.1.2.5. Adding a Variable
          6. 11.1.2.6. Creating the Output Value
          7. 11.1.2.7. Extracting the Workflow Output
      2. 11.2. CREATING FLOWCHARTS AND CODED WORKFLOWS
        1. 11.2.1. Flowcharts in WF 4.0
          1. 11.2.1.1. Adding a Flowchart to the Workflow
          2. 11.2.1.2. Adding a FlowDecision Activity
          3. 11.2.1.3. Adding a ForEach<T> Activity
          4. 11.2.1.4. Adding a FlowSwitch Activity
          5. 11.2.1.5. Running the Flowchart Workflow
        2. 11.2.2. Code-Only Workflows
          1. 11.2.2.1. Declaring Workflow Arguments
          2. 11.2.2.2. Declaring Variables
          3. 11.2.2.3. Building Activities
          4. 11.2.2.4. Using Expressions
      3. 11.3. WORKFLOW ARCHITECTURE
        1. 11.3.1. WorkflowApplication and Hosts
        2. 11.3.2. Activities
        3. 11.3.3. Extensions
        4. 11.3.4. Workflow Activity Model Changes
          1. 11.3.4.1. SimpleHelloWF35
          2. 11.3.4.2. SimpleHelloWF4
      4. 11.4. WORKFLOW ACTIVITY LIBRARY
        1. 11.4.1. Primitive Activities
        2. 11.4.2. Flow Control Activities
        3. 11.4.3. Workflow Run-Time Activities
        4. 11.4.4. Flowchart-Specific Activities
        5. 11.4.5. Error-Handling Activities
        6. 11.4.6. Transaction-Handling Activities
        7. 11.4.7. Collection-Handling Activities
        8. 11.4.8. Messaging Activities
      5. 11.5. USING THE COMPENSATING TRANSACTION MODEL
        1. 11.5.1. The ConferenceWorkflow Example
        2. 11.5.2. Implementing Cancellation, Confirmation, and Compensation
        3. 11.5.3. Cancellation
        4. 11.5.4. Compensation
      6. 11.6. PERSISTENCE AND HUMAN INTERACTIONS
        1. 11.6.1. The DomainNameWorkflow Project
          1. 11.6.1.1. The Structure of the Project
          2. 11.6.1.2. The Main Workflow
          3. 11.6.1.3. Preparing the Workflow Database
          4. 11.6.1.4. Storing a New Request into the Database
          5. 11.6.1.5. Communicating with the Host Application
          6. 11.6.1.6. Suspending the Workflow Instance
          7. 11.6.1.7. Configuring SqlWorkflowInstanceStore
          8. 11.6.1.8. Resuming the Workflow Instance
        2. 11.6.2. Workflow Tracking
          1. 11.6.2.1. Tracking Records
          2. 11.6.2.2. Participating in the Tracking Process
          3. 11.6.2.3. Persisting Tracking Information
          4. 11.6.2.4. Configuring the Tracking Participant
          5. 11.6.2.5. Custom Tracking Events
          6. 11.6.2.6. Running the DomainNameWorkflowTracking Application
      7. 11.7. WORKFLOW SERVICES
        1. 11.7.1. Creating a Workflow Service
        2. 11.7.2. Using WorkflowServiceHost
          1. 11.7.2.1. Changing the Main Workflow
          2. 11.7.2.2. The Approval Workflow
          3. 11.7.2.3. Configuring WorkflowServiceHost
          4. 11.7.2.4. Workflow Behaviors
          5. 11.7.2.5. Running the Application
      8. 11.8. SUMMARY
    6. 12. Enhancements to the .NET Data Framework
      1. 12.1. LANGUAGE INTEGRATED QUERY (LINQ)
        1. 12.1.1. LINQ Operators
        2. 12.1.2. LINQ Implementations
          1. 12.1.2.1. LINQ to Objects
          2. 12.1.2.2. LINQ to XML
          3. 12.1.2.3. LINQ to DataSet
          4. 12.1.2.4. LINQ to SQL
        3. 12.1.3. PARALLEL LINQ (PLINQ)
      2. 12.2. ENTITY FRAMEWORK
        1. 12.2.1. Entity Framework Architecture
          1. 12.2.1.1. The Entity Data Model
          2. 12.2.1.2. LINQ to Entities
          3. 12.2.1.3. Entity Client
          4. 12.2.1.4. Entity SQL
          5. 12.2.1.5. Object Services
      3. 12.3. THE ENTITY DATA SOURCE CONTROL
      4. 12.4. CHOOSING BETWEEN LINQ TO ENTITIES AND LINQ TO SQL
      5. 12.5. SUMMARY
    7. 13. Enhancements to the .NET Communication Framework
      1. 13.1. ENHANCEMENTS IN WCF FRAMEWORK 3.5
      2. 13.2. ENHANCEMENTS IN WCF FRAMEWORK 4.0
        1. 13.2.1. Simplified Configuration
        2. 13.2.2. Standard Endpoints
        3. 13.2.3. Discovery
        4. 13.2.4. REST Improvements
        5. 13.2.5. Routing Service
      3. 13.3. SUMMARY
    8. 14. .NET Charting Components
      1. 14.1. CREATING CHARTS
        1. 14.1.1. Creating a Simple Chart
          1. 14.1.1.1. Adding a Chart Control to a Form
          2. 14.1.1.2. Manually Adding Data to the Chart
          3. 14.1.1.3. Adding a New Chart Area
          4. 14.1.1.4. Setting up Titles and Legends
          5. 14.1.1.5. Adding a Three-Dimensional Effect to the Chart
        2. 14.1.2. Adding Data to the Chart Programmatically
          1. 14.1.2.1. Adding Data Points Programmatically
          2. 14.1.2.2. Binding a Data Source to the Chart
        3. 14.1.3. Adding Charts to WPF Applications
      2. 14.2. USING CHART CONTROLS
        1. 14.2.1. Elements of a Chart
        2. 14.2.2. The Chart Class
        3. 14.2.3. Chart Types
          1. 14.2.3.1. Column and Bar Charts
          2. 14.2.3.2. Line Charts
          3. 14.2.3.3. Point Charts
          4. 14.2.3.4. Area Charts
          5. 14.2.3.5. Pie and Doughnut Charts
          6. 14.2.3.6. Range Charts
          7. 14.2.3.7. Special Chart Types
          8. 14.2.3.8. More About Custom Properties
        4. 14.2.4. Chart Coordinate System
        5. 14.2.5. Three-Dimensional Charts
        6. 14.2.6. Appearance of Chart Elements
        7. 14.2.7. Axes and Related Chart Elements
          1. 14.2.7.1. Strip Lines
          2. 14.2.7.2. Custom Axis Labels
        8. 14.2.8. Data Points
      3. 14.3. ADVANCED CHART MANIPULATION
        1. 14.3.1. Annotations
          1. 14.3.1.1. Annotation Types
          2. 14.3.1.2. Anchoring Annotations
          3. 14.3.1.3. Moving Annotations
        2. 14.3.2. Binding Data to Series
        3. 14.3.3. The DataManipulator class
          1. 14.3.3.1. Filtering Data
          2. 14.3.3.2. Sorting Data
          3. 14.3.3.3. Copying Values
          4. 14.3.3.4. Export Data to a DataSet Object
          5. 14.3.3.5. Apply Statistical Formula to Data
        4. 14.3.4. Apply Financial Formula to Data
        5. 14.3.5. More Chart Manipulations
      4. 14.4. SUMMARY
  9. III. ASP.NET 4.0
    1. 15. ASP.NET Version History
      1. 15.1. DEVELOPMENT OF THE WEB AND WEB DEVELOPMENT
      2. 15.2. ENTER ASP
      3. 15.3. ENTER ASP.NET
      4. 15.4. ASP.NET VERSION HISTORY
        1. 15.4.1. ASP.NET 1.0
        2. 15.4.2. ASP.NET 1.1
        3. 15.4.3. ASP.NET 2.0
          1. 15.4.3.1. Support for 64-Bit Processors
          2. 15.4.3.2. New Data Controls
          3. 15.4.3.3. New Techniques for Declarative Data Access
          4. 15.4.3.4. Navigation Controls
          5. 15.4.3.5. Master Pages
          6. 15.4.3.6. Login Controls
          7. 15.4.3.7. Themes and Skins
          8. 15.4.3.8. Web Parts
          9. 15.4.3.9. Personalization Services
          10. 15.4.3.10. Full Pre-Compilation
          11. 15.4.3.11. Localization
          12. 15.4.3.12. Provider Class Model
        4. 15.4.4. ASP.NET 3.0
          1. 15.4.4.1. Windows Communication Foundation (WCF)
          2. 15.4.4.2. Windows CardSpace (WCS)
        5. 15.4.5. ASP.NET 3.5
          1. 15.4.5.1. New Data Controls
          2. 15.4.5.2. ASP.NET Ajax
          3. 15.4.5.3. Support for HTTP Pipelining and Syndication Feeds
          4. 15.4.5.4. WCF Support for RSS, JSON, POX, and Partial Trust
        6. 15.4.6. ASP.NET 3.5 SP1
        7. 15.4.7. ASP.NET 4.0
          1. 15.4.7.1. Web Forms Framework
          2. 15.4.7.2. MVC Framework
      5. 15.5. SUMMARY
    2. 16. ASP.NET Charting Controls
      1. 16.1. CREATING CHARTS
        1. 16.1.1. Adding a Chart Control to a Page
        2. 16.1.2. Setting up Charts in an Event Handler Method
        3. 16.1.3. Binding Data to the Chart
      2. 16.2. RENDERING ASP.NET CHARTS
        1. 16.2.1. Image URL Rendering
          1. 16.2.1.1. Changing Image Location
          2. 16.2.1.2. Changing the Image File Format
        2. 16.2.2. Using Charts with Legacy Web Sites
        3. 16.2.3. Binary Stream Rendering
      3. 16.3. CHART STATE MANAGEMENT
        1. 16.3.1. Saving Chart State
        2. 16.3.2. Advanced Chart State Management
          1. 16.3.2.1. Chart Serialization Basics
          2. 16.3.2.2. Using Serialization in State Management
          3. 16.3.2.3. Playing with the Serialization Content
      4. 16.4. USER INTERACTIVITY
        1. 16.4.1. Using Tooltips
        2. 16.4.2. Handling Clicks on Data Points
        3. 16.4.3. Interactivity With Ajax
          1. 16.4.3.1. Handling Click Events
          2. 16.4.3.2. Triggering Chart Events
          3. 16.4.3.3. Real Time Charts
        4. 16.4.4. A Few More Points on User Interactivity
      5. 16.5. SUMMARY
    3. 17. ASP.NET Dynamic Data
      1. 17.1. CREATING A NEW DYNAMIC DATA WEB SITE
        1. 17.1.1. Working Against a Data Model
          1. 17.1.1.1. Creating the Website Using a Template
          2. 17.1.1.2. Adding the Data Model and Registering the Data Context
        2. 17.1.2. Displaying Data from Existing Tables
        3. 17.1.3. Creating Simple CRUD Applications
          1. 17.1.3.1. Understanding the Default URLs
          2. 17.1.3.2. Customizing Dynamic Data's URL Routing
          3. 17.1.3.3. Performing CRUD Operations on the Same Page
        4. 17.1.4. Creating a Dynamic Data Application for Master-Detail Relationships
          1. 17.1.4.1. Filtering Data from Many Related Tables
          2. 17.1.4.2. Performing Complex CRUD Operations on the Same Page
      2. 17.2. WORKING TO MODIFY IMPLEMENTATION TO FIT BUSINESS NEEDS
        1. 17.2.1. Understanding Dynamic Data's Structure
        2. 17.2.2. Customizing the Look and Feel
        3. 17.2.3. Working with Page Templates
        4. 17.2.4. Working with Field Templates
        5. 17.2.5. Working with Entity Templates
        6. 17.2.6. Working with Filter Templates
        7. 17.2.7. Creating Custom Pages
        8. 17.2.8. Customizing Validations
      3. 17.3. SUMMARY
    4. 18. ASP.NET Model View Controller (MVC)
      1. 18.1. INTRODUCTION TO MVC
        1. 18.1.1. Similar Design Patterns
          1. 18.1.1.1. Model-View-Presenter
          2. 18.1.1.2. Model-View-ViewModel
        2. 18.1.2. Microsoft and the Web Platform
        3. 18.1.3. What Is Microsoft ASP.NET MVC 2?
          1. 18.1.3.1. Test Driven Development (TDD)
          2. 18.1.3.2. Interface-Based Development
          3. 18.1.3.3. Repository Design Pattern
          4. 18.1.3.4. Dependency Injection
          5. 18.1.3.5. Service Locator Pattern
        4. 18.1.4. Extensibility in MVC
      2. 18.2. CREATING AN MVC 2 APPLICATION
        1. 18.2.1. The Project Structure
        2. 18.2.2. How Does it Work?
          1. 18.2.2.1. Routing
          2. 18.2.2.2. The Controller Class
          3. 18.2.2.3. The View
      3. 18.3. ADDING NEW MVC 2 PAGES
        1. 18.3.1. Create a Database
        2. 18.3.2. Create a Model
        3. 18.3.3. Listing Books
          1. 18.3.3.1. Creating the BookController Class
          2. 18.3.3.2. Creating the Index View
        4. 18.3.4. Adding Book Actions
          1. 18.3.4.1. Adding the Details View
          2. 18.3.4.2. Adding the Edit View
          3. 18.3.4.3. Adding the Create View
          4. 18.3.4.4. Adding the Delete View
      4. 18.4. CUSTOMIZATION IN MVC 2
        1. 18.4.1. Model Binding
        2. 18.4.2. Validation
          1. 18.4.2.1. Validation Attributes
          2. 18.4.2.2. Extending the Model with Validation Metadata
          3. 18.4.2.3. Preparing the Controller for Validation
          4. 18.4.2.4. Displaying Validation Issues
          5. 18.4.2.5. Managing Business Rules
          6. 18.4.2.6. Client-Side Validation
        3. 18.4.3. UI Customization
          1. 18.4.3.1. Using Templated Helpers
          2. 18.4.3.2. Display and Edit Templates
          3. 18.4.3.3. Metadata Attributes
            1. 18.4.3.3.1. DisplayColumnAttribute
            2. 18.4.3.3.2. DisplayFormatAttribute
            3. 18.4.3.3.3. ScaffoldColumnAttribute
            4. 18.4.3.3.4. UIHintAttribute
            5. 18.4.3.3.5. DisplayAttribute
            6. 18.4.3.3.6. HiddenInputAttribute
            7. 18.4.3.3.7. DisplayNameAttribute
          4. 18.4.3.4. Custom Templates
          5. 18.4.3.5. View Engines
      5. 18.5. ROUTING DETAILS
        1. 18.5.1. Controller Factory
        2. 18.5.2. Influencing the Execution Flow
        3. 18.5.3. Authorization
          1. 18.5.3.1. AuthorizationAttribute
          2. 18.5.3.2. ChildActionOnlyAttribute
          3. 18.5.3.3. RequireHttpsAttribute
          4. 18.5.3.4. ValidateAntiForgeryTokenAttribute
          5. 18.5.3.5. ValidateInputAttribute
        4. 18.5.4. Action and Result Filtering
        5. 18.5.5. Exception Filtering
        6. 18.5.6. ActionResult
      6. 18.6. TESTING WITH MVC 2
        1. 18.6.1. Refactoring AcmeLibrary
          1. 18.6.1.1. What Needs to Be Changed?
          2. 18.6.1.2. New Project Structure
          3. 18.6.1.3. Setting Up the Domain Model
          4. 18.6.1.4. Implementing the Repository
          5. 18.6.1.5. Attaching Book to IBook
        2. 18.6.2. Creating and Running Unit Tests
      7. 18.7. A FEW MORE POINTS ON MVC 2
        1. 18.7.1. Areas
        2. 18.7.2. Metadata Providers
        3. 18.7.3. Value Providers
        4. 18.7.4. Model Binders
        5. 18.7.5. Child Actions
        6. 18.7.6. Asynchronous Controllers
      8. 18.8. SUMMARY
    5. 19. ASP.NET Ajax Improvements
      1. 19.1. UNDERSTANDING AJAX
        1. 19.1.1. The XMLHttpRequest Object
        2. 19.1.2. ASP.NET and Ajax
      2. 19.2. USING THE ASP.NET AJAX SERVER CONTROLS
        1. 19.2.1. Refactoring the Framework Libraries
        2. 19.2.2. Using the Microsoft CDN
      3. 19.3. USING THE MICROSOFT AJAX LIBRARY
        1. 19.3.1. Working with DOM Elements
        2. 19.3.2. The Script Loader
        3. 19.3.3. Client-Side Data Binding with Templates
          1. 19.3.3.1. Using the DataView Control
          2. 19.3.3.2. Using Pseudo-Columns in a Template
          3. 19.3.3.3. Running Code Inside a Template
          4. 19.3.3.4. Adding Interaction with Events Inside the Template
          5. 19.3.3.5. Using External Templates
        4. 19.3.4. Advanced Data-Binding Scenarios
          1. 19.3.4.1. Live Binding
          2. 19.3.4.2. Top-Level Binding
          3. 19.3.4.3. Two-Way Binding
          4. 19.3.4.4. Custom Converters
          5. 19.3.4.5. Master-Detail Binding
        5. 19.3.5. Working with Server-Side Data
          1. 19.3.5.1. Updating the Data on the Server
          2. 19.3.5.2. Working with ADO.NET Data Services
          3. 19.3.5.3. Retrieving Cross-Domain Data
      4. 19.4. SUMMARY
    6. 20. ASP.NET Ajax Control Toolkit and jQuery
      1. 20.1. FIRST LOOK AT THE AJAX CONTROL TOOLKIT
        1. 20.1.1. Installing the Ajax Control Toolkit
          1. 20.1.1.1. Controls Installed with the Toolkit
          2. 20.1.1.2. Upgrading to a New Version
        2. 20.1.2. Creating a Simple Web Application with the Toolkit
          1. 20.1.2.1. The FindAnExpertDemo Project
          2. 20.1.2.2. Improving FindAnExpertDemo with Ajax Control Toolkit
            1. 20.1.2.2.1. Adding a ToolkitScriptManager to the Page
            2. 20.1.2.2.2. Adding CascadingDropDown Extenders
            3. 20.1.2.2.3. Adding the ExpertiseService Class to the Project
            4. 20.1.2.2.4. Discovering the Effect of CascadingDropDown
            5. 20.1.2.2.5. Using an UpdatePanel
      2. 20.2. USING THE CONTROLS OF THE TOOLKIT
        1. 20.2.1. New Server Controls
          1. 20.2.1.1. The ComboBox Control
          2. 20.2.1.2. The TabContainer Control
          3. 20.2.1.3. The Accordion Control
          4. 20.2.1.4. The AsyncFileUpload Control
          5. 20.2.1.5. The Editor Control
        2. 20.2.2. Control Extenders
          1. 20.2.2.1. Button and Checkbox Extenders
          2. 20.2.2.2. TextBox Extenders
          3. 20.2.2.3. List Extenders
          4. 20.2.2.4. Panel Extenders
          5. 20.2.2.5. Popup Extenders
          6. 20.2.2.6. The ValidatorCalloutExtender Control
        3. 20.2.3. Animations
      3. 20.3. THE JQUERY LIBRARY
        1. 20.3.1. "Hello, World" with jQuery
          1. 20.3.1.1. jQuery Library and jQuery Object
        2. 20.3.2. Selectors and Filters
        3. 20.3.3. Chaining and Utility Functions
        4. 20.3.4. Eventing Model and Event Handlers
        5. 20.3.5. Visual Effects and Animations
        6. 20.3.6. jQuery Ajax Features
      4. 20.4. SUMMARY
  10. IV. VB.NET
    1. 21. History of Visual Basic
      1. 21.1. THE ROOTS OF VISUAL BASIC
        1. 21.1.1. Structured and Unstructured BASIC
        2. 21.1.2. Moving to "Visual"
        3. 21.1.3. Visual Basic in the 1990s
      2. 21.2. VISUAL BASIC IN THE .NET FRAMEWORK
        1. 21.2.1. Design Goals and Debates
        2. 21.2.2. Visual Basic .NET (7.0) and .NET 2003 (7.1)
          1. 21.2.2.1. Type System
          2. 21.2.2.2. Memory Management
        3. 21.2.3. Visual Basic 2005 (8.0)
          1. 21.2.3.1. Generic Types
          2. 21.2.3.2. Partial Types
          3. 21.2.3.3. Nullable Types
          4. 21.2.3.4. Documentation Comments
          5. 21.2.3.5. Operator Declarations
          6. 21.2.3.6. New Unsigned and Signed Integer Types
          7. 21.2.3.7. Using Construct
        4. 21.2.4. Visual Basic 2008 (9.0)
          1. 21.2.4.1. Local Variable Type Inference
          2. 21.2.4.2. Extension Methods
          3. 21.2.4.3. Object-Creation Expressions
          4. 21.2.4.4. Lambda Expressions
          5. 21.2.4.5. Query Expressions
          6. 21.2.4.6. Partial Methods
          7. 21.2.4.7. XML Literal Expressions
          8. 21.2.4.8. Nullable Value Type Modifier
          9. 21.2.4.9. A True Conditional Operator
      3. 21.3. SUMMARY
    2. 22. Visual Basic 10.0 Language Improvements
      1. 22.1. NEW PRODUCTIVITY-IMPROVING SYNTAX
        1. 22.1.1. Implicit Line Continuation
        2. 22.1.2. Auto-Implemented Properties
        3. 22.1.3. Collection Initializers
        4. 22.1.4. Multiline Lambda Expressions
      2. 22.2. WORKING WITH DYNAMIC OBJECTS
        1. 22.2.1. Late Binding in Visual Basic 2010
        2. 22.2.2. Accessing an IronPython Library
      3. 22.3. VARIANCE
        1. 22.3.1. Type Substitution
        2. 22.3.2. Variance in Visual Basic 2010
          1. 22.3.2.1. Covariance
          2. 22.3.2.2. Contravariance
        3. 22.3.3. A Few More Points on Variance
          1. 22.3.3.1. Variance with Multiple Type Parameters
          2. 22.3.3.2. Variance with User Types
          3. 22.3.3.3. Variance and Reflection
      4. 22.4. SUMMARY
  11. V. C#
    1. 23. History of C#
      1. 23.1. THE EVOLUTION OF C#
        1. 23.1.1. Design Goals
        2. 23.1.2. Short History
        3. 23.1.3. Implementations
      2. 23.2. C# 1.0
        1. 23.2.1. Type System
        2. 23.2.2. Memory Management
        3. 23.2.3. Syntactic Sugar
        4. 23.2.4. C# 1.1
      3. 23.3. C# 2.0
        1. 23.3.1. Generic Types
        2. 23.3.2. Partial Types
        3. 23.3.3. Static Classes
        4. 23.3.4. Iterators
        5. 23.3.5. Anonymous Methods
        6. 23.3.6. Delegate Inference
        7. 23.3.7. Delegate Covariance and Contravariance
        8. 23.3.8. Nullable Types
        9. 23.3.9. Property Accessors
        10. 23.3.10. Null-Coalesce Operator
        11. 23.3.11. Namespace Aliases
      4. 23.4. C# 3.0
        1. 23.4.1. Local Variable Type Inference
        2. 23.4.2. Extension Methods
        3. 23.4.3. Anonymous Types
        4. 23.4.4. Lambda Expressions
        5. 23.4.5. Query Expressions
        6. 23.4.6. Expression Trees
        7. 23.4.7. Automatic Properties
        8. 23.4.8. Object Initializers
        9. 23.4.9. Collection Intializers
        10. 23.4.10. Partial Methods
      5. 23.5. SUMMARY
    2. 24. C# 4.0 Language Improvements
      1. 24.1. PAINS WITH INTEROPERABILITY
        1. 24.1.1. Creating the PainWithOffice Application
        2. 24.1.2. Frustrating Issues
        3. 24.1.3. Remove the Pain
      2. 24.2. DYNAMIC LOOKUP
        1. 24.2.1. Dynamic Binding
        2. 24.2.2. The dynamic Type
        3. 24.2.3. Dynamic Operations
          1. 24.2.3.1. Dynamic Dispatch
          2. 24.2.3.2. Compile Time Semantics
          3. 24.2.3.3. System.Object and dynamic
        4. 24.2.4. The Dynamic Language Run-time
      3. 24.3. NAMED AND OPTIONAL PARAMETERS
        1. 24.3.1. Using Optional Parameters
          1. 24.3.1.1. Rules for Using Optional Parameters
          2. 24.3.1.2. Optional Parameters and Indexers
        2. 24.3.2. Using Named Parameters
        3. 24.3.3. Overload Resolution
          1. 24.3.3.1. Abstract and Virtual Members
          2. 24.3.3.2. Resolving Applicable Signatures
      4. 24.4. COM-SPECIFIC INTEROPERABILITY FEATURES
        1. 24.4.1. Dynamic Import
        2. 24.4.2. Omitting ref from Parameters
        3. 24.4.3. Indexed Properties
        4. 24.4.4. Compiling Without PIAs
      5. 24.5. VARIANCE
        1. 24.5.1. Type Substitution
        2. 24.5.2. Bird's-Eye View of Variance
        3. 24.5.3. Variance in C# 4.0
          1. 24.5.3.1. Covariance
          2. 24.5.3.2. Contravariance
        4. 24.5.4. A Few More Points on Variance
          1. 24.5.4.1. Variance with Multiple Type Parameters
          2. 24.5.4.2. Variance with User Types
          3. 24.5.4.3. Variance and Reflection
      6. 24.6. SUMMARY
  12. VI. F#
    1. 25. Visual F# and the Other .NET Languages
      1. 25.1. A BRIEF HISTORY OF F#
      2. 25.2. F# AT FIRST GLANCE
        1. 25.2.1. Trying Things Out with F#
        2. 25.2.2. Understanding Syntax
          1. 25.2.2.1. First Taste
          2. 25.2.2.2. Understanding Functions and Piping
          3. 25.2.2.3. Understanding Optional Parentheses Around Function Arguments
          4. 25.2.2.4. Understanding Currying
          5. 25.2.2.5. Significant Whitespace, Indentation Matters
          6. 25.2.2.6. Naming Conventions
          7. 25.2.2.7. Using Comments
      3. 25.3. YOUR FIRST F# PROJECT
      4. 25.4. PROGRAMMING WITH F#
        1. 25.4.1. Namespaces and Modules
        2. 25.4.2. Attributes
        3. 25.4.3. Literals and Bindings
          1. 25.4.3.1. Numbers, Booleans, and Unit
          2. 25.4.3.2. Strings
          3. 25.4.3.3. Syntax for Various Collections
          4. 25.4.3.4. Null Values
          5. 25.4.3.5. Type Signatures
          6. 25.4.3.6. Bindings
          7. 25.4.3.7. Access Control
        4. 25.4.4. Expressions
          1. 25.4.4.1. Operators
          2. 25.4.4.2. Conditionals
          3. 25.4.4.3. Loops
          4. 25.4.4.4. Reference Cells
          5. 25.4.4.5. Core Functions — Formatted Printing
          6. 25.4.4.6. Converting Literals and Values
        5. 25.4.5. Values and F# Types
          1. 25.4.5.1. Class Types, Objects, and Object Expressions
            1. 25.4.5.1.1. Inheritance
            2. 25.4.5.1.2. Interfaces
            3. 25.4.5.1.3. Object Expressions
            4. 25.4.5.1.4. Objects
            5. 25.4.5.1.5. Object State via let Bindings
            6. 25.4.5.1.6. Object Initialization
            7. 25.4.5.1.7. Setters and Getters
            8. 25.4.5.1.8. Indexers
            9. 25.4.5.1.9. Named and Optional Arguments to Constructors
          2. 25.4.5.2. Anonymous Functions
          3. 25.4.5.3. Using Tuples
          4. 25.4.5.4. Using Discriminated Unions
          5. 25.4.5.5. Using Options
          6. 25.4.5.6. Using Records
          7. 25.4.5.7. Using Lists
        6. 25.4.6. Type Augmentations
        7. 25.4.7. Computation Expressions
        8. 25.4.8. Sequences
        9. 25.4.9. Range Expressions
        10. 25.4.10. Sequence Expressions
        11. 25.4.11. Asynchronous Workflows
        12. 25.4.12. Pattern Matching
        13. 25.4.13. Active Patterns
        14. 25.4.14. Exceptions
        15. 25.4.15. Units of Measure
        16. 25.4.16. Lazy Computations
        17. 25.4.17. Quotations
        18. 25.4.18. Working with Database Queries
      5. 25.5. A LARGER APPLICATION IN F#
        1. 25.5.1. The Ast Module
        2. 25.5.2. The Language Module
        3. 25.5.3. The Evaluator Module
        4. 25.5.4. The FunctionPlotter Module
        5. 25.5.5. Running the Function Plotter
      6. 25.6. OTHER .NET LANGUAGES
        1. 25.6.1. IronRuby
        2. 25.6.2. IronPython
      7. 25.7. SUMMARY