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

# Solution

The solution to the challenge is provided below. Feel free to explore the following files:

* `IUserRepo.cs`
* `Startup.cs`
* `MockUserRepo.cs`
* `/Controllers/Api/UsersController.cs`
* `SqlUserRepo.cs`


<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" Version="3.1.9" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.9">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.9" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.9" />
    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="3.1.9" />
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="3.1.4" />
  </ItemGroup>

</Project>


using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace People
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.EntityFrameworkCore;
using People.Data;

namespace People
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

            services.AddDbContext<UsersContext>(options => options.UseSqlite(Configuration.GetConnectionString("UsersContext")));

            services.AddScoped<IUserRepo, MockUserRepo>();
            // services.AddScoped<IUserRepo, SqlUserRepo>();

        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }
            app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

React

Dart

GoJS React

Typescript React

Vue.js

Click **Run** to check out the result. After the application has fully launched, click on the link to launch in a new browser tab. Remove `/name/neo` from the URL to obtain the complete list of users in the database in JSON format. From the output, pick any other name you would like and add `/name/{the name you picked}` into the URL.
# Explanation

## `IUserRepo.cs`

Start off by adding a new function definition to your repository interface. It will be named `GetUsersByName`. It shall take a variable called `name` of type string as an input parameter. Its return type shall be `IEnumerable<User>`, to return an array of users.

You will need to navigate to `MockUserRepo.cs` and then `SqlUserRepo.cs`. Add the newly defined function from your interface and return `null`. This will remove any compile-time errors. 

```C#
public IEnumerable<User> GetUsersByName(string name)
{
    return null;
}
```
## `Startup.cs`
First, you will confirm the mock repository is activated in your `Startup.cs` class and the SQL repository is commented out. Then, you will implement the function that you wrote in your interface.

## `MockUserRepo.cs` 

1. The `name` string is case-sensitive. You will convert the input parameter to lowercase.
2. Implement a query that searches for all names in object `users` and return the result to the object called `result`. This is your query:
```C#
u => u.Name.ToLower().Contains(name)
```
   This query will go through the entire list. It will check if the value in the variable `name` is part of the `Name` property for each user. If it is, it will be added to the object `result`.

Add more objects to your list of User objects `users` for testing purposes.

## `Api/UsersController.cs`

>You are updating the controller before updating your SQL repository to (at the very least)  make sure your mock repository implementation is working correctly. Once you have confirmed it is working correctly, then you will begin to implement your SQL repository.

After implementing the mock repository, go to your controller and add a new endpoint to your controller to find users with respect to their names.

### Routing

Since you already have an `HttpGet` method that takes one input parameter, you cannot just call this method `HttpGet` and assign an input parameter as well. Some modifications need to be implemented to have a separate route for your new method. For this, you will add the attribute `[Route("name/{name}")]` above your new action method.

### Action method
Your action method will be called `GetUsersByTheirName`. The input parameter and the return type will be the same as implemented in `IUserRepo.cs`. You will simply call the interface's implementation of `GetUsersByName()` and pass in the input string `name`. The result will be returned.

# `SqlUserRepo.cs`

Before implementing the SQL repository, switch your repository from the mock repository to the SQL repository in your `Startup.cs`.

Just like your mock repository implementation, convert the input string into a lower case string. Then, access your table and return a list that contains only those objects where `Name` contains your input string. This list is stored in `allUsers` and returned.

This lesson covers the solution to implementing a custom query with a repository.

Introduction

Getting Started

MVC in ASP.NET Core

JSON Web APIs in ASP.NET Core

Working with Repositories

Relationships

Authentication and Authorization

Appendix

Conclusion

Solution: Implement Custom Query with Repository

Solution