Pass Your Microsoft 70-595 Exam Easy!

Microsoft 70-595 (TS: Developing Business Process and Integration Solutions by Using Microsoft BizTalk Server 2010) exam dumps vce, practice test questions, study guide & video training course to study and pass quickly and easily. Microsoft 70-595 TS: Developing Business Process and Integration Solutions by Using Microsoft BizTalk Server 2010 exam dumps & practice test questions and answers. You need avanset vce exam simulator in order to study the Microsoft 70-595 certification exam dumps & Microsoft 70-595 practice test questions in vce format.

Mastering the 70-595 Exam: Foundational Concepts and BizTalk Architecture

The Microsoft 70-595 Exam, officially titled "TS: Developing Business Process and Integration Solutions by Using Microsoft BizTalk Server 2010," was the definitive certification for developers specializing in this enterprise-level integration platform. Passing this exam validated a developer's expertise in designing, building, and deploying robust solutions that connect disparate systems and automate complex business processes. As a Technology Specialist exam, it was a rigorous test of the practical skills needed to leverage the full power of the BizTalk Server platform.

This certification was aimed at a specialized audience of integration developers, solution architects, and professionals focused on Enterprise Application Integration (EAI) and Business Process Management (BPM). The 70-595 Exam certified that an individual had a deep understanding of the core BizTalk architecture, including its messaging engine, transformation capabilities, and process orchestration engine. It was a testament to their ability to solve real-world integration challenges, such as connecting legacy systems to modern applications or automating cross-departmental workflows.

The exam's curriculum was comprehensive, covering the entire development lifecycle of a BizTalk solution. This included creating the data contracts (schemas), building the data transformations (maps), defining the business logic (orchestrations), and configuring the connectivity to external systems (adapters). A successful candidate needed to be proficient in the Visual Studio-based development environment and understand how all the different BizTalk artifacts work together to form a cohesive solution.

For a developer's career, earning the credential associated with the 70-595 Exam was a significant achievement. It signified a high level of expertise in a niche but critical enterprise technology. It opened doors to specialized roles as an integration specialist and was a clear signal to employers that the certified individual had the proven skills to tackle complex, mission-critical integration projects.

The Role of an Enterprise Service Bus (ESB)

To understand the importance of the 70-595 Exam, one must first understand the problem that BizTalk Server is designed to solve. In any large organization, there are dozens or even hundreds of different applications, each with its own data format and communication protocol. Getting these systems to talk to each other is a major challenge. A common but inefficient approach is to create direct, point-to-point connections between each application. This quickly becomes a complex and brittle web of integrations that is difficult to manage and maintain.

BizTalk Server acts as an Enterprise Service Bus (ESB), providing a centralized "hub and spoke" model for integration. Instead of connecting directly to each other, all the applications connect to the central BizTalk bus. BizTalk becomes the universal translator and message broker for the entire enterprise. An application simply sends a message to BizTalk in its native format, and BizTalk takes care of transforming it and routing it to the correct destination system in the format that the destination system understands.

This architectural pattern, known as a publish-subscribe model, provides a high degree of decoupling between systems. The sending application does not need to know anything about the receiving application. This makes the entire integration landscape much more flexible and resilient. If a destination system is changed or upgraded, only its connection to BizTalk needs to be updated, and none of the other systems are affected.

The 70-595 Exam is fundamentally about testing a developer's ability to build solutions that leverage this powerful ESB architecture to solve complex business integration and process automation problems.

Core Architecture of BizTalk Server 2010

A deep understanding of the BizTalk Server architecture is the absolute foundation for passing the 70-595 Exam. At the very heart of the architecture is the MessageBox database. The MessageBox is a set of SQL Server databases that acts as the central message broker for the entire system. Every single message that flows through BizTalk is published to the MessageBox. Other components, such as orchestrations or send ports, can then subscribe to receive messages of a certain type from the MessageBox.

Messages enter the system through a "Receive Port." A receive port is a logical endpoint that is associated with one or more physical "Receive Locations." A receive location is configured with a specific "Adapter," which determines the communication protocol (e.g., FILE, FTP, SQL, or WCF). When a message arrives at a receive location, it is processed by a "Pipeline," which prepares the message for the MessageBox.

