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