Vérifier que ma variable contient bien une valeur de ma structure

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

j'utilise la structure pour la première fois parce que j'ai une variable qui ne peux prendre que 6 valeurs (en base je fais un check pour voir si elle est égale à une de ces valeurs).

donc j'ai ma structure (incomplète encore):
Code:

1 2 3 4 5 6 public struct TypeCategorie { public static const string Secteur = "Secteur"; public static const string Complexe = "Complexe"; }
et ma variable qui prend une de ces valeurs:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public string Categorie { get; set { if (value == TypeCategorie.Secteur) { Categorie = value; } else { throw new Exception("La catégorie d'exploitation est incorrecte: elle doit correspondre a secteur, complexe..."); } } }
je voulais déjà savoir si ce code était correcte et si c'était possible de vérifier si ma variable était bien égale à un des champs de ma structure sans faire la vérification champs par champs.

30/06/2011, 11h20
Er3van

Si TypeCategorie était une classe, tu pourrais lui affecter une méthode statique du type

Code:

public static boolean IsTypeCategorie(String value) { ... }

Ca serait sans doute plus propre que de tout tester dans ta classe consommatrice.

ça revient à faire une vérification champs par champs?
je voulais savoir s'il existait un moyen de faire ça

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public string Categorie
        {
            get;
            set
            {
                if (value == ValueOf(TypeCategorie))
                { Categorie = value; }
                else
                { throw new Exception("La catégorie d'exploitation est incorrecte: elle doit correspondre a secteur, complexe..."); }
            }
        }

Une fonction déjà toute faite qui permettrait de faire ça?

30/06/2011, 11h48
NicoL__

Et pourquoi pas une enum ça simplifierait la chose non ?
30/06/2011, 11h53
Er3van

Tu pourrais utiliser le mot clé IS si tu construisais tes avec la classe TypeCategorie, mais à mon avis tu les construits avec String...

(Et ça ferait une utilisation farfelue...)
30/06/2011, 11h54
youtpout978
le problème de l’énumération c'est qu'il ne peut pas renvoyer de string ce qui reviendrait à faire un switch derrière pour récupérer la string correspondant a mon enum alors qu'avec la structure je peut directement affecté une string en faisant:
Code:

1 2 3 Exploitation test=new Exploitation(); test.Categorie = Exploitation.TypeCategorie.Secteur;

bon bein on va faire une vérification champs par champs

Code:

1
2
3
4
5
6
7
8
9
 
private bool IsTypeCategorie(string value)
        {
            bool ok = false;
            if (value == TypeCategorie.Complexe || value == TypeCategorie.Secteur)
            { ok = true; }
 
            return ok;
        }

30/06/2011, 12h44
NicoL__

un enum peut renvoyer : toString()
http://msdn.microsoft.com/en-us/library/16c1xs4z.aspx

Autre option :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class TypeCategorie
        {
           private static const string Secteur = "Secteur";
           private static const string Complexe = "Complexe";
           private static const List<String> categories = new List<string> { Secteur, Complexe };
 
           private bool IsTypeCategorie(string value)
           {
               if (categories.contains(value)) {
                      return true;
               }
               return false;
           }
        }

30/06/2011, 13h53
youtpout978
pour l'enum toString on est obligé de faire:
Code:

1 2 3 Enum typeCategorie=TypeCategorie.Complexe; String categorie=typeCategorie.ToString();
et pour la classe ça m'oblige a créer une liste contenant toutes les valeur en plus je voudrais pourvoir faire simplement:
Code:

1 2 String categorie=TypeCategorie.Complexe;
on dirait qu'il n'y a pas vraiment de méthode permettant le listing de tout ce qu'une structure contient ce qui m'aurai permis de faire une simple recherche dessus.

tu veux peut être créer un List<TypeCategorie>, franchement je crois pas que tu es compris ce qu'est une struct par rapport à une class... ça se ressemble beaucoup.
Enfin moi ce que j'ai compris de ton problème ça donne ça comme solution :
Code:

1 2 enum TypeCategorie {Secteur, Complexe}
Variable :
Code:

1 2 3 4 5 6 7 8 9 public TypeCategorie Categorie { get; set; } public String CategorieString { get{return Categorie.toString()} }

