Premiers pas avec Identity dans ASP.NET Core

Avant-propos

Dans ASP.NET Core, la bibliothèque de composants Identity dans ASP.NET est toujours utilisée, qui est chargée d'authentifier l'identité de l'utilisateur. De manière générale, il n'y a pas de <.>MVC 5 est tellement compliqué parce qu'OWIN est introduit dans MVC 5, de nombreux débutants ont du mal à l'apprendre. Ils sont tous confus au sujet de l'identité, y compris moi-même. Cela a pris plus d'un mois. pour comprendre les principes à l'intérieur. Par conséquent, la plupart des développeurs n’aiment pas l’identité et ne l’utilisent pas. Ils se sentent kidnappés.

Heureusement, dans ASP.NET Core, en raison de l'abstraction progressivement claire des modules et de l'utilisation de

middleware, cela rend le parcours d'apprentissage et d'utilisation d'Identity plus clair. jetons un coup d'oeil.

Mise en route

Avant de commencer, oublions sa relation avec

et sa relation avec Entity Framework. Apprenons d'abord quelques mots anglais. Authentication

Il y a tellement de "

mots" que vous devrez peut-être comprendre :

# 1 : Réclamations

Tout le monde devriez-vous savoir à quoi ressemble la carte d'identité, comme suit :

Parmi eux,

Nom : Obama Sexe : Homme ; ; Nationalité : Kenya ; Naissance : 1961.08.04, etc. Ces informations d'identité, on voit qu'elles sont toutes des paires clé-valeur une par une. , alors si nous voulons Comment stocker ces choses et les concevoir ? Oui, vous avez peut-être pensé à utiliser un dictionnaire pour le stockage, une Clé et une Valeur répondent juste aux besoins. Mais Key et Value ne semblent pas conviviaux et pas très orientés objet, alors ne serait-il pas préférable d'en faire un objet ? Au moins, vous pouvez utiliser l'invite intelligente de vs. Modifions-la et changeons-la comme suit :

//我给对象取一个名字叫`Claim`你没有意见吧
public class Claim
{
    public string ClaimType { get; set; }

    public string ClaimValue { get; set; }
}

ClaimType est Key et ClaimValue représente une valeur. Dans ce cas, il peut simplement stocker

une paire clé-valeur. A ce moment puis-je le déposer ? 姓名：奥巴马

Les gens de Microsoft sont très prévenants et nous ont préparé des valeurs par défaut

 ? De nombreux points couramment utilisés s'y trouvent, jetons un coup d'œil : ClaimType

Ici, nous étendons le premier point de connaissance : ClaimTypes

Pour Expérience de lecture, je n'ai inclus qu'une partie de la capture d'écran. Vous pouvez voir quels Nom,

Email, Gender, MobilePhone et autres noms couramment utilisés sont déjà là, et il y en a bien d'autres. Les lecteurs attentifs ont peut-être remarqué que son espace de noms est , ce qui signifie que cette chose fait partie du framework .net System.Security.Claims Eh bien, c'est tout ce que nous devons savoir pour le moment. . D'ACCORD.

La réclamation

Introduction est complète. N'est-ce pas très simple ? Je me fiche de la façon dont elle est traduite dans d'autres endroits. Dans cet article, elle s'appelle « Unité de certificat. ».

#2 : ClaimsIdentity

Après avoir "

Unité de document", nous pouvons l'utiliser pour créer une carte d'identité, puis comment devrait-il être fait ? Certains étudiants ont peut-être pensé, oui, créez simplement un nouvel objet, puis transférez l'unité de carte d'identité dans le constructeur , et vous obtiendrez alors une carte d'identité. Nous donnons à cette carte d'identité un nom anglais "ClaimsIdentity". Ce nom semble tout à fait approprié. Il a à la fois des revendications pour représenter ses composants et une identité pour représenter son objectif.

En fait, dans la vraie vie, une partie des informations sur nos cartes d'identité est cachée, et une partie est directement visible. Par exemple, vous ne pouvez pas voir les informations relatives à vos empreintes digitales stockées dans la nouvelle génération de cartes d'identité. Elles sont toutes stockées dans la puce à l'intérieur de la carte d'identité. Ce que vous pouvez voir, c'est votre nom, votre âge, etc. La même chose est vraie lorsque nous concevons un objet. Nous devons exposer quelque chose, donc ici notre ClaimsIdentity expose un nom, une étiquette, etc.

我们造的身份证（ClaimsIdentity）还有一个重要的属性就是类型（AuthenticationType），等等，AuthenticationType是什么东西？看起来有点眼熟的样子。我们知道我们自己的身份证是干嘛的吧，就是用来证明我们的身份的，在你证明身份出示它的时候，其实它有很多种形式载体的，什么意思呢？比如你可以直接拿出实体形式的身份证，那也可以是纸张形式的复印件，也可以是电子形式的电子码等等，这个时候就需要有一个能够表示其存在形式的类型字段，对，这个AuthenticationType就是干这个事情的。

然后我们在给我们的身份证添加一些润色，让其看起来好看，比如提供一些方法添加 Claims 的，删除 Claims的，写到二进制流里面的啊等等，最终我们的身份证对象看起来基本上是这样了：

public class ClaimsIdentity
{
    public ClaimsIdentity(IEnumerable<Claim> claims){}
    
    //名字这么重要，当然不能让别人随便改啊，所以我不许 set，除了我儿子跟我姓，所以是 virtual 的
    public virtual string Name { get; }
    public string Label { get; set; }
    
