Use ASP.NET methods to redirect users to different pages in- and outside of your app

Redirection

In the past, our handler methods had a `void` return type:
```cs
public void OnGet() {}
```
To perform redirection we need our methods to return an object. This object will determine what kind of response is sent back to the browser. 

This object can be any type that implements the `IActionResult` interface. There are a few types that do, but we don't need to dive into those. All we need to know is that the methods in this lesson return something that implements `IActionResult`.

Let's start with `RedirectToPage()`. For basic redirection, call it with a string argument and return the result. The string will represent the destination page, written like the URL segment, like `"/Privacy"` or `"/About/Me"`.

Here's an example handler method that always redirects learners to the checkout page:

```cs
public IActionResult OnPost()
{
  return RedirectToPage("/Checkout");
}
```

Note that the `/` (slash) makes the path relative to the **Pages** folder. In other words, this takes the user to the contents in **Pages/Checkout.cshtml**. Removing the slash makes the path relative to the current page.

Optional information: For those of you already familiar with HTTP status codes, `RedirectToPage()` produces an HTTP status code of 302, and the browser knows where to browse to by using information in the response header.


RedirectToPage()


You're on your way to becoming an ASP.NET master! In this lesson we learned some methods and types that are used to redirect users to pages:

* When a handler method has no return statement, it will send the associated page as a response.
* When a redirect method is used in a handler method, it must return the type `IActionResult` (or some type that implements the interface) or `Task<IActionResult>` if asynchronous.
* `Page()` causes the server to render the Razor view page associated with the current page model.
* `RedirectToPage()` causes the server to render the Razor view page described in the method argument. Generates a 302 HTTP status code.
* `NotFound()` causes the server to send a "Status 404 Not Found" response.

These are just a few common redirection methods. You can find a [full list of them defined within the `PageModel` type](https://docs.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.mvc.razorpages.pagemodel#methods). A good one to start with is `Redirect()`, which works similarly to `RedirectToPage()`, but can redirect to URLs outside of your own application. 

You can find [further examples of redirection methods in the Microsoft tutorials](https://docs.microsoft.com/en-us/aspnet/core/razor-pages#url-generation-for-pages) and a [nice list of common redirection methods on Learn Razor Pages](https://www.learnrazorpages.com/razor-pages/action-results). 


Review

Before we were redirecting users, we were using `void` and `Task` as our return types.

`void` was for synchronous methods:
```cs
public void OnGet()
```

`Task` was for asynchronous methods:
```cs
public async Task OnGetAsync()
```

With redirection, we will now return `IActionResult` and `Task<IActionResult>`.

`IActionResult` is for synchronous methods:
```cs
public IActionResult OnGet()
```

`Task<IActionResult>` is for asynchronous methods:

```cs
public async Task<IActionResult> OnGetAsync()
```

We don't need to get into the details of `Task<IActionResult>` now, but you can imagine it as some kind of operation that will eventually return an `IActionResult`.


Async Redirects

An HTTP response includes more than just HTML &mdash; it also includes an HTTP status code. A popular one is 404, which means that a requested resource was not found. For example, a user requests a profile page of a non-existent person.

We can generate that kind of response using `NotFound()`.

In this example, a request with the username `"Machiavelli"` will lead to a 404 response:

```cs
public IActionResult OnPost(string username)
{
  if (username == "Machiavelli")
  {
    return NotFound();
  }
  
  return Page();
}
```


NotFound()


So far, every handler method has rendered the same view page. For example, `OnGet()` in **Index.cshtml.cs** will always send a response with **Index.cshtml**, and `OnPost()` in **About.cshtml.cs** will always send a response with **About.cshtml**.

Sometimes we want to redirect users to a different page. 

* A blog website has a "Posts" page showing blog posts and a separate "Create" page. After submitting on "Create", the user should be redirected to the list of blog posts on "Posts".

* A page on your education website has become outdated, and you add a new one to replace it. Learners requesting the old page should be redirected to the newer version of the page (assuming you have to keep the old page for those who are half-way through the content).

* A user submitted a request for non-existent data on your site and you want to show them a "Not Found" page.

This lesson will show you some useful methods to satisfy those examples, including:
* `RedirectToPage()`
* `NotFound()`
* `Page()`


Introduction to Redirection

Say that we only want to redirect in some cases. Otherwise we want to have the original response, which included the current page.

Now that our handler methods are returning `IActionResult` values, we need a way to return the current page. The answer is calling and returning the `Page()` method.

Returning `Page()` will lead to the same behavior we saw when we had `void` handler methods (although we now have the flexibility to redirect as well).

These two methods have the same behavior:

```cs
public void OnGet()
{}
```

```cs
public IActionResult OnGet()
{
  return Page();
}
```