Once a message is published to the MessageBox, it is picked up by a subscriber. A subscriber could be a "Send Port," which is a logical endpoint for sending a message out of BizTalk. The send port will also have a pipeline to format the message and an adapter to handle the communication with the destination system.

The other major type of subscriber is an "Orchestration." An orchestration is a graphical, executable business process that can be used to implement complex, long-running business logic. It can receive messages, transform them using "Maps," make decisions, and send out new messages. A complete mastery of this message flow and the role of each of these core components is essential.

Introduction to BizTalk Schemas

For BizTalk to be able to process a message, it must first understand its structure. The BizTalk artifact that is used to define the structure and data types of a message is the "Schema." An understanding of how to create and use schemas is a fundamental skill tested on the 70-595 Exam. A BizTalk schema is an implementation of the standard XML Schema Definition (XSD) language. It provides a formal, machine-readable definition of a message.

Even for messages that are not in XML format, such as a comma-separated flat file, you must first create an XSD schema to represent its structure. The BizTalk pipeline components will then use this schema to parse the incoming flat file and convert it into an XML representation internally. All messages within BizTalk are treated as XML.

Schemas are created in the Visual Studio-based BizTalk development environment. The tool provides a graphical schema editor that allows a developer to build the hierarchical structure of a message by defining its records and fields and setting their data types.

A critical concept related to schemas is "property promotion." This is the mechanism by which a developer can "promote" a specific field from within the message into a separate, lightweight context property. This promoted property can then be used by the BizTalk messaging engine to make routing decisions without having to load and parse the entire large message. This is a key technique for building high-performance solutions.

Understanding BizTalk Adapters

BizTalk Server communicates with the outside world through a set of pluggable components called "Adapters." Adapters are the connectors that handle the specifics of a particular communication protocol or application format. A deep understanding of the role of adapters is a core requirement for the 70-595 Exam. An adapter is responsible for both receiving messages from and sending messages to an external system.

BizTalk Server 2010 comes with a rich set of built-in adapters to connect to a wide variety of common systems. This includes transport adapters like the FILE adapter (for reading and writing files to a folder), the FTP adapter, the HTTP adapter, and the SMTP adapter (for sending emails). These adapters handle the low-level details of the protocol, allowing the BizTalk developer to focus on the business logic.

There are also application adapters, such as the SQL Server adapter. This powerful adapter can be used to poll a database table for new records, execute stored procedures, or perform insert and update operations on a SQL Server database. Other adapters provided connectivity to systems like IBM WebSphere MQ or Microsoft SharePoint.

The most modern and flexible set of adapters in BizTalk 2010 were the WCF adapters. These adapters provided a way to communicate with any system that exposed a Windows Communication Foundation (WCF) service. This made it possible to integrate with a huge range of modern web services and line-of-business applications. The exam will expect you to know the purpose of these common adapters.

The BizTalk Development Environment

All the development of a BizTalk solution is done within a specialized version of Microsoft Visual Studio. Proficiency in this development environment is a prerequisite for passing the 70-595 Exam. When you install BizTalk Server, it adds a new set of project templates and visual designers to Visual Studio. To create a new solution, a developer would start by creating a "BizTalk Project."

A BizTalk solution is typically composed of multiple projects. A common practice is to have a project for schemas, a project for maps, a project for pipelines, and a project for orchestrations. This modular approach helps to keep the solution organized and makes it easier for multiple developers to work on different parts of the solution at the same time.

The development environment provides a set of powerful, visual designers for creating the different BizTalk artifacts. There is a graphical schema editor, a graphical mapper for creating data transformations, a graphical pipeline designer, and the graphical Orchestration Designer for building business processes. These tools allow the developer to build complex solutions with a minimum of hand-coding.

Once the development is complete, the developer will build the projects, which compiles all the artifacts into a .NET assembly. They will then set a strong name key for the assembly and deploy it to the BizTalk Server management database. The 70-595 Exam will test your practical knowledge of this entire development and deployment cycle.

Preparing for the 70-595 Exam: First Principles

As you begin your preparation for the 70-595 Exam, it is essential to build your knowledge on a solid foundation of first principles. BizTalk Server is a complex product with many moving parts, and trying to learn everything at once can be overwhelming. The most effective approach is to start by mastering the fundamental message flow and the core architectural components.

