Пользовательские столбцы AspNetUsers не отображаются в intellisense

Question

Я пытаюсь создать базу данных пользователей, которую я могу изменить в соответствии с тем, что мои пользователи должны будут отправить при регистрации для моей службы. Я создал базу данных и могу изменить ее и включить любые столбцы, которые я хочу Кажется, что к ним нет доступа в моем коде c#, единственные поля, которые появляются, являются собственными для AspNetUsers, я пробовал смотреть на похожие вопросы, но я не могу понять asp концепции, указанные c, чтобы что мне нужно, любой, кто может помочь мне прояснить этот вопрос, немного новичок в работе с IdentityUser.

   

     //Registration/Login
        public class Identify : IIdentify
        {
            private readonly UserManager<IdentityUser> _manager;
        
            private readonly Mystery _jwtset;
            private readonly DataContext _personality;
        
            public Identify(UserManager<IdentityUser> userManager, Mystery jW, DataContext users)
            {
                _manager = userManager;
                _jwtset = jW;
                _personality = users;
            }
        
            public async Task<Authentication_result> RegisterAsync(string email, string password, string Username)
            {
                var exists = await _manager.FindByEmailAsync(email);
        
        
                if (exists != null)
                {
                    return new Authentication_result
                    {
                        Errors = new[] { "User with this email already exists" }
                    };
                }
        
        
                var newPerson = new IdentityUser()
                {
                    Email = email,
                    UserName = Username
                };
        
        
                var Creation = await _manager.CreateAsync(newPerson, password);
        
                if (!Creation.Succeeded)
                {
                    return new Authentication_result
                    {
                        Errors = new[] { "Invalid user!" }
                    };
                }
        
                return Generate_Authentication_Result(newPerson);
            }
        
            public async Task<Authentication_result> LoginAsync(string email, string Password)
            {
        
                var exists = await _manager.FindByEmailAsync(email);
        
        
                if (exists == null)
                {
                    return new Authentication_result
                    {
                        Errors = new[] { "User does not exists" }
                    };
                }
        
                var pass_validation = await _manager.CheckPasswordAsync(exists, Password);
        
                if (!pass_validation)
                {
                    return new Authentication_result
                    {
                        Errors = new[] { "f78wrvep034rf wrong" }
                    };
                }
        
                return Generate_Authentication_Result(exists);
            }
        
        
        
            private Authentication_result Generate_Authentication_Result(IdentityUser newPerson)
            {
                var Tokenhandler = new JwtSecurityTokenHandler();
                var key = Encoding.ASCII.GetBytes(_jwtset.Secret);
                var TokenDescripter = new SecurityTokenDescriptor
                {
                    Subject = new ClaimsIdentity(new[]
                   {
                               new Claim(JwtRegisteredClaimNames.Sub, newPerson.UserName),
                               new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
                               new Claim(JwtRegisteredClaimNames.Email, newPerson.Email),
                               new Claim("id",newPerson.Id)
        
                           }),
        
                    Expires = DateTime.UtcNow.AddHours(2),
                    SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
                };
        
                var token = Tokenhandler.CreateToken(TokenDescripter);
        
                return new Authentication_result
                {
                    Success = true,
                    Token = Tokenhandler.WriteToken(token)
                };
            }
        
        }
        //Controller for the above
        
        public class IdentifyMe : Controller
        {
            private readonly IIdentify _identify;
        
        
            public IdentifyMe(IIdentify identifying)
            {
                _identify = identifying;
        
            }
        
            [HttpPost(Api_Routes.Identity.Register)]
            public async Task<IActionResult> Register(UserRegistration register)
            {
        
                if (!ModelState.IsValid)
                {
                    return BadRequest(new Unauthenticated
                    {
                        Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
                    });
                }
        
        
                var authresponce = await _identify.RegisterAsync(register.Email, register.Password, register.User_Name);
        
                if (!authresponce.Success)
                {
                    return BadRequest(new Unauthenticated
                    {
                        Errors = authresponce.Errors
                    });
                }
                return Ok(new Authenticated
                {
                    Token = authresponce.Token
                });
            }
        
        
        
            [HttpPost(Api_Routes.Identity.Login)]
            public async Task<IActionResult> LoginAsync(User_login login)
            {
                var authresponce = await _identify.LoginAsync(login.email, login.Password);
        
                if (!authresponce.Success)
                {
                    return BadRequest(new Unauthenticated
                    {
                        Errors = authresponce.Errors
                    });
                }
                return Ok(new Authenticated
                {
                    Token = authresponce.Token
                });
            }
        
        
        }
        //Domain object, these are the values I would like to be able to access
        
        public class Users : IdentityUser
        {
            public string PreferredNet { get; set; }
            public int Inactive { get; set; }
            public int Active { get; set; }
            public int Max_Return { get; set; }
            public DateTime Time { get; set; }
        
        }
    //Other controller
    public ActionResult <IEnumerable<Time_dto>> Getitem(string usernum, int amt, string user, string server)
            {
                
              
                var Total = caller.Getusers();
//This is my attempt to acces the domain object, pitcture below[![Intelisense does not display fields in domain object][1]][1]
                var container=Total.Select(x=>x.)
                var totalin = _digital.Map<IEnumerable<User_dto>>(Total).Count(x => x.PreferredNet == user);
                var totalout= _digital.Map<IEnumerable<User_dto>>(Total).Count(x=>x.PreferredNet== server);
             
                int factor = 1;
                var HCD = caller.rates(factor, user, server);
             
                var result = shift;
                int retrive = caller.Total(amt, user, server, HCD);
                var serials = caller.cards(retrive);
                int differential = retrive > serials.Sum() ? retrive serials.Sum() : serials.Sum() - retrive;
                int number = serials.Count();
                IEnumerable<int> Real_cards=new List<int>();
    }
        ```


  [1]: https://i.stack.imgur.com/HEenG.png