Pass Your Microsoft 70-235 Exam Easy!

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

Introduction to the 70-235 Exam and BizTalk Server Fundamentals

The 70-235 Exam, officially titled "TS: Developing Business Process and Integration Solutions by Using Microsoft BizTalk Server 2006," was a key certification in Microsoft's Technology Specialist (MCTS) track. It was designed for developers and integration specialists who were responsible for building, deploying, and managing enterprise-level integration solutions. Passing this exam demonstrated a developer's proficiency in using the BizTalk Server 2006 platform to connect disparate systems and automate complex business processes. It was a validation of skills in a highly specialized and critical area of enterprise IT.

It is essential to recognize that the 70-235 Exam is long retired. The technology it covers, BizTalk Server 2006, is a legacy product that has been succeeded by many newer versions and, more significantly, by a new generation of cloud-based integration platforms. The modern equivalent of the skills tested in the 70-235 Exam would be found in certifications for Microsoft Azure Integration Services, which include technologies like Logic Apps, Functions, and API Management. This shift from on-premises servers to cloud-native services reflects the broader evolution of the IT industry.

Despite its age, the fundamental concepts and architectural patterns that were the focus of the 70-235 Exam remain incredibly relevant. The challenges of application integration, such as message transformation, process orchestration, and protocol mediation, are timeless. Studying the topics of the 70-235 Exam provides a solid and valuable education in the principles of Enterprise Application Integration (EAI) and Business Process Management (BPM). This series will explore those core principles through the lens of the BizTalk Server 2006 platform.

Core Concepts of Enterprise Application Integration (EAI)

To understand the purpose of BizTalk Server and the knowledge required for the 70-235 Exam, one must first understand the problem of Enterprise Application Integration (EAI). In any large organization, there are numerous different software applications, each designed for a specific purpose. There might be an ERP system for finance, a CRM system for sales, and a custom-built system for manufacturing. These systems often do not know how to communicate with each other, creating information silos and inefficient manual processes.

EAI is the discipline of creating a connected enterprise where data can flow seamlessly between these different applications. BizTalk Server is a "message broker" or "integration platform" that sits in the middle of these applications and facilitates their communication. Instead of building dozens of direct, point-to-point connections between every system, each system simply connects to the central BizTalk hub. This "hub-and-spoke" model dramatically simplifies the integration landscape and makes it much easier to manage.

BizTalk Server achieves this by providing three core capabilities. First, it offers "protocol mediation," allowing a system that communicates via files to talk to a system that uses web services. Second, it provides "message transformation," converting data from the format of one application to the format required by another. Third, it enables "process orchestration," allowing a developer to define a complex, long-running business process that involves multiple steps and interactions with several different systems.

BizTalk Server 2006 Architecture

A key domain of the 70-235 Exam was a solid understanding of the BizTalk Server architecture. The heart of this architecture is the "MessageBox" database. The MessageBox is a set of SQL Server databases that acts as the central message bus for the entire system. Every single message that flows through BizTalk is published to the MessageBox. This creates a highly durable and reliable system; even if a receiving application is temporarily offline, the message will wait safely in the MessageBox until it can be delivered.

This publish-subscribe model is a cornerstone of the architecture. An application or an orchestration does not send a message to a specific destination. Instead, it publishes the message to the MessageBox with certain properties. Other applications or orchestrations can then create "subscriptions" based on these properties. The MessageBox engine is responsible for matching the published messages to the active subscriptions and routing them accordingly. This completely decouples the sender from the receiver, which is a key principle of EAI.

The work of interacting with external systems, transforming data, and executing business logic is performed by various BizTalk components. "Adapters" are responsible for connecting to different applications and protocols. "Pipelines" are used to process and prepare messages as they enter or leave the system. "Maps" are used for transformation, and "Orchestrations" are used to define the business process logic. The 70-235 Exam required a developer to understand the role of each of these components.

The BizTalk Development Experience

The 70-235 Exam was a developer-focused certification, so a deep familiarity with the development environment was essential. BizTalk Server development was done within a specialized version of Microsoft Visual Studio. A developer would create a "BizTalk Project," which served as a container for all the different artifacts, or components, that made up their integration solution. These artifacts included schemas, maps, orchestrations, and pipelines.

The development experience was highly graphical and designer-based. Instead of writing thousands of lines of code, a developer would spend most of their time working with visual tools. The "BizTalk Schema Editor" was used to graphically define the structure of XML messages. The "BizTalk Mapper" provided a graphical, drag-and-drop interface for transforming one schema to another. The "Orchestration Designer" allowed a developer to draw their business process as a flowchart-like diagram.

