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

## POST

You will create an action method to handle POST requests and call it `PostUser()`. It will take the object `User` as an input parameter.

### Code snippet

[HttpPost]
public async Task<ActionResult<User>> PostUser(User user)
{
    _context.Users.Add(user);
    await _context.SaveChangesAsync();

    return CreatedAtAction("GetUser", new { id = user.ID }, user);
}

### Explanation

The method is annotated with `[HttpPost]`. This will help the framework identify the request type. The route will be `/Api/User` with request type POST. 

Your action method return type is `Task<ActionResult<User>>`. Break this down to get a better understanding of what is going on:

* `ActionResult<>`: The return type could be `User` but that would not be able to handle exceptions. A different return type is needed for exceptions. To allow the return type to be either `User` or an exception, use `ActionResult<>`.
* `Task<>`: This allows a task to be performed asynchronously.

Similar to your controller that returned views, you are adding new data into your tables. First, you call the database context with `_context`. Then, you are referring to the Users' table with `.Users` and tell the framework to add a new object into it with the help of `.Add(user)`. After that, you are saving changes that have been made to your database asynchronously.

```C#
_context.Users.Add(user);
await _context.SaveChangesAsync();
```
Lastly, the return statement:

```C#
return CreatedAtAction("GetUser", new { id = user.ID }, user);
```

The `CreatedAtAction()` method takes three parameters: _actionName_ of type string, _routeValues_ which will be an object, and `user`, which will also be an object. In _actionName_, you will pass the name of the action method to use for generating the URL. _routeValues_ is responsible for generating routes with respect to some parameters which is `ID` in this case.

## PUT

To implement HTTP PUT, you will create an action method and call it `PutUser()`. It will take two parameters as inputs, an `id` of type integer and an object `User`. `id` shall be used to find the object in the table whose value needs to be updated and the `User` object that needs to replace the existing object in the table.

### Code snippet

# POST

You will create an action method to handle POST requests and call it `PostUser()`. It will take the object `User` as an input parameter.

## Code snippet

## Explanation

The method is annotated with `[HttpPost]`. This will help the framework identify the request type. The route will be `/Api/User` with request type POST. 

Your action method return type is `Task<ActionResult<User>>`. Break this down to get a better understanding of what is going on:

* `ActionResult<>`: The return type could be `User` but that would not be able to handle exceptions. A different return type is needed for exceptions. To allow the return type to be either `User` or an exception, use `ActionResult<>`.
* `Task<>`: This allows a task to be performed asynchronously.

Similar to your controller that returned views, you are adding new data into your tables. First, you call the database context with `_context`. Then, you are referring to the Users' table with `.Users` and tell the framework to add a new object into it with the help of `.Add(user)`. After that, you are saving changes that have been made to your database asynchronously.

```C#
_context.Users.Add(user);
await _context.SaveChangesAsync();
```
Lastly, the return statement:

```C#
return CreatedAtAction("GetUser", new { id = user.ID }, user);
```

The `CreatedAtAction()` method takes three parameters: _actionName_ of type string, _routeValues_ which will be an object, and `user`, which will also be an object. In _actionName_, you will pass the name of the action method to use for generating the URL. _routeValues_ is responsible for generating routes with respect to some parameters which is `ID` in this case.

# PUT

To implement HTTP PUT, you will create an action method and call it `PutUser()`. It will take two parameters as inputs, an `id` of type integer and an object `User`. `id` shall be used to find the object in the table whose value needs to be updated and the `User` object that needs to replace the existing object in the table.

## Code snippet

Learn to create action methods for creating and updating data via JSON Web APIs.


Introduction

Getting Started

MVC in ASP.NET Core

JSON Web APIs in ASP.NET Core

Working with Repositories

Relationships

Authentication and Authorization

Appendix

Conclusion

HTTP POST and PUT

POST

Code snippet

Explanation