We now have all the dependencies our JsonToDb program needs to do its job.

Now we need to do is use these libraries in our code and write the program.

Because this workshop is about package management with NuGet,

we'll leave that task for another day.

To play with some more features of NuGet, let's create a whole new project.

This time we'll create a project for an ASP.NET MVC application.

So we'll click File > New > Project.

Under Web, click ASP.Net Web Application.

For this demo, just leave the project name and location the same, and click OK.

We'll create an MVC web application and uncheck this box to host in the cloud.

Pay attention to what happens when I click OK here.

Because this is the first time I've created an ASP.NET MVC application on this

computer, it will take a bit longer than usual to create this project.

The reason for this is because most of the libraries that are needed to

create an MVC application are downloaded from NuGet.

when we look at our project,

we can see that there's already a packages.config file.

If we open the file, we can see a list of all the NuGet packages that our

project needs, and we have a lot of assemblies listed under References.

These were all installed from NuGet when the project was created.

Let's add another package to our project.

ELMAH is a popular way to add error logging to a website.

It makes it much easier to troubleshoot errors that happen

in ASP.NET applications.

Since we only have a single project in our solution, just right-click

on the project name to manage the NuGet packages for this project.

In the search bar under Browse, we'll type elmah.

Since we're creating an ASP.NET MVC application, we'll select Elmah.MVC.

Look over here in the details.

Notice that this package has a dependency on the ELMAH core library package.

Nuget packages can have dependencies on other Nuget packages.

By installing Elmah.MVC, it will install elmah.corelibrary for us automatically.

So NuGet not only manages the dependencies of our project, but

also the dependencies of those dependencies, and so forth.

Here it says that Elmah.MVC will work with

version 1.2.0 or greater of elmah.corelibrary.

Let's go back up here and expand the Options area.

These options don't only apply to the Elmah.MVC package we've selected.

Changing these options will change them for

all future packages we want to install.

But we can change these options each time we want to install, update, or

uninstall a package.

Just be aware that they will remain set that way for

the next package you want to install unless you change them again.

Here we have a few options for how to deal with dependencies.

Inside the Dependency behavior drop-down we see an option for Ignore Dependencies.

If this is selected,

then none of the dependencies of our packages will be installed automatically.

These other options allow us to control which version of the dependencies

should be used.

NuGet assumes that all packages are versioned using

the Semantic Versioning schema.

Semantic Versioning refers to three numbers separated by dots.

It's pretty straightforward.

The three numbers correspond to the major, minor, and patch version numbers.

[SOUND] When versioning the library, we should increment the major version number

when we make breaking changes to the API, meaning code that worked with the previous

version might need to be changed in order for it to work with the new version.

We should increment the minor version when we add new features to the library

that won't break any code that uses the library.

And we should increment the patch version when releasing a version that

only contains bug fixes.

Finally we can identify prerelease versions of the library

by appending -alpha, -beta and so on to the end of the version number.

When searching for NuGet libraries, we can see packages that are only in prerelease

by checking this check box here.

This is handy when we want to experiment with future versions of a library.

With Semantic Versioning in mind, the rest of these options start to make sense.

Lowest refers to the lowest version that can be used.

In the case of elmah.corelibrary, this is 1.2.0 because that's

the lowest version that Elmah.MVC says it can work with.

Highest Patch refers to the lowest minor version, but highest patch version.

In the case of elmah.corelibrary, the lowest minor version is 1.2.

But it should get the highest patch of 1.2 available.

Highest Minor would get the highest minor and

patch version for elmar.corelibrary that has a major version of 1.

Highest gets the latest and greatest non-prerelease version of the library.

By default, NuGet comes preconfigured to always install the lowest version of

the dependency.

However it's usually best to use the latest version of the library possible

because it probably contains the fewest bugs and

we can use it longer without it becoming too far out of date.

You might think that NuGet should always install the highest version that's

guaranteed to work with the library that depends on it.

In that case, we would always want the highest minor version.

The reason NuGet doesn't select this by default is because not all libraries

are versioned using Semantic Versioning.

They may use their own versioning system where a minor version may contain breaking

changes.

elmah.corelibrary uses Semantic Versioning, so

I'm going to pick Highest Minor.

This means we'll get a later version of elmah.corelibrary then we would have

had we left this at Lowest.

I mentioned earlier that NuGet packages have the ability to add files to a project

other than just libraries.

The File conflict action option here tells NuGet what to do if the file it's

trying to add already exists in the project.

We can also tell NuGet what to do when a package is uninstalled from a project.

By checking this box, we tell NuGet to uninstall any dependencies

that were installed with the package when this package is uninstalled.

The second checkbox, Force uninstall,

has to do with uninstalling packages that are dependencies of other packages.

By checking this box, NuGet can uninstall a package even if there is another package

in the project that depends on it.

In most cases we want to keep Remove dependencies checked and

Force uninstall unchecked.

Let's click the Install button to install Elmah.MVC.

Now this preview makes even more sense.

We can review here the versions of the packages that will get installed.

We can see here that instead of installing version 1.2.0 of elmah.corelibrary,

we're getting 1.2.2 instead because we chose to install the highest minor and

patch versions available.