Discussion :

[Maniak]

(gah, toujours le bug quand il y a plusieurs niveaux de quotes

- pas de polymorphisme avec les méthodes statiques

Désolé, c'est faux. Je l'ai vérifié en C# et en C++/CLI.

Tu as réussi à faire une méthode statique virtuelle ? Faudra m'expliquer alors

- pas de moyen de remplacer l'instance par une version 'light' pour les tests

Là, je ne vois pas la différence.

Parce que tu n'en as pas fait

Exemple bidon :
- tu as une méthode qui effectue un traitement lourd, qui accède à des ressources distantes, pas disponibles en dehors de l'environnement d'exécution normal etc.
- tu veux tester un bout de code qui utilise notamment cette méthode. Tu te fiches de ce qu'elle fait, c'est le reste que tu veux tester.

Si c'est une méthode statique, pas le choix, il faut te taper le traitement. Donc s'il y a besoin de mettre en place tout un environnement autour pour que ce traitement marche, il faut le simuler.

Si cette méthode est utilisée via un singleton, il y a toujours moyen de remplacer ce singleton par un mock, qui ne ferait aucun traitement spécial mais renverrait simplement des données bidons. Rien de spécial à mettre en place, tu te concentres sur ce que tu veux tester.

(et bien sûr, le mieux est encore de ne pas avoir besoin de point d'accès global à quoi que ce soit, et de passer directement aux objets ce dont ils ont besoin, genre dans leur constructeur)

Maintenant je présume qu'il faut s'être tapé des tests unitaires de systèmes blindés de dépendances de ce genre pour que l'intérêt saute aux yeux

Pour autant on surcharge souvent l'opérateur + pour ajouter un élément à une liste par exemple.

Tu as un exemple sous la main ? Je vois mal comment on pourrait utiliser 'a = b + c' pour faire ce genre de choses. À moins bien sûr d'aimer faire du code incompréhensible qui change discrètement la sémantique du langage.
Mais ceux qui font ça devraient être pendus

C'est le vice de la surcharge d'opérateurs. On peut l'utiliser pour faire des choses très différentes sémantiquement.

Cf au-dessus
C'est sûr qu'un développeur mal intentionné (ou mauvais, ou qui aime faire des trucs tordus qui perdent tout le monde, autrement dit un mauvais) peut toujours mettre le boxon. Pas que sur les opérateurs d'ailleurs.
D'où la pendaison.

En tout cas, voilà qui répond à ma question... et qui m'incite à ne jamais utiliser la surcharge d'opérateurs en C#

Pas plus mal, c'est rarement utile de toute façon
(juste si tu fais tes propres types 'valeur' et qu'ils sont censés pouvoir fonctionner avec les opérateurs arithmétiques normaux, et à condition de bien conserver la sémantique normale, comme théoriquement indiqué dans MSDN pour chaque opérateur

[rozwel]

Je vais m'attirer des foudres là mais je vais recopier tel quel un exemple tiré de l'introduction à C# de Serge Tahé, disponible sur DVP, chapitre 2.3.2:

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
 
using System;
using System.Collections;
// classe personne
public class listeDePersonnes : ArrayList{
  // redéfinition opérateur +
  // pour ajouter une personne à la liste  
  public static listeDePersonnes operator +(listeDePersonnes l, personne p){
    l.Add(p);
    return l;
  }// operator +
  // toString
  public override string ToString(){
    // rend (él1, él2, ..., éln)
    string liste="(";
    int i;
    // on parcourt le tableau dynamique
    for (i=0;i<Count-1;i++){
      liste+="["+base[i]+"]"+",";
    }//for
    // dernier élémenr
    if(Count!=0) liste+="["+base[i]+"]";
    liste+=")";
    return liste;
  }//ToString
  public static void Main(){
    // une liste de personnes
    listeDePersonnes l=new listeDePersonnes();
    // ajout de personnes
    l=l+new personne("jean",10)+new personne("pauline",12);
    // affichage
    Console.Out.WriteLine("l="+l);
    l=l+new personne ("tintin",27);
    Console.Out.WriteLine("l="+l);
  }//Main
}//class

[NicolasG]

Tu as réussi à faire une méthode statique virtuelle ? Faudra m'expliquer alors

Ah, on ne parlait pas de la même chose alors.
J'avais compris le polymorphisme paramétrique alors que tu parlais d'héritage.
Rien que pour ça, je commence à être convaincu par les avantages du pattern singleton. Oui je sais, je suis dur à convaincre.

Sinon, quand on est en test, il est aussi facile de remplacer une classe par une autre que de le faire pour une instance de ces classes.
Il y a toujours deux classes différentes, une de test et une fonctionnelle qui ont la même interface.

Pour l'exemple de roswel, il est à mon avis mauvais.
Toutes les collections du framework ont une interface cohérente avec une méthode Add() qui correspond à l'opérateur += plutôt qu'à l'opérateur +.
Comme l'a dit Maniak, quand on écrit tutu = toto + titi, cela suppose que tutu est un objet différent de toto et de titi.

En plus, la ligne suivante me gène beaucoup :

Code :

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

l=l+new personne("jean",10)+new personne("pauline",12);

Il faut vraiment être un expert pour savoir à quel variante cela correspond :

Code :

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

1
2
3
l=l+(new personne("jean",10)+new personne("pauline",12));
ou
l=(l+new personne("jean",10))+new personne("pauline",12);

Là, c'est évidemment la seconde.
Mois si on a défini l'opérateur + sur personne?

[davcha]

Je vais m'attirer des foudres là mais je vais recopier tel quel un exemple tiré de l'introduction à C# de Serge Tahé, disponible sur DVP, chapitre 2.3.2:

C'est là qu'on se dit que c'est pas parce que c'est écrit que c'est forcément vrai/correct/ce qu'il faut faire/etc...

Le gros problème que je vois tout de suite avec cet exemple, c'est que l'opérateur +, mathématiquement parlant, est sensé être commutative.
Et avec cette écriture là, c'est loin d'être évident.

Mois si on a défini l'opérateur + sur personne?

A priori ça reste la seconde. Il n'y a pas de différence de précédence entre + et +.

Par contre... l = l + new personne(...) * new personne(...); avec operator*(personne,personne) qui agit comme la création d'une liste de deux personnes....

Mais bon, là c'est vraiment débile de programmer comme ça, je trouve.

[Maniak]

Je vais m'attirer des foudres là mais je vais recopier tel quel un exemple tiré de l'introduction à C# de Serge Tahé, disponible sur DVP, chapitre 2.3.2:

Ah en effet.

Là pour le coup, j'aimerais bien voir un gros *ATTENTION ATTENTION NE JAMAIS FAIRE ÇA DANS DU VRAI CODE*
Un opérateur d'addition qui modifie une des opérandes, dans un cas d'appel particulier... non quoi :)

Sinon, quand on est en test, il est aussi facile de remplacer une classe par une autre que de le faire pour une instance de ces classes.
Il y a toujours deux classes différentes, une de test et une fonctionnelle qui ont la même interface.

Tu arrives à appeler des méthodes statiques via des interfaces toi ? :)

Un singleton peut implémenter une interface, cette interface peut être la seule exposée publiquement, donc on peut remplacer ça par un autre objet sans problème (il faut juste accepter d'avoir une propriété 'set' pour pouvoir changer l'instance, ce qui peut faire peur:)

Pour une méthode statique, il faut l'appeler en mettant le nom de la classe qui la contient. Comment veux-tu remplacer ça par une autre classe, mis à part avec des #if qu'il est hors de question d'utiliser pour ça ? :)