Si, si tu veux y accéder aussi en lecture :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class TypeCategorie
        {
           private static const string _secteur = "Secteur";
           public static string Secteur {
                 get { return _secteur ; }
           }
 
           private static const string _complexe = "Complexe";
           public static string Complexe {
                 get { return _complexe ; }
           }
 
           private static const List<String> categories = new List<string> { Secteur, Complexe };
 
           private bool IsTypeCategorie(string value)
           {
               if (categories.contains(value)) {
                      return true;
               }
               return false;
           }
        }

Là tu peux bien faire TypeCategorie.Complexe, et tu peux ne pas parcourir l'ensemble. Je vois difficilement comment faire mieux dans ton cas...

Voilà ce que j'ai fais:

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
26
27
28
29
30
31
 
 
    public class Exploitation : ObjetDomaine
    {
        public string Identifiant { get; set; }
        public string Parent_id { get; set; }
        public string Libelle { get; set; }
        public string Categorie
        {
            get { return Categorie; }
            set
            {
                if (TypeCategorie.categories.Contains(value))
                { Categorie = value; }
                else
                { throw new Exception("La catégorie d'exploitation est incorrecte: elle doit correspondre à secteur, complexe..."); }
            }
        }
 
 
        public struct TypeCategorie
        {
            public const string Secteur = "Secteur";
            public const string Complexe = "Complexe";
            public const List<string> categories = new List<string> { Secteur, Complexe };
 
        }
 
        public Exploitation() { }
 
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
 public class Exploitation : ObjetDomaine
    {
        public enum TypeCategorie {Secteur, Complexe}
        private TypeCategorie  cat;
        public string Identifiant { get; set; }
        public string Parent_id { get; set; }
        public string Libelle { get; set; }
 
        public string Categorie
        {
            get { return cat.ToString(); }
            set
            {
               cat = (TypeCategorie ) Enum.Parse(typeof(TypeCategorie ), value, true);
            }
        }
 
        public Exploitation() { }
 
    }

ça enverra une exception (ArgumentException) si la valeur n'est pas possible.

30/06/2011, 15h32
youtpout978

merci pour cette seconde solution, je comprends pas pourquoi ils n'ont pas rajouté la possibilité d'énumérer des string et autre ...
30/06/2011, 15h53
Nathanael Marchand

On parle de ca?

Code:

var list = Enum.GetNames(typeof(MonEnum));
30/06/2011, 15h53
NicoL__

Oui c'est vrai, de base l'enum se converti implicitement en int donc c'est pratique si on manipule des entiers. Et en général en base de données le pk et autre id sont numérique donc ça marche bien.
Avec les string les enum sont moyennement pratique, c'est un peu tordu.
30/06/2011, 15h59
Nathanael Marchand

Je rajoute égalment que les structures NE SONT PAS FAITES POUR CA
La seule différence entre une classe et une structure c'est que la première est un type valeur, l'autre un type référence.

Citation:

Envoyé par Nathanael Marchand

Je rajoute égalment que les structures NE SONT PAS FAITES POUR CA

+1000

Dans le code de l'appli sur laquelle je bosse au bureau il y avait un truc comme ça, j'ai sauté au plafond quand je l'ai vu :
Code:

1 2 3 4 5 6 7 8 9 public struct ItemState { public const int ToBeSaved = 0; public const int Saved = 1; public const int NotModified = 2; public const int Deleted = 3; public const int UnSelected = 4; public const int Incomplete = 5; }
Ici c'est très clairement un enum qu'il faut utiliser. On peut tester si une valeur appartient à l'enum avec la méthode Enum.IsDefined (ça peut prendre un paramètre une valeur de l'enum, ou le nom d'une valeur de l'enum)

Citation:
Envoyé par tomlev
+1000

Dans le code de l'appli sur laquelle je bosse au bureau il y avait un truc comme ça, j'ai sauté au plafond quand je l'ai vu :
Code:

1 2 3 4 5 6 7 8 9 public struct ItemState { public const int ToBeSaved = 0; public const int Saved = 1; public const int NotModified = 2; public const int Deleted = 3; public const int UnSelected = 4; public const int Incomplete = 5; }
Ici c'est très clairement un enum qu'il faut utiliser. On peut tester si une valeur appartient à l'enum avec la méthode Enum.IsDefined (ça peut prendre un paramètre une valeur de l'enum, ou le nom d'une valeur de l'enum)
Surtout qu'en fait, que ca soit une structure ou une classe, ca change strictement rien car aucune instance n'est jamais créée, c'est des membres statiques ou des constantes remplacées au moment de la compilation!

Voir 40 message(s) de cette discussion en une page