Wie lege ich ein readonly-Feld in einer Initialisierungsmethode fest, die vom Konstruktor aufgerufen wird?

Ich bin sicher, ich habe irgendwo gesehen, dass ich Folgendes tun können über ein Attribut über meine Init () - Methode, das sagt dem compiler, dass die Methode Init() muss nur aufgerufen werden, aus dem Konstruktor, so dass die readonly-Feld gesetzt werden. Ich habe vergessen, was das Attribut heißt aber, und ich kann nicht scheinen, um es zu finden über 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 der Frage Ben Anderson | 2010-09-16

c#constructor readonly

39

Rob ' s Antwort ist der Weg, es zu tun, in meinem Buch. Wenn Sie brauchen, um zu initialisieren mehreren Feldern kann man es mit out Parameter:
```
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;
    }
}
```
Ich persönlich finde, dass macht Sinn in bestimmten Szenarien, etwa wenn Sie möchten, dass Ihre Felder zu readonly aber Sie auch wollen in der Lage sein, um Sie anders in einer abgeleiteten Klasse (ohne Kette eine Tonne von Parametern durch einige protected Konstruktor). Aber vielleicht ist das nur mir.

InformationsquelleAutor der Antwort Dan Tao

Statt über eine Initialize-Methode, wie zum Erben ein basic-Konstruktor durch alle anderen Konstruktoren.
also

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
    }
}

Dies ist vielleicht ein wenig zu spät zu erreichen, die ursprüngliche person in not, aber wie es scheint, dies wird sauber das problem zu lösen... Ohne die Notwendigkeit der Verwendung von jeder Art von bösen Reflexions-oder out-Parameter.

InformationsquelleAutor der Antwort tvt173

Die einzige Lösung, die ich denken kann, ist, um den Rückgabewert aus der Init() Methode, die readonly Feld muss zugewiesen werden:

public class Class
{
    private readonly int readonlyField;

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

    private int Init()
    {
        return 1;
    }
}

InformationsquelleAutor der Antwort Rob

6

Diese nicht getan werden kann. Felder, die markiert sind mit readonly kann nur eingestellt werden, aus dem Konstruktor

InformationsquelleAutor der Antwort JaredPar
5

Jared ist richtig; das ist nicht möglich. Die workarounds, die ich denken kann, sind:
1. Initialisieren Sie das Feld in der Erklärung.
2. Initialisieren das Feld im Konstruktor (Manuell inline-Ihre Init - Methode).
3. Weisen Sie das Feld mit dem Rückgabewert einer Methode, z.B.: _myField = GetInitialMyFieldValue();
4. Pass das Feld, um die Init Methode, mit der out modifier. Dies kann nützlich sein, wenn Sie viele Felder zu initialisieren, die abhängig von der Konstruktor-Parameter. 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 der Antwort Ani

Was ich am Ende tun, in der aktuellen tech-C# 7.x) ist die Verwendung der Wert-Tupel-system:

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);
    }
}

Nicht der sauberste, Aber scheint sauberer zu mir.

InformationsquelleAutor der Antwort Ran Sagy

1

C# - compiler nur können Sie set-readonly-Felder, wenn Sie diese initialisiert werden inline:
```
private readonly int readonlyField = 1;
```
oder aus dem Konstruktor:
```
public Class()
{
    readonlyField = 1;
}
```
InformationsquelleAutor der Antwort Steve Michelotti

Ich denke, es funktioniert, wenn die Reflektion verwenden. Tatsächlich, das funktioniert für mich:

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

und

static void Main(string[] args)
        {

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

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

dies ist 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;          
        }

die einzige Sache ist, dass readonlyField ist öffentlich, nicht privat. Ich weiß, dass Sie Bearbeiten ein eigenes Feld, aber ich bin mir nicht sicher, warum es funktioniert nicht für mich!

InformationsquelleAutor der Antwort Derar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.