Failure to implicitly convert class to base class when using LINQ IEnumerable.ToDictionary()

Question

I have the following situation which is confusing me.

Given:

public class ThermoRawFile : MsDataFile { }

public abstract class MSDataFile { }

I am unable to run this LINQ IEnumerable.ToDictionary() method:

IEnumerable<string> rawFiles;
Dictionary<string, MSDataFile> dataFiles = rawFiles.ToDictionary(
    file => file,
    file => new ThermoRawFile(file)
);

as the compiler gives the following error:

"Cannot implicitly convert type System.Collections.Generic.Dictionary<string,CSMSL.IO.Thermo.ThermoRawFile> to System.Collections.Generic.Dictionary<string,CSMSL.IO.MSDataFile>"

Why cannot it implicit convert ThermoRawFile into MSDataFile when it is a simple inheritance?

This works just fine:

 MSDataFile dataFile = new ThermoRawFile("someFile.raw");

score 3 · Accepted Answer · answered Sep 06 '13 at 16:41

3

The error does not say that it cannot convert CSMSL.IO.Thermo.ThermoRawFile to CSMSL.IO.MSDataFile, only that it cannot convert a generic dictionary type based on CSMSL.IO.Thermo.ThermoRawFile to a generic dictionary type based on CSMSL.IO.MSDataFile. This is expected, because these types are not covariant.

You can fix this by supplying a cast:

IEnumerable<string> rawFiles;
Dictionary<string, MSDataFile> dataFiles = rawFiles.ToDictionary(
    file => file,
    file => (MSDataFile)new ThermoRawFile(file)
);

answered Sep 06 '13 at 16:41

Sergey Kalinichenko

714,442
84
1,110
1,523

1

Why not use an *actual* cast instead of `as`? Usually the presence of `as` implies that the conversion *may* fail, and will be handled with a nullity check. – Jon Skeet Sep 06 '13 at 16:44
@JonSkeet You're right, that was somewhat misleading. This is now fixed. Thanks! – Sergey Kalinichenko Sep 06 '13 at 16:46

Jon Skeet · Answer 2 · 2013-09-06T19:06:44.547

The problem is that type inference has inferred your ToDictionary call to be:

rawFiles.ToDictionary<string, string, ThermoRawFile>(...)

That means the returned value will be of type Dictionary<string, ThermoRawFile>, and there's no conversion from that to Dictionary<string, MSDataFile> (partly because dictionaries are invariant in general, and partly because all classes are invariant).

Now you can cast the value selection part to make type inference work:

var dataFiles = rawFiles.ToDictionary(
    file => file,
    file => (MSDataFile) new ThermoRawFile());

Or you could just explicitly specify the type arguments:

var dataFiles = rawFiles.ToDictionary<string, string, MSDataFile>(
    file => file,
    file => new ThermoRawFile());

That will still be fine, as the compiler can convert the lambda expression file => new ThermoRawFile() into a Func<string, MSDataFile>.

@Moop: It would really have helped if you'd stated the error message rather than just "doesn't work". I'll look at it in a minute. — Jon Skeet, Sep 06 '13 at 19:03
@Moop: Fixed now. Just had the wrong number of type arguments. — Jon Skeet, Sep 06 '13 at 19:06

score 0 · Answer 3 · answered Sep 06 '13 at 16:47

This has to do with covariance. A ThermoRawFile is a MSDataFile, but a Dictionary<string, ThermoRawFile> is not a Dictionary<string, MSDataFile>.

If it were, then you could do something like this:

public class FooFile : MsDataFile { }

dataFiles["blah"] = new FooFile();

This would be putting a FooFile into a Dictionary<string, ThermoRawFile>, which would wreak all kinds of havoc.

In this case you need to construct a dictionary that is actually of type Dictionary<string, MSDataFile> to begin with, even if you populate it with entirely ThermoRawFile values. You can do so by adding in a cast (as shown in a bunch of other answers here):

IEnumerable<string> rawFiles;
Dictionary<string, MSDataFile> dataFiles = rawFiles.ToDictionary(
    file => file,
    file => (MSDataFile)new ThermoRawFile(file)
);

Failure to implicitly convert class to base class when using LINQ IEnumerable.ToDictionary()

3 Answers3