Question

鉴于泛型类的当前结构。

public abstract class Foo<TFoo, TBar>
    where TFoo : Foo<TFoo, TBar>
    where TBar : Bar<TFoo, TBar>
{
}

public abstract class Foo<TFoo> : Foo<TFoo, BarImpl>
    where TFoo : Foo<TFoo>
{
}

public class FooImpl : Foo<FooImpl>
{
}

public abstract class Bar<TFoo, TBar>
    where TFoo : Foo<TFoo, TBar>
    where TBar : Bar<TFoo, TBar>
{
}

public abstract class Bar<TFoo> : Bar<TFoo, BarImpl>
    where TFoo : Foo<TFoo>
{
}

public class BarImpl : Bar<FooImpl>
{
}

我想要的是在Bar的每个实现上设置默认Foo<TFoo>。在代码的其他部分创建了TBar的实例，如果它是Bar<TFoo>则会失败，因为这是abstract类。

然而，抛出以下错误，我不明白我能做什么，或者根本不可能。

'BarImpl'类型必须可转换为'Bar'才能在泛型类'Foo'中将其用作参数'TBar'

我已经尝试让BarImpl从[{1}}派生而来，但效果不明显。

将其更改为

Bar<FooImpl, BarImpl>

将一直有效，直到public abstract class Foo<TFoo> : Foo<TFoo, Bar<TFoo>> where TFoo : Foo<TFoo> { } public abstract class Bar<TFoo> : Bar<TFoo, Bar<TFoo>> where TFoo : Foo<TFoo> { }类型的对象被实例化（因为它是abtract）。

Answer 1

我猜你必须结束你的通用递归循环：

一般接口：

public interface IFoo
{
}

public interface IBar
{
}

取决于您想要的继承类型：

public interface IFoo<TFoo> : IFoo
    where TFoo : IFoo
{
}

public interface IBar<TBar> : IBar
    where TBar : IBar
{
}

public interface IFoo<TFoo, TBar> : IFoo<IFoo>
    where TFoo : IFoo
    where TBar : IBar
{
}

public interface IBar<TFoo, TBar> : IBar<IBar>
    where TFoo : IFoo
    where TBar : IBar
{
}

或者：

public interface IFoo<TFoo, TBar> : IFoo
    where TFoo : IFoo
    where TBar : IBar
{
}

public interface IBar<TFoo, TBar> : IBar
    where TFoo : IFoo
    where TBar : IBar
{
}

public interface IFoo<TFoo> : IFoo<TFoo, IBar>
    where TFoo : IFoo
{
}

public interface IBar<TBar> : IBar<IFoo, TBar>
    where TBar : IBar
{
}

摘要课程：

public abstract class AFoo<TFoo, TBar> : IFoo<TFoo, TBar>
    where TFoo : IFoo
    where TBar : IBar
{
}

public abstract class ABar<TFoo, TBar> : IBar<TFoo, TBar>
    where TFoo : IFoo
    where TBar : IBar
{
}

实施班级：

public class Foo<TFoo, TBar> : AFoo<TFoo, TBar>
    where TFoo : IFoo
    where TBar : IBar
{
}

public class Bar<TFoo, TBar> : ABar<TFoo, TBar>
    where TFoo : IFoo
    where TBar : IBar
{
}


public class Foo<TFoo> : AFoo<TFoo, IBar>
    where TFoo : IFoo
{
}

public class Bar<TBar> : ABar<IFoo, TBar>
    where TBar : IBar
{
}

public class Foo : AFoo<IFoo, IBar>
{
}

public class Bar : ABar<IFoo, IBar>
{
}

用法：

var test = new Foo<IFoo<IFoo<IFoo, IBar<IFoo, IBar>>, IBar>, IBar>();

我仍然不明白你要在这里完成什么，更好的解释是应该有更好的解决方案。

该类型必须是可转换的，以便将其用作泛型类中的参数

1 个答案: