Assegnare dei ruoli è sempre stato un modo rapido ed efficace per regolare l'accesso di interi gruppi di utenti a funzionalità riservate nella nostra applicazione.

ASP.NET Identity supporta questa possibilità ma il template di Visual Studio 2013 per le applicazioni ASP.NET non ci offre una dimostrazione pratica di come creare tali ruoli ed assegnarli agli utenti. Andiamo dunque a scoprire come usare il RoleManager, la API di ASP.NET Identity per la gestione dei ruoli.

Per prima cosa, apriamo il file App_Start/IdentityConfig.cs e creiamo al suo interno una classe ApplicationRoleManager derivata da RoleManager. Sarà il nostro punto di accesso ai metodi di gestione.

public class ApplicationRoleManager : RoleManager<IdentityRole>
{
  public ApplicationRoleManager(IRoleStore<IdentityRole, string> store)
    : base(store)
  {
  }
  //Factory method
  public static ApplicationRoleManager Create(
    IdentityFactoryOptions<ApplicationRoleManager> options, IOwinContext context)
  {
    var manager = new ApplicationRoleManager(
      new RoleStore<IdentityRole>(context.Get<ApplicationDbContext>()));
    return manager;
  }
}

Ora registriamo il factory method del nostro ApplicationRoleManager nel file App_Start/Startup.Auth.cs, aggiungendo la seguente istruzione al metodo ConfigureAuth.

app.CreatePerOwinContext<ApplicationRoleManager>(
  ApplicationRoleManager.Create);

Con l'extension method CreatePerOwinContext, abbiamo affidato la costruzione e la gestione del ciclo di vita del nostro ApplicationRoleManager al middleware IdentityFactory. Questo è vantaggioso perché:

• il middleware si assume l'onere di creare gli oggetti per l'accesso ai dati e di distruggerli al momento opportuno, al termine della richiesta web corrente;
• consente ai componenti della nostra applicazione di riutilizzare la stessa istanza di quegli oggetti, almeno finché siamo nel contesto della stessa richiesta.

Nel controller in cui desideriamo compiere operazioni sui ruoli, creiamo una proprietà chiamata RoleManager che ci fornirà l'istanza di ApplicationRoleManager legata al contesto OWIN corrente. Nel farlo, non dimentichiamo di aggiungere una direttiva using Microsoft.AspNet.Identity.Owin;.

private ApplicationRoleManager _roleManager;
protected ApplicationRoleManager RoleManager
{
  get
  {
    return _roleManager ?? 
      HttpContext.GetOwinContext().Get<ApplicationRoleManager>();
  }
}

Da un'action asincrona del controller, usiamo subito questa nuova proprietà per creare un ruolo con il metodo CreateAsync.

//In uno scenario reale, il nome del ruolo lo otterremmo dall'input dell'utente
await RoleManager.CreateAsync(new IdentityRole { Name = "Administrator" });

Ovviamente, possiamo anche rimuovere dei ruoli grazie al metodo DeleteAsync.

var role = await RoleManager.FindByNameAsync("Guest");
await RoleManager.DeleteAsync(role);

Per creare o sciogliere relazioni tra utenti a ruoli, invece, dobbiamo ricorrere allo UserManager e ai suoi metodi AddToRoleAsync e RemoveFromRoleAsync.

// UserManager è anch'essa una proprietà da creare nel
// controller attuale che usiamo per recuperare un'istanza di 
// ApplicationUserManager dal contesto OWIN
var user = await UserManager.FindByNameAsync("Joe");
await UserManager.AddToRoleAsync(user.Id, "Administrator");
await UserManager.RemoveFromRoleAsync(user.Id, "Customer");

I metodi asincroni di gestione visti finora restituiscono un IdentityResult che ci indica l'esito dell'operazione. La sua proprietà booleana Succeeded assumerà il valore false se cerchiamo di compiere operazioni superflue, come aggiungere un ruolo ad un utente che lo possedeva già. Questi eventuali errori saranno consultabili dalla proprietà Errors dell'IdentityResult.

var result = await UserManager.AddToRoleAsync(user.Id, "Administrator");
//Se l'operazione non ha avuto buon esito...
if (!result.Succeeded)
{
  //...otteniamo gli Errors, un semplice elenco di stringhe
  IEnumerable<string> errors = result.Errors;
  //e li passiamo al ViewBag, in modo che siano poi visualizzati dalla view
  ViewBag.Errors = errors;
}

Dopo aver assegnato opportunamente i ruoli, possiamo iniziare a regolare l'accesso alla nostra applicazione ASP.NET MVC in maniera molto precisa grazie all'uso dell'attributo Authorize, come illustrato in un nostro script precedente:
https://www.aspitalia.com/script/1158/Override-Regole-Autenticazione-ASP.NET-MVC.aspx