Using .NET to make applications play together

Enterprise Application Integration Using .NET
by Butch Clark
Addison-Wesley, 2005
482 pages, $49.99
Code in C#

You probably know the problem: there are six different systems involved in handling a simple business process, and no easy way to make them all talk to each other. This book offers one application integrator's perspective on how to come up with a .NET-based solution. You might not find yourself agreeing with Clark's approach when you get to the end of the book, but you'll probably pick out a few nuggets that make it worth reading.

Though the content is in C#, you won't find much code in the first four chapters. These chapters may be the strongest point of the entire book: they give an overview of the EAI process from the standpoint of someone who's gotten through a few projects. If you're being pushed into such a project and feel like you're over your head, it's worth going through this part of the book for tips. Clark hits the human side of the equation as well as the technology side, recognizing that both are important to any successful project.

After that, he gets into the meat of the application. The architecture is fairly simple: a Web service takes requests from any desired front end and feeds them into a database-backed EAI framework. The framework engine looks at the XML from the front end systems and routes it as appropriate to back end systems. While this is an easy to understand way to put things together, it does mean that there's pretty tight coupling between the front end and back end; I would have liked to see the back end systems abstracted with some component that could be used to cover the inevitable changes. But it's a reasonable compromise for a book's worth of code.

And there certainly is a book's worth of code here. Clark works through each component of his framework and shows large chunks of code, discussing it as he goes along. By the time he finishes, he's built a sort of lightweight analog of BizTalk and shown you how to extend it to handle new requests or to run new agents; indeed, some of the most valuable content here discusses extending the system.

Curiously, chapters on the database structure, UML, SOAP, and XML come at the end, even though those concepts are needed in earlier chapters. You may find yourself flipping back and forth quite a bit if you're not familiar with the underlying technologies. I do give him major points for setting up an online repository of the book's code, even though it doesn't appear that there's a lot going on over there yet. As an author myself, I know how tough it is to go back to a book's subject after finally getting the darned thing off your desk.

Overall, I think this is worth reading if you're looking to integrate legacy systems within a .NET-based framework. The author is the first to admit that the code he's giving away isn't a fullblown production system, but if it inspires you to design a robust implementation for your own needs, then its purpose has been met.

About the Author

Mike Gunderloy has been developing software for a quarter-century now, and writing about it for nearly as long. He walked away from a .NET development career in 2006 and has been a happy Rails user ever since. Mike blogs at A Fresh Cup.

Upcoming Events