Before you dive into the complexities of orchestrations or custom pipelines, you must have a crystal-clear understanding of the basic "message-in, message-out" pattern. Be able to trace the path of a simple message: it arrives at a receive location, is processed by a receive adapter and a receive pipeline, is published to the MessageBox database, is picked up by a send port subscriber, is processed by a send pipeline, and is sent out through a send adapter.

Build a simple "pass-through" application in your lab environment that does exactly this. This hands-on exercise will solidify your understanding of the core messaging engine. Get comfortable with the BizTalk Administration Console and how to create and configure the receive ports, receive locations, and send ports that form the plumbing of any BizTalk application.

By focusing on these first principles, you will build a strong mental model of how the BizTalk engine works. This architectural understanding is the foundation upon which all the more advanced topics, such as mapping, orchestration, and business rules, are built. A solid start with the fundamentals is the key to successfully navigating the challenging curriculum of the 70-595 Exam.

Data Transformation for the 70-595 Exam

A core function of any integration platform is the ability to transform data from one format to another. This is a central theme of the 70-595 Exam. In a typical integration scenario, the source application will send a message in its own proprietary format, and the destination system will expect to receive the message in a different format. BizTalk Server must be able to act as a universal translator, and the primary tools for this are schemas and maps.

The process begins with defining the structure of the source and destination messages. This is done by creating BizTalk "Schemas." A schema is a formal definition of the message's layout, its fields, and their data types. Even if the message is a non-XML format like a flat file, a corresponding XML schema must be created to represent it. All data transformation within BizTalk happens in an XML-to-XML context.

Once you have a schema for the source message and a schema for the destination message, you can create a "Map." A BizTalk map is a graphical representation of the transformation. It provides a visual designer where you can draw links from the fields in the source schema to the fields in the destination schema.

The map designer also provides a rich library of data manipulation components called "functoids," which can be used to perform more complex transformations, such as string concatenations, mathematical calculations, or logical operations. A deep and practical understanding of how to build and test these schemas and maps is a fundamental skill for the exam.

A Deep Dive into BizTalk Schemas

While a basic schema simply defines the structure of a message, the 70-595 Exam requires a developer to understand the more advanced schema concepts that are used to solve complex integration problems. One of the most important of these advanced concepts is property promotion. As mentioned before, property promotion is the mechanism for making a specific field from within a message visible to the BizTalk routing engine.

There are two types of property promotion. A "Distinguished Field" is a lightweight promotion that is used when you only need to access the value of the field from within an orchestration. A "Property Field" is a more powerful type of promotion that creates a separate, searchable context property for the field. This context property can then be used in the filter expressions of a send port or an orchestration to make routing decisions.

Another advanced concept is the use of an "Envelope Schema." An envelope schema is used to handle situations where a single file or message contains multiple, individual business documents. For example, you might receive a single XML file that contains a batch of one hundred purchase orders. An envelope schema is used to define the structure of the overall batch, while a separate schema is used to define the structure of the individual purchase order.

When this message is processed by the XML Disassembler pipeline component, it will use the envelope schema to recognize the batch and will then split it into one hundred individual purchase order messages, each of which can then be processed independently by BizTalk.

Mastering the BizTalk Mapper

The BizTalk Mapper is the graphical tool within Visual Studio that is used to create the data transformations, or "Maps." A complete mastery of the Mapper is a core requirement for the 70-595 Exam. The Mapper provides a three-pane view. The left pane shows the source schema, the right pane shows the destination schema, and the central pane is the design surface where you build the transformation logic.

The simplest type of transformation is a direct link. You can simply drag a field from the source schema and drop it onto a field in the destination schema. This creates a direct copy of the data from the source to the destination. However, most real-world transformations are more complex than this.

To handle these more complex requirements, the Mapper provides a toolbox full of components called "functoids." A functoid is a small, reusable piece of logic that can be placed on the mapping surface and connected to the source and destination fields. BizTalk provides a rich library of built-in functoids that are organized into different categories.

