const, readonly and mutable value types

I'm continuing my study of C# and the language specification and Here goes another behavior that I don't quite understand:

The C# Language Specification clearly states the following in section 10.4:

The type specified in a constant declaration must be sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, an enum-type, or a reference-type.

It also states in section 4.1.4 the following:

Through const declarations it is possible to declare constants of the simple types (§10.4). It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.

Ok, so a similar effect can be gained by using static readonly. Reading this I went and tried the following code:

static void Main()
{
    OffsetPoints();
    Console.Write("Hit a key to exit...");
    Console.ReadKey();
}

static Point staticPoint = new Point(0, 0);
static readonly Point staticReadOnlyPoint = new Point(0, 0);

public static void OffsetPoints()
{
    PrintOutPoints();
    staticPoint.Offset(1, 1);
    staticReadOnlyPoint.Offset(1, 1);
    Console.WriteLine("Offsetting...");
    Console.WriteLine();
    PrintOutPoints();
}

static void PrintOutPoints()
{
    Console.WriteLine("Static Point: X={0};Y={1}", staticPoint.X, staticPoint.Y);
    Console.WriteLine("Static readonly Point: X={0};Y={1}", staticReadOnlyPoint.X, staticReadOnlyPoint.Y);
    Console.WriteLine();
}

The output of this code is:

Static Point: X=0;Y=0

Static readonly Point: X=0;Y=0

Offsetting...

Static Point: X=1;Y=1

Static readonly Point: X=0;Y=0

Hit a key to exit...

I really expected the compiler to give me some kind of warning about mutating a static readonly field or failing that, to mutate the field as it would with a reference type.

I know mutable value types are evil (why did Microsoft ever implement Point as mutable is a mystery) but shouldn't the compiler warn you in some way that you are trying to mutate a static readonly value type? Or at least warn you that your Offset() method will not have the "desired" side effects?

---

Eric Lippert explains what's going on here:

...if the field is readonly and the reference occurs outside an instance constructor of the class in which the field is declared, then the result is a value, namely the value of the field I in the object referenced by E.

The important word here is that the result is the value of the field, not the variable associated with the field. Readonly fields are not variables outside of the constructor. (The initializer here is considered to be inside the constructor; see my earlier post on that subject.)

Oh and just to stress on the evilness of mutable structs, here is his conclusion:

This is yet another reason why mutable value types are evil. Try to always make value types immutable.

---

The point of the readonly is that you cannot reassign the reference or value.

In other words if you attempted this

staticReadOnlyPoint = new Point(1, 1);

you would get a compiler error because you are attempting to reassign staticReadOnlyPoint . The compiler will prevent you from doing this.

However, readonly doesn't enforce whether the value or referenced object itself is mutable - that is a behaviour that is designed into the class or struct by the person creating it.

[ EDIT : to properly address the odd behaviour being described]

The reason you see the behaviour where staticReadOnlyPoint appears to be immutable is not because it is immutable itself, but because it is a readonly struct. This means that every time you access it, you are taking a full copy of it.

So your line

staticReadOnlyPoint.Offset(1, 1);

is accessing, and mutating, a copy of the field, not the actual value in the field. When you subsequently write out the value you are then writing out yet another copy of the original (not the mutated copy).

The copy you did mutate with the call to Offset is discarded, because it is never assigned to anything.

---

The compiler simply doesn't have enough information available about a method to know that the method mutates the struct. A method may well have a side-effect that's useful but doesn't otherwise change any members of the struct. If would technically be possible to add such analysis to the compiler. But that won't work for any types that live in another assembly.

The missing ingredient is a metadata token that indicates that a method doesn't mutate any members. Like the const keyword in C++. Not available. It would have be drastically non-CLS compliant if it was added in the original design. There are very few languages that support the notion. I can only think of C++ but I don't get out much.

Fwiw, the compiler does generate explicit code to ensure that the statement cannot accidentally modify the readonly. This statement

staticReadOnlyPoint.Offset(1, 1);

gets translated to

Point temp = staticReadOnlyPoint;   // makes a copy
temp.Offset(1, 1);

Adding code that then compares the value and generates a runtime error is also only technically possible. It costs too much.

链接地址: http://www.djcxy.com/p/21078.html

上一篇: 受保护的只读字段与受保护的属性

下一篇: const，只读和可变值类型