NuGet manages the packages of an entire solution or project.

So let's create ourselves a project to add dependencies to.

Click File New Project.

Let's make sure we're using the latest version of .net here.

Let's start by creating a console application.

So in the templates, under Visual C# > Windows, click on Console Application.

This console app will take the data from JSON files and store it in a database.

So, let's call it JsonToDb.

We'll just create it in the default directory right here.

Now we have a basic console app project that we can start coding in.

Let's take a look at which assemblies our program depends on so far.

We can do that by looking under references in the Solution Explorer.

Each of these references represents a single .NET

assembly that our application might need in order to run.

Let's take a look at one of them.

Click on one of them, and

details about the assembly will appear in the Properties window.

If you don't have the Properties window, you can right-click on the assembly and

click Properties.

Scroll down and take a look at the Path property.

This dll file extension here stands for dynamically linked library.

So, this is where the actual library file resides on the computer.

Remember in dot net we call these DDLs assemblies.

Look a little further down to runtime version,

this assembly will work with this version of dot net or later.

A computer can have multiple versions of dot net installed on it.

Look a little further down at the version property.

This is the actual version number of this specific assembly.

Looking back at this list of references, this seems like a lot of dependencies for

an app that doesn't do anything yet.

It turns out that our app as it's written right now

doesn't actually need any of these.

Visual Studio added these references when it created the project from the console

application template, because they're a commonly used assemblies.

It added them automatically because it suspects that some

time in the future we'll want them.

Having them here doesn't hurt anything,

because all the assemblies here are already part of

the .Net framework that's installed on every Windows computer.

So it's not like having these dependencies is going to increase the size of our app

to demonstrate this.

Let's go ahead and build this app.

First, let's change the build configuration to release so

that we can make sure that it's only building what's needed to

run this program on another computer.

Let's click build and then build solution.

See here that we can type Ctrl+Shift+B on the keyboard instead, the project build.

Now let's take a look at the project's bin directory.

I right clicking on the project's name and clicking Open Folder in File Explorer.

When Visual Studio builds a Windows application,

it copies all of the files that are needed to run the program into the bin directory.

Take a look inside the bin directory, and then go inside the Release folder.

All these vshost and PDB files are only used by Visual Studio.

The exe.config file allows us to change the runtime configuration of the program.

Technically, JsonToDb.exe is the only file we really need.

Notice that all of those other DLLs that were listed in references aren't here.

We just expect that they'll be on the users' computers

as part of the .NET Framework.

Most developers just leave these references here

a fun way to explore these assemblies is to look at the object browser window.

We can open it by clicking on view and

Object Browser over here on the left side of the window.

We see a list of all the assemblies that are application is using so far.

We can explore around them by clicking this triangle.

Now we can see all of the types that this assembly provides organized by name space.

To see what our program really needs in order to run, we can remove

all of the references over here by selecting them all, right clicking and

clicking remove, then confirm that we really want to remove these items.

Removing these assemblies from references just tells Visual Studio

that they shouldn't be considered dependencies of our application anymore.

I'll build the solution by typing control+Shift+B to show that the project

builds just fine without these references.

See here in the output window shows that everything built successfully,

notice that in the Object Browser there are still a few items.

Json to DB is our executable assembly MSCoreLib and

system.core are the core of the .Net Framework.

Every .Net project at a minimum has a dependency on these two assemblies.

Even though they aren't listed in the references of the project,

they're considered implicit dependencies of our project.

I encourage you to explore around these assemblies a bit to see

what these provide you.

You'll see that you can do a lot with just what's in MS core lib,

even with everything that done it provides right out of the box, inevitably

you want to leverage some libraries that don't come pre-installed with .Net.

That's where NuGet comes in our project

is about as simple as a project in visual studio can be.

In the next video let's start adding to it.