通用接口的非通用实现

Question

I have the following group of 3 interfaces and 3 implementations of those said interfaces. The interfaces are defined with generics, and the topmost interface requires its parameter to extend the second one down; same with the second interface to the third. The classes have no generic parameters and instead implement the interface with a specific class, each of which meets the requirements for the interface.

namespace GenericsIssueExample
{
    interface IGroup<Row> where Row : IRow<IEntry>
    {
        Row[] Rows {
            get;
            set;
        }
    }

    interface IRow<Entry> where Entry : IEntry
    {
        Entry[] Entries {
            get;
            set;
        }
    }

    interface IEntry
    {
        int Value {
            get;
            set;
        }
    }

    class ExampleGroup : IGroup<ExampleRow>
    {
        private ExampleRow[] rows;

        public ExampleRow[] Rows {
            get { return rows; }
            set { rows = value; }
        }
    }

    class ExampleRow : IRow<ExampleEntry>
    {
        private ExampleEntry[] entries;

        public ExampleEntry[] Entries {
            get { return entries; }
            set { entries = value; }
        }
    }

    class ExampleEntry : IEntry
    {
        private int val = 0;

        public int Value {
            get { return val; }
            set { val = value; }
        }
    }
}

When I try to compile the above code, I get the following compile error:

The type 'GenericsIssueExample.ExampleRow' cannot be used as type parameter 'Row' in the generic type or method 'GenericsIssueExample.IGroup<Row>'. There is no implicit reference conversion from 'GenericsIssueExample.ExampleRow' to 'GenericsIssueExample.IRow<GenericsIssueExample.IEntry>'.

This error is on line 27, which is the definition of ExampleGroup :

class ExampleGroup : IGroup<ExampleRow>

I don't understand why this is occurring, as ExampleRow does implement IRow<IEntry> . ( IRow<ExampleEntry> ).

How would I correct the above code to resolve that error?

Answer 1

Just because ExampleEntry can be implicitly converted to an IEntry does not mean that an IRow<ExampleEntry> can be converted to an IRow<IEntry> . If IRow is covariant with respect to its generic argument, then yes, that would be possible, but it's not as it stands, so the implicit conversion isn't possible.

If you could implicitly convert an IRow<ExampleEntry> to an IRow<IEntry> then you could set the Entries property to an array of an IEntry type that is not an ExampleRow .

Answer 2

The problem is you're intermixing interfaces and generics where it is not applicable. It's hard to see in your example but if you fix the naming convention so all generic type parameters are named TSomething then it'll be clear.

Once we do this, then it's clear we want to specify that we want a row of classes that implement IEntry , not a row of IEntry instances themselves.

Here's a working example:

namespace GenericsIssueExample
{
    interface IGroup<TRow, TEntry>
        where TRow : IRow<TEntry>
        where TEntry : IEntry 
    {
        TRow[] Rows
        {
            get;
            set;
        }
    }

    interface IRow<TEntry> where TEntry : IEntry
    {
        TEntry[] Entries
        {
            get;
            set;
        }
    }

    interface IEntry
    {
        int Value
        {
            get;
            set;
        }
    }

    class ExampleGroup : IGroup<ExampleRow, ExampleEntry>
    {
        private ExampleRow[] rows;

        public ExampleRow[] Rows
        {
            get { return rows; }
            set { rows = value; }
        }
    }

    class ExampleRow : IRow<ExampleEntry>
    {
        private ExampleEntry[] entries;

        public ExampleEntry[] Entries
        {
            get { return entries; }
            set { entries = value; }
        }
    }

    class ExampleEntry : IEntry
    {
        private int val = 0;

        public int Value
        {
            get { return val; }
            set { val = value; }
        }
    }
}