Book description
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.
Table of contents
- Copyright
- About the Authors
- About the Technical Reviewer
- Acknowledgments
-
Introduction
- We're a Team, You and I
-
An Overview of This Book
- Chapter 1: Introducing VB 2010
- Chapter 2: Building Visual Basic 2010 Applications
- Chapter 3: Core VB 2010 Programming Constructs, Part I
- Chapter 4: Core VB Programming Constructs, Part II
- Chapter 5: Defining Encapsulated Class Types
- Chapter 6: Understanding Inheritance and Polymorphism
- Chapter 7: Understanding Structured Exception Handling
- Chapter 8: Understanding Object Lifetime
- Chapter 9: Working with Interfaces
- Chapter 10: Understanding Generics
- Chapter 11: Delegates, Events, and Lambdas
- Chapter 12: Advanced VB 2010 Language Features
- Chapter 13: LINQ to Objects
- Chapter 14: Configuring .NET Assemblies
- Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming
- Chapter 16: Processes, AppDomains, and Object Contexts
- Chapter 17: Understanding CIL and the Role of Dynamic Assemblies
- Chapter 18: Dynamic Types and the Dynamic Language Runtime
- Chapter 19: Multithreaded and Parallel Programming
- Chapter 20: File I/O and Object Serialization
- Chapter 21: ADO.NET Part I: The Connected Layer
- Chapter 22: ADO.NET Part II: The Disconnected Layer
- Chapter 23: ADO.NET Part III: The Entity Framework
- Chapter 24: Introducing LINQ to XML
- Chapter 25: Introducing Windows Communication Foundation
- Chapter 26: Introducing Windows Workflow Foundation
- Chapter 27: Introducing Windows Presentation Foundation and XAML
- Chapter 28: Programming with WPF Controls
- Chapter 29: WPF Graphical Rendering Services
- Chapter 30: WPF Resources, Animations, and Styles
- Chapter 31: WPF Control Templates and UserControls
- Chapter 32: Building ASP.NET Web Pages
- Chapter 33: ASP.NET Web Controls, Master Pages, and Themes
- Chapter 34: ASP.NET State Management Techniques
- Appendix A: Programming with Windows Forms
- Appendix B: Platform-Independent .NET Development with Mono
- Obtaining This Book's Source Code
- Obtaining Updates for This Book
-
1. Introducing VB 2010
- 1.1. Understanding the Previous State of Affairs
- 1.2. The .NET Solution
- 1.3. Introducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)
- 1.4. Additional .NET-Aware Programming Languages
- 1.5. An Overview of .NET Assemblies
- 1.6. Understanding the Common Type System
- 1.7. Understanding the Common Language Specification
- 1.8. Understanding the Common Language Runtime
- 1.9. The Assembly/Namespace/Type Distinction
- 1.10. Exploring an Assembly Using ildasm.exe
- 1.11. Exploring an Assembly Using Reflector
- 1.12. Deploying the .NET Runtime
- 1.13. The Platform-Independent Nature of .NET
- 1.14. Summary
-
2. Building Visual Basic 2010 Applications
- 2.1. The Role of the .NET Framework 4.0 SDK
- 2.2. Building VB 2010 Applications Using vbc.exe
- 2.3. Building .NET Applications Using Notepad++
- 2.4. Building .NET Applications Using Visual Basic 2010 Express
-
2.5. Building .NET Applications Using Visual Studio 2010
- 2.5.1. Some Unique Features of Visual Studio 2010
- 2.5.2. Targeting the .NET Framework Using the New Project Dialog Box
- 2.5.3. Using the Solution Explorer Utility
- 2.5.4. The Class View Utility
- 2.5.5. The Object Browser Utility
- 2.5.6. Integrated Support for Code Refactoring
- 2.5.7. Code Expansions Techniques
- 2.5.8. The Visual Class Designer
- 2.5.9. The Integrated .NET Framework 4.0 SDK Documentation System
- 2.6. Summary
-
3. Core VB 2010 Programming Constructs, Part I
- 3.1. The Role of the Module Type
- 3.2. The Anatomy of a Simple VB 2010 Program
- 3.3. An Interesting Aside: Some Additional Members of the System.Environment Class
- 3.4. The System.Console Class
-
3.5. System Data Types and VB 2010 Shorthand Notation
- 3.5.1. Variable Declaration and Initialization
- 3.5.2. Intrinsic Data Types and the New Operator
- 3.5.3. The Data Type Class Hierarchy
- 3.5.4. Members of Numerical Data Types
- 3.5.5. Members of System.Boolean
- 3.5.6. Members of System.Char
- 3.5.7. Parsing Values from String Data
- 3.5.8. System.DateTime and System.TimeSpan
- 3.5.9. The .NET 4.0 System.Numerics Namespace
- 3.6. Working with String Data
- 3.7. Narrowing and Widening Data Type Conversions
- 3.8. Understanding Implicitly Typed Local Variables
- 3.9. VB 2010 Iteration Constructs
- 3.10. Decision Constructs and the Relational/Equality Operators
- 3.11. Summary
- 4. Core VB 2010 Programming Constructs, Part II
-
5. Defining Encapsulated Class Types
- 5.1. Introducing the VB 2010 Class Type
- 5.2. Understanding Constructors
- 5.3. The Role of the Me Keyword
- 5.4. Understanding the Shared Keyword
- 5.5. Defining the Pillars of OOP
- 5.6. VB 2010 Access Modifiers
-
5.7. The First Pillar: VB 2010 Encapsulation Services
- 5.7.1. Encapsulation Using Traditional Accessors and Mutators
- 5.7.2. Encapsulation Using .NET Properties
- 5.7.3. Using Properties within a Class Definition
- 5.7.4. Internal Representation of Properties
- 5.7.5. Controlling Visibility Levels of Property Get/Set Statements
- 5.7.6. Read-Only and Write-Only Properties
- 5.7.7. Shared Properties
- 5.8. Understanding Automatic Properties
- 5.9. Understanding Object Initializer Syntax
- 5.10. Working with Constant Field Data
- 5.11. Understanding Partial Types
- 5.12. Summary
-
6. Understanding Inheritance and Polymorphism
- 6.1. The Basic Mechanics of Inheritance
- 6.2. Revising Visual Studio Class Diagrams
- 6.3. The Second Pillar of OOP: The Details of Inheritance
- 6.4. Programming for Containment/Delegation
- 6.5. The Third Pillar of OOP: VB's Polymorphic Support
- 6.6. Understanding Base Class/Derived Class Casting Rules
- 6.7. The Master Parent Class: System.Object
- 6.8. Summary
-
7. Understanding Structured Exception Handling
- 7.1. Ode to Errors, Bugs, and Exceptions
- 7.2. The Role of .NET Exception Handling
- 7.3. The Simplest Possible Example
- 7.4. Configuring the State of an Exception
- 7.5. System-Level Exceptions (System.SystemException)
- 7.6. Application-Level Exceptions (System.ApplicationException)
- 7.7. Processing Multiple Exceptions
- 7.8. Who Is Throwing What?
- 7.9. The Result of Unhandled Exceptions
- 7.10. Debugging Unhandled Exceptions Using Visual Studio
- 7.11. A Brief Word Regarding Corrupted State Exceptions (CSE)
- 7.12. Summary
-
8. Understanding Object Lifetime
- 8.1. Classes, Objects, and References
- 8.2. The Basics of Object Lifetime
- 8.3. The Role of Application Roots
- 8.4. Understanding Object Generations
- 8.5. Concurrent Garbage Collection under .NET 1.0 - 3.5
- 8.6. The System.GC Type
- 8.7. Building Finalizable Objects
- 8.8. Building Disposable Objects
- 8.9. Building Finalizable and Disposable Types
- 8.10. Understanding Lazy Object Instantiation
- 8.11. Summary
-
9. Working with Interfaces
- 9.1. Understanding Interface Types
- 9.2. Defining Custom Interfaces
- 9.3. Implementing an Interface
- 9.4. Invoking Interface Members at the Object Level
- 9.5. Interfaces As Parameters
- 9.6. Interfaces As Return Values
- 9.7. Arrays of Interface Types
- 9.8. Implementing Interfaces Using Visual Studio 2010
- 9.9. Resolving Name Clashes via Explicit Interface Implementation
- 9.10. Designing Interface Hierarchies
- 9.11. Building Enumerable Types (IEnumerable and IEnumerator)
- 9.12. Building Cloneable Objects (ICloneable)
- 9.13. Building Comparable Objects (IComparable)
- 9.14. Summary
- 10. Understanding Generics
-
11. Delegates, Events, and Lambdas
- 11.1. Understanding the .NET Delegate Type
- 11.2. Defining a Delegate Type in VB 2010
- 11.3. The System.MulticastDelegate and System.Delegate Base Classes
- 11.4. The Simplest Possible Delegate Example
- 11.5. Sending Object State Notifications Using Delegates
- 11.6. Method Group Conversion Syntax
- 11.7. Understanding Delegate Covariance
- 11.8. Understanding Generic Delegates
- 11.9. Understanding VB 2010 Events
- 11.10. Understanding VB 2010 Anonymous Methods
- 11.11. Understanding Lambda Expressions
- 11.12. Summary
-
12. Advanced VB 2010 Language Features
- 12.1. Understanding Indexer Methods
-
12.2. Understanding Operator Overloading
- 12.2.1. Overloading Binary Operators
- 12.2.2. And What of the += and –= Operators?
- 12.2.3. Overloading Unary Operators
- 12.2.4. Overloading Equality Operators
- 12.2.5. Overloading Comparison Operators
- 12.2.6. The Internal Representation of Overloaded Operators
- 12.2.7. Final Thoughts Regarding Operator Overloading
-
12.3. Understanding Custom Type Conversions
- 12.3.1. Recall: Numerical Conversions
- 12.3.2. Recall: Conversions Among Related Class Types
- 12.3.3. Creating Custom Conversion Routines
- 12.3.4. Additional Explicit Conversions for the Square Type
- 12.3.5. Defining Implicit Conversion Routines
- 12.3.6. The Internal Representation of Custom Conversion Routines
-
12.3.7. Understanding Extension Methods
- 12.3.7.1. Defining Extension Methods
- 12.3.7.2. Invoking Extension Methods on an Instance Level
- 12.3.7.3. Invoking Extension Methods as Shared Methods
- 12.3.7.4. The Scope of an Extension Method
- 12.3.7.5. Importing Types That Define Extension Methods
- 12.3.7.6. The IntelliSense of Extension Methods
- 12.3.7.7. Building and Using Extension Libraries
- 12.3.7.8. Extending Interface Types via Extension Methods
- 12.3.8. Understanding Partial Methods
- 12.3.9. Understanding Anonymous Types
- 12.4. Summary
-
13. LINQ to Objects
- 13.1. LINQ Specific Programming Constructs
- 13.2. Understanding the Role of LINQ
- 13.3. Applying LINQ Queries to Primitive Arrays
- 13.4. Returning the Result of a LINQ Query
- 13.5. Applying LINQ Queries to Collection Objects
-
13.6. Investigating the VB 2010 LINQ Query Operators
- 13.6.1. Basic Selection Syntax
- 13.6.2. Obtaining Subsets of Data
- 13.6.3. Projecting New Data Types
- 13.6.4. Obtaining Counts Using Enumerable
- 13.6.5. Reversing Result Sets
- 13.6.6. Sorting Expressions
- 13.6.7. LINQ As a Better Venn Diagramming Tool
- 13.6.8. Removing Duplicates
- 13.6.9. LINQ Aggregation Operations
-
13.7. The Internal Representation of LINQ Query Statements
- 13.7.1. Building Query Expressions with Query Operators (Revisited)
- 13.7.2. Building Query Expressions Using the Enumerable Type and Lambda Expressions
- 13.7.3. Building Query Expressions Using the Enumerable Type and Anonymous Methods
- 13.7.4. Building Query Expressions Using the Enumerable Type and Raw Delegates
- 13.8. Summary
-
14. Configuring .NET Assemblies
- 14.1.
- 14.2. The Role of .NET Assemblies
- 14.3. Understanding the Format of a .NET Assembly
- 14.4. Building and Consuming a Single-File Assembly
- 14.5. Building and Consuming a Multifile Assembly
- 14.6. Understanding Private Assemblies
- 14.7. Understanding Shared Assemblies
- 14.8. Consuming a Shared Assembly
- 14.9. Configuring Shared Assemblies
- 14.10. Understanding Publisher Policy Assemblies
- 14.11. Understanding the <codeBase> Element
- 14.12. The System.Configuration Namespace
- 14.13. Summary
-
15. Type Reflection, Late Binding, and Attribute-Based Programming
- 15.1. The Necessity of Type Metadata
- 15.2. Understanding Reflection
- 15.3. Building a Custom Metadata Viewer
- 15.4. Dynamically Loading Assemblies
- 15.5. Reflecting on Shared Assemblies
- 15.6. Understanding Late Binding
- 15.7. Understanding the Role of .NET Attributes
- 15.8. Building Custom Attributes
- 15.9. Assembly-Level (and Module-Level) Attributes
- 15.10. Reflecting on Attributes Using Early Binding
- 15.11. Reflecting on Attributes Using Late Binding
- 15.12. Putting Reflection, Late Binding, and Custom Attributes in Perspective
- 15.13. Building an Extendable Application
- 15.14. Summary
-
16. Processes, AppDomains, and Object Contexts
- 16.1. The Role of a Windows Process
- 16.2. Interacting with Processes Under the .NET Platform
- 16.3. Understanding .NET Application Domains
- 16.4. Interacting with the Default Application Domain
- 16.5. Creating New Application Domains
- 16.6. Understanding Object Context Boundaries
- 16.7. Summarizing Processes, AppDomains, and Context
- 16.8. Summary
-
17. Understanding CIL and the Role of Dynamic Assemblies
- 17.1. Reasons for Learning the Grammar of CIL
- 17.2. Examining CIL Directives, Attributes, and Opcodes
- 17.3. Pushing and Popping: The Stack-Based Nature of CIL
- 17.4. Understanding Round-Trip Engineering
-
17.5. Understanding CIL Directives and Attributes
- 17.5.1. Specifying Externally Referenced Assemblies in CIL
- 17.5.2. Defining the Current Assembly in CIL
- 17.5.3. Defining Namespaces in CIL
- 17.5.4. Defining Class Types in CIL
- 17.5.5. Defining and Implementing Interfaces in CIL
- 17.5.6. Defining Structures in CIL
- 17.5.7. Defining Enums in CIL
- 17.5.8. Defining Generics in CIL
- 17.5.9. Compiling the CILTypes.il file
- 17.6. .NET Base Class Library, VB 2010, and CIL Data Type Mappings
- 17.7. Defining Type Members in CIL
- 17.8. Examining CIL Opcodes
- 17.9. Building a .NET Assembly with CIL
-
17.10. Understanding Dynamic Assemblies
- 17.10.1. Exploring the System.Reflection.Emit Namespace
- 17.10.2. The Role of the System.Reflection.Emit.ILGenerator
- 17.10.3. Emitting a Dynamic Assembly
- 17.10.4. Emitting the Assembly and Module Set
- 17.10.5. The Role of the ModuleBuilder Type
- 17.10.6. Emitting the HelloClass Type and the String Member Variable
- 17.10.7. Emitting the Constructors
- 17.10.8. Emitting the SayHello() Method
- 17.10.9. Using the Dynamically Generated Assembly
- 17.11. Summary
-
18. Dynamic Types and the Dynamic Language Runtime
- 18.1. Basics of Dynamic Typing in VB 2010
- 18.2. The Role of Dynamic Typing in VB 2010
- 18.3. The Role of the Dynamic Language Runtime (DLR)
- 18.4. Simplifying Late Bound Calls Using Dynamic Typing
- 18.5. Simplifying COM Interoperability using Dynamic Data
- 18.6. COM Interop using VB 2010 Language Features
- 18.7. Summary
-
19. Multithreaded and Parallel Programming
- 19.1. The Process/AppDomain/Context/Thread Relationship
- 19.2. A Brief Review of the .NET Delegate
- 19.3. The Asynchronous Nature of Delegates
- 19.4. Invoking a Method Asynchronously
- 19.5. The System.Threading Namespace
- 19.6. The System.Threading.Thread Class
- 19.7. Programmatically Creating Secondary Threads
- 19.8. The Issue of Concurrency
- 19.9. Programming with Timer Callbacks
- 19.10. Understanding the CLR ThreadPool
- 19.11. Parallel Programming under the .NET Platform
- 19.12. Parallel LINQ Queries (PLINQ)
- 19.13. Summary
-
20. File I/O and Object Serialization
- 20.1. Exploring the System.IO Namespace
- 20.2. The Directory(Info) and File(Info) Types
- 20.3. Working with the DirectoryInfo Type
- 20.4. Working with the Directory Type
- 20.5. Working with the DriveInfo Class Type
- 20.6. Working with the FileInfo Class
- 20.7. Working with the File Type
- 20.8. The MustInherit Stream Class
- 20.9. Working with StreamWriters and StreamReaders
- 20.10. Working with StringWriters and StringReaders
- 20.11. Working with BinaryWriters and BinaryReaders
- 20.12. Watching Files Programmatically
- 20.13. Understanding Object Serialization
- 20.14. Configuring Objects for Serialization
- 20.15. Choosing a Serialization Formatter
- 20.16. Serializing Objects Using the BinaryFormatter
- 20.17. Serializing Objects Using the SoapFormatter
- 20.18. Serializing Objects Using the XmlSerializer
- 20.19. Serializing Collections of Objects
- 20.20. Customizing the Soap/Binary Serialization Process
- 20.21. Summary
-
21. ADO.NET Part I: The Connected Layer
- 21.1. A High-Level Definition of ADO.NET
- 21.2. The Three Faces of ADO.NET
- 21.3. Understanding ADO.NET Data Providers
- 21.4. Additional ADO.NET Namespaces
-
21.5. The Types of the System.Data Namespace
- 21.5.1. The Role of the IDbConnection Interface
- 21.5.2. The Role of the IDbTransaction Interface
- 21.5.3. The Role of the IDbCommand Interface
- 21.5.4. The Role of the IDbDataParameter and IDataParameter Interfaces
- 21.5.5. The Role of the IDbDataAdapter and IDataAdapter Interfaces
- 21.5.6. The Role of the IDataReader and IDataRecord Interfaces
- 21.6. Abstracting Data Providers Using Interfaces
- 21.7. Creating the AutoLot Database
- 21.8. The ADO.NET Data Provider Factory Model
- 21.9. Understanding the Connected Layer of ADO.NET
- 21.10. Working with Data Readers
- 21.11. Building a Reusable Data Access Library
-
21.12. Creating a Console UI–Based Front End
- 21.12.1. Implementing the Main() Method
- 21.12.2. Implementing the ShowInstructions() Method
- 21.12.3. Implementing the ListInventory() Method
- 21.12.4. Implementing the DeleteCar() Method
- 21.12.5. Implementing the InsertNewCar() Method
- 21.12.6. Implementing the UpdateCarPetName() Method
- 21.12.7. Implementing LookUpPetName()
- 21.13. Understanding Database Transactions
- 21.14. Summary
-
22. ADO.NET Part II: The Disconnected Layer
- 22.1. Understanding the Disconnected Layer of ADO.NET
- 22.2. Understanding the Role of the DataSet
- 22.3. Working with DataColumns
- 22.4. Working with DataRows
- 22.5. Working with DataTables
- 22.6. Binding DataTable Objects to Windows Forms GUIs
- 22.7. Working with Data Adapters
- 22.8. Adding Disconnection Functionality to AutoLotDAL.dll
- 22.9. Multitabled DataSet Objects and Data Relationships
-
22.10. The Windows Forms Database Designer Tools
- 22.10.1. Visually Designing the DataGridView
- 22.10.2. The Generated app.config File
- 22.10.3. Examining the Strongly Typed DataSet
- 22.10.4. Examining the Strongly Typed DataTable
- 22.10.5. Examining the Strongly Typed DataRow
- 22.10.6. Examining the Strongly Typed Data Adapter
- 22.10.7. Completing the Windows Forms Application
- 22.11. Isolating Strongly Typed Database Code into a Class Library
- 22.12. Programming with LINQ to DataSet
- 22.13. Summary
-
23. ADO.NET Part III: The Entity Framework
- 23.1. Understanding the Role of Entity Framework
- 23.2. Building and Analyzing your First EDM
- 23.3. Programming Against the Conceptual Model
- 23.4. AutoLotDAL Version 4.0, Now with Entities
- 23.5. Data Binding Entities to Windows Forms GUIs
- 23.6. Summary
- 24. Introducing LINQ to XML
-
25. Introducing Windows Communication Foundation
- 25.1. A Potpourri of Distributed Computing APIs
- 25.2. The Role of WCF
- 25.3. Investigating the Core WCF Assemblies
- 25.4. The Visual Studio WCF Project Templates
- 25.5. The Basic Composition of a WCF Application
- 25.6. The ABCs of WCF
- 25.7. Building a WCF Service
- 25.8. Hosting the WCF Service
- 25.9. Building the WCF Client Application
- 25.10. Simplifying Configuration Settings with WCF 4.0
- 25.11. Using the WCF Service Library Project Template
- 25.12. Hosting the WCF Service within a Windows Service
- 25.13. Invoking a Service Asynchronously from the Client
- 25.14. Designing WCF Data Contracts
- 25.15. Summary
-
26. Introducing Windows Workflow Foundation 4.0
- 26.1. Defining a Business Process
- 26.2. Building a (Painfully) Simple Workflow
- 26.3. The WF 4.0 Runtime
- 26.4. Examining the Workflow 4.0 Activities
-
26.5. Building a Flowchart Workflow
- 26.5.1. Connecting Activities in a Flowchart
- 26.5.2. Working with the InvokeMethod Activity
- 26.5.3. Defining Workflow Wide Variables
- 26.5.4. Working with the FlowDecision Activity
- 26.5.5. Working with the TerminateWorkflow Activity
- 26.5.6. Building the "True" Condition
- 26.5.7. Working with the ForEach<T> Activity
- 26.5.8. Completing the Application
- 26.5.9. Reflecting on What We Have Done
- 26.6. Isolating Workflows into Dedicated Libraries
- 26.7. Consuming the Workflow Library
- 26.8. Summary
-
27. Introducing Windows Presentation Foundation and XAML
- 27.1. The Motivation Behind WPF
- 27.2. The Various Flavors of WPF
-
27.3. Investigating the WPF Assemblies
- 27.3.1. The Role of the Application Class
-
27.3.2. The Role of the Window Class
- 27.3.2.1. The Role of System.Windows.Controls.ContentControl
- 27.3.2.2. The Role of System.Windows.Controls.Control
- 27.3.2.3. The Role of System.Windows.FrameworkElement
- 27.3.2.4. The Role of System.Windows.UIElement
- 27.3.2.5. The Role of System.Windows.Media.Visual
- 27.3.2.6. The Role of System.Windows.DependencyObject
- 27.3.2.7. The Role of System.Windows.Threading.DispatcherObject
- 27.4. Building a WPF Application without XAML
- 27.5. Building a WPF Application using Only XAML
- 27.6. Transforming Markup into a .NET Assembly
-
27.7. Understanding The Syntax of WPF XAML
- 27.7.1. Introducing Kaxaml
- 27.7.2. XAML XML Namespaces and XAML "Keywords"
- 27.7.3. Controlling Class and Member Variable Declarations
- 27.7.4. XAML Elements, XAML Attributes and Type Converters
- 27.7.5. Understanding XAML Property-Element Syntax
- 27.7.6. Understanding XAML Attached Properties
- 27.7.7. Understanding XAML Markup Extensions
- 27.8. Building a WPF Application using Code-Behind Files
- 27.9. Building WPF Applications Using Visual Studio 2010
- 27.10. Summary
-
28. Programming with WPF Controls
- 28.1. A Survey of the Core WPF Controls
- 28.2. Controlling Content Layout Using Panels
- 28.3. Building a Window's Frame Using Nested Panels
- 28.4. Understanding WPF Control Commands
- 28.5. Building a WPF User Interface with Expression Blend
- 28.6. Building the Ink API Tab
- 28.7. Introducing the Documents API
- 28.8. Building the Documents Tab
- 28.9. Introducing the WPF Data-Binding Model
- 28.10. Summary
-
29. WPF Graphics Rendering Services
- 29.1. Understanding WPF's Graphical Rendering Services
- 29.2. Rendering Graphical Data Using Shapes
- 29.3. WPF Brushes and Pens
- 29.4. Applying Graphical Transformations
- 29.5. Working with Shapes using Expression Blend
- 29.6. Rendering Graphical Data Using Drawings and Geometries
- 29.7. Generating Complex Vector Graphics using Expression Design
- 29.8. Rendering Graphical Data Using the Visual Layer
- 29.9. Summary
-
30. WPF Resources, Animations, and Styles
- 30.1. Understanding the WPF Resource System
-
30.2. Working with Object (Logical) Resources
- 30.2.1. The Role of the Resources Property
- 30.2.2. Defining Window-Wide Resources
- 30.2.3. The {StaticResource} Markup Extension
- 30.2.4. Changing a Resource after Extraction
- 30.2.5. The {DynamicResource} Markup Extension
- 30.2.6. Application-Level Resources
- 30.2.7. Defining Merged Resource Dictionaries
- 30.2.8. Defining a Resource-Only Assembly
- 30.2.9. Extracting Resources in Expression Blend
- 30.3. Understanding WPF's Animation Services
- 30.4. Authoring Animations in XAML
-
30.5. Understanding the Role of WPF Styles
- 30.5.1. Defining and Applying a Style
- 30.5.2. Overriding Style Settings
- 30.5.3. Automatically Applying a Style with TargetType
- 30.5.4. Subclassing Existing Styles
- 30.5.5. The Role of Unnamed Styles
- 30.5.6. Defining Styles with Triggers
- 30.5.7. Defining Styles with Multiple Triggers
- 30.5.8. Animated Styles
- 30.5.9. Assigning Styles Programmatically
- 30.6. Generating Styles with Expression Blend
- 30.7. Summary
-
31. WPF Control Templates and UserControls
- 31.1. Understanding the Role of Dependency Properties
- 31.2. Building a Custom Dependency Property
- 31.3. Understanding Routed Events
- 31.4. Logical Trees, Visual Trees and Default Templates
- 31.5. Building a Custom Control Template with Visual Studio 2010
- 31.6. Building Custom UserControls with Blend
- 31.7. Creating the Jackpot Deluxe WPF Application
- 31.8. Summary
-
32. Building ASP.NET Web Pages
- 32.1. The Role of HTTP
- 32.2. Understanding Web Applications and Web Servers
- 32.3. The Role of HTML
- 32.4. The Role of Client-Side Scripting
- 32.5. Posting Back to the Web Server
- 32.6. The Feature Set of the ASP.NET API
- 32.7. Building a Single File ASP.NET Web Page
- 32.8. Building an ASP.NET Web Page using Code Files
- 32.9. ASP.NET Web Sites and ASP.NET Web Applications
- 32.10. The ASP.NET Web Site Directory Structure
- 32.11. The Inheritance Chain of the Page Type
- 32.12. Interacting with the Incoming HTTP Request
- 32.13. Interacting with the Outgoing HTTP Response
- 32.14. The Life Cycle of an ASP.NET Web Page
- 32.15. The Role of the Web.config File
- 32.16. Summary
-
33. ASP.NET Web Controls, Master Pages, and Themes
- 33.1. Understanding the Nature of Web Controls
- 33.2. The Control and WebControl Base Classes
- 33.3. Major Categories of ASP.NET Web Controls
- 33.4. Building the ASP.NET Cars Web Site
- 33.5. The Role of the Validation Controls
- 33.6. Working with Themes
- 33.7. Summary
-
34. ASP.NET State Management Techniques
- 34.1. The Issue of State
- 34.2. ASP.NET State Management Techniques
- 34.3. Understanding the Role of ASP.NET View State
- 34.4. The Role of the Global.asax File
- 34.5. Understanding the Application/Session Distinction
- 34.6. Working with the Application Cache
- 34.7. Maintaining Session Data
- 34.8. Understanding Cookies
- 34.9. The Role of the <sessionState> Element
- 34.10. Understanding the ASP.NET Profile API
- 34.11. Summary
-
A. Programming with Windows Forms
- A.1. The Windows Forms Namespaces
- A.2. Building a Simple Windows Forms Application
- A.3. The Visual Studio Windows Forms Project Template
- A.4. The Anatomy of a Form
- A.5. Responding to Mouse and Keyboard Activity
- A.6. Designing Dialog Boxes
- A.7. Rendering Graphical Data Using GDI+
-
A.8. Building a Complete Windows Forms Application
- A.8.1. Building the Main Menu System
- A.8.2. Defining the ShapeData Type
- A.8.3. Defining the ShapePickerDialog Type
- A.8.4. Adding Infrastructure to the MainWindow Type
- A.8.5. Implementing the Tools Menu Functionality
- A.8.6. Capturing and Rendering the Graphical Output
- A.8.7. Implementing the Serialization Logic
- A.9. Summary
-
B. Platform-Independent .NET Development with Mono
- B.1. The Platform-Independent Nature of .NET
- B.2. Obtaining and Installing Mono
- B.3. The Mono Development Languages
- B.4. Microsoft-Compatible Mono Development Tools
- B.5. Building .NET Applications with Mono
- B.6. Who is Using Mono?
- B.7. Suggestions for Further Study
- B.8. Summary
Product information
- Title: Pro VB 2010 and the .NET 4 Platform
- Author(s):
- Release date: October 2010
- Publisher(s): Apress
- ISBN: 9781430229858
You might also like
book
Professional Visual Basic® 2010 and .NET 4
Intermediate and advanced coverage of Visual Basic 2010 and .NET 4 for professional developers If you've …
book
Visual Basic® 2012 Unleashed, Second Edition
Fully updated for Windows 8 support, .NET 4.5, and Windows Phone development, this is the most …
book
Professional C# 5.0 and .NET 4.5.1
Comprehensive, advanced coverage of C# 5.0 and .NET 4.5.1 Whether you're a C# guru or transitioning …
book
Professional Development with Visio® 2000
Professional Development with Visio 2000 empowers you to create your own Visio solutions quickly and easily. …