Błąd: „Nie można zmodyfikować wartości zwracanej” C #

Używam właściwości zaimplementowanych automatycznie. Wydaje mi się, że najszybszym sposobem rozwiązania tego problemu jest zadeklarowanie własnej zmiennej bazowej?

public Point Origin { get; set; }

Origin.X = 10; // fails with CS1612

Komunikat o błędzie: Nie można zmodyfikować wartości zwracanej „wyrażenie”, ponieważ nie jest to zmienna

Podjęto próbę zmodyfikowania typu wartości, który był wynikiem wyrażenia pośredniego. Ponieważ wartość nie jest utrwalana, pozostanie niezmieniona.

Aby rozwiązać ten błąd, zapisz wynik wyrażenia w wartości pośredniej lub użyj typu odwołania dla wyrażenia pośredniego.

Dzieje się tak, ponieważ Pointjest to typ wartości ( struct).

Z tego powodu, gdy uzyskujesz dostęp do Originwłaściwości, uzyskujesz dostęp do kopii wartości przechowywanej przez klasę, a nie do samej wartości, jak w przypadku typu referencyjnego ( class), więc jeśli ustawisz na niej Xwłaściwość, to ustawiasz właściwość na kopii, a następnie odrzucenie jej, pozostawiając pierwotną wartość niezmienioną. Prawdopodobnie nie jest to zamierzone przez Ciebie rozwiązanie, dlatego kompilator ostrzega Cię o tym.

Jeśli chcesz zmienić tylko Xwartość, musisz zrobić coś takiego:

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

Używanie zmiennej bazowej nie pomoże. PointTyp to typ wartości.

Musisz przypisać całą wartość Point do właściwości Origin: -

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

Problem polega na tym, że kiedy uzyskujesz dostęp do właściwości Origin, to, co jest zwracane przez, getjest kopią struktury Point w automatycznie utworzonym polu Właściwości Origin. W związku z tym modyfikacja pola X ta kopia nie wpłynie na pole bazowe. Kompilator wykrywa to i wyświetla błąd, ponieważ ta operacja jest całkowicie bezużyteczna.

Nawet jeśli użyłeś własnej zmiennej getbazowej, wyglądałoby to tak: -

get { return myOrigin; }

Nadal zwracałbyś kopię struktury Point i otrzymywałbyś ten sam błąd.

Hmm ... po dokładniejszym przeczytaniu pytania, być może faktycznie masz na myśli zmodyfikowanie zmiennej bazowej bezpośrednio z poziomu swojej klasy: -

myOrigin.X = 10;

Tak, to byłoby to, czego potrzebujesz.

Teraz już wiesz, jakie jest źródło błędu. W przypadku, gdy nie istnieje konstruktor z przeciążeniem, aby przejąć twoją właściwość (w tym przypadku X), możesz użyć inicjatora obiektu (który wykona całą magię za kulisami). Nie chodzi o to, że nie musisz uczynić swoich struktur niezmiennymi , ale po prostu podać dodatkowe informacje:

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.

Jest to możliwe, ponieważ dzieje się to za kulisami:

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

Wygląda to na bardzo dziwną czynność, w ogóle niezalecaną. Podaj tylko inny sposób. Lepszym sposobem jest uczynienie struktury niezmienną i zapewnienie odpowiedniego konstruktora.

Oprócz omawiania zalet i wad struktur kontra klas, staram się patrzeć na cel i podchodzić do problemu z tej perspektywy.

Biorąc to pod uwagę, jeśli nie musisz pisać kodu za właściwością metody get i set (jak w twoim przykładzie), to czy nie byłoby łatwiej po prostu zadeklarować the Originjako pole klasy, a nie właściwość? Myślę, że to pozwoliłoby ci osiągnąć twój cel.

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

Problem polega na tym, że wskazujesz wartość znajdującą się na stosie, a wartość nie zostanie ponownie przeniesiona z powrotem do właściwości oryginalnej, więc C # nie zezwala na zwrócenie odwołania do typu wartości. Myślę, że możesz rozwiązać ten problem, usuwając właściwość Origin i zamiast tego użyj publicznego pola, tak, wiem, że to nie jest miłe rozwiązanie. Innym rozwiązaniem jest nie używanie Point, a zamiast tego utworzenie własnego typu Point jako obiektu.

Wydaje mi się, że haczyk polega na tym, że próbujesz przypisać wartości podrzędne obiektu w instrukcji, zamiast przypisywać sam obiekt. W tym przypadku musisz przypisać cały obiekt Point, ponieważ typ właściwości to Point.

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

Mam nadzieję, że mam tam sens

Po prostu usuń właściwość „get set” w następujący sposób, a wszystko będzie działać jak zawsze.

W przypadku typów pierwotnych instread użyj polecenia 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]

    }
}      

Myślę, że wiele osób jest tu zdezorientowanych, ten konkretny problem jest związany ze zrozumieniem, że właściwości typu wartości zwracają kopię typu wartości (tak jak w przypadku metod i indeksatorów), a pola typu wartości są dostępne bezpośrednio . Poniższy kod robi dokładnie to, co próbujesz osiągnąć, uzyskując bezpośredni dostęp do pola zapasowego właściwości (uwaga: wyrażenie właściwości w postaci pełnej za pomocą pola zapasowego jest odpowiednikiem właściwości automatycznej, ale ma tę zaletę, że w naszym kodzie możemy uzyskać bezpośredni dostęp do pola zapasowego):

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

Otrzymany błąd jest pośrednią konsekwencją niezrozumienia, że ​​właściwość zwraca kopię typu wartości. Jeśli otrzymasz kopię typu wartości i nie przypiszesz jej do zmiennej lokalnej, wszelkie zmiany, które wprowadzisz w tej kopii, nigdy nie mogą zostać odczytane, a zatem kompilator zgłasza to jako błąd, ponieważ nie może to być zamierzone. Jeśli przypiszemy kopię do zmiennej lokalnej, możemy zmienić wartość X, ale zostanie ona zmieniona tylko na kopii lokalnej, co naprawia błąd czasu kompilacji, ale nie będzie miało pożądanego efektu modyfikacji właściwości Origin. Poniższy kod ilustruje to, ponieważ błąd kompilacji zniknął, ale asercja debugowania zakończy się niepowodzeniem:

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