Bonjour, je me pose quelques questions sur les operators et de leur utilité.
Par exemple, le compilateur demande de définir '!=' quand '==' est définit.
Logique puisque '!(==)' égal à '!='. Donc quand '<' est définit le
compilateur devrait demander '=>' (car égal à '!(<)'). Mais le compil veut
'>' !!! Bon ok, ceci n'est qu'un petit détail sans intérêt mais j'en
comprends pas la logique.
Le fait que les operators ne puissent pas être appliqués aux classes
génériques, me prouve leur mauvais implémentation philosophique. J'aimerai
savoir s'il va y avoir une amélioration dans ce domaine (dans C# 3) ?
C'est pourquoi je me demande s'il ne serait pas plus simple de carrément les
enlever !? Je veux dire que leur implémentation soit implicite. Par exemple
pour que les operators '==', '!=', '=<', '>', '<' et '<=' soient valide il
suffirait d'implémenter la méthode 'Compare' avec l'interface IComparable ou
seulement IEqualCompare pour '==' et '!='. Avec ceci plus de problème en
génériques (avec un code plus court et moins redondant). A noter que les
operators comme '+=' allaient déjà dans ce sens.
Idem pour l'operator '+' où il suffirait d'implémenter la méthode 'Add' (non
statique). Donc Il faudrait que 'int', 'double', etc... dérivent d'une (des)
interface(s) 'IAddable'. Grâce à cela, les langages ne supportant les
operators pourront toujours accéder au méthode les définissants.
Bon, il doit sûrement exister des milliers de cas particuliers ne permettant
pas de réaliser les choses de cette façon. C'est pourquoi j'attends votre
avis sur la question.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Philippe MASINA
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que j'en ai vu au niveau de la spec.
"ijk" a écrit :
Bonjour, je me pose quelques questions sur les operators et de leur utilité.
Par exemple, le compilateur demande de définir '!=' quand '==' est définit. Logique puisque '!(==)' égal à '!='. Donc quand '<' est définit le compilateur devrait demander '=>' (car égal à '!(<)'). Mais le compil veut '>' !!! Bon ok, ceci n'est qu'un petit détail sans intérêt mais j'en comprends pas la logique.
Le fait que les operators ne puissent pas être appliqués aux classes génériques, me prouve leur mauvais implémentation philosophique. J'aimerai savoir s'il va y avoir une amélioration dans ce domaine (dans C# 3) ?
C'est pourquoi je me demande s'il ne serait pas plus simple de carrément les enlever !? Je veux dire que leur implémentation soit implicite. Par exemple pour que les operators '==', '!=', '=<', '>', '<' et '<=' soient valide il suffirait d'implémenter la méthode 'Compare' avec l'interface IComparable ou seulement IEqualCompare pour '==' et '!='. Avec ceci plus de problème en génériques (avec un code plus court et moins redondant). A noter que les operators comme '+=' allaient déjà dans ce sens.
Idem pour l'operator '+' où il suffirait d'implémenter la méthode 'Add' (non statique). Donc Il faudrait que 'int', 'double', etc... dérivent d'une (des) interface(s) 'IAddable'. Grâce à cela, les langages ne supportant les operators pourront toujours accéder au méthode les définissants.
Bon, il doit sûrement exister des milliers de cas particuliers ne permettant pas de réaliser les choses de cette façon. C'est pourquoi j'attends votre avis sur la question.
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà
avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à
ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que
j'en ai vu au niveau de la spec.
"ijk" a écrit :
Bonjour, je me pose quelques questions sur les operators et de leur utilité.
Par exemple, le compilateur demande de définir '!=' quand '==' est définit.
Logique puisque '!(==)' égal à '!='. Donc quand '<' est définit le
compilateur devrait demander '=>' (car égal à '!(<)'). Mais le compil veut
'>' !!! Bon ok, ceci n'est qu'un petit détail sans intérêt mais j'en
comprends pas la logique.
Le fait que les operators ne puissent pas être appliqués aux classes
génériques, me prouve leur mauvais implémentation philosophique. J'aimerai
savoir s'il va y avoir une amélioration dans ce domaine (dans C# 3) ?
C'est pourquoi je me demande s'il ne serait pas plus simple de carrément les
enlever !? Je veux dire que leur implémentation soit implicite. Par exemple
pour que les operators '==', '!=', '=<', '>', '<' et '<=' soient valide il
suffirait d'implémenter la méthode 'Compare' avec l'interface IComparable ou
seulement IEqualCompare pour '==' et '!='. Avec ceci plus de problème en
génériques (avec un code plus court et moins redondant). A noter que les
operators comme '+=' allaient déjà dans ce sens.
Idem pour l'operator '+' où il suffirait d'implémenter la méthode 'Add' (non
statique). Donc Il faudrait que 'int', 'double', etc... dérivent d'une (des)
interface(s) 'IAddable'. Grâce à cela, les langages ne supportant les
operators pourront toujours accéder au méthode les définissants.
Bon, il doit sûrement exister des milliers de cas particuliers ne permettant
pas de réaliser les choses de cette façon. C'est pourquoi j'attends votre
avis sur la question.
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que j'en ai vu au niveau de la spec.
"ijk" a écrit :
Bonjour, je me pose quelques questions sur les operators et de leur utilité.
Par exemple, le compilateur demande de définir '!=' quand '==' est définit. Logique puisque '!(==)' égal à '!='. Donc quand '<' est définit le compilateur devrait demander '=>' (car égal à '!(<)'). Mais le compil veut '>' !!! Bon ok, ceci n'est qu'un petit détail sans intérêt mais j'en comprends pas la logique.
Le fait que les operators ne puissent pas être appliqués aux classes génériques, me prouve leur mauvais implémentation philosophique. J'aimerai savoir s'il va y avoir une amélioration dans ce domaine (dans C# 3) ?
C'est pourquoi je me demande s'il ne serait pas plus simple de carrément les enlever !? Je veux dire que leur implémentation soit implicite. Par exemple pour que les operators '==', '!=', '=<', '>', '<' et '<=' soient valide il suffirait d'implémenter la méthode 'Compare' avec l'interface IComparable ou seulement IEqualCompare pour '==' et '!='. Avec ceci plus de problème en génériques (avec un code plus court et moins redondant). A noter que les operators comme '+=' allaient déjà dans ce sens.
Idem pour l'operator '+' où il suffirait d'implémenter la méthode 'Add' (non statique). Donc Il faudrait que 'int', 'double', etc... dérivent d'une (des) interface(s) 'IAddable'. Grâce à cela, les langages ne supportant les operators pourront toujours accéder au méthode les définissants.
Bon, il doit sûrement exister des milliers de cas particuliers ne permettant pas de réaliser les choses de cette façon. C'est pourquoi j'attends votre avis sur la question.
ijk
"Philippe MASINA" a écrit :
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que j'en ai vu au niveau de la spec.
Desolé d'avoir fait un racourci. Quand je veux dire que les operators ne marchent pas avec les génériques, je le sous-entends dans un exemple comme celui-ci :
class Bidule<T> { void Truc(T a, T b) { ... T c = a + b; // erreur à la compil. ... } }
Il n'y a aucun moyen d'indiquer au compil cette operation. Donc impossible de faire une classe/structure générique sur les nombres complexes. Si seulement les 'float' et autres 'double' possédaient une interface 'ICalulable' implementant un 'Add', 'Sub', 'Mult', etc...
"Philippe MASINA" a écrit :
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà
avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à
ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que
j'en ai vu au niveau de la spec.
Desolé d'avoir fait un racourci. Quand je veux dire que les operators ne
marchent pas avec les génériques, je le sous-entends dans un exemple comme
celui-ci :
class Bidule<T>
{
void Truc(T a, T b)
{
...
T c = a + b; // erreur à la compil.
...
}
}
Il n'y a aucun moyen d'indiquer au compil cette operation.
Donc impossible de faire une classe/structure générique sur les nombres
complexes.
Si seulement les 'float' et autres 'double' possédaient une interface
'ICalulable' implementant un 'Add', 'Sub', 'Mult', etc...
Je suis surpris du fait que cela ne fonctionne pas car j'ai déjà utiliser cà avec == et !=, y compris avec des generics. Dans la spec de LINQ, il n'y a à ma connaissance rien de + au niveau de la surcharge des opérateurs de ce que j'en ai vu au niveau de la spec.
Desolé d'avoir fait un racourci. Quand je veux dire que les operators ne marchent pas avec les génériques, je le sous-entends dans un exemple comme celui-ci :
class Bidule<T> { void Truc(T a, T b) { ... T c = a + b; // erreur à la compil. ... } }
Il n'y a aucun moyen d'indiquer au compil cette operation. Donc impossible de faire une classe/structure générique sur les nombres complexes. Si seulement les 'float' et autres 'double' possédaient une interface 'ICalulable' implementant un 'Add', 'Sub', 'Mult', etc...
