Raccourci conditionnel en C# similaire au mot clé SQL 'in'

Question

En C#, existe-t-il un raccourci pour écrire ceci :

public static bool IsAllowed(int userID)
{
    return (userID == Personnel.JohnDoe || userID == Personnel.JaneDoe ...);
}

Comme:

public static bool IsAllowed(int userID)
{
    return (userID in Personnel.JohnDoe, Personnel.JaneDoe ...);
}

Je sais que je pourrais aussi utiliser switch, mais il y a probablement une cinquantaine de fonctions comme celle-ci que je dois écrire (portage d'un site ASP classique sur ASP.NET), donc j'aimerais les garder aussi courtes que possible.

Answer 1

Que dis-tu de ça?

public static class Extensions
{
    public static bool In<T>(this T testValue, params T[] values)
    {
        return values.Contains(testValue);
    }
}

Usage:

Personnel userId = Personnel.JohnDoe;

if (userId.In(Personnel.JohnDoe, Personnel.JaneDoe))
{
    // Do something
}

Je ne peux pas en revendiquer le mérite, mais je ne me souviens pas non plus où je l'ai vu.Alors, merci à vous, étranger anonyme sur Internet.

Answer 2

Que diriez-vous quelque chose comme ça:

public static bool IsAllowed(int userID) {
  List<int> IDs = new List<string> { 1,2,3,4,5 };
  return IDs.Contains(userID);
}

(Vous pouvez bien sûr modifier le statut statique, initialiser la classe IDs à ​​un autre endroit, utiliser un IEnumerable<>, etc., en fonction de vos besoins.Le point principal est que l'équivalent le plus proche du dans L’opérateur en SQL est la fonction Collection.Contains().)

Answer 3

J'encapsulerais la liste des identifiants autorisés comme données pas code.Ensuite, sa source peut être facilement modifiée ultérieurement.

List<int> allowedIDs = ...;

public bool IsAllowed(int userID)
{
    return allowedIDs.Contains(userID);
}

Si vous utilisez .NET 3.5, vous pouvez utiliser IEnumerable au lieu de List grâce aux méthodes d'extension.

(Cette fonction ne doit pas être statique.Voir cette publication : utiliser trop de statique, mauvais ou bon ?.)

Answer 4

Les autorisations sont-elles basées sur l’ID utilisateur ?Si tel est le cas, vous obtiendrez peut-être une meilleure solution en accédant aux autorisations basées sur les rôles.Ou vous devrez peut-être modifier cette méthode assez fréquemment pour ajouter des utilisateurs supplémentaires à la liste des « utilisateurs autorisés ».

Par exemple, Enum Userrole {utilisateur, administrateur, lordemperor}

class User {
    public UserRole Role{get; set;}
    public string Name {get; set;}
    public int UserId {get; set;}
}

public static bool IsAllowed(User user) {
    return user.Role == UserRole.LordEmperor;
}

Answer 5

Une petite astuce intéressante consiste en quelque sorte à inverser la façon dont vous utilisez habituellement .Contains(), comme : -

public static bool IsAllowed(int userID) {
  return new int[] { Personnel.JaneDoe, Personnel.JohnDoe }.Contains(userID);
}

Où vous pouvez mettre autant d’entrées dans le tableau que vous le souhaitez.

Si Personnel.x est une énumération, vous rencontrerez des problèmes de diffusion avec cela (et avec le code original que vous avez publié), et dans ce cas, il serait plus facile à utiliser : -

public static bool IsAllowed(int userID) {
  return Enum.IsDefined(typeof(Personnel), userID);
}

Answer 6

Voici le plus proche auquel je puisse penser :

using System.Linq;
public static bool IsAllowed(int userID)
{
  return new Personnel[]
      { Personnel.JohnDoe, Personnel.JaneDoe }.Contains((Personnel)userID);
}

Answer 7

Pouvez-vous écrire un itérateur pour Personnel.

public static bool IsAllowed(int userID)
{
    return (Personnel.Contains(userID))
}

public bool Contains(int userID) : extends Personnel (i think that is how it is written)
{
    foreach (int id in Personnel)
        if (id == userid)
            return true;
    return false;
}

Answer 8

Juste une autre idée de syntaxe :

return new [] { Personnel.JohnDoe, Personnel.JaneDoe }.Contains(userID);