Can derived C# interface properties override base interface properties with the same name?

Question

I'm trying to create an interface inheritance system that uses the same property but always of a further derived type. So the base property should be somehow overridden or hidden by the deriving interface.

Take, for instance, two interfaces, Man and Woman, that derive into Husband and Wife, also interfaces. Man and Husband interfaces both have a "sweetheart" property, while Woman and Wife have a "darling" property. Now, the Man's "sweetheart" property is of type Woman, while the Husband's same "sweetheart" property should be a Wife (derived from Woman). And the same with the Woman and Wife's "darling" property.

public interface Man // base interface for Husband
{
    Woman sweetheart { get; set; }
}

public interface Woman // base interface for Wife
{
    Man darling { get; set; }
}

public interface Husband : Man // extending Man interface
{
    new Wife sweetheart { get; set; } // narrowing "sweetheart" property's type
}

public interface Wife : Woman // extending Woman interface
{
    new Husband darling { get; set; } // narrowing "darling" property's type
}

public class RandomHusband : Husband // implementing the Husband interface
{
    private RandomWife wife;
    public Wife sweetheart { get { return wife; } set { wife = value; } }
}

public class RandomWife : Wife // implementing the Wife interface
{
    private RandomHusband husband;
    public Husband darling { get { return husband; } set { husband = value; } }
}

This code is wrong, it doesn't work. I'm beeing notified that I didn't implement the basic Man.sweetheart and Woman.darling properties, and that the implemented Husband.sweetheart and Wife.darling will not do, because the types don't match. Is there any way of narrowing a property's type to a derived one? How do you attain it in C#?

Answer 1

You can do this by parameterising your Man and Woman interfaces with the concrete implementation types:

public interface IMan<M, W>
    where M : IMan<M, W>
    where W : IWoman<W, M>
{
    W Sweetheart { get; set; }
}

 public interface IWoman<W, M>
    where W : IWoman<W, M>
    where M : IMan<M, W>
{
    M Darling { get; set; }
}

Your implementations are then:

public class Man : IMan<Man, Woman>
{
    public Woman Sweetheart { get; set; }
}

public class Woman : IWoman<Woman, Man>
{
    public Man Darling { get; set; }
}

public class Husband : IMan<Husband, Wife>
{
    public Wife Sweetheart { get; set; }
}

public class Wife : IWoman<Wife, Husband>
{
    public Husband Darling { get; set; }
}

Since the types get quite complicated, you might want to consider moving the relationship into an external class/interface:

public interface Relationship<TMan, TWoman> 
    where TMan : Man 
    where TWoman : Woman
{
    TMan Darling { get; }
    TWoman Sweetheart { get; }
}

public class Marriage : Relationship<Husband, Wife>
{
}

Then you can use this class to retain type safety when dealing with concrete implementations:

public static void HandleMarriage(Relationship<Husband, Wife> marriage)
{
    Husband h = marriage.Darling;
    Wife w = marriage.Sweetheart;
}

Answer 2

you will still need to satisy the Man and Woman interfaces as well as the Husband and Wife...

public class RandomWife : Wife // implementing the Wife interface

    {
        private RandomHusband husband;
        public Husband darling { get { return husband; } set { husband = value; } }
        public Man  Wife.darling { get { return husband; } set { /* can't set anything */ } }

    }