WCF Multi-tier Services Development with LINQ Table of Contents

Table of Contents

• Preface

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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

• Chapter 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
• 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

• Chapter 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

• Chapter 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

• Index