While the primary development experience was graphical, the underlying artifacts were based on standard technologies. BizTalk schemas are standard XML Schema Definitions (XSD). Orchestrations are based on a language called XLANG/s, which is an extension of web services standards. All the artifacts in a BizTalk project are ultimately compiled into a standard .NET assembly, which can then be deployed to the BizTalk Server runtime environment.

Exam Objectives Overview

The 70-235 Exam was structured to test a developer's competency across the entire lifecycle of building an integration solution. The first major objective area focused on the creation and management of message structures. This included creating "schemas" to define the data format of the messages and creating "maps" to transform messages from a source schema to a destination schema. This is the foundation of any integration, as you must first be able to define and manipulate the data.

The second major area was the development of "orchestrations." This tested a candidate's ability to use the Orchestration Designer to model an executable business process. This included understanding all the different logical shapes, such as Receive, Send, and Decide, as well as more advanced concepts like correlation for managing long-running processes, and transaction and exception handling for building robust solutions.

The third area focused on connectivity. This included configuring "adapters" to connect to various external systems and protocols, and designing "pipelines" to process the raw message data as it entered or exited the BizTalk environment. Finally, the exam covered the deployment and management of BizTalk applications, including how to configure the solution in the BizTalk Administration Console and how to monitor the health of the running processes.

Schemas: The Blueprint of a Message

In the world of BizTalk, every message has a specific type and structure, and this structure is defined by a "schema." A deep understanding of schemas was a fundamental requirement for the 70-235 Exam. A schema is the blueprint that describes the data elements, their data types, and their hierarchical relationship within a message. BizTalk Server uses the industry-standard XML Schema Definition (XSD) language for this purpose. By using schemas, BizTalk can ensure that all the messages it processes are well-formed and valid.

For example, if you were building an integration to process purchase orders, you would first create a purchase order schema. This schema would define all the required fields, such as "PONumber" (a string), "OrderDate" (a date), and a repeating "LineItem" record that contains "ItemNumber" and "Quantity" (integers). When BizTalk receives a purchase order message, it will first validate it against this schema. If the message is missing a required field or has data of the wrong type, it will be rejected.

This strong typing and validation at the entry point of the system is critical for building reliable and robust integration solutions. It prevents bad data from entering the system and causing failures in downstream processes. The BizTalk Schema Editor in Visual Studio provided a graphical tool for creating and managing these XSD schemas.

Maps: The Art of Transformation

It is very rare that two different computer systems will use the exact same data format for the same business entity. For example, the purchase order format used by your ERP system will almost certainly be different from the purchase order format used by your supplier's system. The process of converting data from one format to another is called "transformation," and in BizTalk, this is accomplished using a "map." This was a major hands-on topic in the 70-235 Exam.

A BizTalk map is a graphical representation of the transformation between a source schema and a destination schema. The developer opens the "BizTalk Mapper" tool in Visual Studio, which displays the source schema on the left and the destination schema on the right. The developer then creates the transformation logic by drawing lines, or "links," between the elements in the source schema and their corresponding elements in the destination schema.

For more complex transformations that involved more than just direct data mapping, the BizTalk Mapper provided a rich library of "functoids." A functoid is a small piece of reusable code that can be dropped onto the mapping surface to perform a specific function. There were functoids for string manipulation, mathematical calculations, logical comparisons, and even for performing database lookups. A developer needed to be an expert in using these functoids to build complex transformations.

The Role of Schemas in BizTalk

In any BizTalk Server solution, the schema is the most fundamental artifact, a concept heavily tested in the 70-235 Exam. A schema acts as a contract, providing a precise, unambiguous definition of a message's structure and content. By leveraging the XML Schema Definition (XSD) standard, BizTalk ensures that this contract is both machine-readable and based on open standards. This allows BizTalk to validate incoming messages, ensuring that they conform to the expected format before any processing begins. This upfront validation is a cornerstone of building robust and fault-tolerant integration processes.

The importance of schemas extends beyond simple validation. The entire BizTalk development experience is schema-driven. When a developer builds a map to transform a message, they are mapping from a source schema to a destination schema. When they build an orchestration, the messages the process receives and sends are defined by their schemas. This strong typing permeates the entire platform, providing a level of compile-time checking and runtime safety that is critical for enterprise-grade integrations where data integrity is paramount.

For a developer preparing for the 70-235 Exam, mastering the BizTalk Schema Editor within Visual Studio was a primary requirement. They needed to be able to create schemas from scratch, import them from existing XSD or instance files, and define complex structures, including repeating records and choice elements, to accurately model any business document.

