Implement a readonly (immutable) object interface in C#

Question

My goal is to make sure that in most scenarios objects are used via a "read-only interface" that is a subset of the full interface.

• As an example, if I were using C++, I would just return a const object.
• In C#, if I could achieve this with interfaces, I would just implement a read-only interface and use it everywhere. However, I need operator overloading, which is not allowed for interfaces. That's why I have to use an abstract base class.
• But if I define an abstract base class, I am not allowed to change accessibility in the derived type.

So, how can I achieve my goal in C#?

Answer 1

Do you really need operator overloading? We are talking about syntactic sugar here. Also, not all .NET languages utilize operator overloading in the same way. So, if you use operator overloading, you are effectively making your code language-specific.

I would implement the read-only interface and drop the operator overloading requirement.

Answer 2

If anyone is interested in what I did, I finally went for an abstract class instead of interface, and I did hide the method in the derived class to get the right accessors:

Like, in the base abstract class (readonly interface):

protected double accuracy;
public double Accuracy { get { return accuracy; } }

In the derived class:

public new double Accuracy
{
    get { return accuracy; }
    set { accuracy = value; }
}

Of course, ugly with the "new" keyword, but in this case it will do for me.

Answer 3

How about if you placed your write operations in an interface and then implement in explicitly on the abstract base class? It would not be a 100% perfect solution (you could still cast the object to the modification interface), but for most part it would prevent anyone from accidentally calling the modifying methods.

Answer 4

You could implement the readonly behaviour via state in the object, and throw an exception if a modifying method is called?