book

Pro VB 2010 and the .NET 4 Platform

Name: Pro VB 2010 and the .NET 4 Platform
ISBN: 9781430229858

by Andrew Troelsen, Vidya Vrat Agarwal

October 2010

Intermediate to advanced

1799 pages

41h 27m

English

Apress

Read now

Unlock full access

Copyright
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction
We're a Team, You and IAn Overview of This BookChapter 1: Introducing VB 2010Chapter 2: Building Visual Basic 2010 ApplicationsChapter 3: Core VB 2010 Programming Constructs, Part IChapter 4: Core VB Programming Constructs, Part IIChapter 5: Defining Encapsulated Class TypesChapter 6: Understanding Inheritance and PolymorphismChapter 7: Understanding Structured Exception HandlingChapter 8: Understanding Object LifetimeChapter 9: Working with InterfacesChapter 10: Understanding GenericsChapter 11: Delegates, Events, and LambdasChapter 12: Advanced VB 2010 Language FeaturesChapter 13: LINQ to ObjectsChapter 14: Configuring .NET AssembliesChapter 15: Type Reflection, Late Binding, and Attribute-Based ProgrammingChapter 16: Processes, AppDomains, and Object ContextsChapter 17: Understanding CIL and the Role of Dynamic AssembliesChapter 18: Dynamic Types and the Dynamic Language RuntimeChapter 19: Multithreaded and Parallel ProgrammingChapter 20: File I/O and Object SerializationChapter 21: ADO.NET Part I: The Connected LayerChapter 22: ADO.NET Part II: The Disconnected LayerChapter 23: ADO.NET Part III: The Entity FrameworkChapter 24: Introducing LINQ to XMLChapter 25: Introducing Windows Communication FoundationChapter 26: Introducing Windows Workflow FoundationChapter 27: Introducing Windows Presentation Foundation and XAMLChapter 28: Programming with WPF ControlsChapter 29: WPF Graphical Rendering ServicesChapter 30: WPF Resources, Animations, and StylesChapter 31: WPF Control Templates and UserControlsChapter 32: Building ASP.NET Web PagesChapter 33: ASP.NET Web Controls, Master Pages, and ThemesChapter 34: ASP.NET State Management TechniquesAppendix A: Programming with Windows FormsAppendix B: Platform-Independent .NET Development with MonoObtaining This Book's Source CodeObtaining Updates for This Book
1. Introducing VB 2010
1.1. Understanding the Previous State of Affairs1.1.1. Life As a C/Windows API Programmer1.1.2. Life As a C++/MFC Programmer1.1.3. Life As a Visual Basic 6.0 Programmer1.1.4. Life As a Java Programmer1.1.5. Life As a COM Programmer1.1.5.1. The Complexity of COM Data Type Representation1.2. The .NET Solution1.3. Introducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)1.3.1. The Role of the Base Class Libraries1.3.2. What Visual Basic 2010 Brings to the Table1.4. Additional .NET-Aware Programming Languages1.4.1. Life in a Multi-Language World1.5. An Overview of .NET Assemblies1.5.1. Single-File and Multi-File Assemblies1.5.2. The Role of the Common Intermediate Language1.5.2.1. Benefits of CIL1.5.2.2. Compiling CIL to Platform-Specific Instructions1.5.3. The Role of .NET Type Metadata1.5.4. The Role of the Assembly Manifest1.6. Understanding the Common Type System1.6.1. CTS Class Types1.6.2. CTS Interface Types1.6.3. CTS Structure Types1.6.4. CTS Enumeration Types1.6.5. CTS Delegate Types1.6.6. CTS Type Members1.6.7. Intrinsic CTS Data Types1.7. Understanding the Common Language Specification1.7.1. Ensuring CLS Compliance1.8. Understanding the Common Language Runtime1.9. The Assembly/Namespace/Type Distinction1.9.1. The Role of the Microsoft Root Namespace1.9.2. Accessing a Namespace Programmatically1.9.3. Referencing External Assemblies1.10. Exploring an Assembly Using ildasm.exe1.10.1. Viewing CIL Code1.10.2. Viewing Type Metadata1.10.3. Viewing Assembly Metadata (aka the Manifest)1.11. Exploring an Assembly Using Reflector1.12. Deploying the .NET Runtime1.12.1. The .NET Client Profile Runtime1.13. The Platform-Independent Nature of .NET1.14. Summary
2. Building Visual Basic 2010 Applications
2.1. The Role of the .NET Framework 4.0 SDK2.1.1. The Visual Studio 2010 Command Prompt2.2. Building VB 2010 Applications Using vbc.exe2.2.1. Specifying Input and Output Targets2.2.2. Referencing External Assemblies2.2.3. Referencing Multiple External Assemblies2.2.4. Compiling Multiple Source Files2.2.5. Working with VB 2010 Response Files2.2.5.1. The Default Response File (vbc.rsp)2.3. Building .NET Applications Using Notepad++2.4. Building .NET Applications Using Visual Basic 2010 Express2.4.1. Some Unique Features of Visual Basic 2010 Express2.5. Building .NET Applications Using Visual Studio 20102.5.1. Some Unique Features of Visual Studio 20102.5.2. Targeting the .NET Framework Using the New Project Dialog Box2.5.3. Using the Solution Explorer Utility2.5.3.1. Referencing External Assemblies2.5.3.2. Viewing Project Properties2.5.4. The Class View Utility2.5.5. The Object Browser Utility2.5.6. Integrated Support for Code Refactoring2.5.7. Code Expansions Techniques2.5.8. The Visual Class Designer2.5.9. The Integrated .NET Framework 4.0 SDK Documentation System2.6. Summary
3. Core VB 2010 Programming Constructs, Part I
3.1. The Role of the Module Type3.1.1. Projects with Multiple Modules3.1.2. Modules Are Not Creatable3.1.3. Renaming Your Initial Module3.1.4. Members of Modules3.2. The Anatomy of a Simple VB 2010 Program3.2.1. Variations on the Main() Method3.2.2. Specifying an Application Error Code3.2.3. Processing Command-Line Arguments3.2.4. Specifying Command-Line Arguments with Visual Studio 20103.3. An Interesting Aside: Some Additional Members of the System.Environment Class3.4. The System.Console Class3.4.1. Basic Input and Output with the Console Class3.4.2. Formatting Console Output3.4.3. Formatting Numerical Data3.4.4. Formatting Numerical Data Beyond Console Applications3.5. System Data Types and VB 2010 Shorthand Notation3.5.1. Variable Declaration and Initialization3.5.2. Intrinsic Data Types and the New Operator3.5.3. The Data Type Class Hierarchy3.5.4. Members of Numerical Data Types3.5.5. Members of System.Boolean3.5.6. Members of System.Char3.5.7. Parsing Values from String Data3.5.8. System.DateTime and System.TimeSpan3.5.9. The .NET 4.0 System.Numerics Namespace3.6. Working with String Data3.6.1. Basic String Manipulation3.6.2. String Concatenation3.6.3. Special Character Constants3.6.4. End SubStrings and Equality3.6.5. Strings Are Immutable3.6.6. The System.Text.StringBuilder Type3.7. Narrowing and Widening Data Type Conversions3.7.1. Trapping Narrowing Data Conversions3.7.2. Understanding Option Strict3.7.3. Setting Project-wide Overflow Checking3.7.4. The Role of System.Convert3.8. Understanding Implicitly Typed Local Variables3.8.1. Restrictions on Implicitly Typed Variables3.8.2. Implicit Typed Data Is Strongly Typed Data3.8.3. Usefulness of Implicitly Typed Local Variables3.9. VB 2010 Iteration Constructs3.9.1. The For Loop3.9.2. The For Each Loop3.9.2.1. Use of Implicitly Typed Variables Within For Each Constructs3.9.3. The While and Do/While Looping Constructs3.10. Decision Constructs and the Relational/Equality Operators3.10.1. The If/Then/Else Statement3.10.2. The Select/Case Statement3.11. Summary
4. Core VB 2010 Programming Constructs, Part II
4.1. Methods and Parameter Modifiers4.1.1. The ByVal Parameter Modifier4.1.2. The ByRef Modifier4.1.3. The <Out()> Attribute4.1.4. The ParamArray Modifier4.1.5. Defining Optional Parameters4.1.6. Invoking Methods using Named Parameters4.1.7. Understanding Method Overloading4.2. Understanding VB 2010 Arrays4.2.1. VB 2010 Array Initialization Syntax4.2.2. Implicitly Typed Local Arrays4.2.3. Defining an Array of Objects4.2.4. Working with Multidimensional Arrays4.2.5. Arrays As Arguments or Return Values4.2.6. The System.Array Base Class4.3. Understanding the Enum Type4.3.1. Controlling the Underlying Storage for an Enum4.3.2. Declaring Enum Variables4.3.3. The System.Enum Type4.3.4. Dynamically Discovering an Enum's Name/Value Pairs4.4. Understanding the Structure Type4.4.1. Creating Structure Variables4.5. Understanding Value Types and Reference Types4.5.1. Value Types, References Types, and the Assignment Operator4.5.2. Value Types Containing Reference Types4.5.3. Passing Reference Types by Value4.5.4. Passing Reference Types by Reference4.5.5. Final Details Regarding Value Types and Reference Types4.6. Understanding VB 2010 Nullable Types4.6.1. Working with Nullable Types4.6.2. The Nullable If Operator4.7. Summary
5. Defining Encapsulated Class Types
5.1. Introducing the VB 2010 Class Type5.1.1. Allocating Objects with the New Keyword5.2. Understanding Constructors5.2.1. The Role of the Default Constructor5.2.2. Defining Custom Constructors5.2.3. The Default Constructor Revisited5.3. The Role of the Me Keyword5.3.1. Chaining Constructor Calls Using Me5.3.2. Observing Constructor Flow5.3.3. Revisiting Optional Arguments5.4. Understanding the Shared Keyword5.4.1. Defining Shared Methods5.4.2. Defining Shared Field Data5.4.3. Defining Shared Constructors5.4.4. Defining Modules in VB 20105.5. Defining the Pillars of OOP5.5.1. The Role of Encapsulation5.5.2. The Role of Inheritance5.5.3. The Role of Polymorphism5.6. VB 2010 Access Modifiers5.6.1. The Default Access Modifiers5.6.2. Access Modifiers and Nested Types5.7. The First Pillar: VB 2010 Encapsulation Services5.7.1. Encapsulation Using Traditional Accessors and Mutators5.7.2. Encapsulation Using .NET Properties5.7.3. Using Properties within a Class Definition5.7.4. Internal Representation of Properties5.7.5. Controlling Visibility Levels of Property Get/Set Statements5.7.6. Read-Only and Write-Only Properties5.7.7. Shared Properties5.8. Understanding Automatic Properties5.8.1. Interacting with Automatic Properties5.8.2. Regarding Automatic Properties and Default Values5.9. Understanding Object Initializer Syntax5.9.1. Calling Custom Constructors with Initialization Syntax5.9.2. Nested Objects5.10. Working with Constant Field Data5.10.1. Understanding Read-Only Fields5.10.2. Shared Read-Only Fields5.11. Understanding Partial Types5.12. Summary

