Discussion :

[soazig]

Bonjour,
Je cherchais à faire une fonction MAx avec un type générique de façon à ne pas réinventer la poudre.
Voilà la fonction que j'ai écrite

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
       /// <summary>
        /// Renvoie le max de deux valeurs nullables
        /// </summary>
        /// <typeparam name="T">type de base</typeparam>
        /// <param name="val1"></param>
        /// <param name="val2"></param>
        /// <returns></returns>
        public static T? Max<T>(T? val1, T? val2) where T : IComparable
        {
            T? retVal = null;
            if (val1 == null)
                retVal = val2;
            if (val2 == null)
                retVal = val1;
 
            if ((val1.HasValue) && (val2.HasValue))
            {
                if (val2.Value.CompareTo(val1.Value) < 0)
                    retVal = val1;
            }
 
 
 
            return retVal;
        }

Elle ne compile pas message d'erreur:

Erreur 89 Le type 'T' doit être un type valeur non nullable afin d'être utilisé comme paramètre 'T' dans le type ou la méthode générique 'System.Nullable

En revanche je ne vois pas quelle sotise j'ai commise, je m'en remet donc à vous.
Merci
Soazig

[tomlev]

Il faut préciser que T est un type valeur, sinon T? n'a pas de sens

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public static T? Max<T>(T? val1, T? val2) where T : struct, IComparable

[soazig]

Bonjour,
merci pour la réponse c'était bien cela, et voici la version finale de la fonction.
La première avait un petit bug.

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
29
30
31
32
33
34
35
        /// <summary>
        /// Renvoie le max de deux valeurs nullables , si l'une est nulle le maximum est l'autre
        /// </summary>
        /// <typeparam name="T">type de base</typeparam>
        /// <param name="val1"></param>
        /// <param name="val2"></param>
        /// <returns></returns>
        public static T? Max<T>(T? val1, T? val2) where T : struct, IComparable
        {
            T? retVal = null;
            if (val1 == null)
                retVal = val2;
            if (val2 == null)
                retVal = val1;
 
            if ((val1.HasValue) && (val2.HasValue))
            {
                retVal = Max(val1.Value, val2.Value);
            }
            return retVal;
        }
        /// <summary>
        /// Renvoie le max de deux valeurs qui implémente Icomparable
        /// </summary>
        /// <typeparam name="T">type de base</typeparam>
        /// <param name="val1">première valeur à comparer</param>
        /// <param name="val2">deuxième valeur à comparer</param>
        /// <returns></returns>
        public static T Max<T>(T val1, T val2) where T :  IComparable
        {
            T retVal = val2;
            if (val2.CompareTo(val1) < 0)
                retVal = val1;
            return retVal;
        }

En espérant que cela puisse aider d'autres personnes.

[tomlev]

Fais gaffe, dans ta 2e surcharge ça va planter sur val2 vaut null...

[soazig]

je ne comprends pas ta remarque tomlev.

Fait gaffe, dans ta 2e surcharge ça va planter sur val2 vaut null...

La deuxième surcharge:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 public static T Max<T>(T val1, T val2) where T :  IComparable

C'est celle de signature non nullable.

La première fonctionne avec des paramètres null.

Soazig

[tomlev]

je ne comprends pas ta remarque tomlev.


La deuxième surcharge:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 public static T Max<T>(T val1, T val2) where T :  IComparable

C'est celle de signature non nullable.

La première fonctionne avec des paramètres null.

Soazig

Bah si T est un type référence (String ou Version par exemple), ça peut être null... Si tu veux gérer seulement les types valeurs, ajoute une contrainte struct comme sur la 1e surcharge

[soazig]

Et voilà, j'espère la version finale, je n'ai corrigé que la deuxième surcharge, et les commentaires de la première.

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
29
30
31
32
33
34
35
36
37
38
39
40
        /// <summary>
        /// Renvoie le max de deux valeurs nullables , si l'une est nulle le maximum est l'autre
        /// </summary>
        /// <typeparam name="T">type de base</typeparam>
        /// <param name="val1">première valeur à comparer</param>
        /// <param name="val2">deuxième valeur à comparer</param>
        /// <returns></returns>
        public static T? Max<T>(T? val1, T? val2) where T : struct, IComparable
        {
            T? retVal = null;
            if (val1 == null)
                retVal = val2;
            if (val2 == null)
                retVal = val1;
 
            if ((val1.HasValue) && (val2.HasValue))
            {
                retVal = Max(val1.Value, val2.Value);
            }
            return retVal;
        }
        /// <summary>
        /// Renvoie le max de deux valeurs qui implémentent Icomparable
        /// </summary>
        /// <typeparam name="T">type de base</typeparam>
        /// <param name="val1">première valeur à comparer</param>
        /// <param name="val2">deuxième valeur à comparer</param>
        /// <returns></returns>
        public static T Max<T>(T val1, T val2) where T :  IComparable
        {
            T retVal = val2;
            if (val1 != null && val2 != null)
            {
                if (val2.CompareTo(val1) < 0)
                    retVal = val1;
            }
            else
                retVal = default(T);
            return retVal;
        }

Merci de tes conseil tomlev.
soazig

[antoine.debyser]

Bonjour,

Le problème indiqué par Tomlev est ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if (val2.CompareTo(val1) < 0)

EDIT :
Erf j'ai raté un bou de la discution