    //这是我的证件类型，也很重要，同样不许 set
    public virtual string AuthenticationType { get; }
    
    public virtual void AddClaim(Claim claim);
    
    public virtual void RemoveClaim(Claim claim);
    
    public virtual void FindClaim(Claim claim);
}

嗯，到这里，我们的身份证看起来似乎很完美了，但是从面向对象的角度来说好像还少了点什么东西？ 对~，还是抽象，我们需要抽象出来一个接口来进行一些约束，约束什么呢？既然作为一个证件，那么肯定会涉及到这几个属性信息：
1、名字。2、类型。3、证件是否合法。
反应到接口里面的话就是如下，我们给接口取个名字叫：“身份(IIdentity)”：

这里延伸第二个知识点：IIdentity接口。

// 定义证件对象的基本功能。
public interface IIdentity
{
    //证件名称
    string Name { get; }
    
    // 用于标识证件的载体类型。
    string AuthenticationType { get; }
    
    //是否是合法的证件。
    bool IsAuthenticated { get; }
}

所以我们的 ClaimsIdentity 最终看起来定义就是这样的了：

public class ClaimsIdentity : IIdentity
{
    //......
}

ClaimsIdentity 介绍完毕，是不是发现也很简单，其他地方怎么翻译我不管，在本篇文章里面，它叫 “身份证”。

# 3： ClaimsPrincipal

有了身份证，我们就能证明我就是我了，有些时候一个人有很多张身份证，你猜这个人是干嘛的？ 对，不是黄牛就是诈骗犯。

但是，有些时候一个人还有其他很多种身份，你猜这个人是干嘛的？这就很正常了对不对，比如你可以同时是一名教师，母亲，商人。如果你想证明你同时有这几种身份的时候，你可能需要出示教师证，你孩子的出生证，法人代表的营业执照证。

在程序中，一个身份证不仅仅代表你这个人了，而是代表一个身份，是证明你自己的主要身份哦。如果一个人还有其他很多种身份，这个时候就需要有一个东西（载体）来携带着这些证件了对吧？OK，我们给需要携带证件的这个对象取一个贴切点的名字，叫“证件当事人（ClaimsPrincipal）”吧。

以下是 Principal 这个单词在词典给出的解释，我用它你应该没意见吧：

principal  ['prɪnsəpl]  
adj. 主要的；资本的
n. 首长；校长；资本；当事人

这个时候可能有同学会问了，是不是应该叫ClaimsIdentityPrincipal比较好呢？嗯，我也觉得应该叫 ClaimsIdentityPrincipal 可能更好一点，或许微软的人偷懒了，简写成了ClaimsPrincipal。

知道其功能后，代码就很好写了，和上面ClaimsIdentity一样的套路：

public class ClaimsPrincipal 
{
    //把拥有的证件都给当事人
    public ClaimsPrincipal(IEnumerable<ClaimsIdentity> identities){}
    
    //当事人的主身份呢
    public virtual IIdentity Identity { get; }
    
    public virtual IEnumerable<ClaimsIdentity> Identities { get; }
    
    public virtual void AddIdentity(ClaimsIdentity identity);
    
    //为什么没有RemoveIdentity ， 留给大家思考吧？
}

当时人看起来也几乎完美了，但是我们还需要对其抽象一下，抽象哪些东西呢？ 作为一个当事人，你应该有一个主身份吧，就是你的身份证咯，可能你还会用到角色（角色后面会详细介绍，这里你知道有这么个东西就行了）。

这里延伸第三个知识点：IPrincipal 接口。

public interface IPrincipal
{
    //身份
    IIdentity Identity { get; }
    
    //在否属于某个角色
    bool IsInRole(string role);
}

然后，我们的 证件当事人 看起来应该是这样的：

public class ClaimsPrincipal : IPrincipal 
{
   //...
}

ClaimsPrincipal 介绍完了，也很简单吧？ 其他地方怎么翻译我不管，在本篇文章里面，它叫 “证件当事人”。

想在，我们已经知道了 “证件单元（Claims）” ， “身份证（ClaimsIdentity）” ， “证件当事人（ClaimsPrincipal）”，并且整理清楚了他们之间的逻辑关系，趁热打铁，下面这个图是一个identity登入部分的不完全示意图，虚线圈出来的部分应该可以看懂了吧：

可以看出，首先我们在app这边有一些证件单元，然后调用ClaimsIdentity把证件单元初始化为一个身份证，然后再把身份证交给证件当事人由其保管。

才把 Getting Started 写完，发现已经这么长了，所以打算写成一个系列了，可能3 - 4篇吧。

Résumé

D'accord, cet article sera présenté ici en premier Dans ce blog, nous avons appris quelques mots anglais et connaissons ces mots anglais. Quel type d'objet fait. ça joue dans le programme ? Et d'après la figure, on sait où se trouvent ces objets dans l'ensemble du système d'authentification. J'ai trouvé que si je veux expliquer clairement l'identité, ce blog à lui seul ne suffit pas. Dans le prochain article, nous décollerons le .NET Authentication middleware jusqu'à ce que nous maîtrisions tout le système d'authentification de .NET. Ensuite, nous y jetterons un œil. chez Identité et Entité. Quelle relation amour/haine existe-t-il avec Framework.

Ce n'est que le début. Si vous pensez que ce blog vous est utile, merci pour votre [recommandation]. Si vous êtes intéressé par .NET Core, vous pouvez me suivre, je partagerai régulièrement des informations sur. sur le blog. Expérience d'apprentissage .NET Core.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!