WCF Multi-tier Services Development with LINQ

Spis treści książki

• WCF Multi-tier Services Development with LINQ
  • Table of Contents
  • 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
      • 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
  • Index

pokaż cały spis treści

ukryj recenzje