sténographie conditionnelle en C# similaire à SQL « dans » mot-clé

Question

En C# est-il un moyen raccourci d'é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 l'interrupteur, mais il y a probablement une cinquantaine de fonctions comme celle-ci que je dois écrire (en transférant un site ASP classique vers ASP.NET), donc je voudrais les garder aussi courtes que possible.

Answer 1

Que pensez-vous de cela?

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

Utilisation:

Personnel userId = Personnel.JohnDoe; 

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

Je ne peux pas demander un crédit pour cela, mais je peux aussi ne me souviens pas où je l'ai vu. Donc, crédit à vous, étranger anonyme sur Internet.

Answer 2

Je voudrais encapsuler la liste des ID autorisés comme données pas code. Ensuite, sa source peut être changée facilement plus tard.

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 à des méthodes d'extension.

(Cette fonction ne doit pas être statique Voir cette annonce:.. using too much static bad or good ?)

Answer 3

Que diriez-vous quelque chose comme ceci:

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 changer l'état statique, initialiser les ID classe dans un autre endroit, utilisez un IEnumerable <>, etc., en fonction de vos besoins. le point principal est que le plus proche équivalent au à opérateur dans SQL est la fonction Collection.Contains().)

Answer 4

Les autorisations sont-elles basées sur l'identifiant de l'utilisateur? Si c'est le cas, vous pouvez obtenir une meilleure solution en accédant aux autorisations basées sur les rôles. Vous pouvez également devoir modifier cette méthode assez fréquemment pour ajouter d'autres utilisateurs à 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

Un petit truc sympa est sorte d'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 placer autant d'entrées dans le tableau que vous le souhaitez.

Si le Personnel.x est un ENUM que vous auriez des problèmes de coulée avec ce (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

est ici le plus proche que je peux penser à:

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

Answer 7

Juste une autre idée de syntaxe:

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

Answer 8

Pouvez-vous écrire un iter ator pour le 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; 
}