Expert .NET Delivery Using NAnt and CruiseControl.NET und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Expert .NET Delivery Usin... ist in Ihrem Einkaufwagen hinzugefügt worden
+ EUR 3,00 Versandkosten
Gebraucht: Gut | Details
Verkauft von britbooksde
Zustand: Gebraucht: Gut
Kommentar: Einfach Brit: Wir haben von unserem England Lager Bücher von guter Zustand auf über 1 Million zufriedene Kunden weltweit versandt. Wir sind bemüht, Ihnen mit einem zuverlässigen und effizienten Service zu allen Zeiten begangen.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

Expert .NET Delivery Using NAnt and CruiseControl.NET (Expert's Voice in .NET) (Englisch) Gebundene Ausgabe – 1. Mai 2005

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Gebundene Ausgabe
"Bitte wiederholen"
EUR 68,47
EUR 26,40 EUR 3,83
10 neu ab EUR 26,40 10 gebraucht ab EUR 3,83

Hinweise und Aktionen

  • Große Hörbuch-Sommeraktion: Entdecken Sie unsere bunte Auswahl an reduzierten Hörbüchern für den Sommer. Hier klicken.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr



At first glance, building and deploying applications seem simple enough. But in fact, difficult releases without any confidence or processes backing them are very common. Integration and management of a new deployment can be laborious and fraught with risk. So as team size and volume of projects grow, management becomes more difficult and risk more pronounced. This book is a guide to the implementation of good processes in a .NET environment. Author Marc Holmes focuses on actual implementation, and details patterns and anti-patterns to watch out for. He also provides a practical and in-depth look at NAnt and CruiseControl.NET, and solutions to common problem scenarios. For additional insights, visit the author's blog, Marc: My Words.

Über den Autor und weitere Mitwirkende

Marc Holmes is one of the lucky ones he was born into a generation of home computing. His first computer, acquired at age 10, was a Commodore Vic20. This was followed up with a Commodore 64 and Holmes' first programming project: SpaceBats. He has willingly been chained to a computer since then. After studying computer science and artificial intelligence at university, Holmes has devoted his time to working and developing technology in various industries including retail, semiconductors, and media. As a developer, Holmes has written numerous systems, from WAP-based "m-commerce" applications to media management systems. Since the dotcom era, Holmes has concentrated on software design and engineering processes, following closely the introduction of the .NET platform. This currently forms the basis of his day-to-day activities. Holmes is passionate about the provision of software engineering processes as the glue that binds and industrializes software development, and he is a firm believer in software as a commodity. Currently, Holmes is the technical design authority at a global media corporation. He and the development team oversee dozens of systems from small "brochureware" sites to significant enterprise systems for human resources, customer relationship management, and logistics operations. Holmes can also be found participating in the blogosphere and in various newsgroups and discussion groups. And in his spare time, Holmes enjoys cooking, fine wine, and occasional interaction with other humans.

In diesem Buch

(Mehr dazu)
Mehr entdecken
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Hier reinlesen und suchen:


Es gibt noch keine Kundenrezensionen auf
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne

Die hilfreichsten Kundenrezensionen auf (beta) 6 Rezensionen
16 von 16 Kunden fanden die folgende Rezension hilfreich
A decent introduction to NAnt and CC.NET 13. August 2005
Von Lasse Koskela - Veröffentlicht auf
Format: Gebundene Ausgabe
I picked up "Expert .NET Delivery Using NAnt and CruiseControl.NET" as a developer familiar with the original open source projects, Ant and CruiseControl, from the world of Java development. I have been long interested in how "the .NET people" do things even though my personal experience with .NET technologies has been limited to doing a day of training every now and then. From this perspective, I have to say I find a lot of good stuff in this book but it's still missing that something. The author, Marc Holmes, clearly states in the introduction that the book's goal is not to be a comprehensive guide for the tools being used. Instead, his focus has been to show the reader a practical approach to tackling problems involved in "delivering software." I had some difficulty seeing that focus while reading.

The first chapter titled "A Context for Delivery" is actually an excellent albeit short overview of the variety of aspects involved when discussing how to manage software configuration, the build process, and the deployment process. The next couple of chapters

introduce the NAnt build tool and its essential built-in tasks. As a tutorial to NAnt, these chapters felt a bit too lightweight. Chapter 2 is an excellent tutorial for getting started with NAnt and chapter 3 briefly enumerates the most important built-in tasks available. These first three chapters were definitely the ones I liked the most.

Chapter 4 presents a simple case study, getting a GUI application for performing XSLT transformations to build with a NAnt script. The author follows through creating the script from scratch, all the way from the classic "clean" target to checking out the project from Visual SourceSafe, incrementing a version counter on assemblies, running automated tests, static analysis, and packaging the build output into a .zip file for deployment. There's some discussion of NAnt features that weren't illustrated in the previous chapters but not much more than that.

Chapter 5, titled "Process Standards", talks about the case study team refactoring their build scripts towards a structure that supports a "standard" build script to be used throughout the company's .NET projects. Very little meat in there. Most of this chapter seemed to present a topic of interest only to move on right away, without giving solutions beyond tiny snippets of NAnt tasks. As someone not familiar with most .NET concepts, I found it very difficult to follow.

Chapter 6 brings continuous integration into the picture. After a brief explanation of why one would want to implement a continuous integration process, Holmes proceeds to describe CruiseControl.NET and how to configure it to build your .NET project. Again, only superficial coverage of the configuration options available which is consistent with the stated goal of the book not being about the tools themselves. Yet, at this point I realized that the good stuff had all been about the tools -- NAnt and (to a smaller degree) CruiseControl.NET. This pattern continued through chapter 7 which talks about extending NAnt with your own custom tasks. In fact, this chapter does a good job in showing the ropes through developing a FxCop task.

Chapter 8 is a good one. It talks about techniques for dealing with the database schema in the context of continuous integration and incremental development. The example scripts do leave a sense of "magic" happening that I would've liked to know more about, but even as such this chapter can be useful for getting started with automated integration of the database alongside the application.

Chapter 9 talks about code generation (with XSLT and CodeSmith) and how to incorporate it into the build process. The examples were a bit difficult to follow and there wasn't much background on the tools (CodeSmith and XSLT) themselves.

To finish off, chapter 10 presents some closing thoughts as a summary for all the things discussed in the body of the book. Good stuff, makes a lot of sense. I find it interesting, though, that beyond the first and last chapters I found very little content that I could associate directly with practical delivery other than from the tool perspective.

As a summary, I consider "Expert .NET Delivery Using NAnt and CruiseControl.NET" to be a nice tutorial for NAnt and CruiseControl.NET. Having said that, a large part of the book seemed to be somewhat disconnected from the stated goal of showing a practical approach to problems in delivering software.
15 von 16 Kunden fanden die folgende Rezension hilfreich
Outstanding guide for automating software delivery. Concepts apply beyond .NET. 5. Juli 2005
Von James Holmes - Veröffentlicht auf
Format: Gebundene Ausgabe
Holy smokes, what a terrific book! This isn't some fluffy, shallow overview of a toolset; rather it's about real world delivery issues and dives deep into very practical, real world details.

Disclaimer: I got this book free as a giveaway for our .NET Developers Group. Some folks might think this could influence my opinion, but they'd be wrong.

What's cool about this book is that the author, Marc Holmes (no relation to me), approaches the process of designing a good delivery system/methodology just like designing good software: a few use cases with expected outcomes which are used as guidelines for building up the various scripts needed to get delivery tasks done. He's got a great blurb at the start of the book: "Design for delivery." That's how he approaches the tasks necessary to make an end-to-end solution for automated, reliable software delivery.

Marc uses one software product as an example through the entire book, starting out with a simple product then moving into more complicated configurations. He uses an evolutionary process to get the build and deployment scripts up and working. He starts out with a simple, rough build script which works, then refactors to demonstrate the power of the tools covered in the book.

The author covers NAnt fundamentals in very good detail, but he makes it clear the book's not a reference for any of the tools he uses. He covers features necessary only to get his job done, but that coverage is in great depth and is in very clear detail. He shows off some pretty cool stuff about NAnt, including how to wrap in third-party tools (FxCop, before its inclusion as a nant-contrib task, e.g.), then walks through some good tutorials on extending NAnt.

The book's centered around NAnt and CruiseControl.NET, but he also integrates other tools like FxCop and discusses how to use code generation tools to help solve complex issues in build files. CodeSmith is covered in detail for this task.

Two things make any automated delivery system particularly difficult: source control and database integration. Marc covers both topics in great depth in separate, detailed chapters. He starts out by laying out the end goal and what process standards should apply to the routines. He then moves forward with basic implementations wrapping Source Safe and database integration into the process.

A complete download of all the various build files, tools, and source code examples is available from Apress's website.

An important note: I think this book is applicable to cross-platform use. Sure the specific tools are NAnt and CruiseControl.NET (plus several other widgets), but many of the concepts are applicable to folks doing Java development using Ant and CruiseControl. Furthermore, I think this book pairs up terrifically with Steve Loughran's Java Development with Ant. Loughran's book was a terrific eye opener to me for specifics of laying out projects with abstracted build files, plus he hits testing, deployment, and library inclusion too. Both books together really help out folks using Ant/NAnt and CruiseControl/.NET.

This really is a terrific book, and a must-read for anyone looking to automate their build and delivery processes.
5 von 5 Kunden fanden die folgende Rezension hilfreich
great tools explanations 19. August 2005
Von W Boudville - Veröffentlicht auf
Format: Gebundene Ausgabe
Holmes gives you a very motivated guide to using NAnt and CruiseControl.NET. I'm from the linux/Java world, and am familiar with Ant. So the NAnt discussion was very relevant to my experience. Holmes explicitly says that this book is not a comprehensive guide to the abilities of either package. But in some ways, while not comprehensive, it may well be better than a text devoted to either [or both]. You can see in Holmes' text, very plausible ways for why and how you can use those packages. Going through the chapters, he delves into a detailed practical application. Helps you build a context in which you might use the tools for yourself.

I was unfamiliar with CruiseControl.NET. But ended up being impressed with how it lets you do this agile, continual integration. On the broader issue of explicating issues in code delivery, I tend to agree with a previous reviewer, Koskela. Who stated that the book doesn't give a bigger view than that of the tools. Though it certainly does that well.
Good information on NAnt and CruiseControl 23. Juni 2008
Von P Davies - Veröffentlicht auf
Format: Gebundene Ausgabe Verifizierter Kauf
This serves as a good introduction to NAnt and NAnt contrib. Working through the excercises was helpful. The introduction for CC.NET is also good.

I recommend this for anyone new to NAnt and CruiseControl. I caution the use of Continuous Integration. It is an excellent way to immediately identify build and integration issues; however, you have to beware of "false positives". For example, an auto-build everytime something is checked in will determine if that checkin causes a build failure with everything else that is checked in.... however, you need to do some soul-searching to determine if this is what you really want. Do you want to trap failures and correct them, or determine a development strategy ahead of time that will prevent these surprises? The continuous build isn't a bad idea, but it becomes troublesome if you are substituting that for a good development and integration plan.
2 von 6 Kunden fanden die folgende Rezension hilfreich
Great for VS.NET 2003 6. Juli 2005
Von Another Reader - Veröffentlicht auf
Format: Gebundene Ausgabe Verifizierter Kauf
Great NAnt & CruiseControl.NET reference for .NET developers. The author includes several related & helpful discussions, such as, how to apply code generation techniques. But since some of the subject tools have yet to be updated for VS.NET 2005, the samples might not work too well without a little testing. :-)
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.