C＃中的自定义自动属性

Question

I have the following class with auto properties:

class Coordinates
{
    public Coordinates(int x, int y)
    {
        X = x * 10;
        Y = y * 10;
    }

    public int X { get; set; }

    public int Y { get; set; }
}

As you can see from the constructor I need the value to be multiplied by 10. Is there anyway to do it without removing autoproperties?

I tried the following not thinking that it causes recursion and then everything goes fubar

public int X { get {return X;} set{ X *= 10;} }

I would like to assign values to X and Y multiplied by 10.

Coordinates coords = new Coordinates(5, 6); // coords.X = 50 coords.Y = 60
coords.X = 7; // this gives 7 to X but I would like it to be 70.

Answer 1

In order to make setter working like that, you'll need to use backing field:

class Coordinates
{
    public Coordinates(int x, int y)
    {
        X = x;
        Y = y;
    }

    private int _x;
    public int X
    {
        get { return _x; }
        set { _x = value * 10; }
    }

    private int _y;
    public int Y
    {
        get { return _y; }
        set { _y = value * 10; }
    }
}

Given your example:

Coordinates coords = new Coordinates(5, 6); // coords.X = 50 coords.Y = 60
coords.X = 7; // this gives 70

However, I don't recommend you having such setter because it could lead to confusion. It's better to have a dedicated method which will do such multiplication. In the end, your code will be more descriptive and intuitive.

Answer 2

You get a recursion, because you again call the same property, which in turn calls the same property, which in turn calls the same property... you get the point.

public int X { get {return X ;} set{ X *= 10;} }

How does auto properties works ?
Behind the scenes Properties are actually methods, which means they don't actually store data. So who saves the data ? AutoProperties generate private backend field to save the data.

So in the simple declaration of auto property

int X { get; set; }

The compiler translate it into something like that

private int <X>k__BackingField;

public int X
{
    [CompilerGenerated]
    get
    {
        return <X>k__BackingField;
    }
    [CompilerGenerated]
    set
    {
        <X>k__BackingField = value;
    }
}

So no matter if you use it as Auto Properties or simple property, they are the same.

Now, to answer you question, with paraphrasing, "How do i return the value multiply with 10"

You can solve it with using 2 ways: 1. By saving the data multiply by 10 (setter implementation) 2. By returning the data multiply by 10 (getter implementation)

I won't elavorate, which one you should use, because for this kind of simple scenario, both will be perfectly valid. I would just say that some of the factors for the choice will be micro(micro micro micro) performence, true state storage.

Here is the setter implementation

private int _x;
public int X
{
    get
    {
        return _x;
    }

    set
    {
        return _x*10;
    }
}