Creating and Validating Schemas

The 70-235 Exam required practical, hands-on knowledge of the BizTalk Schema Editor. This tool, fully integrated into Visual Studio, provides a graphical, tree-based representation of an XSD schema. A developer can build a new schema by right-clicking on the root node and adding new elements and records. For each element, they can specify its data type (e.g., string, integer, date), set occurrence constraints (e.g., optional or required), and define other properties like default values or length restrictions.

Beyond manual creation, a common task was to generate a schema from an existing document. The Schema Editor included a wizard that could take a well-formed XML instance file and automatically infer the schema structure from it. This was a significant time-saver when working with systems that could provide sample files but not formal schema definitions.

Once a schema was created, it could be validated directly within the development environment. A developer could provide a sample XML instance file and ask the editor to validate it against the schema. This allowed for rapid testing and debugging of the schema definition, ensuring that it correctly represented the business document before it was used in other parts of the BizTalk solution, such as maps or orchestrations.

Property Promotion and Distinguished Fields

One of the most important and unique concepts in BizTalk, which was a guaranteed topic on the 70-235 Exam, is the ability to access specific data fields within a message without having to load and parse the entire XML document. This is achieved through two mechanisms: "Property Promotion" and "Distinguished Fields." This capability is critical for the performance of the message routing engine.

"Property Promotion" is the more powerful of the two. A developer can select a specific element in a schema (e.g., the "City" field in a customer address) and promote it as a "property." When a message of this schema type is received by BizTalk, the engine automatically extracts the value of that promoted field and writes it into the message's "context." The context is a collection of metadata that travels with the message. The routing engine can then use this context property in its subscriptions to make routing decisions very quickly.

"Distinguished Fields" are similar but are used for accessing message data from within an orchestration. A distinguished field is easier to create than a promoted property, but it is less efficient as it does not use the context. Instead, the orchestration must use an XPath query to access the value directly from the message body. The key takeaway for the 70-235 Exam was to use promoted properties for routing and distinguished fields for access within a business process.

Introduction to BizTalk Maps

Once the structure of the messages has been defined using schemas, the next step in many integration scenarios is to transform a message from one structure to another. This is the role of the BizTalk Map, a core artifact tested in the 70-235 Exam. A map is a visual representation of the transformation logic between a single source schema and a single destination schema. It is the tool used to bridge the semantic gap between two different applications.

For example, imagine your internal application uses a customer schema with a single "FullName" field, but a partner system requires a customer schema with separate "FirstName" and "LastName" fields. A BizTalk map would be created to perform this transformation. It would take the "FullName" field from the source message, apply some logic to split the string, and then populate the "FirstName" and "LastName" fields in the destination message.

The BizTalk Mapper is the graphical tool in Visual Studio used to create these maps. It provides a design surface with the source schema on the left, the destination schema on the right, and a grid in the middle where the transformation logic is built. This graphical approach makes it easy to visualize and manage even very complex transformations.

Using the BizTalk Mapper

A developer preparing for the 70-235 Exam needed to be an expert in using the BizTalk Mapper. The most basic operation in the mapper is creating a direct link. A developer can simply click on a field in the source schema and drag their mouse to the corresponding field in the destination schema. This creates a simple, one-to-one mapping. When the map is executed, the value from the source field will be copied directly to the destination field.

The mapper also supports the automatic linking of records and fields based on their structure and naming. If the source and destination schemas have records with the same name, the mapper can be instructed to automatically link all the child fields that also have matching names. This can save a significant amount of time when mapping large schemas that are structurally similar.

The real power of the mapper, however, lies in its ability to handle more complex scenarios. It can manage complex looping structures, for example, mapping a flat list of records in the source to a nested, hierarchical structure in the destination. The developer manages this by linking the repeating record nodes in the schemas. The mapper automatically generates the necessary looping logic behind the scenes.

Using Functoids for Transformations

For any transformation logic that goes beyond a simple, direct copy, the BizTalk Mapper provides a rich library of "functoids." A functoid is a graphical object that can be placed on the mapping grid to perform a specific function. A deep knowledge of the different types of functoids was essential for the 70-235 Exam. Functoids are organized into categories based on their purpose.

The "String Functoids" category includes functoids for common string manipulation tasks, such as concatenation, finding substrings, and converting to upper or lower case. The "Mathematical Functoids" provide functions for addition, subtraction, multiplication, and other calculations. The "Logical Functoids" allow a developer to build conditional logic into the map, such as checking if a value is greater than a certain number and then outputting a different value based on the result.

