Inside the Microsoft® Build Engine:
Using MSBuild and Team Foundation
Build (PRO-Developer) by William
Bartholomew
Fantastic Reference For Integrating Team Foundation Build With Msbuild, Not For
Beginners
As software complexity increases, proper build practices become ever
more important. This essential reference drills inside MSBuild and shows
how to maximize your control over the build and deployment process.
Learn how to customize and extend build processes with MSBuild and
scale them to the team, product, or enterprise level with Team Foundation
Build. Discover how to: Create and modify MSBuild files outside the Visual
Studio IDE Use XML-based syntax to declare dynamic properties and
items Apply built-in tasks or write your own Customize the build process
adding code generation, unit testing, or code analysis Use batching and
incremental builds to reduce build times Invoke external tools in scripts and

create reusable files Start and stop services Set assembly versions and
extend the clean process Configure, customize, and extend Team Build
and automate build from end to end
Personal Review: Inside the Microsoft® Build Engine: Using
MSBuild and Team Foundation Build (PRO-Developer) by
William Bartholomew
When the Microsoft Developer Division sat down to consider the future
of .NET development from v2.0 onwards, they recognised the build
process in Visual Studio .NET was primitive in its facilities. It had to be re-
architected to provide a much more flexible and extensible mechanism.
Thus the re-engineering endeavour that brought us MSBuild. Although it
was modeled after NAnt and featured some intriguing concepts,
widespread adoption was not achieved. As in, conscious manipulation and
customisation.
Sure, most developers simply think Ctrl-Shift-B when "build" is mentioned;
it remains an invisible compile tool in Visual Studio in their eyes. But for
those who did knew the advent of MSBuild, the woefully inadequate
documentation prevented many from properly understanding the arcane
concepts it brings to the table. Lack of understanding directly affects
utilisation. I was one such individual who struggled last year to find
relevant material to explain what I needed to know and do to achieve what
I thought were pretty common build steps. Suffice to state I was
disillusioned and disappointed.
Which brings me to this executive summary: I wished Inside the Microsoft
Build Engine: Using MSBuild and Team Foundation Build was published
last year when I needed it.
This book is what the stock documentation should have been. Sayed
Ibrahim Hashimi and William Bartholomew must have realised that -
developers were not getting much out of those materials - and wrote the
first three chapters of Part 1 to slowly and meticulously explain the
concepts and important elements one works with in MSBuild. When
necessary, line-by-line details are elaborated, and the MSBuild samples
are always accompanied by sample prints of the console screen output as
well to illustrate the point. While this is no excuse for relieving folks from
trying things out themselves, it runs the extra mile to help me understand
the theory since I tend to read while commuting. Being able to finally grasp
those elusive concepts was a joyous event.
The book also covers extensibility avenues, teaching the underlying
framework and showing how to develop custom tasks and loggers, even
how to refactor the MSBuild project elements into smaller files; they give a
clearer picture how all these pieces combine together to form the entire
build workflow and possible extensibility points for one to inject custom
targets and tasks. But this book is not just about the official stock product
either; the authors recognise weak points in the current implementation

and devote a significant portion of the book to suggest a variety of
alternative solutions from third-party add-ons from CodePlex or Tigris to
overcome problems that may be commonly encountered by build teams.
Differences between MSBuild 2.0 and 3.5 are also noted to provide
readers with heightened awareness of what they can or cannot do with a
particular version. The last Part that details working with Team Foundation
Build is also an extremely helpful segment that I have been dying to know
how builds are implemented and managed in Team Foundation Server.
As much as I love this book for filling critical gaps in my MSBuild
knowledge, one thing that I did find lacking was a full-fledge demonstration
of how to define an end-to-end build project that does different things all
based on conditions from the previous steps. Like, invoking code analysis
only if unit tests all pass, building and deployment release configuration
only if debug configuration passes tests, emailing to the team the statistics
or status of deployment, etc. Many of the demonstrations are isolated in
their demonstration. While the content has done a fine job explaining the
individual concepts, MSBuild as an XML-based semantic still remains
highly arcane; more unified samples would have helped many. There is no
mention of [..] either, which probably means it is not as popular as I was
led to think.
Any build engineer or developing tinkering with project builds, absolutely
needs to read this book. It will fill many of the blanks the standard
documentation never provided, and widen your search for better ideas to
improve your build.
Overall rating: 9/10
Good: Must-have supplement to SDK docs; meticulous explanations;
liberal alternative recommendations
Bad: could have demonstrated more unified, sophisticated build
sequences with conditional paths; no [...]
For More 5 Star Customer Reviews and Lowest Price:
Inside the Microsoft® Build Engine: Using MSBuild and Team Foundation Build (PRO-
Developer) by William Bartholomew 5 Star Customer Reviews and Lowest Price!