Autorizar atributo con varios roles

Me gustaría agregar autorización a un controlador, para múltiples roles a la vez.

Normalmente, se vería así:

[Authorize(Roles = "RoleA,RoleB,RoleC")]
public async Task<ActionResult> Index()
{
}

Pero he almacenado mis roles en consts, ya que pueden cambiar o extenderse en algún momento.

public const RoleA = "RoleA";
public const RoleB = "RoleB";
public const RoleC = "RoleC";

No puedo hacer esto, ya que la cadena debe conocerse en el momento de la compilación:

[Authorize(Roles = string.join(",",RoleA,RoleB,RoleC)]
public async Task<ActionResult> Index()
{
}

¿Existe alguna forma de evitar el problema?

PODRÍA escribir una constante que simplemente contenga "RoleA, RoleB, RoleC", pero no me gustan las cadenas mágicas y esta es una cadena mágica. Cambiar el nombre de un rol y olvidarse de cambiar la cadena combinada sería un desastre.

Estoy usando MVC5. La identidad ASP.NET y el rol se conocen en tiempo de compilación.

Intente crear un atributo de autorización personalizado como este .

public class AuthorizeRolesAttribute : AuthorizeAttribute
{
    public AuthorizeRolesAttribute(params string[] roles) : base()
    {
        Roles = string.Join(",", roles);
    }
}

Suponiendo que sus roles serán los mismos para varios controladores, cree una clase auxiliar:

public static class Role
{
    public const string Administrator = "Administrator";
    public const string Assistant = "Assistant";
}

Entonces úsalo así:

public class MyController : Controller
{
    [AuthorizeRoles(Role.Administrator, Role.Assistant)]
    public ActionResult AdminOrAssistant()
    {                       
        return View();
    }
}

Asegúrese de derivar su clase de atributo personalizado desactivado System.Web.Mvc.AuthorizeAttributey NO System.Web.Http.AuthorizeAttribute.

Tuve el mismo problema. Una vez que lo cambié, todo funcionó.

También puede agregar lo siguiente a su clase de atributo personalizado:

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)] 

La mejor y más sencilla forma que encontré para resolver este problema es simplemente concatenar roles en el atributo Authorize.

[Authorize(Roles = CustomRoles.Admin + "," + CustomRoles.OtherRole)]

con CustomRole una clase con cadenas constantes como esta:

public static class CustomRoles
{
    public const string Admin = "Admin";
    // and so on..
}

Lo que hice es la respuesta en @Tieson

Modifico un poco su respuesta. En lugar de cadena. ¿Por qué no convertirlo en una lista?

Esta es mi respuesta:

public class AuthorizeRolesAttribute : AuthorizeAttribute
{
    private new List<string> Roles;
    public AuthorizeRolesAttribute(params string[] roles) : base()
    {
        Roles = roles.toList()
    }
}

Y luego verifique si el rol es válido anulando OnAuthorization

public override void OnAuthorization(HttpActionContext actionContext)
{
            if (Roles == null)
                HandleUnauthorizedRequest(actionContext);
            else
            {
                ClaimsIdentity claimsIdentity = HttpContext.Current.User.Identity as ClaimsIdentity;
                string _role = claimsIdentity.FindFirst(ClaimTypes.Role).Value;
                bool isAuthorize = Roles.Any(role => role == _role);

                if(!isAuthorize)
                    HandleUnauthorizedRequest(actionContext);
            }
        }

Y ahí lo tienes, ahora está validando si el rol está autorizado para acceder al recurso

Siento que un atributo de autorización personalizado es excesivo para este problema, a menos que tenga una gran cantidad de roles.

Dado que la cadena debe conocerse en el momento de la compilación, ¿por qué no crear una clase de rol estático que contenga cadenas públicas de los roles que ha definido y luego agregar cadenas separadas por comas con ciertos roles que desea autorizar?

public static class Roles
{
    public const string ADMIN = "Admin";
    public const string VIEWER = "Viewer";

    public const string ADMIN_OR_VIEWER = ADMIN + "," + VIEWER;
}

Y luego puede usar el atributo de autorización como tal en la clase de controlador o el método de controlador (o ambos):

[Authorize(Roles = Roles.ADMIN]
public class ExampleController : Controller
{
    [Authorize(Roles = Roles.ADMIN_OR_VIEWER)
    public ActionResult Create()
    {
        ..code here...
    }
}