Fehler: "Rückgabewert kann nicht geändert werden" c #

Ich verwende automatisch implementierte Eigenschaften. Ich denke, der schnellste Weg, um Folgendes zu beheben, besteht darin, meine eigene Hintergrundvariable zu deklarieren.

public Point Origin { get; set; }

Origin.X = 10; // fails with CS1612

Fehlermeldung: Der Rückgabewert von 'Ausdruck' kann nicht geändert werden, da es sich nicht um eine Variable handelt

Es wurde versucht, einen Werttyp zu ändern, der das Ergebnis eines Zwischenausdrucks war. Da der Wert nicht beibehalten wird, bleibt der Wert unverändert.

Um diesen Fehler zu beheben, speichern Sie das Ergebnis des Ausdrucks in einem Zwischenwert oder verwenden Sie einen Referenztyp für den Zwischenausdruck.

Dies liegt daran, dass Pointes sich um einen Werttyp ( struct) handelt.

Wenn Sie auf die OriginEigenschaft zugreifen , greifen Sie daher auf eine Kopie des Werts zu, der von der Klasse gehalten wird, und nicht auf den Wert selbst, wie Sie es mit einem Referenztyp ( class) tun würden. Wenn Sie also die XEigenschaft darauf festlegen, legen Sie fest die Eigenschaft auf der Kopie und verwerfen Sie sie dann, wobei der ursprüngliche Wert unverändert bleibt. Dies ist wahrscheinlich nicht das, was Sie beabsichtigt haben, weshalb der Compiler Sie davor warnt.

Wenn Sie nur den XWert ändern möchten , müssen Sie Folgendes tun:

Origin = new Point(10, Origin.Y);

Die Verwendung einer Hintergrundvariablen hilft nicht weiter. Der PointTyp ist ein Werttyp.

Sie müssen der Origin-Eigenschaft den gesamten Punktwert zuweisen: -

Origin = new Point(10, Origin.Y);

Das Problem besteht darin, dass beim Zugriff auf die Origin-Eigenschaft geteine Kopie der Punktstruktur im automatisch erstellten Feld Origin-Eigenschaften zurückgegeben wird. Daher würde Ihre Änderung des X-Felds dieser Kopie das zugrunde liegende Feld nicht beeinflussen. Der Compiler erkennt dies und gibt einen Fehler aus, da dieser Vorgang völlig nutzlos ist.

Selbst wenn Sie Ihre eigene Hintergrundvariable verwenden getwürden, würde dies folgendermaßen aussehen:

get { return myOrigin; }

Sie würden immer noch eine Kopie der Punktstruktur zurückgeben und würden den gleichen Fehler erhalten.

Hmm ... nachdem Sie Ihre Frage genauer gelesen haben, möchten Sie vielleicht tatsächlich die Hintergrundvariable direkt aus Ihrer Klasse heraus ändern: -

myOrigin.X = 10;

Ja, das wäre was du brauchst.

Inzwischen wissen Sie bereits, woher der Fehler stammt. Falls es keinen Konstruktor mit einer Überladung gibt, um Ihre Eigenschaft zu übernehmen (in diesem Fall X), können Sie den Objektinitialisierer verwenden (der die ganze Magie hinter den Kulissen ausführt). Nicht, dass Sie Ihre Strukturen nicht unveränderlich machen müssen , sondern nur zusätzliche Informationen geben müssen:

struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

class MyClass
{
    public Point Origin { get; set; }
}

MyClass c = new MyClass();
c.Origin.X = 23; //fails.

//but you could do:
c.Origin = new Point { X = 23, Y = c.Origin.Y }; //though you are invoking default constructor

//instead of
c.Origin = new Point(23, c.Origin.Y); //in case there is no constructor like this.

Dies ist möglich, weil dies hinter den Kulissen geschieht:

Point tmp = new Point();
tmp.X = 23;
tmp.Y = Origin.Y;
c.Origin = tmp;

Dies scheint eine sehr seltsame Sache zu sein, die überhaupt nicht empfohlen wird. Listen Sie einfach einen alternativen Weg auf. Der bessere Weg ist, struct unveränderlich zu machen und einen geeigneten Konstruktor bereitzustellen.

Abgesehen von der Debatte über die Vor- und Nachteile von Strukturen gegenüber Klassen neige ich dazu, das Ziel zu betrachten und das Problem aus dieser Perspektive zu betrachten.

Wenn Sie jedoch keinen Code hinter die get- und set-Methoden der Eigenschaft schreiben müssen (wie in Ihrem Beispiel), ist es dann nicht einfacher, die einfach Originals Feld der Klasse und nicht als Eigenschaft zu deklarieren ? Ich sollte denken, dies würde es Ihnen ermöglichen, Ihr Ziel zu erreichen.

struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

