can a method parameter pass an object by reference but be read-only?

Question

C#: can you make it so that a method parameter passes an object by reference but is read-only?

eg:

void MyMethod(int x, int y, read-only MyObject obj)

where obj is an object reference but this object cannot be modified during the method.

Can this be achieved in C#?

Answer 1

No. C# has no direct analogue to C++ const (its own const is something different). A common C# pattern for this is to pass in a interface, such as IEnumerable, that does not permit modifications. You can also create an immutable copy or wrapper.

Answer 2

This is not possible in C#.

You can prevent this by passing in an immutable object.

Answer 3

There is no mechanism that does this for you.

Either pass a throwaway copy, or build immutability, even if temporary, into the class itself.

Answer 4

why don't you make a copy of that object and do whatever you want with that copy while your obj remains not modified.

See here how to clone your object: http://stackoverflow.com/questions/78536/cloning-objects-in-c

Answer 5

If the class of the object you're passing was written by you, then you're in luck.

Ask yourself: if C# had a const feature, what operations on the object would I expect to be banned through a const reference to my class?

Then define an interface that leaves out the banned operations.

For example:

class MyClass 
{
    public string GetSomething() { ... }

    public void Clobber() { ... }

    public int Thing { get { ... } set { ... } }
}

The corresponding "const" interface might be:

interface IConstMyClass 
{
    public string GetSomething() { ... }

    public int Thing { get { ... } }
}

Now amend the class:

class MyClass : IConstMyClass
{

Now you can use IConstMyClass to mean const MyClass.

 void MyMethod(int x, int y, IConstMyClass obj)

Note: there will be those who will tell you that this isn't enough. What if MyMethod casts back to MyClass? But ignore them. Ultimately the implementor can use reflection to get around any aspect of the type system - see this amusing example.

The only option to stop reflection attacks is the trivial approach: make a totally disconnected clone.