6. Understanding Inheritance and Polymorphism
6.1. The Basic Mechanics of Inheritance6.1.1. Specifying the Parent Class of an Existing Class6.1.2. Regarding Multiple Base Classes6.1.3. The NotInheritable Keyword6.2. Revising Visual Studio Class Diagrams6.3. The Second Pillar of OOP: The Details of Inheritance6.3.1. Controlling Base Class Creation with the MyBase Keyword6.3.2. Keeping Family Secrets: The Protected Keyword6.3.3. Adding a NotInheritable Class6.4. Programming for Containment/Delegation6.4.1. Understanding Nested Type Definitions6.5. The Third Pillar of OOP: VB's Polymorphic Support6.5.1. The Overridable and Overrides Keywords6.5.2. Overriding Overridable Members Using Visual Studio 20106.5.3. NotOverridable Members6.5.4. Understanding Abstract Classes and the MustInherit Keyword6.5.5. Understanding the Polymorphic Interface6.5.6. Understanding Member Shadowing6.6. Understanding Base Class/Derived Class Casting Rules6.6.1. The VB TryCast Keyword6.6.2. The VB Is Keyword6.7. The Master Parent Class: System.Object6.7.1. Overriding System.Object.ToString()6.7.2. Overriding System.Object.Equals()6.7.3. Overriding System.Object.GetHashCode()6.7.4. Testing Your Modified Person Class6.7.5. The Shared Members of System.Object6.8. Summary
7. Understanding Structured Exception Handling
7.1. Ode to Errors, Bugs, and Exceptions7.2. The Role of .NET Exception Handling7.2.1. The Atoms of .NET Exception Handling7.2.2. The System.Exception Base Class7.3. The Simplest Possible Example7.3.1. Throwing a General Exception7.3.2. Catching Exceptions7.4. Configuring the State of an Exception7.4.1. The TargetSite Property7.4.2. The StackTrace Property7.4.3. The HelpLink Property7.4.4. The Data Property7.5. System-Level Exceptions (System.SystemException)7.6. Application-Level Exceptions (System.ApplicationException)7.6.1. Building Custom Exceptions, Take One7.6.2. Building Custom Exceptions, Take Two7.6.3. Building Custom Exceptions, Take Three7.7. Processing Multiple Exceptions7.7.1. General Catch Statements7.7.2. Rethrowing Exceptions7.7.3. Inner Exceptions7.7.4. The Finally Block7.8. Who Is Throwing What?7.9. The Result of Unhandled Exceptions7.10. Debugging Unhandled Exceptions Using Visual Studio7.11. A Brief Word Regarding Corrupted State Exceptions (CSE)7.12. Summary
8. Understanding Object Lifetime
8.1. Classes, Objects, and References8.2. The Basics of Object Lifetime8.2.1. The CIL of new8.2.2. Setting Object References to Nothing8.3. The Role of Application Roots8.4. Understanding Object Generations8.5. Concurrent Garbage Collection under .NET 1.0 - 3.58.5.1. Background Garbage Collection under .NET 4.08.6. The System.GC Type8.6.1. Forcing a Garbage Collection8.7. Building Finalizable Objects8.7.1. Overriding System.Object.Finalize()8.7.2. Detailing the Finalization Process8.8. Building Disposable Objects8.8.1. Using Keyword with VB 20108.9. Building Finalizable and Disposable Types8.9.1. A Formalized Disposal Pattern8.10. Understanding Lazy Object Instantiation8.10.1. Customizing the Creation of the Lazy Data8.11. Summary
9. Working with Interfaces
9.1. Understanding Interface Types9.1.1. Interface Types vs. Abstract Base Classes9.2. Defining Custom Interfaces9.3. Implementing an Interface9.4. Invoking Interface Members at the Object Level9.4.1. Obtaining Interface References: The TryCast Keyword9.4.2. Obtaining Interface References: The Is Keyword9.5. Interfaces As Parameters9.6. Interfaces As Return Values9.7. Arrays of Interface Types9.8. Implementing Interfaces Using Visual Studio 20109.9. Resolving Name Clashes via Explicit Interface Implementation9.10. Designing Interface Hierarchies9.10.1. Multiple Inheritance with Interface Types9.11. Building Enumerable Types (IEnumerable and IEnumerator)9.12. Building Cloneable Objects (ICloneable)9.12.1. A More Elaborate Cloning Example9.13. Building Comparable Objects (IComparable)9.13.1. Specifying Multiple Sort Orders (IComparer)9.13.2. Custom Properties, Custom Sort Types9.14. Summary
10. Understanding Generics
10.1. The Issues with Non-Generic Collections10.1.1. The Issue of Performance10.1.2. The Issue of Type Safety10.2. The Role of Generic Type Parameters10.2.1. Specifying Type Parameters for Generic Classes / Structures10.2.2. Specifying Type Parameters for Generic Members10.2.3. Specifying Type Parameters for Generic Interfaces10.3. The System.Collections.Generic Namespace10.3.1. Understanding Collection Initialization Syntax10.3.2. Working with the List(Of T) Class10.3.3. Working with the Stack(Of T) Class10.3.4. Working with the Queue(Of T) Class10.3.5. Working with the SortedSet(Of T) Class10.4. Creating Custom Generic Methods10.4.1. Inference of Type Parameters10.5. Creating Custom Generic Structures and Classes10.5.1. The Nothing Keyword in Generic Code10.5.2. Generic Base Classes10.6. Constraining Type Parameters10.6.1. Examples Using the As Keyword10.6.2. The Lack of Operator Constraints10.7. Summary
11. Delegates, Events, and Lambdas
11.1. Understanding the .NET Delegate Type11.2. Defining a Delegate Type in VB 201011.3. The System.MulticastDelegate and System.Delegate Base Classes11.4. The Simplest Possible Delegate Example11.4.1. Investigating a Delegate Object11.5. Sending Object State Notifications Using Delegates11.5.1. Enabling Multicasting11.5.2. Removing Targets from a Delegate's Invocation List11.6. Method Group Conversion Syntax11.7. Understanding Delegate Covariance11.8. Understanding Generic Delegates11.8.1. Simulating Generic Delegates Without Generics11.9. Understanding VB 2010 Events11.9.1. The VB 2010 Event Keyword11.9.2. Events under the Hood11.9.3. Listening to Incoming Events11.9.4. Simplifying Event Registration Using Visual Studio 201011.9.5. Creating Custom Event Arguments11.9.6. The Generic EventHandler(Of T) Delegate11.10. Understanding VB 2010 Anonymous Methods11.10.1. Accessing Local Variables11.11. Understanding Lambda Expressions11.11.1. Dissecting a Lambda Expression11.11.2. Processing Arguments Within Multiple Statements11.11.3. Lambda Expressions with Multiple (or Zero) Parameters11.11.4. Retrofitting the CarEvents Example Using Lambda Expressions11.12. Summary
12. Advanced VB 2010 Language Features
12.1. Understanding Indexer Methods12.1.1. Indexing Data Using String Values12.1.2. Overloading Indexer Methods12.1.3. Indexers with Multiple Dimensions12.1.4. Indexer Definitions on Interface Types12.2. Understanding Operator Overloading12.2.1. Overloading Binary Operators12.2.2. And What of the += and –= Operators?12.2.3. Overloading Unary Operators12.2.4. Overloading Equality Operators12.2.5. Overloading Comparison Operators12.2.6. The Internal Representation of Overloaded Operators12.2.7. Final Thoughts Regarding Operator Overloading12.3. Understanding Custom Type Conversions12.3.1. Recall: Numerical Conversions12.3.2. Recall: Conversions Among Related Class Types12.3.3. Creating Custom Conversion Routines12.3.4. Additional Explicit Conversions for the Square Type12.3.5. Defining Implicit Conversion Routines12.3.6. The Internal Representation of Custom Conversion Routines12.3.7. Understanding Extension Methods12.3.7.1. Defining Extension Methods12.3.7.2. Invoking Extension Methods on an Instance Level12.3.7.3. Invoking Extension Methods as Shared Methods12.3.7.4. The Scope of an Extension Method12.3.7.5. Importing Types That Define Extension Methods12.3.7.6. The IntelliSense of Extension Methods12.3.7.7. Building and Using Extension Libraries12.3.7.8. Extending Interface Types via Extension Methods12.3.8. Understanding Partial Methods12.3.8.1. A First Look at Partial Methods12.3.8.2. Uses of Partial Methods12.3.9. Understanding Anonymous Types12.3.9.1. The Internal Representation of Anonymous Types12.3.9.2. The Implementation of ToString() and GetHashCode()12.3.9.3. The Semantics of Equality for Anonymous Types12.3.9.4. Anonymous Types Containing Anonymous Types12.4. Summary
13. LINQ to Objects
13.1. LINQ Specific Programming Constructs13.1.1. Implicit Typing of Local Variables13.1.2. Object and Collection Initialization Syntax13.1.3. Lambda Expressions13.1.4. Extension Methods13.1.5. Anonymous Types13.2. Understanding the Role of LINQ13.2.1. LINQ Expressions Are Strongly Typed13.2.2. The Core LINQ Assemblies13.3. Applying LINQ Queries to Primitive Arrays13.3.1. Once Again, Without LINQ13.3.2. Reflecting Over a LINQ Result Set13.3.3. LINQ and Implicitly Typed Local Variables13.3.4. LINQ and Extension Methods13.3.5. The Role of Deferred Execution13.3.6. The Role of Immediate Execution13.4. Returning the Result of a LINQ Query13.4.1. Returning LINQ Results via Immediate Execution13.5. Applying LINQ Queries to Collection Objects13.5.1. Accessing Contained Subobjects13.5.2. Applying LINQ Queries to Nongeneric Collections13.5.3. Filtering Data Using OfType(Of T)()13.6. Investigating the VB 2010 LINQ Query Operators13.6.1. Basic Selection Syntax13.6.2. Obtaining Subsets of Data13.6.3. Projecting New Data Types13.6.4. Obtaining Counts Using Enumerable13.6.5. Reversing Result Sets13.6.6. Sorting Expressions13.6.7. LINQ As a Better Venn Diagramming Tool13.6.8. Removing Duplicates13.6.9. LINQ Aggregation Operations13.7. The Internal Representation of LINQ Query Statements13.7.1. Building Query Expressions with Query Operators (Revisited)13.7.2. Building Query Expressions Using the Enumerable Type and Lambda Expressions13.7.3. Building Query Expressions Using the Enumerable Type and Anonymous Methods13.7.4. Building Query Expressions Using the Enumerable Type and Raw Delegates13.8. Summary
14. Configuring .NET Assemblies
14.1.14.1.1. Observing the Root Namespace14.1.2. Defining Namespaces Beyond the Root14.1.3. Defining Custom Namespaces14.1.4. Resolving Name Clashes with Fully Qualified Names14.1.5. Resolving Name Clashes with Aliases14.1.6. Creating Nested Namespaces14.2. The Role of .NET Assemblies14.2.1. Assemblies Promote Code Reuse14.2.2. Assemblies Establish a Type Boundary14.2.3. Assemblies Are Versionable Units14.2.4. Assemblies Are Self-Describing14.2.5. Assemblies Are Configurable14.3. Understanding the Format of a .NET Assembly14.3.1. The Windows File Header14.3.2. The CLR File Header14.3.3. CIL Code, Type Metadata, and the Assembly Manifest14.3.4. Optional Assembly Resources14.3.5. Single-File and Multifile Assemblies14.4. Building and Consuming a Single-File Assembly14.4.1. Exploring the Manifest14.4.2. Exploring the CIL14.4.3. Exploring the Type Metadata14.4.4. Building a VB 2010 Client Application14.4.5. Building a C# Client Application14.4.6. Cross-Language Inheritance in Action14.5. Building and Consuming a Multifile Assembly14.5.1. Exploring the ufo.netmodule File14.5.2. Exploring the airvehicles.dll File14.5.3. Consuming a Multifile Assembly14.6. Understanding Private Assemblies14.6.1. The Identity of a Private Assembly14.6.2. Understanding the Probing Process14.6.3. Configuring Private Assemblies14.6.4. Configuration Files and Visual Studio 201014.7. Understanding Shared Assemblies14.7.1. Understanding Strong Names14.7.2. Generating Strong Names at the Command Line14.7.3. Generating Strong Names using Visual Studio 201014.7.4. Installing Strongly Named Assemblies to the GAC14.8. Consuming a Shared Assembly14.8.1. Exploring the Manifest of SharedCarLibClient14.9. Configuring Shared Assemblies14.9.1. Freezing the Current Shared Assembly14.9.2. Building Shared Assembly Version 2.0.0.014.9.3. Dynamically Redirecting to Specific Versions of a Shared Assembly14.10. Understanding Publisher Policy Assemblies14.10.1. Disabling Publisher Policy14.11. Understanding the <codeBase> Element14.12. The System.Configuration Namespace14.13. Summary
15. Type Reflection, Late Binding, and Attribute-Based Programming
15.1. The Necessity of Type Metadata15.1.1. Viewing (Partial) Metadata for the EngineState Enumeration15.1.2. Viewing (Partial) Metadata for the Car Type15.1.3. Examining a TypeRef15.1.4. Documenting the Defining Assembly15.1.5. Documenting Referenced Assemblies15.1.6. Documenting String Literals15.2. Understanding Reflection15.2.1. The System.Type Class15.2.2. Obtaining a Type Reference Using System.Object.GetType()15.2.3. Obtaining a Type Reference Using System.Type.GetType()15.2.4. Obtaining a Type Reference Using GetType()15.3. Building a Custom Metadata Viewer15.3.1. Reflecting on Methods15.3.2. Reflecting on Fields and Properties15.3.3. Reflecting on Implemented Interfaces15.3.4. Displaying Various Odds and Ends15.3.5. Implementing Main()15.3.6. Reflecting on Generic Types15.3.7. Reflecting on Method Parameters and Return Values15.4. Dynamically Loading Assemblies15.5. Reflecting on Shared Assemblies15.6. Understanding Late Binding15.6.1. The System.Activator Class15.6.2. Invoking Methods with No Parameters15.6.3. Invoking Methods with Parameters15.7. Understanding the Role of .NET Attributes15.7.1. Attribute Consumers15.7.2. Applying Attributes in VB 201015.7.3. VB 2010 Attribute Shorthand Notation15.7.4. Specifying Constructor Parameters for Attributes15.7.5. The Obsolete Attribute in Action15.8. Building Custom Attributes15.8.1. Applying Custom Attributes15.8.2. Named Property Syntax15.8.3. Restricting Attribute Usage15.9. Assembly-Level (and Module-Level) Attributes15.9.1. The Visual Studio 2010 AssemblyInfo.vb File15.10. Reflecting on Attributes Using Early Binding15.11. Reflecting on Attributes Using Late Binding15.12. Putting Reflection, Late Binding, and Custom Attributes in Perspective15.13. Building an Extendable Application15.13.1. Building CommonSnappableTypes.dll15.13.2. Building the VB 2010 Snap-In15.13.3. Building the C# Snap-In15.13.4. Building an Extendable Windows Forms Application15.14. Summary
16. Processes, AppDomains, and Object Contexts
16.1. The Role of a Windows Process16.1.1. The Role of Threads16.2. Interacting with Processes Under the .NET Platform16.2.1. Enumerating Running Processes16.2.2. Investigating a Specific Process16.2.3. Investigating a Process's Thread Set16.2.4. Investigating a Process's Module Set16.2.5. Starting and Stopping Processes Programmatically16.2.6. Controlling Process Startup Using the ProcessStartInfo Class16.3. Understanding .NET Application Domains16.3.1. The System.AppDomain Class16.4. Interacting with the Default Application Domain16.4.1. Enumerating Loaded Assemblies16.4.2. Receiving Assembly Load Notifications16.5. Creating New Application Domains16.5.1. Loading Assemblies into Custom Application Domains16.5.2. Programmatically Unloading AppDomains16.6. Understanding Object Context Boundaries16.6.1. Context-Agile and Context-Bound Types16.6.2. Defining a Context-Bound Object16.6.3. Inspecting an Object's Context16.7. Summarizing Processes, AppDomains, and Context16.8. Summary
17. Understanding CIL and the Role of Dynamic Assemblies
17.1. Reasons for Learning the Grammar of CIL17.2. Examining CIL Directives, Attributes, and Opcodes17.2.1. The Role of CIL Directives17.2.2. The Role of CIL Attributes17.2.3. The Role of CIL Opcodes17.2.4. The CIL Opcode/CIL Mnemonic Distinction17.3. Pushing and Popping: The Stack-Based Nature of CIL17.4. Understanding Round-Trip Engineering17.4.1. The Role of CIL Code Labels17.4.2. Interacting with CIL: Modifying an *.il File17.4.3. Compiling CIL Code Using ilasm.exe17.4.4. Authoring CIL Code Using SharpDevelop17.4.5. The Role of peverify.exe17.5. Understanding CIL Directives and Attributes17.5.1. Specifying Externally Referenced Assemblies in CIL17.5.2. Defining the Current Assembly in CIL17.5.3. Defining Namespaces in CIL17.5.4. Defining Class Types in CIL17.5.5. Defining and Implementing Interfaces in CIL17.5.6. Defining Structures in CIL17.5.7. Defining Enums in CIL17.5.8. Defining Generics in CIL17.5.9. Compiling the CILTypes.il file17.6. .NET Base Class Library, VB 2010, and CIL Data Type Mappings17.7. Defining Type Members in CIL17.7.1. Defining Field Data in CIL17.7.2. Defining Type Constructors in CIL17.7.3. Defining Properties in CIL17.7.4. Defining Member Parameters17.8. Examining CIL Opcodes17.8.1. The .maxstack Directive17.8.2. Declaring Local Variables in CIL17.8.3. Mapping Parameters to Local Variables in CIL17.8.4. The Hidden Me Reference17.8.5. Representing Iteration Constructs in CIL17.9. Building a .NET Assembly with CIL17.9.1. Building CILCars.dll17.9.2. Building CILCarClient.exe17.10. Understanding Dynamic Assemblies17.10.1. Exploring the System.Reflection.Emit Namespace17.10.2. The Role of the System.Reflection.Emit.ILGenerator17.10.3. Emitting a Dynamic Assembly17.10.4. Emitting the Assembly and Module Set17.10.5. The Role of the ModuleBuilder Type17.10.6. Emitting the HelloClass Type and the String Member Variable17.10.7. Emitting the Constructors17.10.8. Emitting the SayHello() Method17.10.9. Using the Dynamically Generated Assembly17.11. Summary
18. Dynamic Types and the Dynamic Language Runtime
18.1. Basics of Dynamic Typing in VB 201018.2. The Role of Dynamic Typing in VB 201018.2.1. Calling Members on Dynamically Declared Data18.2.2. The Role of the Microsoft.VisualBasic.dll Assembly18.2.3. The Scope of the Dynamic Objects18.2.4. Limitations of the Dynamic Type18.2.5. Practical Uses of the Dynamic Types18.3. The Role of the Dynamic Language Runtime (DLR)18.3.1. The Role of Expression Trees18.3.2. The Role of the System.Dynamic Namespace18.3.3. Dynamic Runtime Lookup of Expression Trees18.4. Simplifying Late Bound Calls Using Dynamic Typing18.4.1. Leveraging the Dynamic Typing to Pass Arguments18.5. Simplifying COM Interoperability using Dynamic Data18.5.1. The Role of Primary Interop Assemblies (PIAs)18.5.2. Embedding Interop Metadata18.5.3. Common COM Interop Pain Points18.6. COM Interop using VB 2010 Language Features18.6.1. COM Interop without VB 2010 Language Features18.7. Summary
19. Multithreaded and Parallel Programming
19.1. The Process/AppDomain/Context/Thread Relationship19.1.1. The Problem of Concurrency19.1.2. The Role of Thread Synchronization19.2. A Brief Review of the .NET Delegate19.3. The Asynchronous Nature of Delegates19.3.1. The BeginInvoke() and EndInvoke() Methods19.3.2. The System.IAsyncResult Interface19.4. Invoking a Method Asynchronously19.4.1. Synchronizing the Calling Thread19.4.2. The Role of the AsyncCallback Delegate19.4.3. The Role of the AsyncResult Class19.4.4. Passing and Receiving Custom State Data19.5. The System.Threading Namespace19.6. The System.Threading.Thread Class19.6.1. Obtaining Statistics About the Current Thread19.6.2. The Name Property19.6.3. The Priority Property19.7. Programmatically Creating Secondary Threads19.7.1. Working with the ThreadStart Delegate19.7.2. Working with the ParameterizedThreadStart Delegate19.7.3. The AutoResetEvent Class19.7.4. Foreground Threads and Background Threads19.8. The Issue of Concurrency19.8.1. Synchronization Using the VB 2010 SyncLock Keyword19.8.2. Synchronization Using the System.Threading.Monitor Type19.8.3. Synchronization Using the System.Threading.Interlocked Type19.8.4. Synchronization Using the <Synchronization()> Attribute19.9. Programming with Timer Callbacks19.10. Understanding the CLR ThreadPool19.11. Parallel Programming under the .NET Platform19.11.1. The Task Parallel Library API19.11.2. The Role of the Parallel Class19.11.3. Understanding Data Parallelism19.11.4. The Task Class19.11.5. Handling Cancelation Request19.11.6. Understanding Task Parallelism19.12. Parallel LINQ Queries (PLINQ)19.12.1. Opting in to a PLINQ Query19.12.2. Canceling a PLINQ Query19.13. Summary
20. File I/O and Object Serialization
20.1. Exploring the System.IO Namespace20.2. The Directory(Info) and File(Info) Types20.2.1. The MustInherit FileSystemInfo Base Class20.3. Working with the DirectoryInfo Type20.3.1. Enumerating Files with the DirectoryInfo Type20.3.2. Creating Subdirectories with the DirectoryInfo Type20.4. Working with the Directory Type20.5. Working with the DriveInfo Class Type20.6. Working with the FileInfo Class20.6.1. The FileInfo.Create() Method20.6.2. The FileInfo.Open() Method20.6.3. The FileInfo.OpenRead() and FileInfo.OpenWrite() Methods20.6.4. The FileInfo.OpenText() Method20.6.5. The FileInfo.CreateText() and FileInfo.AppendText() Methods20.7. Working with the File Type20.7.1. Additional File-centric Members20.8. The MustInherit Stream Class20.8.1. Working with FileStreams20.9. Working with StreamWriters and StreamReaders20.9.1. Writing to a Text File20.9.2. Reading from a Text File20.9.3. Directly Creating StreamWriter/StreamReader Types20.10. Working with StringWriters and StringReaders20.11. Working with BinaryWriters and BinaryReaders20.12. Watching Files Programmatically20.13. Understanding Object Serialization20.13.1. The Role of Object Graphs20.14. Configuring Objects for Serialization20.14.1. Defining Serializable Types20.14.2. Public Fields, Private Fields, and Public Properties20.15. Choosing a Serialization Formatter20.15.1. The IFormatter and IRemotingFormatter Interfaces20.15.2. Type Fidelity Among the Formatters20.16. Serializing Objects Using the BinaryFormatter20.16.1. Deserializing Objects Using the BinaryFormatter20.17. Serializing Objects Using the SoapFormatter20.18. Serializing Objects Using the XmlSerializer20.18.1. Controlling the Generated XML Data20.19. Serializing Collections of Objects20.20. Customizing the Soap/Binary Serialization Process20.20.1. A Deeper Look at Object Serialization20.20.2. Customizing Serialization Using ISerializable20.20.3. Customizing Serialization Using Attributes20.21. Summary
21. ADO.NET Part I: The Connected Layer
21.1. A High-Level Definition of ADO.NET21.2. The Three Faces of ADO.NET21.3. Understanding ADO.NET Data Providers21.3.1. The Microsoft-Supplied ADO.NET Data Providers21.3.2. A Word Regarding System.Data.OracleClient.dll21.3.3. Obtaining Third-Party ADO.NET Data Providers21.4. Additional ADO.NET Namespaces21.5. The Types of the System.Data Namespace21.5.1. The Role of the IDbConnection Interface21.5.2. The Role of the IDbTransaction Interface21.5.3. The Role of the IDbCommand Interface21.5.4. The Role of the IDbDataParameter and IDataParameter Interfaces21.5.5. The Role of the IDbDataAdapter and IDataAdapter Interfaces21.5.6. The Role of the IDataReader and IDataRecord Interfaces21.6. Abstracting Data Providers Using Interfaces21.6.1. Increasing Flexibility Using Application Configuration Files21.7. Creating the AutoLot Database21.7.1. Creating the Inventory Table21.7.2. Authoring the GetPetName() Stored Procedure21.7.3. Creating the Customers and Orders Tables21.7.4. Visually Creating Table Relationships21.8. The ADO.NET Data Provider Factory Model21.8.1. A Complete Data Provider Factory Example21.8.2. A Potential Drawback with the Provide Factory Model21.8.3. The <connectionStrings> Element21.9. Understanding the Connected Layer of ADO.NET21.9.1. Working with Connection Objects21.9.2. Working with ConnectionStringBuilder Objects21.9.3. Working with Command Objects21.10. Working with Data Readers21.10.1. Obtaining Multiple Result Sets Using a Data Reader21.11. Building a Reusable Data Access Library21.11.1. Adding the Connection Logic21.11.2. Adding the Insertion Logic21.11.3. Adding the Deletion Logic21.11.4. Adding the Update Logic21.11.5. Adding the Selection Logic21.11.6. Working with Parameterized Command Objects21.11.6.1. Specifying Parameters Using the DbParameter Type21.11.7. Executing a Stored Procedure21.12. Creating a Console UI–Based Front End21.12.1. Implementing the Main() Method21.12.2. Implementing the ShowInstructions() Method21.12.3. Implementing the ListInventory() Method21.12.4. Implementing the DeleteCar() Method21.12.5. Implementing the InsertNewCar() Method21.12.6. Implementing the UpdateCarPetName() Method21.12.7. Implementing LookUpPetName()21.13. Understanding Database Transactions21.13.1. Key Members of an ADO.NET Transaction Object21.13.2. Adding a CreditRisks Table to the AutoLot Database21.13.3. Adding a Transaction Method to InventoryDAL21.13.4. Testing Your Database Transaction21.14. Summary
22. ADO.NET Part II: The Disconnected Layer
22.1. Understanding the Disconnected Layer of ADO.NET22.2. Understanding the Role of the DataSet22.2.1. Key Properties of the DataSet22.2.2. Key Methods of the DataSet22.2.3. Building a DataSet22.3. Working with DataColumns22.3.1. Building a DataColumn22.3.2. Enabling Autoincrementing Fields22.3.3. Adding DataColumn Objects to a DataTable22.4. Working with DataRows22.4.1. Understanding the RowState Property22.4.2. Understanding the DataRowVersion Property22.5. Working with DataTables22.5.1. Inserting DataTables into DataSets22.5.2. Obtaining Data in a DataSet22.5.3. Processing DataTable Data Using DataTableReader Objects22.5.4. Serializing DataTable/DataSet Objects As XML22.5.5. Serializing DataTable/DataSet Objects in a Binary Format22.6. Binding DataTable Objects to Windows Forms GUIs22.6.1. Hydrating a DataTable from a Generic List(Of T)22.6.2. Deleting Rows from a DataTable22.6.3. Selecting Rows Based on Filter Criteria22.6.4. Updating Rows Within a DataTable22.6.5. Working with the DataView Type22.7. Working with Data Adapters22.7.1. A Simple Data Adapter Example22.7.2. Mapping Database Names to Friendly Names22.8. Adding Disconnection Functionality to AutoLotDAL.dll22.8.1. Defining the Initial Class Type22.8.2. Configuring the Data Adapter Using the SqlCommandBuilder22.8.3. Implementing GetAllInventory()22.8.4. Implementing UpdateInventory()22.8.5. Setting Your Version Number22.8.6. Testing the Disconnected Functionality22.9. Multitabled DataSet Objects and Data Relationships22.9.1. Prepping the Data Adapters22.9.2. Building the Table Relationships22.9.3. Updating the Database Tables22.9.4. Navigating Between Related Tables22.10. The Windows Forms Database Designer Tools22.10.1. Visually Designing the DataGridView22.10.2. The Generated app.config File22.10.3. Examining the Strongly Typed DataSet22.10.4. Examining the Strongly Typed DataTable22.10.5. Examining the Strongly Typed DataRow22.10.6. Examining the Strongly Typed Data Adapter22.10.7. Completing the Windows Forms Application22.11. Isolating Strongly Typed Database Code into a Class Library22.11.1. Viewing the Generated Code22.11.2. Selecting Data with the Generated Code22.11.3. Inserting Data with the Generated Code22.11.4. Deleting Data with the Generated Code22.11.5. Invoking a Stored Procedure using the Generated Code22.12. Programming with LINQ to DataSet22.12.1. The Role of the DataSet Extensions Library22.12.2. Obtaining a LINQ-Compatible DataTable22.12.3. The Role of the DataRowExtensions.Field(Of T)() Extension Method22.12.4. Hydrating New DataTables from LINQ Queries22.13. Summary
23. ADO.NET Part III: The Entity Framework
23.1. Understanding the Role of Entity Framework23.1.1. The Role of Entities23.1.2. The Building Blocks of the Entity Framework23.1.2.1. The Role of Object Services23.1.2.2. The Role of the Entity Client23.1.2.3. The Role of the *.edmx File (and Friends)23.1.2.4. The Role of the ObjectContext and ObjectSet(Of T) Classes23.1.2.5. All Together Now!23.2. Building and Analyzing your First EDM23.2.1.23.2.1.1. Generating the *.edmx File23.2.1.2. Reshaping the Entity Data23.2.1.3. Viewing the Mappings23.2.1.4. Viewing the Generated *.edmx File Data23.2.1.5. Viewing the Generated Source Code23.2.1.6. Enhancing the Generated Source Code23.3. Programming Against the Conceptual Model23.3.1.23.3.1.1. Deleting a Record23.3.1.2. Updating a Record23.3.1.3. Querying with LINQ to Entities23.3.1.4. Querying with Entity SQL23.3.1.5. Working with the Entity Client Data Reader Object23.4. AutoLotDAL Version 4.0, Now with Entities23.4.1. Mapping the Stored Procedure23.4.2. The Role of Navigation Properties23.4.3. Using Navigation Properties within LINQ to Entity Queries23.4.4. Invoking a Stored Procedure23.5. Data Binding Entities to Windows Forms GUIs23.5.1. Adding the Data Binding Code23.6. Summary
24. Introducing LINQ to XML
24.1. A Tale of Two XML APIs24.1.1. LINQ to XML As a Better DOM24.1.2. VB 2010 Literal Syntax As a Better LINQ to XML24.2. Members of the System.Xml.Linq Namespace24.2.1. The LINQ to XML Axis Methods24.2.2. The Oddness of XName (and XNamespace)24.3. Working with XElement and XDocument24.3.1. Generating Documents from Arrays and Containers24.3.2. Loading and Parsing XML Content24.4. Manipulating an in Memory XML Document24.4.1. Building the UI of the LINQ to XML App24.4.2. Import the Inventory.xml File24.4.3. Defining a LINQ to XML Helper Class24.4.4. Rigging up the UI to Your Helper Class24.5. Summary
25. Introducing Windows Communication Foundation
25.1. A Potpourri of Distributed Computing APIs25.1.1. The Role of DCOM25.1.2. The Role of COM+/Enterprise Services25.1.3. The Role of MSMQ25.1.4. The Role of .NET Remoting25.1.5. The Role of XML Web Services25.1.5.1. A .NET Web Service Example25.1.5.2. Web Service Standards25.1.6. Named Pipes, Sockets, and P2P25.2. The Role of WCF25.2.1. An Overview of WCF Features25.2.2. An Overview of Service-Oriented Architecture25.2.2.1. Tenet 1: Boundaries Are Explicit25.2.2.2. Tenet 2: Services Are Autonomous25.2.2.3. Tenet 3: Services Communicate via Contract, Not Implementation25.2.2.4. Tenet 4: Service Compatibility Is Based on Policy25.2.3. WCF: The Bottom Line25.3. Investigating the Core WCF Assemblies25.4. The Visual Studio WCF Project Templates25.4.1. The WCF Service Website Project Template25.5. The Basic Composition of a WCF Application25.6. The ABCs of WCF25.6.1. Understanding WCF Contracts25.6.2. Understanding WCF Bindings25.6.2.1. HTTP-Based Bindings25.6.2.2. TCP-Based Bindings25.6.2.3. MSMQ-Based Bindings25.6.3. Understanding WCF Addresses25.7. Building a WCF Service25.7.1. The <ServiceContract()> Attribute25.7.2. The <OperationContract()> Attribute25.7.3. Service Types As Operational Contracts25.8. Hosting the WCF Service25.8.1. Establishing the ABCs Within an App.config File25.8.2. Coding Against the ServiceHost Type25.8.3. Specifying Base Addresses25.8.4. Details of the ServiceHost Type25.8.5. Details of the <system.serviceModel> Element25.8.6. Enabling Metadata Exchange25.9. Building the WCF Client Application25.9.1. Generating Proxy Code Using svcutil.exe25.9.2. Generating Proxy Code Using Visual Studio 201025.9.3. Configuring a TCP-Based Binding25.10. Simplifying Configuration Settings with WCF 4.025.10.1. Default Endpoints in WCF 4.025.10.2. Exposing a Single WCF Service Using Multiple Bindings25.10.3. Changing Settings for a WCF Binding25.10.4. The WCF 4.0 Default MEX Behavior Configuration25.10.5. Refreshing the Client Proxy and Selecting the Binding25.11. Using the WCF Service Library Project Template25.11.1. Building a Simple Math Service25.11.2. Testing the WCF Service with WcfTestClient.exe25.11.3. Altering Configuration Files Using SvcConfigEditor.exe25.12. Hosting the WCF Service within a Windows Service25.12.1. Specifying the ABCs in Code25.12.2. Enabling MEX25.12.3. Creating a Windows Service Installer25.12.4. Installing the Windows Service25.13. Invoking a Service Asynchronously from the Client25.14. Designing WCF Data Contracts25.14.1. Using the Web-Centric WCF Service Project Template25.14.2. Implementing the Service Contract25.14.3. The Role of the *.svc File25.14.4. Examining the Web.config File25.14.5. Testing the Service25.15. Summary
26. Introducing Windows Workflow Foundation 4.0
26.1. Defining a Business Process26.1.1. The Role of WF 4.026.2. Building a (Painfully) Simple Workflow26.2.1. Viewing the Underlying XAML26.3. The WF 4.0 Runtime26.3.1. Hosting a Workflow using WorkflowInvoker26.3.1.1. Passing Arguments to your Workflow using WorkflowInvoker26.3.1.2. Defining Arguments Using the Workflow Designer26.3.2. Hosting a Workflow using WorkflowApplication26.3.3. Recap of your First Workflow26.4. Examining the Workflow 4.0 Activities26.4.1. Control Flow Activities26.4.2. Flowchart Activities26.4.3. Messaging Activities26.4.4. The Runtime and Primitives Activities26.4.5. The Transaction Activities26.4.6. The Collection and Error Handling Activities26.5. Building a Flowchart Workflow26.5.1. Connecting Activities in a Flowchart26.5.2. Working with the InvokeMethod Activity26.5.3. Defining Workflow Wide Variables26.5.4. Working with the FlowDecision Activity26.5.5. Working with the TerminateWorkflow Activity26.5.6. Building the "True" Condition26.5.7. Working with the ForEach<T> Activity26.5.8. Completing the Application26.5.9. Reflecting on What We Have Done26.6. Isolating Workflows into Dedicated Libraries26.6.1. Defining the Initial Project26.6.2. Importing Assemblies and Namespaces26.6.3. Defining the Workflow Arguments26.6.4. Defining Workflow Variables26.6.5. Working with the Assign Activity26.6.6. Working with the If and Switch Activities26.6.7. Building a Custom Code Activity26.7. Consuming the Workflow Library26.7.1. Retrieving the Workflow Output Argument26.8. Summary
27. Introducing Windows Presentation Foundation and XAML
27.1. The Motivation Behind WPF27.1.1. Unifying Diverse APIs27.1.2. Providing a Separation of Concerns via XAML27.1.3. Providing an Optimized Rendering Model27.1.4. Simplifying Complex UI Programming27.2. The Various Flavors of WPF27.2.1. Traditional Desktop Applications27.2.2. Navigation-Based WPF Applications27.2.3. XBAP Applications27.2.4. The WPF/Silverlight Relationship27.3. Investigating the WPF Assemblies27.3.1. The Role of the Application Class27.3.1.1. Constructing an Application Class27.3.1.2. Enumerating the Application.Windows collection27.3.2. The Role of the Window Class27.3.2.1. The Role of System.Windows.Controls.ContentControl27.3.2.2. The Role of System.Windows.Controls.Control27.3.2.3. The Role of System.Windows.FrameworkElement27.3.2.4. The Role of System.Windows.UIElement27.3.2.5. The Role of System.Windows.Media.Visual27.3.2.6. The Role of System.Windows.DependencyObject27.3.2.7. The Role of System.Windows.Threading.DispatcherObject27.4. Building a WPF Application without XAML27.4.1. Creating a Strongly Typed Window27.4.2. Creating a Simple User Interface27.4.3. Interacting with Application Level Data27.4.4. Handling the Closing of a Window Object27.4.5. Intercepting Mouse Events27.4.6. Intercepting Keyboard Events27.5. Building a WPF Application using Only XAML27.5.1. Defining MainWindow in XAML27.5.2. Defining the Application Object in XAML27.5.3. Processing the XAML Files using msbuild.exe27.6. Transforming Markup into a .NET Assembly27.6.1. Mapping the Window XAML Data to VB 2010 Code27.6.2. The Role of BAML27.6.3. Mapping the Application XAML Data to VB 2010 Code27.6.4. XAML-to-Assembly Process Summary27.7. Understanding The Syntax of WPF XAML27.7.1. Introducing Kaxaml27.7.2. XAML XML Namespaces and XAML "Keywords"27.7.3. Controlling Class and Member Variable Declarations27.7.4. XAML Elements, XAML Attributes and Type Converters27.7.5. Understanding XAML Property-Element Syntax27.7.6. Understanding XAML Attached Properties27.7.7. Understanding XAML Markup Extensions27.8. Building a WPF Application using Code-Behind Files27.8.1. Adding a Code File for the MainWindow Class27.8.2. Adding a Code File for the MyApp Class27.8.3. Processing the Code Files with msbuild.exe27.9. Building WPF Applications Using Visual Studio 201027.9.1. The WPF Project Templates27.9.2. Exploring the WPF Designer Tools27.9.3. Designing the GUI of our Window27.9.4. Implementing the Loaded Event27.9.5. Implementing the Button's Click Event27.9.6. Implementing the Closed Event27.9.7. Testing the Application27.10. Summary
28. Programming with WPF Controls
28.1. A Survey of the Core WPF Controls28.1.1. Working with WPF Controls Using Visual Studio 201028.1.2. The WPF Ink Controls28.1.3. The WPF Document Controls28.1.4. WPF Common Dialog Boxes28.1.5. The Details Are in the Documentation28.2. Controlling Content Layout Using Panels28.2.1. Positioning Content Within Canvas Panels28.2.2. Positioning Content Within WrapPanel Panels28.2.3. Positioning Content Within StackPanel Panels28.2.4. Positioning Content Within Grid Panels28.2.4.1. Grids with GridSplitter Types28.2.5. Positioning Content Within DockPanel Panels28.2.6. Enabling Scrolling for Panel Types28.3. Building a Window's Frame Using Nested Panels28.3.1. Building the Menu System28.3.2. Building the ToolBar28.3.3. Building the StatusBar28.3.4. Finalizing the UI Design28.3.5. Implementing the MouseEnter/MouseLeave Event Handlers28.3.6. Implementing the Spell Checking Logic28.4. Understanding WPF Control Commands28.4.1. The Intrinsic Control Command Objects28.4.2. Connecting Commands to the Command Property28.4.3. Connecting Commands to Arbitrary Actions28.4.4. Working with the Open and Save Commands28.5. Building a WPF User Interface with Expression Blend28.5.1. Getting to know the Key Aspects of the Blend IDE28.5.2. Using the TabControl28.6. Building the Ink API Tab28.6.1. Designing the ToolBar28.6.2. The RadioButton Control28.6.3. The InkCanvas Control28.6.4. The ComboBox Control28.6.5. Saving, Loading, and Clearing InkCanvas Data28.7. Introducing the Documents API28.7.1. Block Elements and Inline Elements28.7.2. Document Layout Managers28.8. Building the Documents Tab28.8.1. Populating a FlowDocument using Blend28.8.2. Populating a FlowDocument Using Code28.8.3. Enabling Annotations and Sticky Notes28.8.4. Saving and Loading a Flow Document28.9. Introducing the WPF Data-Binding Model28.9.1. Building the Data Binding Tab28.9.2. Establishing Data Bindings using Blend28.9.3. The DataContext Property28.9.4. Data Conversion Using IValueConverter28.9.5. Establishing Data Bindings in Code28.9.6. Building the DataGrid Tab28.10. Summary
29. WPF Graphics Rendering Services
29.1. Understanding WPF's Graphical Rendering Services29.1.1. WPF Graphical Rendering Options29.2. Rendering Graphical Data Using Shapes29.2.1. Adding Rectangles, Ellipses, and Lines to a Canvas29.2.2. Removing Rectangles, Ellipses, and Lines from a Canvas29.2.3. Working with Polylines and Polygons29.2.4. Working with Paths29.2.4.1. The Path "Modeling Mini Language"29.3. WPF Brushes and Pens29.3.1. Configuring Brushes Using Visual Studio 201029.3.2. Configuring Brushes in Code29.3.3. Configuring Pens29.4. Applying Graphical Transformations29.4.1. A First Look at Transformations29.4.2. Transforming our Canvas Data29.5. Working with Shapes using Expression Blend29.5.1. Selecting a Shape to Render from the Tool Palette29.5.2. Converting Shapes to Paths29.5.3. Combining Shapes29.5.4. The Brush and Transformation Editors29.6. Rendering Graphical Data Using Drawings and Geometries29.6.1. Building a DrawingBrush using Geometries29.6.2. Painting with the DrawingBrush29.6.3. Containing Drawing Types in a DrawingImage29.7. Generating Complex Vector Graphics using Expression Design29.7.1. Exporting a Design Document to XAML29.8. Rendering Graphical Data Using the Visual Layer29.8.1.29.8.1.1. The Visual Base Class and Derived Child Classes29.8.1.2. A First Look at using the DrawingVisual Class29.8.1.3. Rendering Visual Data to a Custom Layout Manager29.8.1.4. Responding to Hit Test Operations29.9. Summary
30. WPF Resources, Animations, and Styles
30.1. Understanding the WPF Resource System30.1.1. Working with Binary Resources30.1.1.1. Including Loose Resource Files in a Project30.1.1.2. Configuring the Loose Resources30.1.1.3. Programmatically Loading an Image30.1.1.4. Embedding Application Resources30.2. Working with Object (Logical) Resources30.2.1. The Role of the Resources Property30.2.2. Defining Window-Wide Resources30.2.3. The {StaticResource} Markup Extension30.2.4. Changing a Resource after Extraction30.2.5. The {DynamicResource} Markup Extension30.2.6. Application-Level Resources30.2.7. Defining Merged Resource Dictionaries30.2.8. Defining a Resource-Only Assembly30.2.9. Extracting Resources in Expression Blend30.3. Understanding WPF's Animation Services30.3.1. The Role of the Animation Class Types30.3.2. The To, From, and By Properties30.3.3. The Role of the Timeline Base Class30.3.4. Authoring an Animation in VB 2010 Code30.3.5. Controlling the Pacing of an Animation30.3.6. Reversing and Looping an Animation30.4. Authoring Animations in XAML30.4.1. The Role of Storyboards30.4.2. The Role of Event Triggers30.4.3. Animation Using Discrete Key Frames30.5. Understanding the Role of WPF Styles30.5.1. Defining and Applying a Style30.5.2. Overriding Style Settings30.5.3. Automatically Applying a Style with TargetType30.5.4. Subclassing Existing Styles30.5.5. The Role of Unnamed Styles30.5.6. Defining Styles with Triggers30.5.7. Defining Styles with Multiple Triggers30.5.8. Animated Styles30.5.9. Assigning Styles Programmatically30.6. Generating Styles with Expression Blend30.6.1. Working with Default Visual Styles30.7. Summary
31. WPF Control Templates and UserControls
31.1. Understanding the Role of Dependency Properties31.1.1. Examining an Existing Dependency Property31.1.2. Important Notes Regarding CLR Property Wrappers31.2. Building a Custom Dependency Property31.2.1. Adding a Data Validation Routine31.2.2. Responding to the Property Change31.3. Understanding Routed Events31.3.1. The Role of Routed Bubbling Events31.3.2. Continuing or Halting Bubbling31.3.3. The Role of Routed Tunneling Events31.4. Logical Trees, Visual Trees and Default Templates31.4.1. Programmatically Inspecting a Logical Tree31.4.2. Programmatically Inspecting a Visual Tree31.4.3. Programmatically Inspecting a Control's Default Template31.5. Building a Custom Control Template with Visual Studio 201031.5.1. Templates as Resources31.5.2. Incorporating Visual Cues using Triggers31.5.3. The Role of {TemplateBinding} Markup Extension31.5.4. The Role of ContentPresenter31.5.5. Incorporating Templates into Styles31.6. Building Custom UserControls with Blend31.6.1. Creating a UserControl Library Project31.6.1.1. Renaming the Initial UserControl31.6.1.2. Designing the SpinControl31.6.1.3. Adding the Initial VB 2010 Code31.6.1.4. Defining an Animation using Blend31.6.1.5. Programmatically Starting our Storyboard31.7. Creating the Jackpot Deluxe WPF Application31.7.1. Extracting a UserControl from a Drawing Geometry31.7.2. The Role of .NET 4.0 Visual States31.7.2.1. Defining Visual States for the StarButton Control31.7.2.2. Defining State Transition Timings31.7.2.3. Viewing the Generated XAML31.7.2.4. Changing Visual States in Code using the VisualStateManager Class31.7.3. Finalizing the Jackpot Deluxe Application31.8. Summary
32. Building ASP.NET Web Pages
32.1. The Role of HTTP32.1.1. The HTTP Request/Response Cycle32.1.2. HTTP Is a Stateless Protocol32.2. Understanding Web Applications and Web Servers32.2.1. The Role of IIS Virtual Directories32.2.2. The ASP.NET Development Web Server32.3. The Role of HTML32.3.1. HTML Document Structure32.3.2. The Role of an HTML Form32.3.3. The Visual Studio 2010 HTML Designer Tools32.3.4. Building an HTML Form32.4. The Role of Client-Side Scripting32.4.1. A Client-Side Scripting Example32.5. Posting Back to the Web Server32.5.1. Postbacks under ASP.NET32.6. The Feature Set of the ASP.NET API32.6.1. Major Features of ASP.NET 1.0-1.132.6.2. Major Features of ASP.NET 2.032.6.3. Major Features of ASP.NET 3.5 (and .NET 3.5 SP1)32.6.4. Major Features of ASP.NET 4.032.7. Building a Single File ASP.NET Web Page32.7.1. Referencing AutoLotDAL.dll32.7.2. Designing the UI32.7.3. Adding the Data Access Logic32.7.4. The Role of ASP.NET Directives32.7.5. Analyzing the "Script" Block32.7.6. Analyzing the ASP.NET Control Declarations32.7.7. Compilation Cycle for Single-File Pages32.8. Building an ASP.NET Web Page using Code Files32.8.1. Referencing the AutoLotDAL.dll Assembly32.8.2. Updating the Code File32.8.3. Compilation Cycle for Multifile Pages32.8.4. Debugging and Tracing ASP.NET Pages32.9. ASP.NET Web Sites and ASP.NET Web Applications32.10. The ASP.NET Web Site Directory Structure32.10.1. Referencing Assemblies32.10.2. The Role of the App_Code Folder32.11. The Inheritance Chain of the Page Type32.12. Interacting with the Incoming HTTP Request32.12.1. Obtaining Brower Statistics32.12.2. Access to Incoming Form Data32.12.3. The IsPostBack Property32.13. Interacting with the Outgoing HTTP Response32.13.1. Emitting HTML Content32.13.2. Redirecting Users32.14. The Life Cycle of an ASP.NET Web Page32.14.1. The Error Event32.15. The Role of the Web.config File32.15.1. The ASP.NET Website Administration Utility32.16. Summary
33. ASP.NET Web Controls, Master Pages, and Themes
33.1. Understanding the Nature of Web Controls33.1.1. Understanding Server-Side Event Handling33.1.2. The AutoPostBack Property33.2. The Control and WebControl Base Classes33.2.1. Enumerating Contained Controls33.2.2. Dynamically Adding and Removing Controls33.2.3. Interacting with Dynamically Created Controls33.2.4. Functionality of the WebControl Base Class33.3. Major Categories of ASP.NET Web Controls33.3.1. A Brief Word Regarding System.Web.UI.HtmlControls33.3.2. Web Control Documentation33.4. Building the ASP.NET Cars Web Site33.4.1. Working with ASP.NET Master Pages33.4.1.1. Working with the TreeView Control Site Navigation Logic33.4.1.2. Establishing Bread Crumbs with the SiteMapPath Type33.4.1.3. Working with the AdRotator33.4.2. Defining the Default Content Page33.4.3. Designing the Inventory Content Page33.4.3.1. Enabling Sorting and Paging33.4.3.2. Enabling In-Place Editing33.4.4. Designing the Build-a-Car Content Page33.5. The Role of the Validation Controls33.5.1. The RequiredFieldValidator33.5.2. The RegularExpressionValidator33.5.3. The RangeValidator33.5.4. The CompareValidator33.5.5. Creating Validation Summaries33.5.6. Defining Validation Groups33.6. Working with Themes33.6.1. Understanding *.skin Files33.6.2. Applying Sitewide Themes33.6.3. Applying Themes at the Page Level33.6.4. The SkinID Property33.6.5. Assigning Themes Programmatically33.7. Summary
34. ASP.NET State Management Techniques
34.1. The Issue of State34.2. ASP.NET State Management Techniques34.3. Understanding the Role of ASP.NET View State34.3.1. Demonstrating View State34.3.2. Adding Custom View State Data34.4. The Role of the Global.asax File34.4.1. The Global Last-Chance Exception Event Handler34.4.2. The HttpApplication Base Class34.5. Understanding the Application/Session Distinction34.5.1. Maintaining Application-Level State Data34.5.2. Modifying Application Data34.5.3. Handling Web Application Shutdown34.6. Working with the Application Cache34.6.1. Fun with Data Caching34.6.2. Modifying the *.aspx File34.7. Maintaining Session Data34.7.1. Additional Members of HttpSessionState34.8. Understanding Cookies34.8.1. Creating Cookies34.8.2. Reading Incoming Cookie Data34.9. The Role of the <sessionState> Element34.9.1. Storing Session Data in the ASP.NET Session State Server34.9.2. Storing Session Data in a Dedicated Database34.10. Understanding the ASP.NET Profile API34.10.1. The ASPNETDB.mdf Database34.10.2. Defining a User Profile Within Web.config34.10.3. Accessing Profile Data Programmatically34.10.4. Grouping Profile Data and Persisting Custom Objects34.11. Summary
A. Programming with Windows Forms
A.1. The Windows Forms NamespacesA.2. Building a Simple Windows Forms ApplicationA.2.1. Populating the Controls CollectionA.2.2. The Role of System.EventArgs and System.EventHandlerA.3. The Visual Studio Windows Forms Project TemplateA.3.1. The Visual Designer SurfaceA.3.2. Dissecting the Initial FormA.3.3. Visually Building a Menu SystemA.3.4. The System.EventHandler DelegateA.4. The Anatomy of a FormA.4.1. The Functionality of the Control ClassA.4.2. The Functionality of the Form ClassA.4.3. The Life Cycle of a Form TypeA.5. Responding to Mouse and Keyboard ActivityA.5.1. Determining Which Mouse Button Was ClickedA.5.2. Determining Which Key Was PressedA.6. Designing Dialog BoxesA.6.1. The DialogResult PropertyA.6.2. Configuring the Tab OrderA.6.3. The Tab Order WizardA.6.4. Setting the Form's Default Input ButtonA.6.5. Displaying Dialog BoxesA.6.6. Understanding Form InheritanceA.7. Rendering Graphical Data Using GDI+A.7.1. The System.Drawing NamespaceA.7.2. The Role of the Graphics TypeA.7.3. Obtaining a Graphics Object with the Paint EventA.7.4. Invalidating the Form's Client AreaA.8. Building a Complete Windows Forms ApplicationA.8.1. Building the Main Menu SystemA.8.2. Defining the ShapeData TypeA.8.3. Defining the ShapePickerDialog TypeA.8.4. Adding Infrastructure to the MainWindow TypeA.8.5. Implementing the Tools Menu FunctionalityA.8.6. Capturing and Rendering the Graphical OutputA.8.7. Implementing the Serialization LogicA.9. Summary
B. Platform-Independent .NET Development with Mono
B.1. The Platform-Independent Nature of .NETB.1.1. The Role of the CLIB.1.2. The Mainstream CLI DistributionsB.1.3. The Scope of MonoB.2. Obtaining and Installing MonoB.2.1. Examining Mono's Directory StructureB.3. The Mono Development LanguagesB.3.1. Working with the VB 2010 CompilerB.3.2. Building Mono Applications using MonoDevelopB.4. Microsoft-Compatible Mono Development ToolsB.4.1. Mono-Specific Development ToolsB.4.1.1. Using monopB.5. Building .NET Applications with MonoB.5.1. Building a Mono Code LibraryB.5.1.1. Assigning CoreLibDumper.dll a Strong NameB.5.1.2. Viewing the Updated Manifest with monodisB.5.1.3. Installing Assemblies into the Mono GACB.5.2. Building a Console Application in MonoB.5.2.1. Loading Your Client Application in the Mono RuntimeB.5.2.2. Executing Your Windows Forms Application Under LinuxB.6. Who is Using Mono?B.7. Suggestions for Further StudyB.8. Summary

