Click here to Skip to main content
13,195,026 members (101,215 online)
Click here to Skip to main content
Add your own
alternative version


10 bookmarked
Posted 6 Apr 2009

Custom BizTalk Pipeline Assembler Component

, 6 Apr 2009
Rate this:
Please Sign up or sign in to vote.
A custom pipeline assembler component for BizTalk.


As part of system integration, specially when dealing with non-XML communication (flat files), a conversion is needed. It is the pipelines that come into the picture and transform the data into something that BizTalk can understand – XML. Essentially, pipelines form a channel for the messages from the adapters to the message box where they are finally delivered.

Pipelines are divided into two parts:

  1. Receive Pipeline: The receive pipeline is executed after the receive adapter. It takes up the chunk of raw data that comes from the external system, and works on it, performing tasks like validation of signatures, decryption, and transformation before disassembling it into zero or more BizTalk messages. The created messages are consumed individually by the BizTalk Server.
  2. The receive pipeline consists of four stages – Decode, Disassemble, Validate, Resolve Party. These are executed in the same sequence as they appear below:

    1. Decode: This stage would involve some pre-processing like verifying message signatures to ensure integrity, or decoding the S/MIME messages.
    2. Disassembler: It is here that a message gets converted entirely into XML format so that the messaging engine can understand it. The input is, of course, a plain text or an XML stream that is passed from the Decode stage. It is processed into one or more messages that are always in XML format.
    3. Validate: Typically, the validate component would check to see if the message is in the correct format or not.
    4. Resolve Party: As MSDN explains it, "The Party Resolution pipeline component is used to map the user security ID and the certificate subject for the client to a BizTalk Server party".
  3. Send Pipeline: It expects a complete well-formed XML message from the BizTalk engine, and then works on it to assemble it into a message that the external system can understand.
  4. Complimenting the receive pipeline, this can again be a flat file. It can also be encrypted and digitally signed before sending it out on the wire.

    The send pipeline consists of four stages:

    1. Preassemble: As the message comes to the Send pipeline, this is the very first stage that gets executed. This is basically a place holder stage that can do any pre-processing of the message before it needs to be assembled. The stage can contain up to 255 components.
    2. Assemble: Once the preassemble stage does its job, the assemble stage takes over to actually convert the message in a format that can be understood by the external system.
    3. Encode: As the message is converted to the external format, it is time to do any additional processing required on the message so that the external system can decode it properly. The processing of this stage includes S/MIME encoding, custom encryption of the message, or digitally signing it to maintain its integrity, or any other processing that can be required to encode the message.

We will cover the implementation of a custom disassembler in this article.


To start with this article, you should be familiar with the Microsoft BizTalk Server, the .NET Framework, and C#.

Using the code

Before we start, you have to get familiar with these three main interfaces:

  • IBaseComponent: Defines the properties that provide the basic information about a component.
  • IPersistPropertyBag: Works with IPropertyBag and IErrorlog to define an individual property-based persistence mechanism.
  • IComponentUI: Defines methods that enable pipeline components to be used within the Pipeline Designer environment.
  • IDisassemblerComponent: is responsible for providing the assembling functionality.

IBaseComponent: there are three properties that must be implemented, that will appear at design time in Visual Studio.

#region IBaseComponent Members

public string Description
    get { return "Testdisassembler"; }

public string Name
    get { return "Test disassembler"; }

public string Version
    get { return ""; }


IPersistPropertyBag: is responsible for getting the design time properties. If you need to have some properties be set during design time or during the deployment stage, you must add the loading and saving functionalities for those properties.

#region IPersistPropertyBag Members

public void GetClassID(out Guid classID)
    classID = new Guid("25984614-BCFD-4c47-82FC-4A2300B76438");

public void InitNew()

public void Load(IPropertyBag propertyBag, int errorLog)
    object val = ReadPropertyBag(propertyBag, "TextProperty");
    if (val != null)
        textProperty = (string)val;

public void Save(IPropertyBag propertyBag, bool clearDirty, 
                 bool saveAllProperties)
    object val = textProperty;
    propertyBag.Write("Namespace", ref val);


IComponentUI: defines the methods that enable the pipeline components to be used within the Pipeline Designer environment.

#region IComponentUI Members

public IntPtr Icon
    get { return System.IntPtr.Zero; }

public System.Collections.IEnumerator Validate(object projectSystem)
    return null;


Now, after understanding the three main interfaces, we can start implementing the components.

Assembler: you have to implement the IAssemblerComponent interface for this.

public void AddDocument(IPipelineContext pContext, IBaseMessage pInMsg)
    System.Diagnostics.Trace.WriteLine("Pipeline Assemble Stage Enter");

    msgPart = pInMsg.BodyPart;
    Stream originalStream = pInMsg.BodyPart.GetOriginalDataStream();
        if (msgPart != null)
            if (originalStream != null)
                string result = string.Empty;
                // Do Assembling and return a xml string
                byte[] arrByte = ConvertToByteArray(result);
                originalStream = (new MemoryStream(arrByte));
    catch (Exception)
        System.Diagnostics.Trace.WriteLine("Pipeline Assemble Stage Exception");
    originalStream.Seek(0, SeekOrigin.Begin);
    msgPart.Data = originalStream;
    IBaseMessage outMsg = pInMsg;
    outMsg.BodyPart.Data = originalStream;
    // promote MessageType and Schema SchemaStrongName
    // in order to the Biztalk to have a unique key
    // for evaluating subscription
    //As an example for Namespace#Root= http://TestCustomPipeline.Schema1#roottagName
    //As an example for SchemaAssembly full name=
    //TestCustomPipeline.Schema1, TestCustomPipeline, Version=,
    //Culture=neutral, PublicKeyToken=f38e6d751bb874eb

      "SchemaAssebly full name");


public IBaseMessage Assemble(IPipelineContext pContext)
    if (qOutputMsgs.Count > 0)
        IBaseMessage msg = (IBaseMessage)qOutputMsgs.Dequeue();
        return msg;
        return null;

Usage in Visual Studio

Copy the DLL and paste it into (Windows installation directory):\Program Files\Microsoft BizTalk Server 2006\Pipeline Components. Insert the DLL into the GAC, open Visual Studio, right click on the Toolbox, click Select Items -> BizTalk Pipeline Components -> select your DLL -> OK. The assembler component will be added to the toolbox. Drag and drop it into the assemble stage and have fun!!


  • Version 1.0.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Wael Al Wirr
Program Manager
Jordan Jordan
Self-motivated, creative and results-driven technology executive who is well versed and experienced in leveraging an end-to-end, holistic vision of business objectives to drive full technology / business alignment.

Skilled in grasping business needs and sudden market demand’s shifts by diving into latest business / technology trends, selecting the best fit business model / technology to create a positive reflection on revenue. His multifaceted approach has enabled him to deliver key solutions across a wide range of disciplines including design, development, UX / UI, Business Intelligence.

Technical Specialties are in .Net, Java, Spring Boot, Maven, MS SQL, Oracle, Postgesql, Redis, Javascript, Bootstrap, Angular 2.

You may also be interested in...


Comments and Discussions

-- There are no messages in this forum --
Permalink | Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.171018.2 | Last Updated 6 Apr 2009
Article Copyright 2009 by Wael Al Wirr
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid