Explore ASP.NET Core by delving into MVC design, JSON web APIs, repository patterns, and adding authentication. Gain insights to confidently develop full-stack or backend applications.

asp.tar.gz

ASP.NET

MVC in ASP.NET Core - Models in ASP.NET

MVC in ASP.NET Core - Models in ASP.NET-copy

This course is for you if you’re looking to start your journey in either full-stack MVC or backend development with ASP.NET Core.

In the first half of the course, you’ll learn about the Model-View-Controller design pattern and how you can use it to organize and develop your web application. You’ll then dive into JSON web APIs which allow communication between your back-end ASP.NET application and front-end web/mobile application.

In the latter half, you’ll learn about the repository pattern, how relationships work, and how to add authentication and authorization to your application.

By the end of this course, you will have the confidence to develop your own applications in ASP.NET Core.

Developing Applications with ASP.NET Core

A quick recap of the one-to-many relationship. One object in one table is related to one or more objects in another table. For example, a category can have a list of products. However, a product belongs to one category only.



Implement a one-to-many relation in an example to understand it in the context of <t>ASP.NET</t>. You will be expanding the example from the previous lesson and then you will be applying the one-to-many relationship to it.

# Requirements

You already have an application that stores students' information such as their name, roll number, grade, and contact information. Now, you need to assign a student to a specific department. 

# Solution

One approach to this can be to add a property `Department` of type `string`. Moreover, while adding a student's information into your application, you can type out the department name. However, this can become a problem if the department name is misspelled due to a typo. During the retrieval process, any student with a department name that is misspelled will not get retrieved.

A better approach to this would be to create a new model class which would at least consist of a department name. You can expand it to include the Head of Department's (HOD) name and other properties easily and if needed. Changes in the `Departments` table will not have an impact on your `Students` tables.

## `Department.cs`

Your department model class will consist of the following properties:
  
```C#
public int ID { get; set; }
public string DepartmentName { get; set; }
public string HOD { get; set; }
```
## Navigation property

You will update your student model class to have its navigation property, which refers to `Department.cs`. These two lines will be added to your student model class.

```C#
public int DepartmentID { get; set; }
public Department Department { get; set; }
```
For your department model class, you will add this line of code:

```C#
public List<Student> Students { get; set; }
```
It has been established that one student can only belong to one department but a department can have more than one student. Hence `List<Students> Students` is your navigation property that represents a list of students.

## Scaffolding controller with views #

You will scaffold `DepartmentsController.cs` and its view. This is followed by updating your `StudentsController.cs` and its views.

## Controller

You can observe one change present in `StudentsController.cs`:

```C#
var studentContext = _context.Students.Include(s => s.Department);
```
This is used to filter and return those entries which have a foreign key assigned to them. In this case, only students who are assigned to a department.

# Code in action

Below is a working code that you can explore and **Run**.

Learn about the one-to-many relationship in ASP.NET Core.

Introduction

Getting Started

MVC in ASP.NET Core

JSON Web APIs in ASP.NET Core

Working with Repositories

Relationships

Authentication and Authorization

Appendix

Conclusion

One-to-Many