Comment puis-je définir un champ en lecture seule dans une méthode initialize qui est appelée à partir du constructeur?

Je suis sûr que j'ai vu quelque part que je peux effectuer les opérations suivantes à l'aide d'un attribut au-dessus de ma méthode Init (), qui indique au compilateur que la méthode Init() doit être appelée uniquement à partir du constructeur, permettant ainsi le champ en lecture seule à être ensemble. J'ai oublié ce que l'attribut est appelé bien, et je n'arrive pas à le trouver sur google.

public class Class
{
    private readonly int readonlyField;

    public Class()
    {
        Init();
    }

    //Attribute here that tells the compiler that this method must be called only from a constructor
    private void Init()
    {
        readonlyField = 1;
    }
}

InformationsquelleAutor Ben Anderson | 2010-09-16

c#constructor readonly

39

Rob répondre est la façon de le faire, dans mon livre. Si vous avez besoin d'initialiser plusieurs champs, vous pouvez le faire en utilisant out paramètres:
```
public class Class
{
    private readonly int readonlyField1;
    private readonly int readonlyField2;

    public Class()
    {
        Init(out readonlyField1, out readonlyField2);
    }

    protected virtual void Init(out int field1, out int field2)
    {
        field1 = 1;
        field2 = 2;
    }
}
```
Personnellement, je trouve que ça fait sens dans certains cas, comme lorsque vous voulez que votre champs à readonly mais vous aussi voulez être en mesure de définir différemment dans une classe dérivée (sans avoir à la chaîne d'une tonne de paramètres par le biais de certains protected constructeur). Mais peut-être que c'est juste moi.
- les paramètres de sortie, beurk!
- Hey, je n'ai jamais dit que c'était assez.
- Je l'ai résolu en utilisant la Réflexion. Voir ci-dessous..
- Merde, les gars... je pense que la réflexion est certainement pas de la façon d'aller à ce sujet. Pourquoi utiliser la réflexion sur votre propre classe, quand tout le code est juste en face de vous?
- Je baisse voté votre solution par erreur. J'avais juste l'impression que tout le monde dit que c'est pas faisable. C'est pourquoi j'ai ajouté de la réflexion à base de solution. La solution de bon mec!
InformationsquelleAutor Dan Tao

Au lieu d'utiliser une méthode Initialize, et hérite d'un constructeur de base par le biais de tous vos autres constructeurs.
c'est à dire

public class MyClass
{
    readonly int field1;
    readonly double field2;
    public MyClass(int field1, double field2)
    {
        //put whatever initialization logic you need here...
        field1 = 10;
        field2 = 30.2;
    }
    public MyClass(int field1, double field2p1, double field2p2)
        : this(field1, (field2p1 + field2p2))
    {
        //put anything extra in here
    }
}

Cela peut être un peu tard pour atteindre la première personne dans le besoin, mais il semble que ce sera proprement résoudre le problème... Sans avoir besoin d'utiliser toute sorte de méchant réflexion ou des paramètres de sortie.

C'est certainement une façon plus intelligente pour partager du code entre les constructeurs.

InformationsquelleAutor tvt173

12

La seule solution que je vois est de renvoyer la valeur de la Init() méthode que le readonly champ doit être affecté:
```
public class Class
{
    private readonly int readonlyField;

    public Class()
    {
        readonlyField = Init();
    }

    private int Init()
    {
        return 1;
    }
}
```
- J'étais sûr que j'ai vu ce fait.. Mon cerveau doit être en train de jouer des tours sur moi. Merci à tous
- Je sais ce que tu veux dire - j'ai passé des heures il y a quelques jours le chalutage sur le net que j'étais sûr que j'avais lu quelque part que SMB2 permet une copie de fichier à partir d'un serveur distant à l'autre pour ne pas être routés via l'ordinateur client qui fait la demande. Les heures perdues et j'ai pu trouver aucune preuve, si j'étais inflexible j'avais lu que c'était possible! :S
InformationsquelleAutor Rob
6

Cela ne peut être fait. Les champs qui sont marqués avec le readonly ne peut être définie qu'à partir du constructeur
- Non pas que c'est complètement faux, mais cette réponse ne fait vraiment pâle figure en comparaison à d'autres réponses ici. Un simple "ne peut pas être fait" une phrase réponse laisse beaucoup à désirer. Peut-être que cela a été une des premières réponses si?
InformationsquelleAutor JaredPar
5

Jared est droit; ce n'est pas possible. Les solutions de contournement que je peux penser sont:
1. Initialiser le champ de la déclaration.
2. Initialiser le champ dans le constructeur (Manuellement inline votre Init méthode).
3. Attribuer le champ à une valeur retournée par une méthode, par exemple: _myField = GetInitialMyFieldValue();
4. Passer sur le terrain de la Init méthode, avec la out modificateur. Cela peut être utile si vous avez de nombreux domaines pour initialiser, qui dépendent des paramètres du constructeur. E. g.
```
 private readonly int _x;
 private readonly string _y;

 private void Init(int someConstructorParam, out int x, out string y){ .. }

 public Class(int someConstructorParam)
 {
     Init(someConstructorParam, out _x, out _y);
 } 
```
InformationsquelleAutor Ani

Ce que j'ai fait dans la technologie actuelle (C# 7.x) est l'utilisation de la valeur du tuple système:

public class MyClass
{
    private readonly int x;
    private readonly int y;
    private readonly int z;

    public MyClass(int x)
    {
        this.x = x;
        (y, z) = InitYandZ();
    }

    private (int, int) InitYandZ()
    {
        return (5, 10);
    }
}

Pas la plus propre qui soit, Mais semble plus propre à moi.

InformationsquelleAutor Ran Sagy

1

Compilateur C# permet uniquement de définir des champs en lecture seule si vous êtes à l'initialisation d'entre eux en ligne:
```
private readonly int readonlyField = 1;
```
ou à partir du constructeur:
```
public Class()
{
    readonlyField = 1;
}
```
InformationsquelleAutor Steve Michelotti

Je pense qu'il fonctionne si l'utilisation de la Réflexion. En fait, ce qui fonctionne pour moi:

    public class Class
        {
            private readonly int readonlyField;
        public int MyField()
        {
             return readonlyField;
        }
        public Class()
        {
            readonlyField = 9;
        }
    }

static void Main(string[] args)
        {

            Class classObj = new Class();
            Console.WriteLine(classObj.MyField());//9

            Misc.SetVariableyByName(classObj, "readonlyField", 20);//20
            Console.WriteLine(classObj.MyField());
         }

c'est SetVariableByName():

public static b

ool SetVariableyByName(object obj, string var_name, object value)
            {
                FieldInfo info = obj.GetType().GetField(var_name, BindingFlags.NonPublic| BindingFlags.Instance);
                if (info == null)
                return false;
            /* ELSE */
            info.SetValue(obj, value);
            return true;          
        }

la seule chose est que readonlyField est public et non privé. Je sais que vous pouvez modifier un champ privé, mais je ne suis pas sûr de savoir pourquoi sa ne fonctionne pas pour moi!

fonctionne maintenant sur les variables de membre Privées..
Juste parce que vous peut faire de cette façon ne signifie pas que vous doit... et, bien sûr, dans de nombreuses situations, vous n'avez pas la permission de le faire.
Je ne pense pas que ce est ce que la réflexion était destinée. Inutile de performances...
Eh bien les gars, vrai! Mais si vous n'avez pas le choix, et doivent faire face à une telle situation, vous devez faire quelque chose.. la Réflexion n'est pas la meilleure technique à utiliser, mais il résout des problèmes.
Pourquoi serait-on faire cela? Semble contrevenir à toute classe d'invariants qui pourrait avoir été mis en place. Une très mauvaise idée.
C'est l'un des types de monstre solution qui rend certains vieux temps de programmeurs c pense que la programmation orientée objet est le mal...lol

InformationsquelleAutor Derar

Vous devez vous connecter pour publier un commentaire.