readonly issue

[puzzlecracker]

When I create a reference type as readonly, can I modify its internals
but not resassing?
class A
{
private int _x;
public int X
{
get; set;
}
}

public static void Main(string [] args){

readonly A a=new A();;
A b=new A();
a.X=5; //is this allowed?
a=b; // is this allowed?
}

[Jon Skeet [C# MVP]]

puzzlecracker <ir*********@gmail.comwrote:

When I create a reference type as readonly

Careful with the terminology - it's not the type which is being marked
as readonly, but the variable.

can I modify its internals but not resassing?

Exactly. There's no way of saying "this is an immutable instance".

--
Jon Skeet - <sk***@pobox.com>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com

[Peter Duniho]

On Mon, 06 Oct 2008 12:05:39 -0700, puzzlecracker <ir*********@gmail.com>
wrote:

When I create a reference type as readonly, can I modify its internals
but not resassing?

Just try to compile it and see yourself.

[puzzlecracker]

On Oct 6, 4:29*pm, Jon Skeet [C# MVP] <[e-mail]:

puzzlecracker <[e-mail]:

When I create a reference type as readonly

Careful with the terminology - it's not the type which is being marked
as readonly, but the variable.

can I modify its internals but not resassing?

Exactly. There's no way of saying "this is an immutable instance".

--
Jon Skeet - <[e-mail]>
Web site:http://www.pobox.com/~skeet*
Blog:http://www.msmvps.com/jon.skeet
C# in Depth:http://csharpindepth.com

isn't string immutable? Or Csharp doesn't have the same concept of
immutability as C++ (const T t; would make t constant, hence no
modifications are allowed to internals)? I suppose readonly SomeType
t=new SomeType() is equivalent to SomeTime *const t in C++. Right?

[Jon Skeet [C# MVP]]

puzzlecracker <ir*********@gmail.comwrote:

isn't string immutable?

Yes, but we happen to know that - there's no way of telling either the
CLR or the compiler that a particular type is immutable.

Or Csharp doesn't have the same concept of
immutability as C++ (const T t; would make t constant, hence no
modifications are allowed to internals)?

Exactly.

I suppose readonly SomeType
t=new SomeType() is equivalent to SomeTime *const t in C++. Right?

I suspect so, but my C++ is very rusty, so I wouldn't swear to it.

--
Jon Skeet - <sk***@pobox.com>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com

[Jon Skeet [C# MVP]]

ozbear <oz****@bigpond.comwrote:

Which is a shame. I had written what I thought was an
immutable class but missed something which rendered it
mutable. It would be nice if there were an attribute
or other decoration that one could put on a class
definition that stated it was (supposed to be) immutable.
Enforcement of that decoration would, I believe, not be difficult for
the compiler. All fields readonly so they could only
be set in a constructor would be adequate.

I agree that it's a shame that there isn't more support for
immutability - but I disagree that it's as simple as making all the
fields readonly:

public class SupposedlyImmutable
{
private readonly List<stringnames = new List<string>();

public void AddName(string name)
{
names.Add(name);
}
}

Eric Lippert has a great series of posts about immutability:

blogs.msdn.com/ericlippert/archive/tags/Immutability/default.aspx

--
Jon Skeet - <sk***@pobox.com>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com