The "Advanced Functoids" category contains the most powerful tools. The "Scripting" functoid allows a developer to write their own custom C# or VB.NET code to perform a transformation that is not possible with the standard functoids. The "Database" functoids can be used to perform a lookup in a SQL Server database during the mapping process to enrich the destination message with additional data. Mastering the use of these functoids was key to building sophisticated transformation maps.

Testing and Validating Maps

A critical part of the map development process, and a topic relevant to the 70-235 Exam, is testing. A developer should never deploy a map to a production environment without first thoroughly testing it to ensure it is producing the correct output. The BizTalk Mapper in Visual Studio has a built-in testing feature that makes this process easy and efficient.

To test a map, the developer simply needs to provide a sample input message, which must be a valid XML file that conforms to the map's source schema. The developer can then right-click on the map file and select the "Test Map" option. The mapper will execute the transformation in memory and display the resulting output message. The developer can then inspect this output XML to verify that all the fields have been populated correctly and that the logic of the functoids has been applied as expected.

This integrated testing capability allows for a rapid, iterative development cycle. A developer can make a change to the map, immediately test it with a sample message, and see the result. This is far more efficient than having to deploy the map to a BizTalk server and send a test message through the live environment just to validate a small change.

Introduction to BizTalk Orchestration

While schemas and maps deal with the structure and transformation of data, "Orchestrations" deal with the process and logic. An orchestration is an executable business process that can be used to coordinate the flow of messages between different systems. A deep understanding of orchestration development was the heart of the 70-235 Exam. An orchestration is created graphically in Visual Studio using the "Orchestration Designer," which presents the process as a flowchart-like diagram.

This graphical representation is not just a picture; it is the actual source code of the business process. The diagram is based on a proprietary Microsoft language called XLANG/s, which combines the concepts of the XML-based BPEL (Business Process Execution Language) with the power of the Microsoft .NET Framework. When an orchestration is compiled, it is converted into a .NET assembly that can be executed by the BizTalk Server engine.

Orchestrations are used to implement complex, long-running, and stateful business processes. For example, an order processing orchestration might receive a purchase order, send it to an inventory system to check for stock, wait for a response, and then, based on the response, either send a confirmation to the customer or send a backorder notification. This ability to manage the state and logic of a process over time is the core purpose of an orchestration.

Orchestration Shapes

The business process logic within an orchestration is defined by connecting a series of graphical "shapes" on the designer surface. A developer preparing for the 70-235 Exam needed to be an expert in the function of each of these shapes. The most fundamental shapes are "Receive" and "Send." The Receive shape is used to accept a message into the orchestration, while the Send shape is used to send a message out to another system.

To control the flow of the process, there are several logical shapes. The "Decide" shape is used to create an if-then-else branch in the process, based on a condition. The "Loop" shape allows a part of the process to be repeated as long as a certain condition is true. The "Parallel Actions" shape allows for two or more branches of the process to be executed concurrently.

Other important shapes include the "Transform" shape, which is used to execute a BizTalk map to transform a message from one format to another. The "Message Assignment" shape allows a developer to create a new message or modify an existing one using custom code. The "Call Orchestration" shape allows for one orchestration to invoke another, enabling the creation of reusable subprocesses. Mastering the use and configuration of these shapes was key to passing the 70-235 Exam.

Message and Variable Types

An orchestration is a message-driven process, so understanding how to work with messages was a core skill for the 70-235 Exam. Within an orchestration, a developer must first declare the "messages" they will be working with. Each message variable is strongly typed to a specific BizTalk schema. For example, you might declare a message variable named IncomingPO and set its type to the PurchaseOrder schema. This allows the developer to access the fields of the message in a structured way within the orchestration's code.

In addition to messages, an orchestration can also use standard .NET "variables" to hold state and data during the execution of the process. A developer can declare variables of any standard .NET type, such as strings, integers, or booleans. These variables are used in expressions within the logical shapes (like the Decide or Loop shapes) and can be used to store intermediate values during a complex calculation.

The combination of strongly typed messages and standard variables gives a developer a powerful toolset for building complex process logic. They can extract a value from an incoming message, store it in a variable, perform some calculations with it, and then use the result to populate a field in an outgoing message.

Logical Ports and Bindings

A critical concept in orchestration design, and a key topic for the 70-235 Exam, is the decoupling of the business process logic from the physical implementation details of the endpoints. This is achieved through the use of "Ports." A port is a gateway through which an orchestration sends and receives messages. When a developer is designing the orchestration, they define "logical ports."

