Question

Is there a way for implementers of an interface where a ReadOnly property is defined to make it a complete Read/Write Property ?

Imagine I define an interface to provide a ReadOnly Property (i.e., just a getter for a given value) :

Interface SomeInterface

    'the interface only say that implementers must provide a value for reading
    ReadOnly Property PublicProperty As String

End Interface

This means implementers must commit to providing a value. But I would like a given implementer to also allow setting that value. In my head, this would mean providing the Property‘s setter as part of the implementation, doing something like this :

Public Property PublicProperty As String Implements SomeInterface.PublicProperty
    Get
        Return _myProperty
    End Get
    Set(ByVal value As String)
        _myProperty = value
    End Set
End Property

but this will not compile as, for the VB compiler, the implementer no longer implements the interface (because it is no longer ReadOnly).

Conceptually, this should work, because, in the end, it just means Implement the getter from the Interface, and add a setter method. For “normal methods”, this would be no problem.

Is there some way of doing it, without resorting to “interface hiding” or “home-made” SetProperty() method, and style having the Property behave like a Read/Write property in the implementations ?

Thanks !

–UPDATE–
(I have moved this question to a separate Question)
My question is really : “why can’t this be done in VB.NET”, when the following is valid in C#.NET?” :

interface IPublicProperty
{
    string PublicProperty { get; }
}

with implementation :

public class Implementer:IPublicProperty
    {
        private string _publicProperty;

        public string PublicProperty
        {
            get
            {
                return _publicProperty;
            }
            set
            {
                _publicProperty = value;
            }
        }
    }

Answer 1

In the end, I ended up with a solution that matches my goal :

• users that access via the Interface see at least a getter
• users that access the implementation can Read and Write.

I did this “shadowing” the implemented property like this :

'users who access through interface see only the Read accessor
Public ReadOnly Property PublicProperty_SomeInterface As String Implements SomeInterface.PublicProperty
    Get
        Return _myProperty
    End Get
End Property


'users who work with the implementation have Read/Write access
Public Property PublicProperty_SomeInterface As String
    Get
        Return _myProperty
    End Get
    Set(ByVal value As String)
        _myProperty = value
    End Set
End Property

Then, depending on how you use it, you can do :

Dim implementorAsInterface As SomeInterface = New InterfaceImplementor()
logger.Log(implementor.PublicProperty) 'read access is always ok
implementor.PublicProperty = "toto" 'compile error : readOnly access

Dim implementor As InterfaceImplementor = New InterfaceImplementor()
implementor.PublicProperty = "toto" 'write access