Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 3 sur 3
  1. #1
    Membre expérimenté Avatar de topolino
    Profil pro
    Inscrit en
    juillet 2003
    Messages
    1 743
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : juillet 2003
    Messages : 1 743
    Points : 564
    Points
    564

    Par défaut Conception - Utilisateur

    Bonjour,

    J'ai besoin de votre avis pour savoir si je vais bien dans la bonne direction.
    Voila, j'ai 3 types d'utilisateur (SimpleUser, ClientUser, AdminUser) dans mon application avec des action differentes, et cela est determiné au login de la personne.

    SimpleUser peut lire les infos
    ClientUser peut lire et ecrire les infos
    AdminUser peut lire, ecrire et effacer les infos

    Voila ce que je propose dans mon domain model de ma couche business:

    Enum User
    Code :
    1
    2
    3
    4
    5
    6
    7
     
        public enum UserType
        {
            SimpleUser = 0,
            ClientUser = 1,
            AdminUser = 2
        }
    interface IUser
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    public interface IUser
        {
            int Id { get; set; }
            string Name { get; set; }
            void ReadInfo();
            void WriteInfo();
            void DeleteInfo();
        }
    User
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
     
    public class User : IUser
        {
     
            public int Id { get; set; }
            public string Name { get; set; }
     
            public User(string name)
            {
                Name = name;
            }
     
            public virtual void ReadInfo()
            {
                string myCode = "Code Here: I can read";
            }
     
            public virtual void WriteInfo()
            {
            }
     
            public virtual void DeleteInfo()
            {
            }
        }
    SimpleUser
    Code :
    1
    2
    3
    4
    5
     
    public class SimpleUser : User
        {
     
        }
    ClientUser
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
     public class ClientUser: User
        {
            public ClientUser(string name)
                : base(name)
            { }
     
            public override void WriteInfo()
            {
                string myCode = "Code Here: I can write";
            }
        }
    AdminUser
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
     class AdminUser: ClientUser
        {
            public AdminUser(string name) : base(name) { }
     
            public override void DeleteInfo()
            {
                string myCode = "Code Here: I can delete";
            }
        }
    NullUser
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
     
        public class NullUser : User
        {
            public override void ReadInfo()
            {
     
            }
        }
    User Repository
    Code :
    1
    2
    3
    4
    5
     
        public interface IUserRepository
        {
            UserType LogIn(string userName);
        }
    UserFactory
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     
        public static class UserFactory
        {
            public static IUser GetUserStrategyFor(UserType userType, string name)
            {
                switch (userType)
                {
                    case UserType.SimpleUser:
                        return new User(name);
                    case UserType.ClientUser:
                        return new ClientUser(name);
                    case UserType.AdminUser:
                        return new AdminUser(name);
                    default:
                        return new NullUser();
                }
            }
        }
    UserService
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
     
        public class UserService
        {
            private IUserRepository _userRepository;
     
            public UserService(IUserRepository userRepository)
            {
                _userRepository = userRepository;
            }
     
            public IUser GetUser()
            {
                UserType userType = _userRepository.LogIn("test");
     
                IUser user = UserFactory.GetUserStrategyFor(userType, "test");
     
                return user;
            }    
        }
    Merci pour vos conseils.
    MCTS Microsoft.
    La conception : Prendre le temps pour gagner du temps.

  2. #2
    Expert Confirmé
    Homme Profil pro Benoît
    Inscrit en
    février 2003
    Messages
    1 710
    Détails du profil
    Informations personnelles :
    Nom : Homme Benoît
    Âge : 33
    Localisation : Belgique

    Informations forums :
    Inscription : février 2003
    Messages : 1 710
    Points : 2 704
    Points
    2 704

    Par défaut

    euh moi je ferai pas comme ca.

    Je mettrai dans User une variable de type UserType

    et dans les fonction Read,Delete je regarderait si le User a le level suffisant
    Je ne suis qu'un pauvre débutant alors ne frappez pas si mes idées ne sont pas bonnes

  3. #3
    Expert Confirmé
    Homme Profil pro Gérald Barré
    Ingénieur R&D
    Inscrit en
    avril 2010
    Messages
    1 165
    Détails du profil
    Informations personnelles :
    Nom : Homme Gérald Barré
    Âge : 23
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : avril 2010
    Messages : 1 165
    Points : 2 736
    Points
    2 736

    Par défaut

    Pourquoi ne pas utiliser l'attribut PrincipalPermissionAttribute
    http://msdn.microsoft.com/fr-fr/library/k8b3sz1a.aspx
    Code :
    1
    2
    [PrincipalPermission(SecurityAction.Demand, Role = 'AdminUser')]
    void MyMethod(){}
    Pensez à la balise ainsi qu'au petit pouce vert
    Mon blog : http://www.meziantou.net
    WindowManager : Gérer facilement vos différentes fenêtres

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •