How to deal with interface inheritance and common properties? I'm trying to design a generic caching system that takes keyed items and allows either read-only or read-write access to a cached version of it. The read-only backing interface is:

public interface IReadableItem&lt;TKey&gt;
{
  TKey Key { get; }
}


However, I need to be able to dynamically update the key of my writable items. I've come up with two options, but both are unappealing.

I can forgo the inheritance:

public interface IWritableItem&lt;TKey&gt;
{
  TKey Key { get; set; }
}


... but this leaves me in a situation where I have to specify that every class is both an IWritableItem and an IReadableItem in order to allow read-write access.

On the other hand, I can use the new keyword to override the underlying inheritence:

public interface IWritableItem&lt;TKey&gt; : IReadableItem&lt;TKey&gt;
{
  new TKey Key { get; set; }
}


... but this leaves me with a bad code-smell, especially when attempting to explicitly implement the interface at the class level.

Is this a situation where I should just take the lesser of two evils, or is there a Third Way?
What I would do is to use inheritance, but have only setter in IWritableItem:

public interface IReadableItem&lt;TKey&gt;
{
    TKey Key { get; }
}

public interface IWritableItem&lt;TKey&gt; : IReadableItem&lt;TKey&gt;
{
    new TKey Key { set; }
}


This still works as expected:

class Foo&lt;T&gt; : IWritableItem&lt;T&gt;
{
    public T Key { get; set; }
}


It also has the advantage that you can't implement the getter for IWritableItem differently from the getter for IReadableItem.