For example, the "String Functoids" category includes functoids for concatenating strings, finding substrings, and converting to uppercase or lowercase. The "Mathematical Functoids" category includes functoids for performing addition, multiplication, and other calculations. The "Logical Functoids" provide a way to perform conditional mapping based on the values in the source data. The exam will expect you to be proficient in using these basic functoids.

Advanced Mapping with Functoids

Beyond the basic string and mathematical functoids, the 70-595 Exam will expect a developer to be familiar with the more advanced functoids that are used to handle complex mapping logic. These advanced functoids provide the power to solve a wide range of transformation challenges without having to write custom code.

One important category is the "Looping Functoids." These are used when the structure of the source and destination schemas do not match up directly. The Looping functoid allows you to iterate over a repeating record in the source schema and create a new output record in the destination for each iteration. This is a common requirement when transforming data between different hierarchical structures.

The "Cumulative Functoids" are used for performing aggregate calculations. For example, the Cumulative Sum functoid can be used to calculate a running total as you loop through a set of records. This is useful for summarizing data during the transformation process.

For situations where the built-in functoids are not sufficient, the Mapper provides "Scripting Functoids." A Scripting functoid allows a developer to write a small piece of custom code (in C#, JScript.NET, or other languages) to perform a highly specific transformation. While custom code should be used sparingly, the Scripting functoid is a powerful tool for handling edge cases. The 70-595 Exam will test your ability to choose the correct functoid to solve a given transformation problem.

Creating and Configuring Pipelines

A BizTalk "Pipeline" is a component that is responsible for processing a message as it enters or leaves the BizTalk system. An understanding of the role and structure of a pipeline is a key topic for the 70-595 Exam. A pipeline is a sequential series of one or more components that are executed in a specific order. Each component performs a specific, focused task, such as decoding, disassembling, validating, or encrypting a message.

Every receive location and every send port in BizTalk must be configured with a pipeline. A "Receive Pipeline" is responsible for preparing an incoming message to be published to the MessageBox. A "Send Pipeline" is responsible for preparing a message that has been retrieved from the MessageBox to be sent to its final destination.

A pipeline is organized into a series of "Stages." Each stage is designed to hold a specific type of pipeline component. A receive pipeline, for example, has stages for Decode, Disassemble, Validate, and Resolve Party. A send pipeline has stages for Pre-assemble, Assemble, and Encode. This staged architecture ensures that the components are executed in the correct logical order.

BizTalk comes with several standard, built-in pipelines, such as the XMLReceive pipeline and the XMLTransmit pipeline. For many simple XML-based scenarios, these standard pipelines are sufficient. However, for more complex scenarios, such as processing flat files or encrypted messages, a developer must create a custom pipeline. This is done using the graphical Pipeline Designer in Visual Studio.

Standard Pipeline Components

The functionality of a pipeline is determined by the "Pipeline Components" that are placed within its stages. The 70-595 Exam requires you to be familiar with the most common and important of these standard components. These components are the building blocks that you use in the Pipeline Designer to create your custom pipelines.

The most important components are the "Assemblers" and "Disassemblers." A disassembler is used in a receive pipeline to parse an incoming message and to break it down into one or more individual XML messages that can be published to the MessageBox. The XML Disassembler is used for XML files and can be configured with an envelope schema to debatch a single file into multiple messages. The Flat File Disassembler is used to parse a text file (like a CSV) and convert it into XML, based on a flat file schema.

On the send side, the assembler components do the reverse. An "Assembler" is used in a send pipeline to take one or more XML messages and serialize them into a final, outgoing format. The XML Assembler is used to create an outgoing XML file, potentially by wrapping a series of messages in an envelope. The Flat File Assembler takes an XML message and converts it into a text-based flat file format.

Other important standard components include the XML Validator, which can be used to validate an incoming XML message against its schema, and various encoder/decoder components. The ability to select and configure these standard components is a core pipeline development skill.

Developing Custom Pipeline Components

While the standard pipeline components can handle a wide variety of common integration scenarios, there are times when a business requirement is too specific or complex to be handled by the out-of-the-box components. For these situations, BizTalk provides a framework for developers to create their own "Custom Pipeline Components." A high-level understanding of this capability is relevant for the 70-595 Exam.

A custom pipeline component is a .NET class that is written by a developer to perform a highly specific piece of logic. This could be anything from decompressing a zipped file, decrypting an encrypted message using a proprietary algorithm, or calling an external service to enrich a message with additional data. The component is then compiled into a DLL and can be added to the Visual Studio toolbox to be used in the Pipeline Designer just like a standard component.

Developing a custom pipeline component requires a developer to implement a specific set of .NET interfaces. These interfaces allow the component to be plugged into the BizTalk pipeline engine and to interact with the message as it flows through.

While the 70-595 Exam will not require you to write the code for a custom pipeline component, it will expect you to understand what they are and the scenarios in which they would be needed. It is a key part of the extensibility story of the BizTalk platform, demonstrating that if the built-in functionality is not sufficient, a developer always has the option to extend the platform with their own custom code.

Orchestrating Business Processes for the 70-595 Exam

While BizTalk's messaging engine is excellent at routing and transforming individual messages, many real-world business processes involve more complex, long-running, and stateful logic. The component in BizTalk Server that is used to model and execute these processes is the "Orchestration." A deep and practical understanding of orchestration development is a major part of the 70-595 Exam. An orchestration is a graphical, executable representation of a business workflow.

Orchestrations are created using a visual tool in Visual Studio called the Orchestration Designer. This designer provides a surface that looks like a flowchart and a toolbox of shapes that can be dragged onto the surface to build the process logic. Each shape represents a specific action, such as receiving a message, sending a message, calling a transformation, or making a decision.

This graphical approach allows developers to model complex business processes in a way that is intuitive and easy for business analysts to understand. The final orchestration is then compiled into a .NET assembly and deployed to the BizTalk Server, where the orchestration engine can execute it.

An orchestration can be used to implement a wide variety of patterns, from simple request-response scenarios to complex, long-running workflows that may take days or even weeks to complete. The 70-595 Exam will test your ability to use the various orchestration shapes to correctly implement a given business process requirement.

Core Orchestration Shapes

The logic of an orchestration is built by connecting a series of "Shapes" from the toolbox. The 70-595 Exam requires you to be an expert in the use of the most common and fundamental shapes. The most basic of these are the Receive and Send shapes. A Receive shape is used to activate an orchestration or to receive a subsequent message in a running process. A Send shape is used to send a message out from the orchestration.

To work with messages, you must first define "Message" variables within the orchestration. Each message variable is strongly typed to a specific BizTalk schema. When a Receive shape gets a message, it populates one of these message variables. When a Send shape sends a message, it sends the content of one of these variables.

To create a new message within an orchestration, you use a Message Assignment shape. Inside this shape, you can write code to construct a new XML message. A Transform shape provides an easy way to create a new message by executing a BizTalk Map. You configure the shape with the input message, the map you want to use, and the output message.

The Expression shape is a general-purpose tool that allows a developer to write a small piece of .NET code to perform calculations or to manipulate the variables within the orchestration. A mastery of these core shapes is the first step to building any functional business process.

Managing Logic and Flow Control

Beyond simply sending and receiving messages, an orchestration must be able to implement business logic and control the flow of the process. The 70-595 Exam will test your ability to use the specific orchestration shapes that are designed for flow control. The most important of these is the Decide shape, which is used to implement an "if-then-else" branching logic.

The Decide shape has one or more branches, each with a rule. The orchestration engine will evaluate the rules in order, and the first branch whose rule evaluates to true will be executed. The rules are written as simple expressions that can check the value of a variable or a promoted property on a message. This allows the orchestration to take different paths based on the data it is processing.

For repetitive tasks, the Loop shape can be used. The Loop shape allows you to define a condition, and the shapes placed inside the loop will be executed repeatedly as long as the condition remains true. This is useful for processing a series of records or for retrying an operation until it succeeds.

For situations where you need to perform multiple tasks at the same time, the Parallel Actions shape can be used. You can define two or more branches within the parallel shape, and the orchestration engine will execute all the branches concurrently. The orchestration will only continue past the parallel shape after all the branches have completed their work.

Correlation and Convoys

A simple orchestration might just receive one message and send one message. However, many real-world business processes are long-running and involve a "conversation" of multiple related messages. For example, a process might start when it receives a purchase order, but then it must wait to receive a separate shipping notification and an invoice before it can complete. The mechanism in BizTalk for managing these stateful conversations is "Correlation," a complex but critical topic for the 70-595 Exam.

Correlation is the process by which the BizTalk engine determines which specific, running instance of an orchestration a new incoming message should be delivered to. For the first message that starts an orchestration, this is not a problem. But for the subsequent messages in the conversation, the engine needs a way to route them to the correct running instance.

This is done by defining a "Correlation Set." A correlation set is a list of one or more promoted properties from the messages in the conversation. For example, a correlation set for an order process might be based on the "PurchaseOrderNumber" property. The first Receive shape in the orchestration will initialize this correlation set with the PO number from the first message.

Subsequent Receive shapes that are waiting for the shipping notice and the invoice will then be configured to follow this correlation set. When a new shipping notice arrives in BizTalk, the engine will look at its PO number and deliver it to the specific orchestration instance that was initialized with that same PO number. This is how BizTalk manages the state of thousands of concurrent, long-running processes. A "convoy" is a specific orchestration pattern that uses correlation to receive a set of related messages in a specific order.

Implementing Transactional and Compensating Logic

Many business processes require a degree of transactional integrity. BizTalk orchestrations provide a powerful feature for managing both short-lived, atomic transactions and complex, long-running transactions. The ability to use this feature is a key skill for the 70-595 Exam. This is all managed through the Scope shape. A Scope shape allows you to group together a set of orchestration shapes into a logical unit of work.

A scope can be configured to be "Atomic." An atomic scope behaves like a classic database transaction. All the work performed within the scope is treated as an all-or-nothing operation. If any part of the work fails, the entire scope is rolled back to its initial state. This is ideal for short-lived transactions that involve updates to transactional systems like a SQL Server database.

For long-running processes, an atomic transaction is not practical, as it would hold locks for too long. For these scenarios, a scope can be configured as "Long-Running." A long-running transaction does not use database locks. Instead, it relies on a pattern called "compensation" to undo its work in the event of an error.

For a long-running scope, a developer can create an "Exception Handler" block to catch errors and a "Compensation" block. The compensation block contains the logic to explicitly undo the actions that were successfully completed before the error occurred. For example, if a process booked a hotel and then failed to book the flight, the compensation block would contain the logic to cancel the hotel booking.

Calling External Code and Services

While the orchestration designer provides a rich set of shapes for building business processes, there are times when you need to perform a piece of logic that is too complex to be implemented with the standard shapes. For these situations, an orchestration provides several ways to call external code and services. An understanding of these integration points is relevant for the 70-595 Exam.

The simplest way to call external code is to reference a standard .NET assembly from your BizTalk project. Once the assembly is referenced, you can create a variable in your orchestration that is of a type defined in that assembly. You can then use an Expression shape or a Message Assignment shape to call the methods of that class. This is a powerful way to leverage existing .NET business logic within your orchestration.

For integrating with external services, an orchestration can be configured to call a web service. The process typically involves using the "Add Generated Items" wizard in Visual Studio to consume the WSDL (Web Services Description Language) of the external service. This wizard will automatically create the necessary BizTalk artifacts, including the schemas for the request and response messages and the port types for communicating with the service.

The developer can then use Send and Receive shapes in their orchestration to call the web service and receive the response. This provides a seamless way to integrate the business process with external or internal services as part of the overall workflow.

Error Handling in Orchestrations

A robust business process must be able to handle exceptions and errors gracefully. The 70-595 Exam requires a developer to know how to implement effective error handling within a BizTalk orchestration. The primary mechanism for this is the Scope shape. In addition to being used for transactions, a scope can be used to group a block of work and to attach one or more "Exception Handler" blocks to it.

An exception handler block is very similar to a catch block in a programming language like C#. You can create a handler block that is configured to catch a specific type of exception. For example, you could have one handler for general system exceptions and another for a specific type of business exception that your process might throw.

If an error occurs within the main block of the scope, the orchestration engine will immediately halt the processing of that block and will look for a matching exception handler. If a match is found, the engine will execute the shapes within that handler block. This allows the developer to implement a clean and structured error handling strategy.

Within the exception handler, the developer can perform a variety of actions. They could log the details of the error to a logging system, send a notification email to an administrator, or send a specific error message back to the calling application. Proper use of scopes and exception handlers is the key to building resilient and reliable business processes.

System Integration Patterns for the 70-595 Exam

The core purpose of BizTalk Server is to integrate different systems, and the 70-595 Exam thoroughly tests a developer's ability to implement common integration patterns. These patterns are reusable solutions to common integration problems. A developer must understand these patterns and know how to build them using the various BizTalk components, particularly adapters.

A very common pattern is "Content-Based Routing." In this pattern, BizTalk receives a message and inspects a piece of its content or metadata to decide where it should be sent. This is typically implemented using a receive port that promotes a specific property from the message. A series of send ports can then subscribe to receive messages based on a filter expression that checks the value of this promoted property.

Another common pattern is the "Aggregator," where a process needs to collect a series of related messages and combine them into a single, composite message. This pattern is often implemented using an orchestration with a looping construct and a correlation set to collect the individual messages before assembling the final, aggregated message.

The "Broadcast" pattern is used when a single incoming message needs to be sent to multiple, different destination systems. This is easily implemented in BizTalk by having multiple send ports that all subscribe to the same message type. The publish-subscribe architecture of the MessageBox makes this pattern very simple to build. The 70-595 Exam will expect you to be able to apply these patterns to solve scenario-based problems.

Configuring File, FTP, and Email Adapters

The simplest and most common way to integrate with many applications is through the exchange of files. The 70-595 Exam requires a developer to be proficient in configuring the standard file-based adapters. The FILE adapter is used to read files from and write files to a local or network folder. On a receive location, the FILE adapter is configured with a path to a folder and a file mask (e.g., *.xml). It will periodically poll this folder and pick up any files that match the mask.

On a send port, the FILE adapter is configured with a destination folder and a filename convention. It will write the outgoing message to a file in that folder. The adapter has various properties for controlling its behavior, such as whether to delete the source file after it has been read.

The FTP adapter works in a very similar way but is used for communicating with a remote FTP server. It has configuration properties for the FTP server name, the username and password, and the remote folder path. It supports both sending (FTP PUT) and receiving (FTP GET) files.

The SMTP adapter is a send-only adapter that is used to send messages from BizTalk as the body of an email. It is configured with the address of an SMTP server and allows the developer to dynamically set the "To," "From," and "Subject" lines of the email from within the BizTalk solution. A solid understanding of the configuration options for these basic adapters is a fundamental skill.

A Deep Dive into the SQL Server Adapter

Integrating with relational databases is a very common requirement in enterprise integration, and the BizTalk adapter for SQL Server is a powerful tool for this purpose. A deep understanding of the capabilities of the SQL adapter is a key topic for the 70-595 Exam. The SQL adapter can be used in several different modes to interact with a SQL Server database.

On a receive location, the SQL adapter is typically used in "polling" mode. The administrator can configure a polling statement (a SELECT statement or a stored procedure) that the adapter will execute periodically. If this query returns any data, the adapter will create a message from the result set and publish it to BizTalk. This is a common way to detect new or changed records in a database table.

On a send port, the SQL adapter can be used to execute data manipulation statements against the database. A developer can configure the send port to perform INSERT, UPDATE, or DELETE operations. The data for these operations is taken from the content of the outgoing BizTalk message. This allows BizTalk to, for example, receive a purchase order from one system and then insert that order into a database table in another system.

The SQL adapter provides a highly flexible and powerful way to integrate directly with the data layer of an application. The 70-595 Exam will expect you to understand these different operational modes and the types of scenarios in which the SQL adapter would be the appropriate integration choice.

Introduction to the WCF Adapters

For integrating with modern, service-oriented applications, BizTalk Server 2010 provided a comprehensive suite of adapters based on Windows Communication Foundation (WCF). An understanding of these WCF adapters is a critical part of the 70-595 Exam curriculum. WCF is a unified programming model for building service-oriented applications, and the WCF adapters allow BizTalk to communicate with any standard WCF service.

The WCF adapters provide much more flexibility and control than the older, basic adapters like the SOAP and HTTP adapters. There are several different WCF adapters, each tailored to a specific WCF binding. The WCF-BasicHttp adapter is used to communicate with basic web services that are compatible with the original ASMX web services standard. The WCF-WSHttp adapter is used to communicate with more advanced services that support the WS-* standards for security and reliability.

The WCF-Custom adapter is the most flexible and powerful of all. It allows an administrator to configure every single aspect of the WCF binding and behavior, enabling communication with almost any type of WCF service. There are also specific WCF adapters for connecting to SQL Server and SAP.

These adapters can be used on both receive locations (to expose BizTalk functionality as a WCF service) and on send ports (to consume an external WCF service). The move to WCF was a major part of the BizTalk 2010 release, and a developer must be comfortable with the purpose of these different adapters.

Consuming WCF and Web Services

A very common integration task is to have a BizTalk process call an external web service to retrieve data or to perform an operation. The 70-595 Exam will test your ability to configure a BizTalk solution to consume a WCF or a standard web service. The process is made relatively simple by a set of wizards that are built into the Visual Studio development environment.

The process begins with the "BizTalk WCF Service Consuming Wizard" or the "Add Service Reference" wizard. The developer provides the wizard with the address of the metadata endpoint for the service (the WSDL or MEX address). The wizard will then connect to the service, download its metadata, and automatically generate all the necessary BizTalk artifacts that are needed to communicate with it.

This includes the BizTalk schemas that represent the request and response messages for all the operations of the service. It also includes a multi-part message type for each operation and a logical "port type" that defines the interaction. The wizard will also generate a "binding file," which is an XML file that contains all the pre-configured information needed to create a physical send port to communicate with the service.

Once these artifacts are generated, the developer can use them within an orchestration. They can create a logical port, bind it to the generated port type, and then use Send and Receive shapes to call the service's operations. This wizard-driven approach greatly simplifies the process of service integration.

Publishing Orchestrations as WCF Services

In addition to consuming external services, a BizTalk developer must also know how to expose a BizTalk process as a service that can be called by external applications. This is another key integration scenario covered in the 70-595 Exam. The "BizTalk WCF Service Publishing Wizard" is the tool that is used to accomplish this.

This wizard allows a developer to take a BizTalk orchestration or a BizTalk schema and publish it as a WCF service. The wizard guides the developer through the process, asking them to choose the type of service they want to create and which BizTalk artifacts they want to expose as service operations.

When the wizard is complete, it generates a complete WCF service, including an .svc file and a web.config file, which can be hosted in Internet Information Services (IIS). This generated service acts as a bridge. When an external client calls this service, the service will receive the request and automatically publish a corresponding message into the BizTalk MessageBox.

This message can then activate an orchestration or be routed to another system. This allows external applications to easily and securely initiate a business process within BizTalk using standard web service protocols. The ability to both consume and publish services is a key skill for any integration developer.

Conclusion

While the BizTalk Administration Console is excellent for technical monitoring, business users often need a way to track the status of a specific business process without having to understand the technical details. Business Activity Monitoring (BAM) is the feature in BizTalk Server designed to provide this business-level visibility, and an understanding of its concepts is part of the 70-595 Exam.

BAM allows a developer to define a business-friendly view of a process. This involves defining "Activities," which represent a business process like "Order Processing," and "Milestones," which are the key stages within that process (e.g., "Order Received," "Shipped," "Invoiced"). The developer also defines the key pieces of business data they want to track, such as the "Order ID" or "Customer Name."

The developer then uses a tool called the Tracking Profile Editor to create a graphical mapping between the items in their business activity and the actual messages and fields in their technical BizTalk solution. For example, they would map the "Order Received" milestone to the firing of a specific Receive shape in an orchestration.

Once this is deployed, as messages flow through the BizTalk solution, the BAM engine will intercept the specified events and data and store them in a separate BAM database. Business users can then use tools like the BAM Portal or an Excel add-in to view the status of their processes in real-time, using the familiar business terms that were defined in the activity.

Go to testing centre with ease on our mind when you use Microsoft 70-595 vce exam dumps, practice test questions and answers. Microsoft 70-595 TS: Developing Business Process and Integration Solutions by Using Microsoft BizTalk Server 2010 certification practice test questions and answers, study guide, exam dumps and video training course in vce format to help you study with ease. Prepare with confidence and study using Microsoft 70-595 exam dumps & practice test questions and answers vce from ExamCollection.