从具有类型约束的类继承-“不存在来自…的隐式引用转换”

Question

I have a base class for databinding a single datasource like this:

public abstract class DataControlBase<TContainer, TDataType> : Control
    where TDataType : new()
    where TContainer : TemplateContainerBase<TDataType>, new()
{
    public TDataType DataSource { get; set; }
}

The container class (TContainer) will always inherit from the container base:

public abstract class TemplateContainerBase<TDataType> : Control
    where TDataType : new()
{
    public TemplateContainerBase() { }

    public TDataType DataItem { get; set; }
}

Finally I have a repeater base where I will bind several data items as the datasource:

public abstract class RepeaterBase<TContainer, TDataType> : DataControlBase<TContainer, List<TDataType>>
    where TDataType : new()
    where TContainer : TemplateContainerBase<TDataType>, new()
{

}

I get an error on the RepeaterBase saying this

Error 1 The type 'TContainer' cannot be used as type parameter 'TContainer' in the generic type or method 'WebTestHarness.Controls.DataControlBase'. There is no implicit reference conversion from 'TContainer' to 'WebTestHarness.Controls.TemplateContainerBase>'.

I have read a few different threads describing similar issues but all seem to relate to methods whereas this is solely to do with class design.

Answer 1

You have

RepeaterBase<TContainer, TDataType> : DataControlBase<TContainer, List<TDataType>>

so you've set List<TDataType> as the second type parameter Y for DataControlBase<X, Y> . But your constraint for DataControlBase requires that X : TemplateContainerBase<Y>, new() . So, in your case, you would need the constraint

where TContainer : TemplateContainerBase<List<DataType>>, new()

on TContainer , not

where TContainer : TemplateContainerBase<DataType>, new()

as you currently have.

That is, just because you've used the same names for the type parameters in the varying classes does not mean that they represent the same types when you start parameterizing things. That is

class Foo<A> { }
class Bar<A> : Foo<List<A>> { }

The A in Bar is not the same as the A in Foo . Instead, List<A> is playing the role of A for Foo<A> in the definition of Bar<A> .