I spend a great deal of time with XML data transfers, and use XSLT on a regular basis to transform, conform, or calculate the XML into formats that I can use. Originally, I used the mapping tool within Microsoft’s BizTalk Server 2002 for complex XSLT. Although it had limitations, the tool presented everything in a visual manner that made editing quick and much less painful.
When the time came to upgrade, my first instinct was to upgrade to BizTalk 2002’s younger, beefier brother, BizTalk Server 2004.
It boasted a ton of enhancements to BT’s Mapper, and to BT’s entire server package as a whole. Among other things, the mapping tool now supported
the W3C standard XML Schema files, improved XSL customization, and integration with the .NET framework.
But was it going to be worth the trouble? The mapping tool is only a small part of BizTalk Server 2004.
The entire package weighs in at over 190MB, with adapters to work with web services, SQL Server, and a business rules
engine, among other things.
If I upgraded to BT 2004 and simply used it for XSLT programming, it would be like swatting a fly
with a tactical nuclear weapon. Successful, but maybe just a little overkill for the task at hand.
That’s when I found there was another option. Altova (makers of the excellent XMLSpy), had released their own “2004” application, MapForce 2004.
Like BizTalk 2004’s mapping tool, it allowed for quick XSLT generation with a visual drawing tool and a minimum of debugging.
Not knowing what else to do, I downloaded the trial versions for both products to try them out,
basing my evaluation on ease of installation, usability, and overall functionality.
Their similarities and their differences were both surprising, as was my final choice for the product that I needed to use.
As previously mentioned, BizTalk Mapper 2004 is part of a much larger package.
Built to work with the .NET framework, SQL Server, and containing a full application suite,
the entire server package takes over 190MB.
That’s not including Visual Studio .NET, SQL Server, and several other dependencies it lists (for the full list of dependencies, click HERE).
Still, I was hoping that a custom installation would be simpler. Even when I selected the minimum components for BizTalk Mapper (64MB), I still needed to have Visual Studio .NET, MDAC 2.8,
and MXML 4.0 Service Pack 2 installed before I get started with BizTalk. After the installation was completed, I was taken to a wizard to configure
a SQL database for BT…even though I didn’t have SQL installed, and it wasn’t necessary for the Mapper.
Installation: MapForce 2004
Installing MapForce 2004 was a breeze by comparison. Built to run on Windows 98/NT/200/XP/2003, the installation weighed in at 5-8MB, depending on which platform you chose to install it on.
As long as you run one of these platforms, and run an 800MHz processor or higher(recommended), you should have no problem getting started with MapForce.
Comparing these two products at installation time really isn’t a fair fight, considering all the dependencies BT Server 2004 has to support,
but I was hoping they could simplify the install process, especially when I was only installing a fraction of the true functionality.
If you don’t have the budget to install the prerequisites for BizTalk Server 2004, you might have to go for MapForce out of necessity.
First off, anyone who uses Visual Studio .NET will be happy to see that BT’s mapping tool automatically integrates with VS.
After installing BizTalk, open up a new Visual Studio Project, and select “BizTalk Projects” to get started. Developers who normally use VS should
be in familiar territory here.
Just like its predecessor, once the source and the destination XML have been defined, the mappings can be created by drawing a line from
one of the source fields to the desired destination field(s). Since drawing a large number of data mappings can easily become
confusing, it also offers a tabbed interface, so the transformation can be grouped into sections of data mappings.
If the transformations you need require something more complex than simply mapping
data from one place to another, BT includes a pre-defined library of .NET-powered
functions to perform a wide variety of operations. Logical, mathematic, string
operations, etc., can all be easily added to the the mix of data mappings to
transform the XML into something useful.
If your transformations also require something that BizTalk’s library of functions doesn’t have, it also allows you to develop your own. BT allows you to enter
.NET code directly into the mappings. Thanks to its integration with Visual Studio, it can compile the code on-the-fly while generating the
XML transform file. Customized functions can be created through any of the .NET languages (Visual Basic, C++, C#, and J#), either by entering the code inline, or referencing it as an external assembly. If you’d rather do without all the .NET code, BT 2004 also allows you to write the function in XSLT for maximum flexibility in customization.
Once the source and the destination locations are defined, MapForce also provides a library of pre-installed functions
to aid in the creation of complex XML transformations. And like BizTalk 2004, if the list of functions doesn’t contain
the operation you need, you can create your own custom functions.
However, unlike BT, the functions are not strictly based on .NET programming. MapForce
instead offers the choice of XSLT, C++, C#, or Java to be the basis of your
functions. While it doesn’t boast the instant integration with .NET that BizTalk does,
the fact that MapForce supports functions from both C# and Java allows it the flexibility
to create XSLT that can work both inside and outside of the .NET framework.
Not all developers create applications for the .NET framework (or even Windows for that matter),
so being able to develop with portability in mind is always a plus.
One feature that I found extremely useful in MapForce 2004 was that it could easily
specify multiple sources and destinations. I could take in data from multiple XML files or databases,
and preview the XSLT code that would be generated for multiple possible transformations.
BizTalk 2004’s integration with Visual Studio gives it the power to add and compile
customized functions for you on-the-fly, and its compatibility inside of .NET applications
is virtually guaranteed. However, if .NET integration isn’t your top priority, and you want to work with multiple possible sources/destinations within XSLT, MapForce is most definitely worth a shot.
Despite its ability to integrate with VS and its .NET functions, “ease of use” isn’t a phrase that comes to mind when I think of BT’s Mapper.
For one thing, since BT was built to integrate with VS .NET, you can’t run the mapping tool without it.
If you want to run BizTalk, you’ll need to purchase and install Visual Studio first.
I already run VS, so this worked out perfect for me. However, I know there
are plenty of developers who (either by necessity or by choice), do not run
Visual Studio. Obviously, the VS integration could be seen as a double-edged
One other problem I encountered when using BT, was that even though it supported
the inline on-the-fly coding of .NET functions, it seemed to actively discourage it at the same time.
The text box where the inline code can be added is NOT resizable,
making any custom functions more than a few lines long increasingly difficult
One other pain with the inline coding was the fact that every .NET command
used within the function had to be specifically defined.
For example, if you created your custom function with Visual Basic, and tried to use
the “Mid()” command on a string, it wouldn’t work. You have to describe
the entire command “Microsoft.VisualBasic.Mid()” for it to compile along with the rest
of your project.
Again, this may not be a problem if your function is a line or two long,
but if you have something that could get a little lengthy, you’re going to be in for some
Usability: MapForce 2004
On the usability score, MapForce is way ahead of BT. After I installed it,
I had a basic XML Transformation test running in less than two minutes.
The interface is sleek, easy to run, and pretty high on the intuitive scale.
That being said, creating custom functions in MapForce is not quite as easy
as BizTalk makes it.
Unlike the Visual Studio-powered BizTalk, it can’t just throw in your custom code as you go.
It must be referenced separately within an mff(MapForce Function) file, which you
can then added into MapForce. The details of creating customized MapForce functions
are available within MapForce’s online manual, available HERE.
In terms of usability, MapForce wins hands down. Compared to MapForce,
BizTalk Mapper looks clunky and cramped. However, BizTalk does score some points
on being able to make custom functions quickly…as long as you keep them short, that is.
If you’re looking for a way to transform XML files with XSLT, and you would like to maximize the portability of your code, MapForce 2004 is definitely the way to go.
It has a sleek, simple interface that still allows for a wide variety of customization,
allowing you to use multiple languages, sources, and destinations within the XML transformation.
I’ve mentioned several times in this article that BizTalk can’t be beat for .NET integration.
If you need .NET in your development, this is the best way to go, as long as you have all the prerequisites
it needs, and get used to its comparably-clunky interface.
Incidentally, I need .NET in my developement, at least in the forseeable future. I sided with BizTalk on this one, and have been swatting flies with tactical nukes since.
About the Author:
David Handlos is a software architect from Lincoln, Nebraska. Working professionally with web-based technologies since 1998, he has also been a computer/electronics enthusiast since 1992. His “enthusiasm” has led him to work with radio communications, hardware programming, web development, XML-related applications, and most recently, Linux.
If you would like to see your thoughts or experiences with technology published, please consider writing an article for OSNews.