For example, a developer might create a logical one-way send port called SendToERP. Within the orchestration logic, they will use a Send shape that sends the message to this logical port. At this design stage, the developer does not need to know the specific physical address or protocol that will be used to send the message to the ERP system. This keeps the business process logic clean and independent of the physical infrastructure.

The actual connection to the physical endpoint is configured later by an administrator, after the orchestration has been deployed. The administrator uses the BizTalk Administration Console to "bind" the logical port (SendToERP) to a physical "Send Port." This physical port contains all the specific details, such as the transport type (e.g., SOAP or FILE), the destination address, and any necessary security credentials. This separation of logical and physical ports is a cornerstone of BizTalk's flexibility.

Correlation for Stateful Processes

Many business processes are not simple request-response interactions; they can be long-running and stateful. For example, an orchestration might send a purchase order to a supplier and then need to wait for several days to receive an invoice for that specific order. This raises a critical question: when the invoice finally arrives, how does the system know which running instance of the order processing orchestration it belongs to? This problem is solved using "correlation," a vital and complex topic in the 70-235 Exam.

Correlation is the mechanism that BizTalk uses to route a message to a specific, running instance of an orchestration. It works by identifying a piece of data that is common to a set of related messages, such as a PurchaseOrderNumber or a CustomerID. The developer defines a "Correlation Set," which specifies which promoted properties will be used to uniquely identify the process instance.

The first Receive shape in a conversation "initializes" the correlation set, capturing the value of the PurchaseOrderNumber from the first message and storing it. Subsequent Receive shapes in the process are configured to "follow" that correlation set. When a new message arrives, BizTalk will look at the value of the PurchaseOrderNumber in its context and will deliver the message only to the orchestration instance that has the matching, initialized value.

Transactions and Exception Handling

To build robust and reliable business processes, a developer must be able to handle transactions and exceptions gracefully. The 70-235 Exam required a solid understanding of these advanced orchestration features. The primary tool for this is the "Scope" shape. A scope shape can be drawn around a block of other shapes in the orchestration to create a logical unit of work.

A scope can be configured as a "transaction." BizTalk supports two types of transactions. "Atomic" transactions are short-lived and provide full ACID properties (Atomicity, Consistency, Isolation, Durability). If any part of an atomic scope fails, the entire scope is rolled back. "Long-running" transactions are designed for processes that can last for hours or days. They do not hold database locks but provide a structured way to handle compensation and error handling for long-running work.

Every scope, whether it is transactional or not, can have one or more "Exception Handlers." An exception handler is a separate block of logic that is executed only if an error occurs within the main body of the scope. This allows a developer to build sophisticated error handling routines, such as catching a specific type of error, sending a notification to an administrator, and then gracefully terminating the process.

Invoking Web Services

In the era of BizTalk Server 2006, Service-Oriented Architecture (SOA) was a dominant architectural paradigm, and the ability to consume and publish web services was a critical capability. The 70-235 Exam tested a developer's knowledge of how to work with web services in an orchestration. Consuming an external web service was made very simple through the "Add Web Reference" wizard in Visual Studio.

A developer could point the wizard at the Web Services Description Language (WSDL) file of an external web service. The wizard would then automatically generate all the necessary BizTalk artifacts, including the schemas for the web service's request and response messages, and a multi-part message type to represent the operation. It would also create a "port type," which is a description of the web service's operations.

The developer could then create a port in their orchestration based on this port type. They could then use a Send shape to send the request message to the web service and a subsequent Receive shape to get the response back. This provided a seamless and strongly typed way to integrate external web services into a business process. Similarly, an orchestration could be easily exposed as a web service using a corresponding wizard.

The Role of Adapters

While orchestrations define the "what" of a business process, adapters are the components that handle the "how" of communication with external systems. A deep understanding of adapters was a core requirement for the 70-235 Exam. An adapter is a software component that provides a standardized way for the BizTalk messaging engine to communicate using a specific protocol or with a specific application. Adapters are the bridge between the internal, message-based world of BizTalk and the diverse world of external applications and transport protocols.

Each adapter is specialized for a particular type of communication. For example, the "FILE" adapter knows how to read files from and write files to a folder on the file system. The "FTP" adapter knows how to communicate with an FTP server. The "SQL" adapter knows how to execute stored procedures in or query data from a SQL Server database. By using adapters, a BizTalk developer can connect to a wide variety of systems without having to write any low-level communication code.