Overview

Be the first to understand .NET 4.0 and Visual Basic 2010. Pro VB 2010 and the .NET 4.0 Platform provides developers with a complete guide to the new technology, explaining the importance of all the key C# 2010 language features. This new edition has been comprehensively revised and rewritten to make it accurately reflect the VB 10 language specification for the .NET 4.0 platform. You'll find new chapters covering the important concepts of dynamic lookups, named and optional arguments, Parallel LINQ (PLINQ), improved COM interop, and variance for generics.

The first edition of this book was released at the 2001 Tech-Ed conference in Atlanta, Georgia. At that time, the .NET platform was still a beta product, and in many ways, so was this book. This is not to say that the early editions of this text did not have merit—after all, the book was a 2002 Jolt Award finalist and it won the 2003 Referenceware Excellence Award. However, over the years that author Andrew Troelsen spent working with the common language runtime (CLR), he gained a much deeper understanding of the .NET platform and the subtleties of the VB programming language, and he feels that this sixth edition of the book is as close to a "final release" as he's come yet!

If you're checking out this book for the first time, do understand that it's targeted at experienced software professionals and/or graduate students of computer science (so don't expect three chapters on iteration or decision constructs!). The mission of this text is to provide you with a rock-solid foundation in the C# programming language and the core aspects of the .NET platform (assemblies, remoting, Windows Forms, Web Forms, ADO.NET, XML web services, etc.). Once you digest the information presented in these 25 chapters, you'll be in a perfect position to apply this knowledge to your specific programming assignments and explore the .NET universe on your own terms.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Pro C# 2008 and the .NET 3.5 Platform, Fourth Edition

Publisher Resources

ISBN: 9781430229858Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills