Xamarin 如何在Android应用程序中使用ASP.NET身份网站登录？

我有一个ASP.NET核心web应用程序。用户可以登录，它使用身份

我现在正在用Xamarin构建一个Android应用程序，它将提供一个非常缩小的站点部分——从库存中添加/删除产品

这是登录操作：

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
    {

        ViewData["ReturnUrl"] = returnUrl;
        if (ModelState.IsValid)
        {
            var result = await _signInManager.PasswordSignInAsync    (model.Email, model.Password, model.RememberMe, lockoutOnFailure: true);
            if (result.Succeeded)
            {  
              var user = await UserManager.FindByNameAsync( model.Email );
                if ( !user.IsApproved ) {
                    await _signInManager.SignOutAsync();
                    _logger.LogWarning(2, "User account not approved.");
                    return RedirectToAction("NotApproved");
                }

                AddAutoLogoutCookie();

                _logger.LogInformation(1, "User logged in.");
                return RedirectToLocal(returnUrl);
            }
            if (result.RequiresTwoFactor)
            {
                return RedirectToAction("VerifyCode", new { Provider = AppSettings.GoogleAuthenticatorProviderName, ReturnUrl = returnUrl, RememberMe = model.RememberMe });
            }
            if (result.IsLockedOut)
            {
                _logger.LogWarning(2, "User account locked out.");
                return View("Lockout");
            }
            else
            {
                ModelState.AddModelError(string.Empty, _localizer["Incorrect creds"]);
                return View(model);
            }
        }

[HttpPost]
[异名]
[ValidateAntiForgeryToken]
公共异步任务登录（LoginViewModel模型，字符串returnUrl=null）
{
ViewData[“ReturnUrl”]=ReturnUrl；
if（ModelState.IsValid）
{
var result=wait _signInManager.PasswordSignInAsync（model.Email、model.Password、model.RememberMe、lockoutOnFailure:true）；
if（result.successed）
{  
var user=await UserManager.FindByNameAsync（model.Email）；
如果（！user.IsApproved）{
等待_signInManager.SignOutAsync（）；
_logger.LogWarning（2，“用户帐户未批准”）；
返回重定向到操作（“未批准”）；
}
addautologutcookie（）；
_logger.LogInformation（1，“用户登录”）；
返回重定向到本地（returnUrl）；
}
if（结果要求系数）
{
return RedirectToAction（“VerifyCode”，新{Provider=AppSettings.GoogleAuthenticatorProviderName，ReturnUrl=ReturnUrl，RememberMe=model.RememberMe}）；
}
如果（结果IsLockedOut）
{
_logger.LogWarning（2，“用户帐户锁定”）；
返回视图（“锁定”）；
}
其他的
{
AddModelError（string.Empty，_本地化程序[“错误的凭据]）；
返回视图（模型）；
}
}

---

那么，我可以用它来让用户登录到Xamarin应用程序吗？我将如何大致做到这一点？谢谢。

您的问题非常广泛，但我会尝试提供帮助。如果您有一个网站和一个移动应用程序访问同一个数据库并使用相同的业务逻辑，我建议您创建一个API，您的API应该处理身份验证和访问to您的数据层，并执行CRUD操作。它不关心使用它的内容（移动应用程序或网站）

您的网站和移动应用程序将向此API发送请求，API将相应地响应。若要处理授权，请发送登录名，API将返回Json Web令牌或cookie（取决于您使用的内容），对于后续请求，请随请求发送此令牌

使用Xamarin可移植类库是处理API使用的好地方，因为它可以在ios和android上重用

如果使用Json Web令牌，Xamarin请求可能是什么样子的示例

public async Task<HttpStatusCode> LoginAsync(CredentialModel credentialModel)
    {
        var uri = new Uri(UrlResourceNames.LoginUrl);
        return await SendCredentialsAsync(credentialModel, uri);
    }
    private async Task<HttpStatusCode> SendCredentialsAsync(CredentialModel credentialModel, Uri uri)
    {
        var jsonProduct = JsonConvert.SerializeObject(credentialModel);
        var httpContent = new StringContent(jsonProduct, Encoding.UTF8, "application/json");
        var response = await _apiConnecter.PostRequest(uri, httpContent);

        if (!response.IsSuccessStatusCode)
            return response.StatusCode;
        string responseJson = await response.Content.ReadAsStringAsync();
        var tokenModel = JsonConvert.DeserializeObject<TokenModel>(responseJson);
        Settings.JwtToken = tokenModel.Token;
        Settings.JwtExpirationDate = tokenModel.Experation;
        return response.StatusCode;
    }

public异步任务LoginAsync（CredentialModel CredentialModel）
{
var uri=新uri（UrlResourceNames.LoginUrl）；
return wait SendCredentialsAsync（credentialModel，uri）；
}
专用异步任务SendCredentialAsync（CredentialModel CredentialModel，Uri）
{
var jsonProduct=JsonConvert.SerializeObject（credentialModel）；
var httpContent=newstringcontent（jsonProduct，Encoding.UTF8，“application/json”）；
var response=await_apiConnecter.PostRequest（uri，httpContent）；
如果（！response.issucessStatusCode）
返回response.StatusCode；
string responseJson=await response.Content.ReadAsStringAsync（）；
var-tokenModel=JsonConvert.DeserializeObject（responseJson）；
Settings.JwtToken=tokenModel.Token；
Settings.JwtExpirationDate=tokenModel.Experation；
返回response.StatusCode；
}

然后是可以处理所有CRUD请求的APIConnector。在本例中，APIConnector会检查是否存在Json Web令牌，如果存在，则会将令牌与所有请求一起发送（因为在本例中，不包括登录和注册的所有请求都需要授权），然后API会验证令牌

public class APIConnecter
{
    HttpClient _httpClient;
    private string _jwtToken;
    public APIConnecter()
    {
        _httpClient = new HttpClient();
        ISettings _appSettings;

        _appSettings = _appSettings = CrossSettings.Current;
        _jwtToken = Settings.JwtToken;
        if(!String.IsNullOrEmpty(_jwtToken))
            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", _jwtToken);
    }
    public async Task<HttpResponseMessage> GetRequest(Uri uri)
    {      
        var response = await _httpClient.GetAsync(uri);
        return response;
    }
    public async Task<HttpResponseMessage> DeleteRequest(Uri uri)
    {
        var response = await _httpClient.DeleteAsync(uri);
        return response;
    }
    public async Task<HttpResponseMessage> PostRequest(Uri uri, HttpContent content)
    {
        var response = await _httpClient.PostAsync(uri, content);
        return response;
    }
    public async Task<HttpResponseMessage> PutRequest(Uri uri, HttpContent content)
    {
        var response = await _httpClient.PutAsync(uri, content);
        return response; 
    }
}

公共类APIConnecter
{
HttpClient HttpClient；
私有字符串_jwtToken；
公共APIConnecter（）
{
_httpClient=新的httpClient（）；
i设置\u应用程序设置；
_appSettings=\u appSettings=CrossSettings.Current；
_jwtToken=Settings.jwtToken；
如果（！String.IsNullOrEmpty（_jwtToken））
_httpClient.DefaultRequestHeaders.Authorization=新的AuthenticationHeaderValue（“承载者”，_jwtToken）；
}
公共异步任务GetRequest（Uri）
{      
var response=await\u httpClient.GetAsync（uri）；
返回响应；
}
公共异步任务DeleteRequest（Uri）
{
var response=await\u httpClient.deleteAncy（uri）；
返回响应；
}
公共异步任务PostRequest（Uri、HttpContent）
{
var response=wait_httpClient.PostAsync（uri，内容）；
返回响应；
}
公共异步任务PutRequest（Uri、HttpContent）
{
var response=await\u httpClient.PutAsync（uri，内容）；
返回响应；
}
}

您在api上的登录看起来像这样

public async Task<IActionResult> Login([FromBody] CredentialModel credentialModel)
    {
        var user = await _userManager.FindByEmailAsync(credentialModel.Email);
        if (user == null)
            return NotFound();
        if (_hasher.VerifyHashedPassword(user, user.PasswordHash, credentialModel.Password) != PasswordVerificationResult.Success)
            return Unauthorized();

        var token = CreateToken(user);
        if (token == null)
            return StatusCode(500, "A problem happened while handling your request");
        return Ok(new
        {
            token = new JwtSecurityTokenHandler().WriteToken(token),
            experation = token.ValidTo
        });
    }

public异步任务登录（[FromBody]CredentialModel CredentialModel）
{
var user=await\u userManager.findbyemailsync（credentialModel.Email）；
if（user==null）
返回NotFound（）；
if（_hasher.VerifyHashedPassword（user，user.PasswordHash，credentialModel.Password）！=PasswordVerificationResult.Success）
未经授权返回（）；
var token=CreateToken（用户）；
if（标记==null）
返回状态代码（500，“处理您的请求时出现问题”）；
返回Ok（新的
{
token=new JwtSecurityTokenHandler（）.WriteToken（令牌），
experation=token.ValidTo
});
}