constant variable, local and passing to methods

[puzzlecracker]

How can I pass a reference to a method as constant?

I tried the following:

Function(const Foo f) or Function(readonly Foo f)
Also, How to declare local variable to be constant

const Foo foo or readonlyFoo f?

[Peter Duniho]

On Wed, 01 Oct 2008 10:51:00 -0700, puzzlecracker <ir*********@gmail.com>
wrote:

How can I pass a reference to a method as constant?

I tried the following:

Function(const Foo f) or Function(readonly Foo f)

You can't.

Also, How to declare local variable to be constant

const Foo foo or readonlyFoo f?

Well, when you tried it, which one worked and which one didn't? :)

Pete

[puzzlecracker]

On Oct 1, 2:18*pm, "Peter Duniho" <[e-mail]>
wrote:

On Wed, 01 Oct 2008 10:51:00 -0700, puzzlecracker <[e-mail]>*
wrote:

How can I pass a reference to a method as constant?

I tried the following:

Function(const Foo *f) or *Function(readonly Foo *f)

You can't.

Also, How to declare local variable to be constant

const Foo foo or readonlyFoo f?

Well, when you tried it, which one worked and which one didn't? *:)

Pete

I'd like to know the standard way to send reference type as const? I
suppose no need for that for value types since they copied anyway.

What if we send value types, not as const, and it contains a
references type as a member. Then reference member will be modified,
hence there is a need to send even value types as const if such
behavior is desired. Now, please tell me how it's done.

Thanks

[Peter Duniho]

On Wed, 01 Oct 2008 11:36:06 -0700, puzzlecracker <ir*********@gmail.com>
wrote:

I'd like to know the standard way to send reference type as const? I
suppose no need for that for value types since they copied anyway.

What if we send value types, not as const, and it contains a
references type as a member. Then reference member will be modified,
hence there is a need to send even value types as const if such
behavior is desired. Now, please tell me how it's done.

As I said, you can't. C# doesn't have the concept of const arguments for
methods. If a reference type is mutable, then any code with a reference
to an instance can theoretically mutate the instance.

"Theoretically" because, of course, you could use member accessibility as
a way of limiting what code can modify the instance, by making any member
of the class that could mutate the instance inaccessible to the code using
the instance. It's not really the same thing as "const" would be, but
depending on your goals, it could work.

Of course, another approach is to design immutable classes. One very
well-known example of an immutable class is the String class. Immutable
types can be inconvenient in some ways, but they offer some surprisingly
powerful promises that can lead to very elegantly safe code. With an
immutable class, any reference to that class is inherently "const".

Note that even in C++, passing an argument as "const" wouldn't cause
mutable members of that argument to also be "const". That is, a reference
member of a class or struct could itself still be modified, even if you
can't change the reference in the passed argument. There might be a
language that supports that sort of thing, but it's not ones I'm most
familiar with. It shouldn't be surprising that C# doesn't include that
feature.

Pete

[Jeff Louie]

PuzzleCracker... As Peter suggest you can use an immutable class.

If you simply want to keep a particular client from modifying the class,
wrap the
mutable class in a read only wrapper so that the client cannot directly
modify
the encapsulated mutable class and pass a reference of type immutable
wrapper
to the client. This is the strong guarantee. The generic collections,
for instance,
have a method AsReadOnly() that returns an object reference that
implements
the read only IList interface.

Finally a kludge is to design an inheritance hierarchy with a read only
base class
and a read write sub class. Create an instance of the read write sub
class and
then create a reference variable of type read only base class. Pass the
reference
of type read only base class to the client. This is the weak guarantee,
since the
client can still cast the read only reference to the read write sub
class type.

Regards,
Jeff

*** Sent via Developersdex http://www.developersdex.com ***