C# Passing a collection as a collection of interfaces

Question

I have simplified and reproduced my problem in the code below. The error that I am receiving is: Argument 1: cannot convert from 'System.Collections.ObjectModel.Collection' to 'System.Collections.ObjectModel.Collection

Some background for the design decisions that led to this issue: I have created a web service for dealing with "IFruit", but due to the nature of SOAP and endpoint bindings as I understand them I have created methods with explicit implementations of IFruit. On the business layer, creating a separate method for each specific implementation of fruit would firstly cause a lot of duplicate code, and secondly couple the business and service layer tightly enough that accepting new IFruit types in the web service later would also require changing my code in the business layer (adding another copy of redundant code). This design is one I have successfully implemented using Java in the past, but C# interfaces seem to be just different enough to throw me. Please advise.

public interface IFruit{
    public string TakeBite();
}

public Apple : IFruit{
    public string TakeBite(){
        return "tasty bite of apple";
    }
}

public void EatFruit(Collection<IFruit> fruits){
    foreach(var fruit in fruits){
        Console.WriteLine(fruit.TakeBite());
    }
}

public void EatApples(Collection<Apple> apples){
    this.EatFruit(apples);
}

Kevin Aenmey · Accepted Answer · 2012-07-06T18:07:04.427

11

Try changing your EatFruit method to accept IEnumerable<IFruit>

public void EatFruit(IEnumerable<IFruit> fruits)
{
    foreach (var fruit in fruits)
    {
        Console.WriteLine(fruit.TakeBite());
    }
}

The interface IEnumerable<out T> supports covariance since it is marked with the out modifier. Collection<T> is not marked with such a modifier.

edited Jul 06 '12 at 18:07

answered Jul 06 '12 at 18:00

Kevin Aenmey

13,259
5
46
45

score 1 · Answer 2 · answered Jul 06 '12 at 17:58

1

That's called covariance.
However, it's not possible with mutable collections.

Otherwise, EatFruit could write

fruits.Add(new Orange());

.Net 4 does support covariance for reas-only interfaces, so you can change it to IEnumerable<IFruit> and it will work.

answered Jul 06 '12 at 17:58

SLaks

868,454
176
1,908
1,964

Assuming Orange implements IFruit then is there an issue there? – Charleh Jul 06 '12 at 17:59
1

@Charleh: `fruits` is _actually_ a `Collection`. It can't hold an `Orange`. – SLaks Jul 06 '12 at 17:59
I thought since fruits was a Collection that it could contain any type that implements IFruit? – Charleh Jul 06 '12 at 18:01
@Charleh: He passed a `Collection`, not a `Collection`. – SLaks Jul 06 '12 at 18:01
Oh sorry completely missed the last method calling the previous :D – Charleh Jul 06 '12 at 18:02
The idea is to reference a Collention as a Collection. But it will always know it is a Collection in its heart (fruits.GetType() will return Collection). – YouGotCSharpInMyJava Jul 06 '12 at 18:03
@YouGotCSharpInMyJava: Yes. And that's not safe. – SLaks Jul 06 '12 at 18:04

score 1 · Answer 3 · answered Jul 06 '12 at 18:16

Simple solution :

public void EatApples(Collection<Apple> apples){
     this.EatFruit(
          new Collection<IFruit>(
              apples.Cast<IFruit>()
          )
     );
}

Better solution : use the covariance introduced in C# 4 : see Kevin's answer

score 0 · Answer 4 · answered Jul 06 '12 at 18:09

0

Aside from using IEnumerable you could type check the collection (bit horrid but it should work):

public void EatApples(Collection<IFruit> fruit)
    var col = new Collection<IFruit>();

    fruit.Where(x => x is Apple).ToList().ForEach(x => col.Add(x));

    this.EatFruit(col);
}

Though I'd use IEnumerable instead - this is just an option if you can't refactor :P

(it's as type safe as you make it!)

answered Jul 06 '12 at 18:09

Charleh

13,749
3
37
57

That would do 2x work - create a List then add each to the Collection. Better to do: `foreach (var x in fruit.OfType()) { col.Add(x); }`. – Kevin Brock Jul 06 '12 at 19:44
Yeah true - nowhere did I say it would be performant (and I did mention horrid in there too!) :D – Charleh Jul 06 '12 at 19:45

C# Passing a collection as a collection of interfaces

4 Answers4