It’s an attribute (decorating), not a preprocessor directive, that allows you to skip a well-tested method when you are using F11 to step-through your code.

When using F11 to step through your code in debug mode, you often go into helper routines that are well-tested and won’t have errors. Wouldn’t it be nice to skip over these? Wouldn’t that speed up your debugging – or at least make it less boring?

Add the “DebuggerStepThroughAttribute” before the method you want to skip.

Below is a simple routine I often use that adds a Slash to a path name, but only when it doesn’t end with a slash. It works, so I never need to walk-into it. (I guess I could also put it in a common library.)

        public static string EndsWithOneSlash(string pathname)

            // make sure we have one slash at the end of a path
            if (!pathname.EndsWith(@""))
                pathname = pathname + @"";
            return pathname;

I’m receiving a csv flat-file. It’s debatching in the pipeline, causing one orchestration to start for each row.

Sometimes I desire such behavior, but in this case I don’t.

I can’t figure out what is making it debatch. The pipeline refers to two schemas, the header and document schema.

Neither one has “Envelope=true” and thus neither had the “Body XPath” parameter set.

Any ideas what else makes it debatch?

The Flat-file disassembler does not use the Envelope semantic to debatch a message.
It uses the structure of the schemas.

If a schema has this structure


Then the Flatfile disassembler will debatch by row.

To receive the entire message change the schema to

<message><row maxOccurs=”unbounded”><field/><field/><field/></row></message>

Thanks to Greg Forsythe in the forum.

BizTalk ESB (Enterprise Serivce Bus) – Interview of Neal Walters and Yogi Veda

An Itinerary would be a sort of a travel plan for the message based on the current information the message can provide to the Itinerary processor. There can be two types of itineraries Predetermined and Dynamic. Predetermined is when the steps are always the same for a business process. Where as with the dynamic itinerary the outcome of a preceeding step might determine what the next step will be.

In our case, we built the itineraries using BizTalk’s business rule engine. The header message in our common cannonical message contains the entire itinerary, along with information about the current step. Data from the message can be used to determine what the next step should be.

BizTalk Deployment Framework

Download or read more information on CodePlex:

BizTalk 2009 Beta – Interview of Neal Walters and Yogi Veda

For more information about BizTalk 2009: BizTalk 2009 – Screen shots and article

Yogi Veda and I took a look at BizTalk 2009 Beta installed on Windows 2008 and SQL 2008.

BizTalk Admin Console – The BizTalk Admin console has many new options in the “search for” list. The HAT utility is no longer included in the “Start Programs” BizTalk tools. Instead, you would go to the BT Admin Console. And finally, tracked messages can be viewed from the utility itself (without being saved to disk).

Properties in Visual Studio BizTalk Projects – BizTalk projects now are handled more like regular C# projects. This is where you specify the strong key file, the application name, etc…

Schemas and pipelines now have .cs code, as orchestrations have in BT2006:

When you look at map propertiies, you now see them in the properties window, instead of the pop-up box.

Windows 2008 and SQL 2008

Somewhat unrelated, the Windows 2008 Task Manger now allows you to start and stop services (such as BizTalk and SSO). But “Restart” not available.

SQL 2008 – when you right-click a table, you can no longer open the entire table, you can “Select Top 1000 rows” or “Edit the top 200 rows”:

Also check out our video discussion about BT2009 Beta:
BizTalk 2009 – Video Interview

string formateddate=DateTime.Now.ToString((“dd-MM-yyyy”);

This page shows the middle of two “butt-ugly” (and complex) BizTalk Maps.

BizTalk Mapper is a plug-in to Visual Studio that allows the BizTalk developer to map from one schema to another. ?It builds XSLT behind the scene, or the developer can do the entire map in XSLT or fragments of it in XSLT.

The developer places “Functoids” from the Toolbar onto the mapping grids (shown below), and connects them . ?See bottom of this blog for example functoids.

Some maps are super simple, but others are incredible complex. ?Documents such as EDI or Rosetta Net can contain as many as 1000 or 2000 elements in the schema that can be mapped. ?It can more complex when those elements are nested and looped (i.e. occur multiple times).

Ugly BizTalk Map – First Sample

Ugly Map – Second Example

The grid can even be subdivided into tabs at the bottom. ?Even then, you can get ugly maps like the ones above. ?When you scroll the schema on the left or the right, the grid is redrawn, and the lines will move and re-draw accordingly.


When a map gets this complicated, you might want to consider re-writing it in XSLT, which is supported by BizTalk Maps. Just click on the map grid and set the “Custom XSLT Path” property to the file in your project that contains the XSLT code.

Example of a simple Functoid Map

Here is an example of a simple map and part of the ToolBox with the functoids is shown on the left. ?This image also let’s you see the schema on the left (source) and the right (target). ?I couldn’t show the schema elements in the maps above because they were proprietary.

The categories of functoids are (each one has a different color code):

  1. Advanced
  2. Conversion
  3. Cumulative
  4. Database
  5. Date/Time
  6. Logical
  7. Mathematical
  8. Scientific
  9. String (shown in last image above, the red “functoids” on the left)

Here are some videos training that I did on BizTalk Maps (from “MrBizTalk” channel on

Do you have some ugly maps? Send me your pictures to: and I’ll post them here!