C# s'enrichit d'un safe navigator operator
à l'image de Groovy, l'opérateur «?.» fait son entrée

Le , par Arsene Newman, Expert éminent sénior
C#, l'un des nombreux apports de Microsoft au développement informatique, figure actuellement parmi les langages les plus populaires selon l'index TIOBE, nul doute que son succès est dû au succès conjoint des systèmes d'exploitation Microsoft et de la plate-forme .Net, toutefois il demeure possible que son succès soit relatif à son équipe de développement qui reste à l'écoute de sa communauté et met à sa disposition un système de retour d'expérience (FeedBack) tel que www.uservoice.com.

C'est ainsi donc qu'il a été décidé d'introduire le nouvel opérateur «?.» au langage C#, après que cette suggestion ait perçu plus de 4.313 votes favorables. Appelé aussi en anglais Safe Navigation Operator, l'opérateur «?.» permet de vérifier si la référence à un membre d'une classe est égale à Null au lieu de générer une exception de type NullReferenceException, économisant par la même occasion plusieurs lignes de code au programmeur.

La force de l'opérateur prend tout son sens, lorsqu'il s'agit d'une référence à un membre d'une classe, qui est membre d'une autre classe et ainsi de suite, dans ce genre de situation il s’avère plus difficile de détecter l'origine de l'exception, un exemple vaut mieux qu'un long discours, considérant ce qui suit :
Code : Sélectionner tout
var g1 = parent.child.child.child;
Si un des child contient la valeur Null, une exception sera levée :
Code : Sélectionner tout
var g1 = [parent].[child].[null].child;

L'utilisation du nouvel opérateur permet d'assigner la valeur Null à la variable, dans le cas où une des références vaut Null :
Code : Sélectionner tout
1
2
var g1 = parent?.child?.child?.child; 
if (g1 != null) // TODO
Au lieu d'un long code équivalent :
Code : Sélectionner tout
1
2
3
4
5
var item = this.Parent; 
item = (item == null) ? null : item.child; 
item = (item == null) ? null : item.child; 
var g1 = (parent == null) ? null : item.child; 
if (g1 != null) // TODO
Enfin Mads Torgersen, le manager du projet C# a révélé que même si cet opérateur a reçu les faveurs de la communauté, son introduction était sur les rails depuis plusieurs mois, vu son utilité, sa facilité d'utilisation. Reste à savoir donc la date de sortie de la prochaine version du langage incluant cet opérateur.

Source : Annonce sur MSDN

Et vous ?
Qu’en pensez-vous ?
Pensez-vous que cet opérateur sera introduit prochainement dans d'autres langages ?


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse

Avatar de Derf59 Derf59 - Membre régulier https://www.developpez.com
le 05/03/2014 à 10:02
Pour moi c'est une abérration, je m'explique :

Si l'on écrit
var g1 = parent?.child1?.child2?.child3;

et qu'on imagine fonctionnellement que la valeur [null] est une valeur possible de child3 mais une valeur qui ne devrait pas arriver sur les parent/child1/child2,
ce type d'affectation masque complétement le problème.

var g1 = parent?.child1?.child2?.child3;
if (g1 != null)
...
Avatar de Beowulf59 Beowulf59 - Membre actif https://www.developpez.com
le 05/03/2014 à 10:22
@Derf59 :

Dans ce cas là l'opérateur n'a pas de raison d'être, vu qu'on ne fait pas child3.child...
Mais si en revanche la valeur null est possible en child2 est pas en child1, rien n'empêche de l'écrire sous la forme :
var g1 = parent.child1.child2?.child3;

Non ? A moins que j'ai mal compris ce point là.

De mon point de vue c'est un opérateur très pratique, mais qu'il faudra utiliser avec parcimonie.
Avatar de tomlev tomlev - Rédacteur/Modérateur https://www.developpez.com
le 05/03/2014 à 10:27
Citation Envoyé par Derf59  Voir le message
et qu'on imagine fonctionnellement que la valeur [null] est une valeur possible de child3 mais une valeur qui ne devrait pas arriver sur les parent/child1/child2,
ce type d'affectation masque complétement le problème.

Je ne vois pas où est le problème. Si tu as besoin de savoir si c'est child3 en particulier qui est null, tu peux toujours le tester explicitement, mais il y a énormément de cas où on s'en fout, et où on veut juste la valeur de parent.child1.child2.child3 si elle est disponible, ou null à défaut.

Évidemment ça ne couvre pas la totalité des cas d'utilisation, mais il y a plein de scénarios où ça va rendre le code plus concis et plus lisible. Perso je suis complètement en faveur de cette fonctionnalité.
Avatar de DelphiManiac DelphiManiac - Membre émérite https://www.developpez.com
le 05/03/2014 à 10:28
Je trouve l'idée très intéressante.