Adapters are classified as either "receive" adapters, which bring messages into BizTalk, or "send" adapters, which send messages out of BizTalk. Some adapters, like the SQL adapter, can do both. The use of adapters is a key part of the decoupling that BizTalk provides; an orchestration is designed to work with generic messages, and the specific details of how those messages are sent or received are handled by the adapter at the edge of the system.

Configuring Receive Locations and Send Ports

Adapters are not used directly; they are configured and managed through two administrative objects: "Receive Locations" and "Send Ports." A developer preparing for the 70-235 Exam needed to be an expert in configuring these objects in the BizTalk Administration Console. A "Receive Location" is a specific endpoint that is configured to listen for incoming messages using a particular adapter.

For example, to receive purchase order files from a specific folder, an administrator would create a new receive location. They would select the FILE adapter, and then configure its properties, such as the path to the folder to monitor (C:\Inbound\POs) and the file mask to look for (*.xml). They would also specify which "pipeline" should be used to process the incoming files. A single BizTalk server can have hundreds of different receive locations, each listening for messages from a different source.

A "Send Port" is the corresponding object for sending messages. To send a confirmation message to a partner's FTP site, an administrator would create a new send port. They would select the FTP adapter and configure its properties, such as the server address, username, and password. The send port also has filters, which define the subscription that determines which messages from the MessageBox will be picked up and sent by this port.

Common Adapters in BizTalk 2006

The 70-235 Exam focused on the set of standard, out-of-the-box adapters that came with BizTalk Server 2006. The "FILE" adapter was one of the most commonly used. It is used to read and write files to the local file system or to network shares. It is simple, reliable, and often used for integrating with legacy applications that produce or consume file-based data.

The "FTP" adapter provides similar functionality but for communicating with remote FTP servers. It supports both sending (PUT) and receiving (GET) files and includes options for security, such as using SSL/TLS. The "SQL" adapter was another critical component. It allows BizTalk to interact directly with a SQL Server database. On the receive side, it can be configured to poll a table or a stored procedure for new data. On the send side, it can be used to execute a stored procedure to insert or update data in the database.

For integrating with modern, service-oriented applications, the "SOAP" adapter was essential. It allowed BizTalk to act as both a client (consuming an external web service) and a server (exposing an orchestration as a web service). Other standard adapters included the HTTP adapter for simple web communication and the MSMQ adapter for guaranteed messaging with Microsoft Message Queuing.

Introduction to Pipelines

Before a message that is received by an adapter can be published to the MessageBox, it often needs to be processed. For example, it might need to be decrypted, decompressed, or parsed from a non-XML format. This pre-processing is the job of a "pipeline," a critical concept for the 70-235 Exam. A pipeline is a software component that processes message data as it flows into or out of BizTalk. Every receive location and every send port must have a pipeline configured.

There are two types of pipelines: "receive pipelines" and "send pipelines." A receive pipeline processes a message after it is picked up by a receive adapter but before it is published to the MessageBox. A send pipeline processes a message after it has been picked up by a send port but before it is handed over to the send adapter.

BizTalk comes with a set of standard, pre-built pipelines for common scenarios. For example, the XMLReceive pipeline is used for processing standard XML messages, and the XMLTransmit pipeline is used for sending them. These standard pipelines are often sufficient, but for more complex scenarios, a developer can create a custom pipeline to meet specific business needs.

Pipeline Components

A pipeline is not a monolithic piece of code; it is a container for a series of smaller, reusable components that are executed in a specific sequence. A developer taking the 70-235 Exam needed to understand the structure of a pipeline and the roles of its components. A receive pipeline is divided into a series of "stages," and each stage has a specific purpose. The main stages are Decode, Disassemble, Validate, and Resolve Party.

The "Decode" stage is used for tasks like decrypting or decoding the message. The "Disassemble" stage is where the main parsing work happens. A component in this stage, like the "XML disassembler," is responsible for taking the raw message stream, parsing it into one or more XML documents, and promoting the properties that are needed for routing. The "Validate" stage can then use a "XML validator" component to validate the message against its schema.

A send pipeline has the reverse set of stages: Pre-assemble, Assemble, and Encode. The "Assemble" stage is used to construct the outgoing message, for example, by using an "XML assembler" to add an envelope to an XML document. The "Encode" stage is used for tasks like encrypting or signing the outgoing message. By combining these small, single-purpose components, a developer can build a powerful message processing workflow.

Creating Custom Pipelines

While the default pipelines, like XMLReceive and PassThruTransmit, can handle many scenarios, a very common requirement is to process data that is not in an XML format. The most frequent example of this is a "flat file," such as a comma-separated value (CSV) file or a fixed-width text file. To handle this, a developer must create a "custom pipeline," a key hands-on skill for the 70-235 Exam.

