IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

Créer un "Set of" de delphi: en C#


Sujet :

C#

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    27
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations forums :
    Inscription : Juin 2008
    Messages : 27
    Par défaut Créer un "Set of" de delphi: en C#
    Bonjour,

    quelqu'un pourrait m'aider à convertir cette déclaration Delphi en CSharp s.v.p.


    Code Delphi : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    Type
       MonType = (mtType1, mtType2, mtType3);
       MesTypes = Set of MonType;


    je cherche aussi à convertir ceci qui sont en fait des constantes en delphi :

    Code Delphi : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
       kUnselectedStates   = [mtType1];
       kSelectedStates     = [mtType1, mtType2];
       kActivatedStates    = [mtType2, mtType3];


    merci.

  2. #2
    Membre averti
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    27
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations forums :
    Inscription : Juin 2008
    Messages : 27
    Par défaut
    Moi qui vient du monde de Delphi Win32, je trouve solide de convertir un composant.


    Je crois que je dois utiliser ENUM

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
        enum eUIState
        {   /* Null */
            None,
            /* Selection */
            Unselected, Selected, SelectActivated, Activated,
            /* Moving */
            Moving,
            /* Sizing */
            SizingWE, SizingNS, SizingNWSE, SizingNESW
        }

    ensuite, je dois me créer des constante regroupant certain status

    exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
       kUnselectedStates   = [uisUnselected];
       kSelectedStates     = [uisSelected, uisSelectActivated];
       kActivatedStates    = [uisActivated, uisSelectActivated];
       kNotActivatedStates = [uisUnselected, uisSelected];
       kSelectionStates    = [uisUnselected, uisSelected, uisSelectActivated, uisActivated];
    Ainsi, dans mon code .net, je désire pouvoir vérifier si mon statut est parmit kSelectedStates.

    Exemple en delphi :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    if ( MonStatut in kSelectedStates ) then
    // le status est bon;

    Je ne suis pas certain si .net fait exactement le même genre de déclaration.
    C'est ce que je cherche à savoir.

    Quelqu'un peut m'aider s.v.p.?

  3. #3
    Rédacteur/Modérateur


    Homme Profil pro
    Développeur .NET
    Inscrit en
    Février 2004
    Messages
    19 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2004
    Messages : 19 875
    Par défaut
    Tu peux faire un enum dont on peut combiner les valeurs en utilisant FlagsAttribute. Ca donne aux éléments de l'enum des valeurs dont un seul bit est à 1, ce qui permet de les combiner avec des OU binaires :
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
        [Flags]
        enum eUIState
        {   /* Null */
            None = 0, // pour t'assurer qu'il n'y a aucun bit à 1
            /* Selection */
            Unselected, Selected, SelectActivated, Activated,
            /* Moving */
            Moving,
            /* Sizing */
            SizingWE, SizingNS, SizingNWSE, SizingNESW
        }

    Pour combiner les valeurs, tu peux faire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    eUIState kSelectionStates = eUIState.uisUnselected | eUIState.uisSelected | eUIState.uisSelectActivated | eUIState.uisActivated;
    Après, pour tester si un état donné est dans kSelectionStates, tu utilises le ET binaire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    if ((MonStatut & kSelectionStates) != eUIState.None)
    {
        // le status est bon;
    }
    Par contre je connais pas delphi, donc je suis pas sûr que ce soit tout à fait équivalent d'un point de vue sémantique...

  4. #4
    Membre averti
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    27
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations forums :
    Inscription : Juin 2008
    Messages : 27
    Par défaut
    Donc, si je comprends bien, si je défini en numéro mes statut, j'ai donc 32 choix possible (int a 4 octets).

    Est-ce bien cela?

    Puis-je en ajouter 85 status? Je sais je sais, c'est trop mais je veux être certain de bien comprendre car pour moi la comparaison binaire limite au nombre de bits composés dans un type.

    en plus, j'ai remarqué que je dois déclarer cela comme variable (donc à l'intérieur d'un classe).

    Je voudrais simplement avoir une constante non modifiable.
    Est-ce possible de faire un readonly?

  5. #5
    Membre averti
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    27
    Détails du profil
    Informations personnelles :
    Localisation : Canada

    Informations forums :
    Inscription : Juin 2008
    Messages : 27
    Par défaut
    Voila, j'ai compris :

    je me suis inspiré du code de tomlev et de mes méninges suite à mon auto-formation

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    26
    27
    28
        public class UIStates
        {
            public enum UIState
            {   /* Null */
                None = 0, 
                /* Selection */
                Unselected = 1, Selected = 2, SelectActivated = 4, Activated = 8,
                /* Moving */
                Moving = 16,
                /* Sizing */
                SizingWE = 32, SizingNS = 64, SizingNWSE = 128, SizingNESW = 256
            }
     
            // Use the binary comparison to know if the status is in the offset.
            // Example : if ((VarState & UIStates.SelectionStates) != 0)          
            public readonly static UIState SelectedStates = 
                            UIState.Selected | UIState.SelectActivated;
     
            public readonly static UIState ActivatedStates =
                            UIState.Activated | UIState.SelectActivated;
     
            public readonly static UIState NotActivatedStates = 
                            UIState.Unselected | UIState.Selected;
     
            public readonly static UIState SelectionStates =
                            UIState.Unselected | UIState.Selected | 
                            UIState.SelectActivated | UIState.Activated;
        }

    Si quelqu'un a mieux je suis preneur car je cherche la meilleur solution.

  6. #6
    Rédacteur/Modérateur


    Homme Profil pro
    Développeur .NET
    Inscrit en
    Février 2004
    Messages
    19 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2004
    Messages : 19 875
    Par défaut
    Si tu effectues des combinaisons sur les états, il faut que tu mettes l'attribut Flags sur ton enum (cf. mon post précédent, et MSDN).

    Citation Envoyé par jimbolelephan Voir le message
    Donc, si je comprends bien, si je défini en numéro mes statut, j'ai donc 32 choix possible (int a 4 octets).

    Est-ce bien cela?

    Puis-je en ajouter 85 status? Je sais je sais, c'est trop mais je veux être certain de bien comprendre car pour moi la comparaison binaire limite au nombre de bits composés dans un type.
    Tu peux aller jusqu'à 64 valeurs si tu fais hériter ton enum de long (par défaut c'est int) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public enum UIState : long
    {
        ...
    }
    Citation Envoyé par jimbolelephan Voir le message
    en plus, j'ai remarqué que je dois déclarer cela comme variable (donc à l'intérieur d'un classe).

    Je voudrais simplement avoir une constante non modifiable.
    Est-ce possible de faire un readonly?
    Ben tu pourrais très bien les déclarer comme constantes (const) ... Mais de toutes façons, pour les combinaisons de plusieurs flags, tu peux (et tu devrais) aussi les définir dans l'enum. Au final, tu peux faire quelque chose comme ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
            [Flags]
            public enum UIState
            {   /* Null */
                None = 0,
                /* Selection */
                Unselected = 1, Selected = 2, SelectActivated = 4, Activated = 8,
                /* Moving */
                Moving = 16,
                /* Sizing */
                SizingWE = 32, SizingNS = 64, SizingNWSE = 128, SizingNESW = 256,
                /* Combinations */
                SelectedStates = Selected | SelectActivated,
                ActivatedStates = Activated | SelectActivated,
                NotActivatedStates = Unselected | Selected,
                SelectionStates = Unselected | Selected | SelectActivated | Activated
            }
    Ce qui est quand même un peu plus propre que l'enum englobé dans une classe...

    Autres lectures utiles sur les énumérations et les flags :
    Conception d'énumérations
    Conception d'énumérations d'indicateurs

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [VB.Net] "Impossible de créer le handle de fenêtre"
    Par cedric_g dans le forum Windows Forms
    Réponses: 4
    Dernier message: 06/04/2006, 12h49
  2. creér un user sous interbase avec appli delphi
    Par devalender dans le forum Bases de données
    Réponses: 2
    Dernier message: 15/08/2004, 12h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo