无法实现接口成员，因为它没有匹配的返回类型

Question

I'm working on an abstract algebra library for C#, but am having trouble with implementing interfaces. I have gotten the implementation to work for certain groups, but attempting to create rings is giving me some serious problems. In particular, I've got the following:

public class Scaffolding {

public interface IMonoid<T> : ISemiGroup<T> {
        T Identity { get; set; }
    }

public interface IGroup<T> : IMonoid<T> {
        T Inverse(T a);
    }

 public interface IRing<T> {
       IGroup<T> AdditiveStructure { get; set; }
       IMonoid<T> MultiplicativeStructure { get; set; }
    }
}

 public class ModularMonoid : Scaffolding.IMonoid<int> {
       // Implements all necessary monoid properties
    }

 public class ModularGroup : Scaffolding.IGroup<int> {
       // Implements all necessary group properties
    }

 public class ModularRing : Scaffolding.IRing<int> {
    public ModularGroup AdditiveStructure { get; set; }
    public ModularMonoid MultiplicativeStructure { get; set; }

    // Implement ring-specific properties
}

I get an error stating that 'ModularRing' does not implement interface member 'Scaffolding.IRing.AdditiveStructure'. 'ModularRing.AdditiveStructure' cannot implement 'Scaffolding.IRing.AdditiveStructure' because it does not have the matching return type of 'Scaffolding.IGroup'. I get a similar error for the MultiplicativeStructure. This is strange to me, because both the ModularGroup and ModularMonoid implement IGroup and IMonoid respectively.

Answer 1

Yes, those classes implement the interfaces, but that interface doesn't say "The type of the AdditiveStructure property is something that implements IGroup<T> " - it says that the type of the AdditiveStructure property is IGroup<T> . To implement the interface, you have to match return types exactly .

If you want to be able to implement the interface like that, you'd need to change the interface, potentially like this:

public interface IRing<T, TGroup, TMonoid>
    where TGroup : IGroup<T>
    where TMonoid : IMonoid<T>
{
   TGroup AdditiveStructure { get; set; }
   TMonoid MultiplicativeStructure { get; set; }
}

Then implement it as:

public class ModularRing : Scaffolding.IRing<int, ModularGroup, ModularMonoid>
{
    public ModularGroup AdditiveStructure { get; set; }
    public ModularMonoid MultiplicativeStructure { get; set; }        
}

Alternatively, you should consider making the properties read-only. That way, if you're happy with the ModularRing users only using the IGroup<int> and IMonoid<int> definitions (rather than depending on anything extra exposed on ModularGroup and ModularMonoid ) then you could stick with just the single type parameter, which would simplify things quite a lot. For example:

public interface IMonoid<T> : ISemiGroup<T>
{
    T Identity { get; }
}

public interface IGroup<T> : IMonoid<T>
 {
    T Inverse(T a);
}

public interface IRing<T>
{
   IGroup<T> AdditiveStructure { get; }
   IMonoid<T> MultiplicativeStructure { get; }
}

Implementation:

public class ModularRing : Scaffolding.IRing<int>
{
    public IGroup<int> AdditiveStructure { get; } = new ModularGroup();
    public IMonoid<int> MultiplicativeStructure { get; } = new ModularMonoid();
}

(Or accept them in the constructor; I don't know enough about what you're trying to do with them.)