When Visual Studio set up our project for

us, it created a number of files organized into a set of folders.

When you're first learning MVC, it's helpful to familiarize yourself

with the overall structure and organization of your project.

Before we do that, let's talk a little bit about the MVC design pattern.

Well before we do that, let's talk in general about design patterns.

Over the decades that developers have been creating software,

they noticed a set of problems that kept coming up time and time again,

some of these problems were so common that developers realized it would be helpful to

describe their solutions in very general terms and then share them with others.

That way developers everywhere, regardless of what specific

technology they were using, could learn and benefit from these efforts.

These solutions often represented as written descriptions, or

templates, are referred to as design patterns.

So, what is in MVC?

MVC is a design pattern.

In fact, MVC is a very common design pattern

used by developers to create all sorts of applications including websites and

mobile applications like iPhone or Android apps.

Let's take a closer look.

MVC is an acronym that stands for Model-View-Controller.

For now, think of the model as the data in your website,

the view is the visual part, and the controller as the coordinator.

When users browse to a specific page in our website,

the controller is responsible for coordinating what specific actions

need to be performed in order to return a response to that user request.

At this point,

don't worry if you don't fully understand how the MVC pattern works.

For this workshop, it's good enough to know that there's something

called a model, a view, and a controller.

In future courses, we'll explore the MVC design pattern in greater detail.

Let's take a look at the project that Visual Studio created for us.

Within Visual Studio,

we can use the Solution Explorer panel to see our project's folders and files.

If you're not able to see this panel,

you can display it by selecting the View, Solution menu item.

We can make more room for

the Solution Explorer by clicking the pin here on the Properties panel,

and while we're at it, let's go ahead and collapse the output panel, there.

Now we have more room to see the folders and files in our project.

Let's start by looking at the heart of our website.

The Controllers folder contains all the files for our controllers.

If we double-click it to expand it,

we see that we have just one controller, our Home Controller.

The Models folder contains all the files for our models.

Hmm, that's interesting.

There aren't any files here.

Remember though, models are used to represent data within our website.

But our website doesn't work with any data, at least for now.

So, the Models folder is empty.

The Views folder contains all the files for

our views, organized into folders, one folder for each of our controllers.

Remember, we just have the Home Controller now, so

that means we have just the one Home sub folder.

Looking inside the Home sub folder,

we can see there are three files, About.cshtml,

Contact.cshtml, and Index.cshtml.

We'll take a closer look at these files in a bit.

The Shared folder contains views that are shared across our controllers.

The _ Layout.cshtml file, often referred to as the layout or master page,

is used to specify the overall look and feel for every page on our website.

Later in this workshop, we'll be making changes to this file.

Most websites have CSS and JavaScript files, and ours is no exception.

The Content folder contains all of our website's CSS files,

while the Scripts folder contains all of our website's JavaScript files.

For now, we're going to ignore everything else that we see here, but

don't worry, we'll be taking a closer look in future courses, so

in time, you'll be familiar with every part of a MVC project.

Not every aspect of our project's folder structure is required by ASP.NET MVC.

That being said, the majority of projects will look very similar to,

if not exactly like, our project's folder structure.

Following the standard project structure makes it easier for

other developers to quickly find what they're looking for.

Now that we're more familiar with the parts of our project,

let's work on adding a new page to our website.