Ошибка: «Невозможно изменить возвращаемое значение» c #

Я использую автоматически реализованные свойства. Я думаю, что самый быстрый способ исправить следующее - объявить собственную переменную поддержки?

public Point Origin { get; set; }

Origin.X = 10; // fails with CS1612

Сообщение об ошибке: невозможно изменить возвращаемое значение выражения, поскольку оно не является переменной

Была предпринята попытка изменить тип значения, являющийся результатом промежуточного выражения. Поскольку значение не сохраняется, оно не изменится.

Чтобы устранить эту ошибку, сохраните результат выражения в промежуточном значении или используйте ссылочный тип для промежуточного выражения.

Это потому, что Pointэто значение типа ( struct).

Из-за этого, когда вы Originобращаетесь к свойству, вы получаете доступ к копии значения, хранящегося в классе, а не самого значения, как если бы вы использовали ссылочный тип ( class), поэтому, если вы установите для него Xсвойство, тогда вы устанавливаете свойство на копии, а затем отбрасывает его, оставляя исходное значение без изменений. Это, вероятно, не то, что вы хотели, поэтому компилятор предупреждает вас об этом.

Если вы хотите изменить только Xзначение, вам нужно сделать что-то вроде этого:

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

Использование резервной переменной не поможет. PointТип представляет собой тип значения.

Вам необходимо присвоить целое значение Point свойству Origin:

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

Проблема заключается в том, что при доступе к свойству Origin то, что возвращается, getявляется копией структуры Point в автоматически создаваемом поле свойств Origin. Следовательно, ваша модификация поля X этой копии не повлияет на базовое поле. Компилятор обнаруживает это и выдает ошибку, поскольку эта операция совершенно бесполезна.

Даже если бы вы использовали свою собственную переменную поддержки, вы getбы выглядели так:

get { return myOrigin; }

Вы все равно будете возвращать копию структуры Point, и вы получите ту же ошибку.

Хм ... прочитав ваш вопрос более внимательно, возможно, вы действительно хотите изменить вспомогательную переменную прямо из вашего класса:

myOrigin.X = 10;

Да, это было бы то, что вам нужно.

К настоящему времени вы уже знаете, что является источником ошибки. В случае, если конструктор не существует с перегрузкой для получения вашего свойства (в данном случае X), вы можете использовать инициализатор объекта (который сделает всю магию за кулисами). Не то, что вам не нужно делать свои структуры неизменяемыми , а просто давать дополнительную информацию:

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.

Это возможно, потому что за кадром это происходит:

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

Это выглядит очень странно, совсем не рекомендуется. Просто перечисление альтернативного пути. Лучший способ сделать это - сделать структуру неизменной и предоставить правильный конструктор.

Помимо обсуждения плюсов и минусов структур по сравнению с классами, я склонен смотреть на цель и подходить к проблеме с этой точки зрения.

При этом, если вам не нужно писать код за свойством get и set методов (как в вашем примере), то не будет ли проще просто объявить Originкак поле класса, а не как свойство? Я должен подумать, что это позволит вам достичь своей цели.

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

Проблема в том, что вы указываете на значение, находящееся в стеке, и оно не будет возвращено обратно в свойство orignal, поэтому C # не позволяет вам возвращать ссылку на тип значения. Я думаю, что вы можете решить эту проблему, удалив свойство Origin и вместо этого воспользовавшись открытым полем, да, я знаю, что это не очень хорошее решение. Другое решение - не использовать Point, а вместо этого создать собственный тип Point в качестве объекта.

Я предполагаю, что выгода заключается в том, что вы пытаетесь назначить под-значения объекта в выражении, а не сам объект. В этом случае вам необходимо назначить весь объект Point, поскольку типом свойства является Point.

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

Надеюсь, у меня есть смысл

Просто удалите свойство «get set», как показано ниже, и тогда все работает как всегда.

В случае примитивных типов instread используйте 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]

    }
}      

Я думаю, что многие люди запутываются здесь, эта конкретная проблема связана с пониманием того, что свойства типа значения возвращают копию типа значения (как с методами и индексаторами), и к полям типа значения обращаются напрямую . Следующий код делает именно то, что вы пытаетесь достичь, напрямую обращаясь к полю поддержки свойства (примечание: выражение свойства в его подробной форме с помощью поля поддержки является эквивалентом свойства auto, но имеет то преимущество, что в нашем коде мы можем получить доступ к вспомогательному полю напрямую):

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

Ошибка, которую вы получаете, является косвенным следствием непонимания того, что свойство возвращает копию типа значения. Если вам возвращается копия типа значения и вы не присваиваете ее локальной переменной, то любые изменения, которые вы вносите в эту копию, никогда не будут считаны, и поэтому компилятор выдаст это как ошибку, поскольку это не может быть преднамеренным. Если мы присвоим копию локальной переменной, мы сможем изменить значение X, но оно будет изменено только для локальной копии, что исправляет ошибку времени компиляции, но не будет иметь желаемого эффекта изменения свойства Origin. Следующий код иллюстрирует это, так как ошибка компиляции исчезла, но утверждение отладки не выполнится:

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