Microsoft BizTalk Server 2010 Patterns

Microsoft BizTalk Server 2010 Patterns
eBook: $32.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $87.98    Print cover: $54.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • Provides a unified example from the beginning to end of a real world solution
  • A starter guide expecting little or no previous BizTalk experience, but offering advanced concepts and techniques
  • Provides in-depth background and introduction to the platform and technology
  • Written by a Biztalk architecture MVP


Book Details

Language : English
Paperback : 396 pages [ 235mm x 191mm ]
Release Date : October 2011
ISBN : 184968460X
ISBN 13 : 9781849684606
Author(s) : Dan Rosanova
Topics and Technologies : All Books, Enterprise Products and Platforms, Microsoft Servers, Enterprise, Microsoft

Table of Contents

Chapter 1: Introducing BizTalk Server 2010
Chapter 2: Introduction to BizTalk Development
Chapter 3: BizTalk Development Guidelines
Chapter 4: Operating BizTalk
Chapter 5: Basic Messaging Solution
Chapter 6: Unit Tests and BAM
Chapter 7: Leveraging Orchestration
Chapter 8: The WCF-SQL Adapter and WCF Services
Chapter 9: Expanding the Solution with Services and Rules
Chapter 10: Envelopes, Flat Files, and Batching
Chapter 11: Completing the Order Processing Solution
Chapter 12: Asynchronous Solutions
Chapter 13: Performing Parallel Processing and Branching
Chapter 14: Processing Message Convoys
  • Chapter 1: Introducing BizTalk Server 2010
    • Understanding what is BizTalk Server
    • Stating the goals of BizTalk Server
      • Increasing reliability
      • Decoupling systems
      • Providing reuse
      • Decreasing development time
      • Providing rich information to technical as well as business consumers
      • Improving administration
    • When to use BizTalk Server
    • Where does BizTalk fit into the Enterprise?
    • Exploring the architecture of BizTalk Server
    • Design patterns within the BizTalk architecture
      • Messaging
      • Publish Subscribe
      • Adapter
      • Streaming
    • Understanding BizTalk message flow
      • The Message Box
      • Other BizTalk databases
    • Presenting the BizTalk runtime environment
      • Servers and services
        • Application Servers
        • Database Servers
        • Web Servers
        • Enterprise Single Sign-On Servers
      • Understanding roles and relationships
        • The BizTalk group
        • Hosts
        • Host instances
        • Isolated vs. in-process hosts
    • Summary
    • Chapter 2: Introduction to BizTalk Development
      • Developing BizTalk solutions
      • Partitioning the BizTalk solution
        • Specifying the requirements of solution structure
      • Understanding the layers of a BizTalk solution
      • Visual Studio solution structure
        • Projects
          • External Schemas (.xsd files)
          • Internal Schemas (.xsd files)
          • Maps (.btm files)
          • Pipelines (.btp files)
          • Pipeline components (.cs files)
          • Orchestrations (.odx files)
          • Libraries (C#, resources, and so on)
          • Testing (.xml, .dtd, .cs files)
          • Non-project artifacts
        • Motivations for solution structure
      • Understanding types in BizTalk
        • Message types
        • Types in contexts
        • Type resolution
      • Understanding the solution at runtime
      • Monitoring
        • Why BAM?
        • Understanding BAM concepts
        • Creating a BAM activity
        • Creating a BAM view
        • Creating a BAM tracking profile
        • Advanced BAM concepts
          • Continuation
          • Relationship
          • Document reference URL
      • Introducing the BAM portal
        • Presenting BAM alerts
      • Summary
      • Chapter 3: BizTalk Development Guidelines
        • Core guidance
          • Determining where to place different types of logic
            • Maps
            • Orchestrations
            • Business rules
            • Pipelines and pipeline components
            • General concept
          • Mapping at the port level
        • Orchestration best practices
          • Avoid overuse of orchestration
          • Always use multipart messages in orchestrations
          • Avoid large orchestrations
          • Minimize trips to the message box (persistence points)
          • Avoid using atomic scopes to call .NET methods
          • Don't use XmlDocument for a message type… ever
          • Avoid loading messages into classes via the XmlSerializer
          • Use direct bound ports and Content Based Routing
          • Leverage filters in orchestrations
          • Use distinguished fields instead of XPath
          • Avoid unnecessary looping on collections
        • Pipelines
          • What are pipelines?
          • Stages in a receive pipeline
          • Stages in a send pipeline
          • Pipeline components
          • Metadata and message context
          • Stream processing
        • Summary
        • Chapter 4: Operating BizTalk
          • Understanding BizTalk operational architecture
          • Administering BizTalk Server
          • Scalability in BizTalk Server
            • Scaling SQL Server
            • Scaling BizTalk Server
              • Adding more hosts and host instances
              • Adding more servers to the group
          • Exploring high availability in BizTalk
            • High availability in SQL Server
            • High availability with clustered BizTalk hosts
          • Understanding disaster recovery
            • The BizTalk backup job
            • Standing the new BizTalk environment up
          • Examining sample installation topologies
            • A single application with a single database
            • Dual application with dual database (active/passive)
            • Dual application with dual database (active/active)
            • Sample Enterprise topology
          • Walking through the BizTalk deployment process
          • Presenting the best practices for BizTalk configuration
            • Separating BizTalk hosts
            • Host-specific settings
            • HTTP performance optimization settings
          • Troubleshooting BizTalk issues
          • Summary
          • Chapter 5: Basic Messaging Solution
            • Pass thru messaging scenario
              • Examining the solution
              • Adding a second receive location
              • Transport properties
                • Basic subscriptions
            • Simple XML messaging with maps
              • Creating schemas
              • Creating maps
                • Creating a map from external PoPurchaseOrder to PurchaseOrder
                • Creating a map from canonical PurchaseOrder to SalesOrder
              • Wiring up the solution
                • Creating the receive port
                • Creating the send port
              • Testing the solution
            • Content-based routing and promoted properties
              • Property promotion
              • Updating the solution routing
            • Multicasting messages
              • Adding the new send port
            • Summary
            • Chapter 6: Unit Tests and BAM
              • What are unit tests?
                • Tenets of a good test
                • Composition of a test
                • Test steps
              • Tests for the current solution
                • Standard Purchase Order test
                  • Test setup and cleanup
                  • The test execution stage
                • Harnessing a test
                • Visual Studio Project Settings for tests
              • Creating BAM for a solution
                • Creating a basic BAM profile
                • Creating an Activity
                • Creating a View
                • Creating the Tracking Profile
              • Examining the BAM database infrastructure
                • BAM tables
                • BAM views
                • BAM maintenance
                  • Data maintenance
                  • Analysis
              • Receiving a new Legacy Order format
                • Creating a BizUnit test
              • Summary
              • Chapter 7: Leveraging Orchestration
                • Introducing orchestration
                  • Orchestration basics
                • Creating the orchestration outline
                  • Creating the PurchaseOrder message
                  • Adding ports to the canvas
                  • Implementing the logical comparison
                  • Checkpoint
              • Consuming the order discount service
                • Adding the service artifacts to the solution
                • Creating the maps
                • Distinguished fields
                • Creating a new send port
              • Handling SOAP Faults
                • Using scopes and exceptions
                • Encountering a SOAP Fault
                  • Why is this happening?
                • Using a scope to catch the fault
                • Using a loop to retry the request
                  • Breaking out of retry loop
              • Implementing Failed Message Routing
              • Summary
                • Chapter 8: The WCF-SQL Adapter and WCF Services
                  • Polling a database with the WCF-SQL Adapter
                    • Constructing XML from SQL using FOR XML
                    • Creating the SQL message schema
                    • Creating the map for the website orders
                    • Creating the new WCF-SQL receive location
                  • Creating the unit test for website order
                  • Performing imperative queries with the WCF-SQL Adapter
                    • Creating the schemas to communicate with the database
                    • Creating the external schema for the service request
                    • Creating the internal schema for the service request
                    • Creating maps for the service
                    • Publishing the schemas as a WCF service
                    • Changing the IIS AppPool
                    • Creating the send port for the SQL request
                    • Testing the service
                  • Summary
                  • Chapter 9: Expanding the Solution with Services and Rules
                    • Consuming the customer service
                      • Creating a new map
                      • Adding the data query to the orchestration
                        • Creating the logical port
                        • Adding the new send and receive shapes
                        • Enhancing the discount calculation
                      • Updating the WCF-SQL Send Port
                    • Using Business Rules to improve our process
                      • Introduction to the Business Rules Editor
                      • Creating a vocabulary
                        • Adding a new set of values called definition
                        • Creating XML definitions in a vocabulary
                      • Creating a policy
                      • Updating the orchestration to call this policy
                    • Performing a simple update to the policy
                      • Understanding how business rules work
                    • Expanding the policy
                      • Looping in BRE
                        • Building the Library project
                        • Using the product class from BRE
                    • Deploying policies
                    • Summary
                    • Chapter 10: Envelopes, Flat Files, and Batching
                      • Understanding delimited flat files
                        • Creating the delimited flat file schema
                        • Mapping the delimited flat file
                        • Using the flat file schema
                        • Compile and deploy the solution
                      • Working with positional flat files
                      • Grasping important flat file schema concepts
                        • Using flat file headers and trailers
                      • Processing XML envelopes
                      • Testing envelopes and pipelines
                        • XML Disassmbler
                        • Flat file disassembler
                        • XML assembler / flat file assembler
                        • Pipeline testing
                      • Summary
                      • Chapter 11: Completing the Order Processing Solution
                        • Exposing the process to web service clients
                          • Expose the schema as a service endpoint
                          • Creating a new one-way receive location
                        • Examining the solution bindings
                          • Exporting the bindings
                          • Understanding bindings
                          • Modifying bindings
                            • Creating bindings for each environment
                        • Building and deploying the solution
                          • Building an MSI manually
                          • Examining how the MSI is built
                          • Automating MSI builds
                        • Using advanced BAM features
                          • Updating BAM activities
                          • Defining groups for BAM milestones
                          • Creating dimensions
                          • Defining measures in BAM views
                          • Leveraging BAM continuation
                          • Exploring the improved view
                            • Running the SSIS package to process aggregations
                            • Viewing the aggregation results
                        • Summary
                        • Chapter 12: Asynchronous Solutions
                          • Introducing the inventory management solution
                          • Inventory notification with approval
                            • Creating the notification schema with the WCF SQL adapter
                            • Using SQL table operations
                            • Consuming the vendor order service
                          • Creating the orchestration
                            • Creating messages
                            • Laying out the shapes
                            • Creating the logical ports
                            • Creating the correlation
                          • Updating the inventory
                            • Creating a composite operation schema
                            • Creating the composite operation map
                          • Creating the other maps
                          • Binding the solution
                            • Importing the notification bindings
                            • Importing the WCF-SQL send bindings
                            • Manually creating a WCF-SQL send port
                            • Creating the approval physical ports
                              • Manually creating a web service send port
                              • Binding the orchestration
                          • Exploring other approaches
                            • Querying for missed notifications
                            • Using the polling method
                            • Polling settings
                          • Summary
                          • Chapter 13: Performing Parallel Processing and Branching
                            • Revising solution requirements
                            • Implementing the broker pattern
                              • Using the decide shape
                              • Assessing this approach
                              • Creating a more extensible solution
                                • Understanding roles
                                • Understanding parties
                            • Improving the broker with role-based links
                              • Implementing role party links
                              • Creating parties
                              • Adding a new vendor
                            • Enabling parallel processing
                            • Understanding the parallel shape
                            • Implementing scatter gather
                              • Improving scatter gather
                            • Summary
                            • Chapter 14: Processing Message Convoys
                              • Creating a sequential convoy
                                • Creating the envelope
                                • Creating the pipeline
                                • Creating the orchestration
                                • Creating the convoy correlation
                                • Binding the solution
                                • Running the sequential convoy
                                • Improving our solution
                                • Dealing with zombies
                              • Creating a parallel convoy
                                • Creating the VendorInformation schema
                                  • Creating the promoted property
                                  • Promoting the elements
                                • Creating the orchestration
                                • Wiring up the orchestration ports
                                • Creating the correlation
                                • Binding the solution
                                • Running the parallel convoy
                              • Creating a non-uniform sequential convoy
                              • Using advanced correlations
                              • A note about orchestration development
                              • Summary
                              • Appendix
                                • XML for BizTalk development
                                  • A brief history of XML
                                  • Understanding parts of an XML document
                                    • Declaration
                                    • Elements
                                    • Attributes
                                    • Root elements
                                    • Namespaces
                                  • Understanding XPath
                                  • The rest of XML
                                  • Understanding equivalence
                                • Troubleshooting guide
                                  • Nothing happened—what now?
                                  • I dropped my message and it didn't get picked up
                                  • I dropped my message and it disappears, but does not go where I expect it to go
                                • What is coupling?
                                  • Untyped messages
                                  • Implicitly ordered operations
                                  • The continuum of coupling
                                  • Definition of loose coupling
                                  • State
                                    • What is state?
                                    • Why is state expensive?
                                    • How does state relate to coupling?
                                    • Why do people feel like they need state?
                                    • How can you avoid state?
                                    • Where does all this fit into services?

                                Dan Rosanova

                                Dan Rosanova is a two-time Microsoft BizTalk MVP with over twelve years of experience delivering solutions on Microsoft platforms in the financial services, insurance, banking, telecommunications, and logistics industries, where he has specialized in high volume and low latency distributed applications. Dan has extensive experience with .NET, XML, services, and queuing. Dan is a senior architect in the Technology Integration practice at West Monroe Partners, an international, full-service business and technology consulting firm focused on guiding organizations through projects that fundamentally transform their business.
                                Sorry, we don't have any reviews for this title yet.

                                Code Downloads

                                Download the code and support files for this book.

                                Submit Errata

                                Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

                                Sample chapters

                                You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                                Frequently bought together

                                Microsoft BizTalk Server 2010 Patterns +    Microsoft SQL Server 2012 Performance Tuning Cookbook =
                                50% Off
                                the second eBook
                                Price for both: $47.10

                                Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                                What you will learn from this book

                                • How BizTalk Server 2010 works and appropriate topologies for different scenarios
                                • Structure and unit test BizTalk Server 2010 solutions
                                • Build BizTalk Server 2010 solutions that are easy to modify and expand
                                • Create compelling Business Activity Monitoring
                                • Deploy BizTalk Server 2010 solutions
                                • Consume and expose WCF Services with BizTalk Server 2010
                                • Use the Business Rules Engine to perform complex business processing decisions
                                • Leverage Parties to dynamically route messages without requiring code changes
                                • Implement convoy patterns


                                In Detail

                                Patterns and practices make or break any middleware or integration solution and are especially important with BizTalk Server 2010. Learning the best patterns to use in the appropriate context greatly increases the chances of success for any solution.

                                Microsoft Biztalk server 2010 patterns will provide a thorough introduction to BizTalk Server 2010 as a platform and guide the reader through real world lessons and examples building an advanced unified solution that can be used as a reference architecture.

                                This book will guide you beyond the basics of BizTalk Server 2010 development and give you the relevant background, theory, and techniques necessary to create successful solutions. You will learn how the BizTalk Server 2010 platform works internally and how to plan for the necessary infrastructure for an installation. You will learn how to build messaging-based solutions including content-based routing that are easy to manage and change. You will learn how to solve common integration and middleware challenges by leveraging the strengths of BizTalk Server 2010.

                                This book addresses using Microsoft BizTalk Server 2010 and associated tools to create middleware and integration solutions with established patterns and practices that increase the effectiveness and impact of your solutions.


                                This book is broken into two distinct parts. The first is a general introduction to BizTalk Server 2010 as well as the patterns commonly used in solutions built on the platform. It also includes explanations and motivations for these core patterns and practices.

                                The second part is a hands-on real world example presented in a step-by-step manner that takes the reader through a multiphase solution and builds this simple project into a robust and complex middleware integration solution.

                                Who this book is for

                                This book is targeted at the professional developer or architect tasked with creating solutions that leverage BizTalk Server 2010. It assumes experience with Visual Studio and at least a minimal exposure to any version of BizTalk Server from 2004 to the present. Development managers with a technical background will also find this book useful in guiding their implementation teams. Cursory knowledge of XML, although useful, is not required; the text does include an XML primer in the appendix.

                                Advanced BizTalk developers will learn many tips and techniques to improve the solutions they develop on the BizTalk 2010 platform.

                                Code Download and Errata
                                Packt Anytime, Anywhere
                                Register Books
                                Print Upgrades
                                eBook Downloads
                                Video Support
                                Contact Us
                                Awards Voting Nominations Previous Winners
                                Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                                Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software