尝试转换IEnumerable时出现异常？

Question

I'm still in my first couple weeks of learning C# for a project, and I'm trying to properly implement the IEnumerable interface. I've read a number of tutorials/guidelines, but I still seem to be doing something incorrectly. I have a strong Java background, so I think some of my knowledge of Java generics is muddling my understanding how they work in C#.

A class that I cannot alter contains an instance variable:

public IEnumerable<object> Items;

And I'd like to provide it with an instance of my SampleDataSource class. This class acts as a storage container for a List of MyObject types:

    public class SampleDataSource : IEnumerable
    {
        public List<MyObject> Subjects { get; private set; }

        public IEnumerator<MyObject> GetEnumerator()
        {
            return this.Cast<MyObject>().GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

But when I attempt to cast an instance of this SampleDataSource class to an IEnumerable<object> using this code:

Items = (IEnumerable<MyObject>)App.SampleData;

I receive an exception:

Additional information: Unable to cast object of type 'Expression.Blend.SampleData.SampleDataSource.SampleDataSource' to type 'System.Collections.Generic.IEnumerable`1[Expression.Blend.SampleData.SampleDataSource.MyObject]'.

But I don't quite understand why - isn't my SampleDataSource properly acting as an IEnumerable that returns an enumerator containing MyObject types?

Answer 1

It can't just implement the methods, but rather has to actually implement the interface.

In your case, it'd be better to just make your class implement the appropriate interface.

public class SampleDataSource : IEnumerable<MyObject>, IEnumerable

Otherwise, you can use something like linfu to duck-type your class to the interface.

The other potential object is to use OfType<T> to handle this:

// returns enumerable of the items that are actually assignable to MyObject
IEnumerable<MyObject> values = theDataSource.OfType<MyObject>();

Answer 2

I realize the question is answered already, but I missed a simple explanation of the problem behind your question, so here goes:

The reason you cannot assign your SampleDataSource class to an IEnumerable<object> field is that SampleDataSource does not implement IEnumerable<object> . While it does implement IEnumerable , that's not good enough, because IEnumerable<object> is a subtype of IEnumerable .

Because of interface covariance, you will be able to assign the class to the IEnumerable<object> field if it implements IEnumerable<MyObject> , provided that MyObject is in fact a reference type (ie, a class). That's only applicable to C# 4.0 and later, however.

Reed Copsey's answer doesn't mention that you could declare the SampleDataSource class thus, because IEnumerable<T> inherits from IEnumerable :

public class SampleDataSource : IEnumerable<MyObject>

Further, since you're just wrapping the contained collection, you would normally implement it thus:

public class SampleDataSource : IEnumerable<MyObject>
{  
    public List<MyObject> Subjects { get; private set; }  

    public IEnumerator<MyObject> GetEnumerator()  
    {  
        return Subjects.GetEnumerator();
    }  

    IEnumerator IEnumerable.GetEnumerator()  
    {  
        return GetEnumerator();  
    }  
}  

This is questionable from an object-orientation perspective, though, since you're giving the public read-write access to the list. (The fact that the setter is private means that the public can't reassign the list reference, but it doesn't prevent them from calling Add or Remove or Clear on the list.)

Another take on the object orientation question would be to ask: if a SampleDataSource contains a sequence of MyObjects, why would it also be a sequence of MyObjects? Instead of doing this:

classICannotAlter.Items = (IEnumerable<object>)someSampleDataSourceInstance;

maybe you should be doing this:

classICannotAlter.Items = (IEnumerable<object>)someSampleDataSourceInstance.Subjects;