Roslyn n'a pas réussi à compiler le code

Après avoir migré mon projet de VS2013 vers VS2015, le projet ne se construit plus. Une erreur de compilation se produit dans l'instruction LINQ suivante:

static void Main(string[] args)
{
    decimal a, b;
    IEnumerable<dynamic> array = new string[] { "10", "20", "30" };
    var result = (from v in array
                  where decimal.TryParse(v, out a) && decimal.TryParse("15", out b) && a <= b // Error here
                  orderby decimal.Parse(v)
                  select v).ToArray();
}

Le compilateur renvoie une erreur:

Erreur CS0165 Utilisation de la variable locale non attribuée 'b'

Qu'est-ce qui cause ce problème? Est-il possible de le réparer via un paramètre de compilateur?

Qu'est-ce qui cause ce problème?

Cela ressemble à un bogue du compilateur. Du moins, ça l'a fait. Bien que les expressions decimal.TryParse(v, out a)et decimal.TryParse(v, out b)soient évaluées dynamiquement, je m'attendais à ce que le compilateur comprenne encore qu'au moment où il atteint a <= b, les deux aet bsont définitivement attribués. Même avec les bizarreries que vous pouvez créer dans le typage dynamique, je m'attendrais à n'évaluer a <= bqu'après avoir évalué les deux TryParseappels.

Cependant, il s'avère que grâce à l'opérateur et à la conversion délicate, il est tout à fait possible d'avoir une expression A && B && Cqui évalue Aet Cmais pas B- si vous êtes assez rusé. Voir le rapport de bogue de Roslyn pour l'exemple ingénieux de Neal Gafter.

Faire ce travail dynamicest encore plus difficile - la sémantique impliquée lorsque les opérandes sont dynamiques est plus difficile à décrire, car pour effectuer une résolution de surcharge, vous devez évaluer les opérandes pour savoir quels types sont impliqués, ce qui peut être contre-intuitif. Cependant, encore une fois Neal est venu avec un exemple qui montre que l'erreur du compilateur est nécessaire ... ce n'est pas un bug, il est un bug fix . D'énormes félicitations à Neal pour l'avoir prouvé.

Est-il possible de le réparer via les paramètres du compilateur?

Non, mais il existe des alternatives qui évitent l'erreur.

Premièrement, vous pouvez l'empêcher d'être dynamique - si vous savez que vous n'utiliserez jamais que des chaînes, vous pouvez alors utiliser IEnumerable<string> ou donner à la variable range vun type de string(ie from string v in array). Ce serait mon option préférée.

Si vous avez vraiment besoin de le garder dynamique, donnez simplement bune valeur pour commencer:

decimal a, b = 0m;

Cela ne fera aucun mal - nous savons qu'en fait votre évaluation dynamique ne fera rien de fou, vous finirez donc par attribuer une valeur à bavant de l'utiliser, ce qui rendra la valeur initiale non pertinente.

De plus, il semble que l'ajout de parenthèses fonctionne aussi:

where decimal.TryParse(v, out a) && (decimal.TryParse("15", out b) && a <= b)

Cela change le moment où les différentes parties de la résolution de surcharge sont déclenchées et rend le compilateur heureux.

Il reste un problème à résoudre - les règles de la spécification sur l'affectation définitive avec l' &&opérateur doivent être clarifiées pour indiquer qu'elles ne s'appliquent que lorsque l' &&opérateur est utilisé dans son implémentation "régulière" avec deux boolopérandes. Je vais essayer de m'assurer que cela est corrigé pour la prochaine norme ECMA.

Cela semble être un bogue, ou du moins une régression, dans le compilateur Roslyn. Le bogue suivant a été déposé pour le suivre:

https://github.com/dotnet/roslyn/issues/4509

En attendant, l' excellente réponse de Jon a quelques solutions.

Depuis que j'ai été tellement instruit dans le rapport de bogue, je vais essayer de l'expliquer moi-même.

Imagine Test un type défini par l'utilisateur avec un cast implicite boolqui alterne entre falseet true, en commençant par false. Pour autant que le compilateur le sache, le dynamicpremier argument du premier &&pourrait être évalué à ce type, il doit donc être pessimiste.

Si, alors, il laisse le code se compiler, cela peut arriver:

• Lorsque le classeur dynamique évalue le premier &&, il effectue les opérations suivantes:
  • Évaluer le premier argument
  • C'est un T- implicitement jeté sur bool.
  • Oh, c'est false, donc nous n'avons pas besoin d'évaluer le deuxième argument.
  • Faites du résultat de l' &&évaluation comme premier argument. (Non, non false, pour une raison quelconque.)
• Lorsque le classeur dynamique évalue le second &&, il effectue les opérations suivantes:
  • Évaluez le premier argument.
  • C'est un T- implicitement jeté sur bool.
  • Oh, c'est true, alors évaluez le deuxième argument.
  • ... Oh merde, bn'est pas assigné.

En termes de spécifications, en bref, il existe des règles spéciales "d'affectation définie" qui nous permettent de dire non seulement si une variable est "définitivement affectée" ou "non définitivement affectée", mais aussi si elle est "définitivement affectée après l' falseinstruction" ou "définitivement attribué après la truedéclaration ".

Celles-ci existent pour que, lorsqu'il traite avec &&and ||(et !et ??et ?:), le compilateur puisse examiner si des variables peuvent être affectées dans des branches particulières d'une expression booléenne complexe.

Cependant, ceux-ci ne fonctionnent que tant que les types des expressions restent booléens . Lorsqu'une partie de l'expression est dynamic(ou un type statique non booléen), nous ne pouvons plus dire de manière fiable que l'expression est trueou false- la prochaine fois que nous la castons boolpour décider quelle branche prendre, elle peut avoir changé d'avis.

Mise à jour: ceci est maintenant résolu et documenté :

Les règles d'affectation définies implémentées par les compilateurs précédents pour les expressions dynamiques permettaient certains cas de code pouvant entraîner la lecture de variables qui ne sont pas définitivement affectées. Voir https://github.com/dotnet/roslyn/issues/4509 pour un rapport à ce sujet.

...

En raison de cette possibilité, le compilateur ne doit pas permettre à ce programme d'être compilé si val n'a pas de valeur initiale. Les versions précédentes du compilateur (antérieures à VS2015) permettaient à ce programme de se compiler même si val n'a pas de valeur initiale. Roslyn diagnostique maintenant cette tentative de lecture d'une variable éventuellement non initialisée.

Ce n'est pas un bug. Voir https://github.com/dotnet/roslyn/issues/4509#issuecomment-130872713 pour un exemple de la façon dont une expression dynamique de cette forme peut laisser une telle variable non attribuée.