I have a problem outputing the roles on the page ListRoles.cshtml

Question

Upon trying to output the roles on page ListRoles.cshtml with the admin account in this project it gives me System.NullReferenceException: 'Object reference not set to an instance of an object.'...

I think the problem is in the processing of the request because when i add breakpoints on the lines that return the model to the view the model has it's roles.

Can anyone tell me how to fix it please!

have tried some things but nothing worked.

Here's the project: https://github.com/bul-bbx/Rent_A_Car

and here's the whole error:

NullReferenceException: Object reference not set to an instance of an object.
AspNetCoreGeneratedDocument.Views_Role_Index.get_Model()
AspNetCoreGeneratedDocument.Views_Role_Index.ExecuteAsync() in Index.cshtml
        @if (Model.Any())
Microsoft.AspNetCore.Mvc.Razor.RazorView.RenderPageCoreAsync(IRazorPage page, ViewContext context)
Microsoft.AspNetCore.Mvc.Razor.RazorView.RenderPageAsync(IRazorPage page, ViewContext context, bool invokeViewStarts)
Microsoft.AspNetCore.Mvc.Razor.RazorView.RenderAsync(ViewContext context)
Microsoft.AspNetCore.Mvc.ViewFeatures.ViewExecutor.ExecuteAsync(ViewContext viewContext, string contentType, Nullable<int> statusCode)
Microsoft.AspNetCore.Mvc.ViewFeatures.ViewExecutor.ExecuteAsync(ViewContext viewContext, string contentType, Nullable<int> statusCode)
Microsoft.AspNetCore.Mvc.ViewFeatures.ViewExecutor.ExecuteAsync(ActionContext actionContext, IView view, ViewDataDictionary viewData, ITempDataDictionary tempData, string contentType, Nullable<int> statusCode)
Microsoft.AspNetCore.Mvc.ViewFeatures.ViewResultExecutor.ExecuteAsync(ActionContext context, ViewResult result)
Microsoft.AspNetCore.Mvc.ViewResult.ExecuteResultAsync(ActionContext context)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextResultFilterAsync>g__Awaited|30_0<TFilter, TFilterAsync>(ResourceInvoker invoker, Task lastTask, State next, Scope scope, object state, bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Rethrow(ResultExecutedContextSealed context)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.ResultNext<TFilter, TFilterAsync>(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.InvokeResultFilters()
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextResourceFilter>g__Awaited|25_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, object state, bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Rethrow(ResourceExecutedContextSealed context)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Next(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.InvokeFilterPipelineAsync()
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeAsync>g__Awaited|17_0(ResourceInvoker invoker, Task task, IDisposable scope)
Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeAsync>g__Awaited|17_0(ResourceInvoker invoker, Task task, IDisposable scope)
Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|6_0(Endpoint endpoint, Task requestTask, ILogger logger)
Microsoft.AspNetCore.Authorization.AuthorizationMiddleware.Invoke(HttpContext context)
Microsoft.AspNetCore.Authentication.AuthenticationMiddleware.Invoke(HttpContext context)
Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware.Invoke(HttpContext context)

here's the Index.cshtml file

@page
@using Rent_A_Car_v2.Areas.Identity.Data;
@model List<string>;
@{
    ViewBag.Title = "List Role";
    Layout = "~/Views/Role/_RoleLayout.cshtml";
}

<h1>Roles</h1>
    <table class="table">
        <thead>
            <tr>
                <th>Role Name</th>
            </tr>
        </thead>
        <tbody>
        @if (Model.Any())
        {
            foreach (var role in Model)
            {
                <tr>
                    <td>@role</td>
                    <td>
                        <a asp-action="EditRole" asp-route-roleName="@role">Edit</a> |
                        <a asp-action="DeleteRole" asp-route-roleName="@role">Delete</a>
                    </td>
                </tr>
            }
        }
        else
        {
            <tr>
                <td>No roles available.</td>
            </tr>
        }
        </tbody>
    </table>

here's the RoleController.cs

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis.Differencing;
using Microsoft.EntityFrameworkCore;
using Rent_A_Car_v2.Areas.Identity.Data;

namespace Rent_A_Car_v2.Controllers
{
    public class RoleController : Controller
    {
        private readonly RoleManager<Role> roleManager;
        private readonly UserManager<User> userManager;
        private readonly AppDbContext DbContext;

        public RoleController(UserManager<User> userManager, RoleManager<Role> roleManager, AppDbContext DbContext)
        {
            this.roleManager = roleManager;
            this.userManager = userManager;
            this.DbContext = DbContext;
        }

        [HttpGet]
        public IActionResult AddUserToRole()
        {
            return View();
        }

        [HttpPost]
        public async Task AddUserToRole(string u, string role)
        {
            User user = await userManager.FindByNameAsync(u);
            await userManager.AddToRoleAsync(user, role);
        }

        [HttpPost]
        public async Task AddUserToRole(User u, string role)
        {
            await userManager.AddToRoleAsync(u, role);
        }

        public IActionResult Index()
        {
            var roles = roleManager.Roles;
            var a = roles.Select(role => role.Name).ToList();
            return View(a);
        }


        [HttpGet]
        public IActionResult CreateRole()
        {
            return View();
        }
        [HttpPost]
        public async Task<IActionResult> CreateRole(Role model)
        {
            if (ModelState.IsValid)
            {
                Role Role = new Role
                {
                    Name = model.Name
                };
                IdentityResult result = await roleManager.CreateAsync(Role);

                if (result.Succeeded)
                {
                    RedirectToAction("ListRole", "Role");
                }

                foreach (IdentityError error in result.Errors)
                {
                    ModelState.AddModelError("", error.Description);
                }
            }

            return View(model);
        }

        [HttpGet]
        public async Task<IActionResult> EditRole(string roleId)
        {
            // Retrieve the role from the database
            var role = await roleManager.FindByNameAsync(roleId);
            if (role == null)
            {
                return NotFound(); // Or handle the error as needed
            }

            // Pass the role to the view for editing
            return View(role);
        }

        // POST: /Role/EditRole/roleId
        [HttpPost]
        public async Task<IActionResult> EditRole(string roleId, Role updatedRole)
        {
            if (roleId != updatedRole.Name)
            {
                return BadRequest();
            }

            // Retrieve the role from the database
            var role = await roleManager.FindByNameAsync(roleId);
            if (role == null)
            {
                return NotFound(); // Or handle the error as needed
            }

            // Update role details
            role.Name = updatedRole.Name; // Update other properties as needed

            // Update the role in the database
            var result = await roleManager.UpdateAsync(role);
            if (result.Succeeded)
            {
                // Role updated successfully
                return RedirectToAction("Index", "Home"); // Redirect to a relevant page
            }
            else
            {
                // Failed to update role, handle the error
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
                return View(updatedRole); // Return to the edit form with error messages
            }
        }


        //[HttpGet]
        //public IActionResult DeleteRole()
        //{
        //    return View();
        //}

        //[HttpPost]
        //public async Task<IActionResult> DeleteRole(DeleteRoleViewModel model)
        //{
        //    var role = await roleManager.FindByNameAsync(model.ExistingRoleName);

        //    if (role == null)
        //    {
        //        return NotFound();
        //    }

        //    var result = await roleManager.DeleteAsync(role);

        //    if (result.Succeeded)
        //    {
        //        return RedirectToAction("ListRole", "Role");
        //    }
        //    else
        //    {
        //        foreach (var error in result.Errors)
        //        {
        //            ModelState.AddModelError(string.Empty, error.Description);
        //        }

        //        return View("Error");
        //    }
        //}
    }
}