Fonction max générique avec valeur nullable

Version imprimable

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:

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:

Citation:

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

11/07/2012, 17h52
tomlev

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

Code:

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

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:

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.

12/07/2012, 10h01
tomlev

Fais gaffe, dans ta 2e surcharge ça va planter sur val2 vaut null...
12/07/2012, 10h14
soazig

je ne comprends pas ta remarque tomlev.

Citation:

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

La deuxième surcharge:

Code:

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
12/07/2012, 10h34
tomlev

Citation:

Envoyé par soazig

je ne comprends pas ta remarque tomlev.

La deuxième surcharge:

Code:

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

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:

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

12/07/2012, 10h52
antoine.debyser

Bonjour,

Le problème indiqué par Tomlev est ici

Code:

if (val2.CompareTo(val1) < 0)

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