The process involves creating a new pipeline in the Visual Studio Pipeline Designer. The designer provides a graphical view of the pipeline stages. To process an incoming flat file, a developer would drag the "Flat file disassembler" component from the toolbox and drop it into the Disassemble stage of their custom receive pipeline. They would then configure the properties of this component, most importantly, pointing it to the "flat file schema" that describes the structure of the incoming text file.

When this custom pipeline is used in a receive location, it will correctly parse the incoming CSV or fixed-width file and convert it into its equivalent XML representation based on the flat file schema. This XML message is what is then published to the MessageBox for use by maps and orchestrations. Similarly, a custom send pipeline with a "Flat file assembler" component can be used to convert an XML message back into a flat file format before sending it.

Adapters, Pipelines, and Orchestrations Working Together

It is essential for a candidate for the 70-235 Exam to understand how all these different components work together to process a message. The flow for a typical inbound message would be as follows. First, the message arrives at an endpoint, for example, as a file dropped into a folder. The "adapter" (e.g., the FILE adapter) configured in the "receive location" picks up the message.

The message is then passed to the "receive pipeline" that is specified in the receive location's configuration. The pipeline components execute, for example, parsing a flat file into XML and promoting key properties to the message context. The pipeline then publishes the resulting XML message to the "MessageBox" database.

At this point, the "orchestration," which has a subscription for this type of message (based on the promoted properties), is activated. It receives the message and begins to execute its business logic. The orchestration might then use a "map" to transform the message into a new format and then send the new message back to the MessageBox. Finally, a "send port," which has a subscription for the new message type, picks it up, passes it through its "send pipeline," and uses its configured "adapter" to send it to the final destination system.

Deploying BizTalk Applications

After a developer has created all the necessary artifacts—schemas, maps, orchestrations, and pipelines—in Visual Studio, the solution must be deployed to a BizTalk Server. This deployment process was a key operational topic in the 70-235 Exam. The first step is to build the BizTalk project in Visual Studio. This compiles all the artifacts into a standard .NET assembly. The developer must also assign a strong name key to the project to ensure its uniqueness and security.

Once the assembly is built, it can be deployed. A developer can deploy directly from Visual Studio, which is convenient for development and testing environments. For more controlled deployments to staging or production environments, a better practice is to create a Windows Installer (MSI) package. BizTalk provides a wizard to package all the project artifacts and their configurations into an MSI file. This file can then be handed over to a server administrator for installation.

After the assemblies are deployed, they are registered in the BizTalk management database. The final step is to create a "BizTalk Application." This is a logical container in the BizTalk Administration Console that is used to group all the related artifacts for a specific integration solution. This makes the solution much easier to manage, version, and monitor as a single unit.

The BizTalk Administration Console

The primary tool for managing a deployed BizTalk environment is the "BizTalk Administration Console." A candidate for the 70-235 Exam was expected to be completely comfortable navigating and using this tool. The Administration Console is a Microsoft Management Console (MMC) snap-in that provides a centralized view of the entire BizTalk group. From here, an administrator can perform all the necessary configuration and operational tasks.

One of the main uses of the console is to configure the physical ports for a deployed application. This is where the administrator performs the "binding" of the logical ports in an orchestration to the physical receive locations and send ports. This is also where they configure the properties of the adapters, such as file paths, FTP server addresses, or SQL connection strings.

The console is also the primary tool for day-to-day operations. An administrator can start and stop BizTalk applications, orchestrations, and ports. They can also view the status of running processes, search for messages, and troubleshoot errors. The "Group Hub" page provides a dashboard view of the health of the system, including any suspended messages or dehydrated orchestrations that may require attention.

Business Activity Monitoring (BAM)

While the standard administration console is great for technical monitoring, it does not provide visibility into the business process itself. For this, BizTalk Server provides a powerful feature called "Business Activity Monitoring" (BAM). BAM was an advanced topic on the 70-235 Exam. It is designed to give business users, such as managers and analysts, a real-time, graphical view of their business processes as they are being executed by BizTalk.

BAM works by allowing a business analyst, using a special Excel add-in, to define the key "milestones" and "data points" of a business process that they are interested in. For example, in an order process, they might define milestones like "Order Received," "Inventory Checked," and "Order Shipped." They might also want to track key data, like the "Order Amount" and "Customer Name."

A developer then uses a tool called the "Tracking Profile Editor" to map these business milestones and data points to the underlying implementation in a BizTalk orchestration. When the orchestration runs, it will automatically send this tracking data to the BAM database. Business users can then use the BAM portal, which is a web-based dashboard, to view the status of their processes, create reports, and set up alerts for specific conditions.

