How to hide implementation

Question

Lets say I have a class library, where any classes that are internal have access to the following interface:

interface myInterface
{
    string myProperty { get; set; } // notice setter.
}

But if somebody adds this class library to their project they get the following interface:

public interface myInterface
{
    string myProperty { get; }
}

What is the most efficient and accepted way of doing this? Have one interface implement the other?

Answer 1

Make your public interface have just the getter:

public interface myInterface
{
    string myProperty { get; } 
}

And then derive another internal-only interface from it that has a setter:

internal interface myInternalInterface : myInterface
{
    new string myProperty { get; set; }
}

You can them implement the internal interface:

class myImplementation : myInternalInterface
{
    public string myProperty{get; set;}
}

If you need to call the setter, you can cast your instance to the internal inteface and call it on that. This approach is a bit of a design smell though, so use it sparingly.

Answer 2

You can have the internal interface extend the public interface, like so:

public interface MyInternalInterface: MyPublicInterface
{
    string MyProperty { set; }
}

public interface MyPublicInterface
{
    string MyProperty { get; }
}

internal class A: MyInternalInterface
{
    public string MyProperty { get; set; }
}

public class Foo
{
    private A _a = new A();
    internal MyInternalInterface GetInternalA() { return _a; }
    public MyPublicInterface GetA() { return _a; }

}

This way you don't need any casts or anything.