A nugget of information

Pro NuGet by Maarten Balliauw and Xavier Decoster

I recently had to write a NuGet package at work, and was fairly impressed with how easy it is to take an assembly and push it into a local package store. Admittedly this was made easier by a number of tasks that were available on the build server, but even so, the reverse process of consuming by pulling packages into a Visual Studio project is also really easy. I had spent a little time looking at the implementation of NuGet, but got interested in this again after seeing how fundamental NuGet is as part of the Katana runtime which Microsoft recently announced.

So it was time to find a book on the subject, and I found this book on Amazon – it’s rather expensive but I managed to get a copy of it second hand.

The first thing to point out is that the book is several years old. With something like NuGet which is rapidly evolving, this might mean that it doesn’t cover some of the implementation. However, the book itself doesn’t go that deep into any particular area, but covers the surface area of what NuGet offers, so I don’t think the age matters. There are numerous examples and both the versions of Visual Studio and MVC that are used seem a tiny bit old now.

There’s a quick getting started on how to download the required bits and pieces, and then a walkthrough of consuming some packages inside a Visual Studio project. The book then moves on to creating packages, publishing packages (on the Microsoft Nuget gallery) and then covers how to set up your own NuGet server. It is worth pointing out that the Nuget tooling supports the repository being a simple file share, which makes it trivial to start using NuGet in a small deployment.

This coverage includes some examples of simple PowerShell scripts which can be triggered when a package is installed into a solution and when a package is installed into individual projects in the solution, as well as how you add other assets to a project when a NuGet package is associated with it.

The book then moves to a slightly higher level, discussing continuous deployment using packages as the mechanism for pushing changes. This is followed by a chapter on automated deployment which covers Octopus and Chocolatey, tools that use NuGet packages as a means for pushing entire applications (rather than pushing constituent parts of an application).

The last two chapters talk about extending NuGet itself, and about using NuGet as a protocol. It the latter chapter, the worked example is a technique for deploying plugins using NuGet.

At all times the book goes into just enough detail, letting you know what is available and setting you up to go to other sources to get the fine details. As a bonus it is an easy read.

This entry was posted in Books. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s