Business Rules Engine (BRE)

Another advanced feature covered in the 70-235 Exam was the "Business Rules Engine" (BRE). In many business processes, there is complex and frequently changing logic. For example, the rules for approving a loan application or calculating a shipping discount might change every few months. Hard-coding this logic directly into an orchestration can be problematic, as every change would require a developer to modify, recompile, and redeploy the entire process.

The BRE provides a solution to this problem by externalizing the business logic from the process logic. It allows a business analyst to define a set of business rules in a more user-friendly format, such as a decision table. These rules are then published as a "policy" that can be called from a BizTalk orchestration. The orchestration simply passes the relevant data to the BRE, which executes the current version of the policy and returns the result.

This decoupling of the rules from the process provides significant agility. When a business rule needs to change, a business analyst can use the "Business Rule Composer" tool to modify the policy and publish a new version. This change takes effect immediately, without requiring any changes to the orchestration code. This allows the business to be much more responsive to changing market conditions.

Historical Study Strategy for the 70-235 Exam

To have passed the 70-235 Exam, a candidate would have needed a study plan that was heavily focused on hands-on development. This was not an exam that could be passed by memorization alone. The most effective strategy would have been to build a complete BizTalk integration solution from the ground up in a personal lab environment. This would involve inventing a simple business scenario, such as processing a purchase order, and then building all the required components.

This hands-on practice should have covered every major topic in the exam objectives. The candidate would need to create the schemas for the purchase order and the invoice. They would need to build a map to transform one to the other, using a variety of functoids. They would then need to create an orchestration that receives the order, transforms it, and sends the invoice. Finally, they would need to configure the FILE and FTP adapters and the custom pipelines to get the messages in and out of the system.

A candidate should have spent a significant amount of time practicing with the graphical designers: the Schema Editor, the Mapper, and the Orchestration Designer. They needed to know the properties and common use cases for all the major orchestration shapes and functoids. After building the solution, they should have practiced deploying it and configuring the ports and applications in the Administration Console. This end-to-end practical knowledge was the key to success.

The Evolution to Azure Integration Services

The world of application integration has changed dramatically since the era of the 70-235 Exam. While BizTalk Server is still used in many organizations, the strategic direction for integration at Microsoft is now firmly in the cloud with "Azure Integration Services." This is a suite of services that provide the modern, cloud-native equivalent of the functionalities that were in BizTalk Server.

The modern successor to the BizTalk Orchestration engine is "Azure Logic Apps." Logic Apps provides a graphical, serverless workflow engine that allows developers to connect to hundreds of different services using pre-built "connectors." The concept is the same as in BizTalk: defining a logical process that moves and transforms data between systems. The schemas and maps from BizTalk have their direct equivalents in the "Integration Account" service in Azure, which provides a central repository for these artifacts.

BizTalk's adapters have been replaced by the vast library of "Azure Connectors," which provide connectivity to everything from Salesforce and SAP to Twitter and Office 365. The underlying messaging engine is now "Azure Service Bus," which provides the same kind of durable, publish-subscribe messaging that the BizTalk MessageBox did. An integration developer with a strong foundation in the principles of the 70-235 Exam would find the concepts in Azure Integration Services to be very familiar.

Conclusion

In conclusion, the 70-235 Exam represented a specific point in time in the history of Microsoft's integration technologies. It was a rigorous test of a developer's ability to use BizTalk Server 2006 to solve complex EAI and BPM problems. While the exam and the specific product version are now part of history, the fundamental principles it tested are more relevant than ever.

The need to connect disparate systems, to transform data between different formats, and to automate complex business processes is a challenge that every large organization still faces. The architectural patterns that BizTalk championed, such as a decoupled, message-based architecture and the separation of process logic from physical implementation, are still the best practices for building scalable and maintainable integration solutions today.

A developer who took the time to master the topics of the 70-235 Exam would have acquired a deep and valuable skill set in integration architecture. These skills provide a solid foundation for learning and mastering the modern cloud-based integration platforms of today, such as Azure Integration Services. The tools may have changed, but the core challenge of making different systems talk to each other remains, and the principles for solving that challenge endure.

Go to testing centre with ease on our mind when you use Microsoft 70-235 vce exam dumps, practice test questions and answers. Microsoft 70-235 TS: Developing Business Process and Integration Solutions Using BizTalk Server 2006 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-235 exam dumps & practice test questions and answers vce from ExamCollection.