class MyClass
{
    public Point Origin;
}

MyClass c = new MyClass();
c.Origin.X = 23;   // No error.  Sets X just fine

Das Problem besteht darin, dass Sie auf einen Wert im Stapel verweisen und der Wert nicht an die Eigenschaft orignal zurückgegeben wird, sodass Sie mit C # keinen Verweis auf einen Werttyp zurückgeben können. Ich denke, Sie können dies lösen, indem Sie die Origin-Eigenschaft entfernen und stattdessen eine öffentliche Datei verwenden. Ja, ich weiß, dass dies keine gute Lösung ist. Die andere Lösung besteht darin, den Punkt nicht zu verwenden und stattdessen Ihren eigenen Punkttyp als Objekt zu erstellen.

Ich denke, der Haken hier ist, dass Sie versuchen, die Unterwerte des Objekts in der Anweisung zuzuweisen, anstatt das Objekt selbst zuzuweisen. In diesem Fall müssen Sie das gesamte Point-Objekt zuweisen, da der Eigenschaftstyp Point ist.

Point newOrigin = new Point(10, 10);
Origin = newOrigin;

Hoffe ich habe dort Sinn gemacht

Entfernen Sie einfach die Eigenschaft "get set" wie folgt, und dann funktioniert alles wie immer.

Bei primitiven Typen instread verwenden Sie get; set; ...

using Microsoft.Xna.Framework;
using System;

namespace DL
{
    [Serializable()]
    public class CameraProperty
    {
        #region [READONLY PROPERTIES]
        public static readonly string CameraPropertyVersion = "v1.00";
        #endregion [READONLY PROPERTIES]


        /// <summary>
        /// CONSTRUCTOR
        /// </summary>
        public CameraProperty() {
            // INIT
            Scrolling               = 0f;
            CameraPos               = new Vector2(0f, 0f);
        }
        #region [PROPERTIES]   

        /// <summary>
        /// Scrolling
        /// </summary>
        public float Scrolling { get; set; }

        /// <summary>
        /// Position of the camera
        /// </summary>
        public Vector2 CameraPos;
        // instead of: public Vector2 CameraPos { get; set; }

        #endregion [PROPERTIES]

    }
}      

Ich denke , eine Menge Leute hier sind verwirrt zu werden , dieses besondere Problem bezieht sich auf das Verständnis , dass Werttyp Eigenschaften eine Kopie des Werttyp zurückgeben (wie bei Methoden und Indexer) und Werttyp Felder werden direkt zugegriffen . Der folgende Code macht genau das, was Sie erreichen möchten, indem Sie direkt auf das Hintergrundfeld der Eigenschaft zugreifen (Hinweis: Das Ausdrücken einer Eigenschaft in ihrer ausführlichen Form mit einem Hintergrundfeld entspricht einer Auto-Eigenschaft, hat jedoch den Vorteil, dass dies in unserem Code möglich ist direkt auf das Hintergrundfeld zugreifen):

class Program
{
    static void Main(string[] args)
    {
        var myClass = new MyClass();
        myClass.SetOrigin();
        Debug.Assert(myClass.Origin.X == 10); //succeeds
    }
}

class MyClass
{
    private Point _origin;
    public Point Origin
    { 
        get => _origin; 
        set => _origin = value; 
    }

    public void SetOrigin()
    {
        _origin.X = 10; //this works
        //Origin.X = 10; // fails with CS1612;
    }
}

Der Fehler, den Sie erhalten, ist eine indirekte Folge des Nichtverständnisses, dass eine Eigenschaft eine Kopie eines Werttyps zurückgibt. Wenn Sie eine Kopie eines Werttyps zurückgeben und diese keiner lokalen Variablen zuweisen, können alle Änderungen, die Sie an dieser Kopie vornehmen, niemals gelesen werden. Der Compiler gibt dies daher als Fehler aus, da dies nicht beabsichtigt sein kann. Wenn wir die Kopie einer lokalen Variablen zuweisen, können wir den Wert von X ändern. Er wird jedoch nur für die lokale Kopie geändert, wodurch der Fehler bei der Kompilierung behoben wird, die gewünschte Origin-Eigenschaft jedoch nicht geändert wird. Der folgende Code veranschaulicht dies, da der Kompilierungsfehler behoben ist, die Debug-Bestätigung jedoch fehlschlägt:

class Program
{
    static void Main(string[] args)
    {
        var myClass = new MyClass();
        myClass.SetOrigin();
        Debug.Assert(myClass.Origin.X == 10); //throws error
    }
}

class MyClass
{
    private Point _origin;
    public Point Origin
    { 
        get => _origin; 
        set => _origin = value; 
    }

    public void SetOrigin()
    {
        var origin = Origin;
        origin.X = 10; //this is only changing the value of the local copy
    }
}