Home Page Icon
Home Page
Table of Contents for
Cover
Close
Cover
by Mike Liu
WCF Multi-tier Services Development with LINQ
WCF Multi-tier Services Development with LINQ
WCF Multi-tier Services Development with LINQ
Credits
About the Author
About the Reviewers
Preface
What This Book Covers
What You Need for This Book
Who is This Book For
Conventions
Reader Feedback
Customer Support
Downloading the Example Code for the Book
Errata
Piracy
Questions
1. SOA Service Oriented Architecture
What is SOA?
Why SOA?
How do we implement SOA?
SOA from different users' perspectives
Complexities in SOA implementation
Web services
What is a web service?
Web service WSDL
Web service proxy
SOAP
Web services: standards and specifications
WS-I Profiles
WS-Addressing
WS-Security
WS-ReliableMessaging
WS-Coordination and WS-Transaction
Summary
2. WCF Windows Communication Foundation
What is WCF?
Why is WCF used for SOA?
WCF architecture
Basic WCF concepts WCF ABCs
Address
Binding
Contract
Service contract
Operation contract
Message contract
Data contract
Fault contract
Endpoint
Behavior
Hosting
Self hosting
Windows services hosting
IIS hosting
Windows Activation Services hosting
Channels
Metadata
WCF production and development environments
Summary
3. Implementing a Basic HelloWorld WCF Service
Creating the HelloWorld solution and project
Creating the HelloWorldService service contract interface
Implementing the HelloWorldService service contract
Hosting the WCF service in ASP.NET Development Server
Creating the host application
Testing the host application
ASP.NET Development Server
Adding an svc file to the host application
Adding a web.config file to the host application
Starting the host application
Creating a client to consume the WCF service
Creating the client application project
Generating the proxy and configuration files
Customizing the client application
Running the client application
Setting the service application to AutoStart
Summary
4. Hosting and Debugging the HelloWorld WCF Service
Hosting the HelloWorld WCF service
Hosting the service in a managed application
Hosting the service in a console application
Consuming the service hosted in a console application
Hosting the service in a Windows service
Hosting the service in the Internet Information Server
Preparing the folders and files
Creating the virtual directory
Starting the WCF service in the IIS
Testing the WCF service hosted in the IIS
Advanced WCF service hosting options
Debugging the HelloWorld WCF service
Debugging from the client application
Starting the debugging process
Debugging on the client application
Enabling debugging of the WCF service
Stepping into the WCF service
Debugging only the WCF service
Starting the WCF Service in debugging mode
Starting the client application in non-debugging mode
Starting the WCF service and client applications in debugging mode
Attaching to a WCF service process
Running the WCF service and client applications in non-debugging mode
Debugging the WCF service hosted in IIS
Just-In-Time debugger
Summary
5. Implementing a WCF Service in the Real World
Why layering a service?
Creating a new solution and project using WCF templates
Using the C# WCF service library template
Using the C# WCF service application template
Creating the service interface layer
Creating the service interfaces
Creating the data contracts
Implementing the service contracts
Modifying the app.config file
Testing the service using WCF Test Client
Testing the service using our own client
Adding a business logic layer
Adding the product entity project
Adding the business logic project
Calling the business logic layer from the service interface layer
Testing the WCF service with a business logic layer
Summary
6. Adding Database Support and Exception Handling to the RealNorthwind WCF Service
Adding a data access layer
Creating the data access layer project
Calling the data access layer from the business logic layer
Preparing the database
Adding the connection string to the configuration file
Querying the database (GetProduct)
Testing the GetProduct method
Updating the database (UpdateProduct)
Adding error handling to the service
Adding a fault contract
Throwing a fault exception
Updating client program to catch the fault exception
Disabling the Just My Code debugging option
Testing the fault exception
Summary
7. Modeling a WCF Service with Service Factory
What is the Service Factory?
What are Guidance Packages?
Preparing environments
Installing Guidance Automation packages
Installing Microsoft Service Software Factory
Differences between the December 2006 version and the February 2008 version
Modeling the data contracts
Creating the solution
Adding the data contract model
Adding the product data contract
Adding the product fault contract
Modeling the service contracts
Adding the ProductService contract model
Adding the GetProduct operation
Adding the message contracts
Adding the service contracts
Adding the connectors
Specifying the implementation technology for the models
Choosing the implementation technology for service contract model
Changing the property values for service contracts
Choosing the implementation technology for the data contract model
Changing the order property for data members
Generating source code
Creating the service projects
Linking contract models to projects
Validating the contract models
Generating the source code
Summary
8. Implementing the WCF Service with Service Factory
Creating the business entities
Customizing the data access layer
Adding the connection strings
Adding a reference to the BusinessEntities project
Adding the data access class
Customizing the business logic
Translating the messages
Customizing the Fault contract
Customizing the product service
Modeling the host application and the test client
Modeling the host application
Generating the host application
Adding the test client to the host model
Generating the client proxy
Customizing the client
Testing the service
Summary
9. Introducing Language-Integrated Query (LINQ)
What is LINQ
Creating the test solution and project
New data type var
Automatic properties
Object initializer
Collection initializer
Anonymous types
Extension methods
Lambda expressions
Built-in LINQ extension methods and method syntax
LINQ query syntax and query expression
Built-in LINQ operators
Summary
10. LINQ to SQL: Basic Concepts and Features
ORM Object-Relational Mapping
LINQ to SQL
Comparing LINQ to SQL with LINQ to Objects
LINQ to Entities
Comparing LINQ to SQL with LINQ to Entities
Creating LINQ to SQL test application
Modeling the Northwind database
Adding a LINQ to SQL item to the project
Connecting to the Northwind database
Adding tables and views to the design surface
Generated LINQ to SQL classes
Querying and updating the database with a table
Querying records
Updating records
Inserting records
Deleting records
Running the program
Deferred execution
Checking deferred execution with SQL profiler
Checking deferred execution with SQL logs
Deferred execution for singleton methods
Deferred execution for singleton methods within sequence expressions
Deferred (lazy) loading versus eager loading
Lazy loading by default
Eager loading with load options
Filtered loading with load options
Combining eager loading and filtered loading
Joining two tables
Querying a view
Summary
11. LINQ to SQL: Advanced Concepts and Features
Calling a stored procedure
Calling a simple stored procedure
Mapping a stored procedure to an entity class
Handling output parameters, return codes, multiple shapes of a single result-set, and multiple result-sets
Creating a complex stored procedure
Modeling the stored procedure
Customizing DataContext class for the stored procedure
Testing the stored procedure
Compiled query
Direct SQL
Dynamic query
Inheritance
LINQ to SQL single-table inheritance
LINQ to SQL single-table inheritance
Modeling the BaseProduct and Beverage classes
Modeling the Seafood class
The generated classes with inheritance
Testing the inheritance
Handling simultaneous (concurrent) updates
Detecting conflicts using the Update Check property
Writing the test code
Testing the conflicts
Detecting conflicts using a version column
Adding a version column
Modeling the products table with a version column
Writing the test code
Testing the conflicts
Transactions support
Implicit transactions
Explicit transactions
Participating in existing ADO.NET transactions
Adding validations to entity classes
Debugging LINQ to SQL programs
Summary
12. Applying LINQ to SQL to a WCF Service
Creating the LINQNorthwind solution
Modeling the data contracts
Modeling the service contracts
Generating the source code
Modeling the Northwind database
Implementing the data access layer
Adding GetProduct to the data access layer
Adding UpdateProduct to the data access layer
Implementing the business logic layer
Implementing the service interface layer
Modifying the ProductFault class
Modifying the DataContract class
Modifying the ServiceImplementation class
Adding references to the project
Adding a translator class
Implementing the GetProduct and UpdateProduct operations
Creating the host application and the test client
Modeling the host application and the test client
Implementing the GetProduct functionality
Implementing the UpdateProduct functionality
Testing the GetProduct and UpdateProduct operations
Testing concurrent update manually
Testing concurrent update automatically
Summary
13. Distributed Transaction Support of WCF
Creating the DistNorthwind solution
Testing the transaction behaviour of the WCF service
Creating a client to call the WCF service sequentially
Testing the sequential calls to the WCF service
Wrapping the WCF service calls in one transaction scope
Testing multiple database support of the WCF service
Modifying the data access layer for the second database support
Modifying the business logic layer for the second database support
Modifying the service interface layer for the second database support
Modifying the service host for the second database support
Modifying the client for the second database support
Testing the WCF service with two databases
Enabling distributed transaction support
Enabling transaction flow in bindings
Enabling transaction flow on the service application
Enabling transaction flow on the client application
Modifying the service operation contract to allow a transaction flow
Modifying the service operation implementation to require a transaction scope
Understanding distributed transaction support of a WCF service
Testing the distributed transaction support of the WCF service
Propagating a transaction from client to the WCF service
Configuring the Distributed Transaction Coordinator
Configuring the firewall
Summary
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
Next
Next Chapter
WCF Multi-tier Services Development with LINQ
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