接口作为接口返回类型

Question

In my app I use different web api's for fetching car information. For the services I have implemented ICarService. As all of these Api's return little different set of car data, I have implemented ICar interface, so each services can return their own type of car but in my app I can use "general" ICar.

Here is my implementation:

// Car Model
public interface ICar
{
    string Color { get; }
}

public class CarApiA : ICar
{
    public int car_color { get; set; }
    public Color
    {
        get { return this.car_color; }
    }
}


// Service
public interface ICarService
{
    Task<List<ICar>> GetCarsAsync(string search);
}

public class CarApiAService : ICarService
{
    public async Task<List<CarApiA>> GetCarsAsync(string search)
    {
        HttpClient client = new HttpClient();
        var response = await client.GetAsync(url);
        string content = await response.Content.ReadAsStringAsync();

        return  JsonConvert.DeserializeObject<List<CarApiA>>(content);
    }
}

Now I get the error message "'CarApiAService' does not implement interface member 'ICarService.GetCarsAsync(string)'. 'CarApiAService.GetCarsAsync(string)' cannot implement 'ICarService.GetCarsAsync(string)' because it does not have the matching return type of 'System.Threading.Tasks.Task>'."

How I use interface to return interface? If this my idea of implementation is completely wrong, please guide me to correct direction.

Answer 1

Consider using IEnumerable instead of IList . This allows you to use a covariant generic type:

public async Task<IEnumerable<ICar>> GetCarsAsync(string search)
{
    // ...
    return JsonConvert.DeserializeObject<List<CarApiA>>(content);
}

(Of course the interface also has to be updated…)

public interface ICarService
{
    Task<IEnumerable<ICar>> GetCarsAsync(string search);
}

---

A word of explanation in case you were wondering about covariance with generic types:

• only a generic interface can be covariant (not generic concrete types like List<T> )
• the interface can only be covariant if the generic type is defined as out (ie, read-only). That's why IEnumerable<out T> is covariant but IList<T> is not

See also Jon Skeet's answer here , and Eric Lippert's blog .