Par contre je ne comprend pas cette remarque
Citation Envoyé par Beowulf59  Voir le message
De mon point de vue c'est un opérateur très pratique, mais qu'il faudra utiliser avec parcimonie.

Soit l'opérateur est adapté au besoin et je ne vois pas pourquoi on ne l'utiliserais pas, soit il n'est pas adapté et la question de son utilisation ne se pose pas. Je ne comprend pas en quoi il faudrait être "parcimonieux".
Avatar de Derf59 Derf59 - Membre régulier https://www.developpez.com
le 05/03/2014 à 10:34
Citation Envoyé par tomlev  Voir le message
Je ne vois pas où est le problème. Si tu as besoin de savoir si c'est child3 en particulier qui est null, tu peux toujours le tester explicitement, mais il y a énormément de cas où on s'en fout, et où on veut juste la valeur de parent.child1.child2.child3 si elle est disponible, ou null à défaut.

Évidemment ça ne couvre pas la totalité des cas d'utilisation, mais il y a plein de scénarios où ça va rendre le code plus concis et plus lisible. Perso je suis complètement en faveur de cette fonctionnalité.

Je pense que vous n'avez pas compris ce que je voulais signaler.

Si on écrit
var g1 = parent?.child1?.child2?.child3;
if (g1 != null)

et qu'on obtient une valeur null dans g1, on ne sait pas dire d'où elle provient (parent ? child1 ? child2 ? child3 ?) et que si on considère que dans les spécifications fonctionnelles ni parent/child1/child2 ne devraient retourner une valeur "null", on est là face à un "problème qui est complétement masqué".
Avatar de pokap pokap - Nouveau membre du Club https://www.developpez.com
le 05/03/2014 à 10:34
C'est un opérateur intéressant mais à double tranchant.
Ça évite d'avoir plusieurs tests à écrire par des if, ce qui alourdi la lecture du code, donc ça reste pour des besoins précis, il y aurait peu de cas d'utilisation.

Par contre avec un tel opérateur on serait tenté de l'utiliser partout alors que ça cacherait des erreurs, ou provoquerait des ralentissements.

Pour moi c'est un opérateur pour un développeur averti qui connait très bien le language et les enjeux du code.
Avatar de stailer stailer - Membre chevronné https://www.developpez.com
le 05/03/2014 à 10:37
Je trouve ça assez pratique... Même sans partir sur 3 ou 4 niveaux, si déjà je peux faire ça :

Code : Sélectionner tout
1
2
 
MonObjetNull?.MaPropriété
C'est carrément pratique ! fini les "if" classiques ou "en ligne".
Pour la lecture du code c'est bien plus clair.

A chacun de l'utiliser raisonnablement. Il y a déjà bien d'autres façons de produire du code pourri.

Si les équipes C# ne doivent plus rien proposer au risque que le programmeur ne soit pas raisonnable, plus aucune évolution n'est alors possible sur le langage.
Avatar de Beowulf59 Beowulf59 - Membre actif https://www.developpez.com
le 05/03/2014 à 10:43
Citation Envoyé par DelphiManiac  Voir le message
Je trouve l'idée très intéressante.

Par contre je ne comprend pas cette remarque

Soit l'opérateur est adapté au besoin et je ne vois pas pourquoi on ne l'utiliserais pas, soit il n'est pas adapté et la question de son utilisation ne se pose pas. Je ne comprend pas en quoi il faudrait être "parcimonieux".

pokap a résumé ma pensée juste après ton message : je pensais par exemple à certains développeurs débutants qui peuvent être tentés d'utiliser cet opérateur à tout va plutôt que de gérer proprement les erreurs (et je n'avais pas pensé aux problèmes de performances par contre).
Avatar de tomlev tomlev - Rédacteur/Modérateur https://www.developpez.com
le 05/03/2014 à 10:46
Citation Envoyé par Derf59  Voir le message
et qu'on obtient une valeur null dans g1, on ne sait pas dire d'où elle provient (parent ? child1 ? child2 ? child3 ?) et que si on considère que dans les spécifications fonctionnelles ni parent/child1/child2 ne devraient retourner une valeur "null", on est là face à un "problème qui est complétement masqué".

Si parent, child1 et child2 ne doivent pas être null, alors il suffit de ne pas utiliser l'opérateur "?." pour y accéder... Le but n'est pas de remplacer l'opérateur ".", seulement de le compléter pour les cas où ça a un sens.
Avatar de TiranusKBX TiranusKBX - Expert confirmé https://www.developpez.com
le 05/03/2014 à 11:51
Comment économiser 2^x lignes de code
Offres d'emploi IT
Formation Développeur Logiciel
AFPA - Nord Pas-de-Calais - Lomme (59160)
Stage de pré-embauche Développeur PHP H/F
Smile - Aquitaine - Bordeaux (33000)
Développeur .Net C# / oracle
Experis - Suisse - Lausanne

Voir plus d'offres Voir la carte des offres IT
Contacter le responsable de la rubrique Accueil