Skip navigation
The Perfect Resource for Learning NuGet

The Perfect Resource for Learning NuGet

NuGet lives in a world of its own. Initially it was bolted onto Visual Studio as an add-on, but it's now a full-fledged feature. My hunch is that a huge number of Visual Studio developers still don't really have a good feel for exactly why NuGet exists, how it works, or the true benefits it brings to the table. Frankly, that's too bad, because NuGet is insanely powerful. You're just not likely to really see its true potentially unless you've used it for a long time or unless you've, somehow, been more or less formally introduced to what it can do. Happily, I found a fantastic resource that helped me get up to speed on the benefits of NuGet in the form of Maarten Balliauw's and Xavier Decoster's Pro NuGet (Apress, 2013).

Putting NuGet into Perspective

NuGet has been available as a package manager for .NET Developers using Visual Studio for quite some time now. But I'm guessing that NuGet is used by .NET developers in a several different ways and varying degrees. However, let me outline three broad types of NuGet developers from my perspective -- as a way of setting the background and better describing the types of audiences that can benefit from NuGet.

1. Accidental NuGet Developers

Frankly, I belonged to this group for the longest time. I'd seen demos where the cool kids used NuGet to quickly and painlessly drop references and packages into their demo projects. For the longest time, I equated using NuGet with some of the whiz-bang crap that I'd always seen in demos where developers where dragging and dropping stuff onto designers. In other words, I wasn't sure if NuGet was a parlor trick or something that real developers used. Even more succinctly, when I was an 'accidental' NuGet developer, I used NuGet occasionally without really knowing why, because I simply didn't know enough about NuGet to know the benefits it provided over, say, just copying .dlls into a lib folder somewhere and simply pointing my projects at those binaries directly.

2. Practical NuGet Developers

Eventually, it didn't take too long for me to see that adding NuGet references for commonly-used libraries such as ELMAH, NUnit, and Moq, was drastically easier than downloading files from several different websites. Dropping binaries into lib folders to add references and configuring some libraries was also so much easier via NuGet that it just wasn't funny. Not only did I start looking for different ways to use as many NuGet packages as possible, but I even went as far as buying an upgrade to the third-party encryption library, Kellerman Encryption Library. I've used this encryption library for years simply so I could have a new and better version that would let me plug it in via NuGet rather than the old-school approach of moving a copy of the .dlls into a lib folder and manually adding a reference.

The problem, however, is that even though I was starting to make active use of NuGet and saw some of the benefits that it offered, I still didn't really feel like I totally understood it or feel like I was taking advantage of it the best that I could. In turn, this is when I turned to Pro NuGet after hearing about it on an ASP Insiders mailing list.

3. Strategic NuGet Developers

Where NuGet really starts to shine is when you can start to see what it does for versioning, dependencies, and overall code composition. And my guess is that this doesn't happen with most developers until they start looking at the prospect of both creating their own NuGet packages and more importantly, potentially hosting them through their own private feeds. At this point, you'll start thinking in terms of using NuGet not just for day-to-day development needs, but also as a strategic way to begin managing your own code, internal libraries, dependencies and the likes.

In fact, it's at this point that you'll start looking at code dependencies, builds, and versioning in an entirely new light. My guess is that you'll start thinking about the .NET Framework itself as being a bit bloated and monolithic and start wondering if there's a cleaner way to do things, such as creating more streamlined base libraries and then simply depend more heavily on something like NuGet to help make your code and dependencies all that much more portable.

Pro NuGet by Maarten Balliauw and Xavier Decoster

It would be a travesty if a book solely devoted to NuGet couldn't do a good job of showing readers how to better use NuGet, no matter what their current familiarity and skill level with NuGet was. To that end, there's nothing to fear from this book: It'll do a fantastic job of helping you improve your understanding and knowledge of NuGet, regardless of your current skill level.

Where this book shines, however, is in the almost infectious way in which it not only shows how to better take advantage of NuGet, but also by showing how beneficial it can be from a strategic standpoint in terms of dealing with more than just day-to-day ease of development and reference. For those reasons, this book really belongs on the desk of any .NET developer and any and all architects as a great resource and reference providing practical guidance and insights into how to tackle non-trivial issues surrounding assembly referencing and versioning.

Hide comments


  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.