Pourquoi je ne peux pas initialiser readonly variables dans un initialiseur?

Permettant une readonly être mis dans un initialiseur introduit des contradictions et des complications qui ne peuvent pas être respectées au moment de la compilation. J'imagine que la restriction est d'éviter toute ambiguïté. La grande clé est au moment de la compilation de validation.

Imaginez ceci:

class Foo
{
    public readonly int bar;
    Foo () {
      //compiler can ensure that bar is set in an invoked ctor
      bar = 0;
    }
}

//compiler COULD know that `bar` was set in ctor
//and therefore this is invalid
new Foo { bar = 0; }

Maintenant, pensez à:

class Foo
{
    public readonly int bar;
    Foo () {
      //imagine case where bar not set in ctor
    }
}

//compiler COULD know that `bar` is not bound yet
//therefore, this COULD be valid
new Foo { bar = 0; }

//but this COULD be proved to never be valid
new Foo();

Imaginer que les deux cas ci-dessus sont réunies (par exemple, "par le compilateur de la magie"), toutefois, entrer dans les génériques:

T G<T> () where T : new
{
  //What in heck should happen *at compile time*?
  //(Consider both cases above.)
  //What happens if T (Foo) changes to include/not-include setting the
  //readonly variable in the ctor?
  //Consider intermediate code that invokes G<Foo>() and this other
  //code is NOT recompiled even though Foo is--
  //  Yet a binary incompatibility has been added!
  //  No thanks!
  return new T();
}
G<Foo>();

Je crois que le cas que j'ai décrit montrer certaines complications de l'utilisation d'une "dynamique" readonly approche et, à la fin de la journée, je crois que c'est simplement un choisi de restriction de langue (compilateurs de mettre en œuvre les langues) de l'application/de permettre la compilation de validation.

OriginalL'auteur

Depuis readonly variables doit être initialisé dans le constructeur, et bien d'initialiseurs de s'exécuter après la construction de l'objet, qui n'est pas valide.

OriginalL'auteur decyclone

Ce que vous essayez de faire est ceci:

   class Foo
   {
        public readonly int bar;

        Foo(int b)
        {
             bar = b;  //readonly assignments only in constructor
        }
   }

   Foo x = new Foo(0);

OriginalL'auteur Stefan

Selon cette page, le CLR par défaut-les constructions de l'objet en premier lieu avant le traitement de l'initialiseur de liste, et vous êtes donc d'assigner à bar deux fois (une fois par défaut de la construction, une fois lorsque l'initialisation est traitée).

OriginalL'auteur Platinum Azure

Il n'y a pas beaucoup de mal dans votre code ou les hypothèses, à l'exception peut-être qu'il est une caractéristique importante de l'initialiseur de listes d'imposer aucune séquence de contraintes (particulièrement vrai pour C++). Le point-virgule est un séquençage de l'opérateur, par conséquent initialiseur de listes séparées par des virgules à la place.

Sauf si vous faites valoir que les spécifications sont correctes, par définition, je crois que la spécification du langage est mal ici. En partie à des pauses d'une caractéristique importante de la langue qui est la notion de lecture-seule. L'ambiguïté des problèmes mentionnés dans les autres réponses ont à mon avis une seule cause sous-jacente. Readonly est un très intrusive fonctionnalité et va de la moitié du chemin concernant const correctness est difficile d'obtenir le droit et, plus important encore, nuisible pour le codage des styles développés.

Ce que vous cherchez et probablement trouvé, dans l'intervalle sont les arguments nommés: https://stackoverflow.com/a/21273185/2712726
Ce n'est pas ce que vous avez demandé, mais il obtient près de.

Aussi pour être juste, je dois ajouter qu'il est très compétent, les auteurs qui vont pas du tout d'accord avec ces points de vue sur const exactitude que les développeurs C++ ont souvent. Eric Lippert, qui certes ont des postes a écrit cette (horrible pour les développeurs C++): https://stackoverflow.com/a/3266579/2712726

OriginalL'auteur Patrick Fromberg