接口设计实现错误：…无法实现…，因为它没有匹配的返回类型

Question

I have a few classes in Library1: Class A, Class B, etc. that are used by classes above.

public class A 
{  
    int VarA1;  
}

public class B
{  
    List<A> SetA {get; set; }
    void MethodB1()
    {
            ...
            this.SetA = new List<A>;
            ...
    }
}

Now I want to have an interface for that Library1, so there can be other implementations. Calling the interface library ILibrary:

public interface IA
{  
    int VarA1 {get; set; }  
}

public interface IB
{  
    List<IA> SetA { get; set; }
    void MethodB1();
}

which are being implemented in Library1:

public class A : IA
{  
    int VarA1{ get; set; }  
}

public class B : IB
{  
    List<IA> SetA {get; set; }
    void MethodB1()
    {
            ...
            this.SetA = new List<A>;
            ...
    }
}

But I am getting a compilation error with this code:

Library1.B.SetA cannot implement ILibrary.IB.SetA because it does not have a matching return type.

I also tried:

public class B : IB
{  
    List<A> SetA {get; set; }
    void MethodB1()
    {
            ...
            this.SetA = new List<A>;
            ...
    }
}

But that didn't resolve the issue (same error message). Why is this giving this error and how can I resolve it?

Answer 1

As the error message indicates, in order to comply with the interface, B.MethodB1 will have to return a type of IA , like this:

public class B : IB
{  
    public IA MethodB1() { ... }  
}

An alternative is to declare IB as a generic interface like this:

public interface IB<out T> where T : IA
{  
    public T MethodB1();  
}

And then B like this:

public class B : IB<A>
{  
    public A MethodB1() { ... }  
}

---

Regarding your updated question, your issue is still the same, and so are the solutions. Either do something like this:

public class B : IB
{  
    public List<IA> SetA {get; set; }
    public void MethodB1()
    {
            ...
            this.SetA = new List<IA>();
            ...
    }
}

Or like this:

public interface IB<T> where T : IA
{  
    List<T> SetA { get; set; }
    void MethodB1();
}

public class B : IB<A>
{  
    public List<A> SetA {get; set; }
    public void MethodB1()
    {
            ...
            this.SetA = new List<A>();
            ...
    }
}

Answer 2

The implementation of a method from an interface must return the exact same type, and IA is not the same as A. They have to absolutely match so it must return IA. However your B implementation of MethodB1 does not have a body and the class is not abstract so you will still get an error.

Answer 3

List<A> does not inherit from or implement List<IA> .

The interface IB requires a List<IA> property. The class B has a List<A> property.

Consider:

interface IAnimal()
{
  public void HaveLunch();
}

class Zebra:IAnimal
class Lion:IAnimal


interface IZoo
{
  List<IAnimal> Zebras {get;set;}
  List<IAnimal> Lions {get;set;}
}

public class Zoo
  : IZoo //does not work
{
  List<Zebra> Zebras {get;set;}
  List<Lion> Lions {get;set;}
}


//...
IZoo myZoo = new Zoo;
myZoo.Zebras.Add(new Lion());  //because of this.

Answer 4

the other answers have already said why this will not work:

• An inherited property has to use the exact same type as the parent
• You cannot assign List<IA> myList = new List<A>(); ,
  you must use the same type. This is because List is not covariant.

So you will have to use IA instead of A throughout your code, and only use the public methods accessible to IA

There is however a way to make it work, while still having access to A, if you change the type of ASet to IEnumerable<IA> :

• you can assign IEnumerable<IA> myList = new List<A>();
  because IEnumerable supports covariance , since C# 4.0

IEnumerable does not support all the methods that List does, for example you cannot add more elements to an IEnumerable. This is unfortunately necessary to make covariance work. You can however internally use a List inside class B, and only present the IEnumerable to the outside.

public interface IB
{  
    IEnumerable<IA> SetA { get; set; }
    void MethodB1();
}

public class B : IB
{  
    private List<A> listA;

    public IEnumerable<IA> SetA 
    {
        get {return listA;} 
        set {throw new NotImplementedException();} 
        // the setter is somewhat inelegant, 
        // if you do not need the setter 
        // you should probably leave it out of the interface entirely
    }

    public void MethodB1()
    {
            this.listA = new List<A>()
    }
}