.Net c#通用问题

以下是一个例子：

public class B<T> {}
public class D : B<int> {}
public class A<T, S> where T : B<S> {}
public class C : A<D, int> {}

public class Test1
{
    public class test1
    {
        A<D, int> t = new C();
    }
}

公共类B{}
公共类D:B{}
公共类A，其中T:B{}
公共类C:A{}
公共类Test1
{
公共类test1
{
A t=新的C（）；
}
}

我想做的是声明类C，只说：

C:A

。为什么我需要重复int？因为int已经是D的一部分了

test1方法中也是如此。我想写：

at=newc（）

我如何才能做到这一点

更新 这里有更真实的类名：

public class MyModel<T> { }
public class MyTrueModel : MyModel<int> { }

public class MyManager<T,S> where T : MyModel<S> { }
public class MyTrueManager : MyManager<MyTrueModel, int> { }

public class Test1
{
    public class test1
    {
        MyManager<MyTrueModel, int> t = new MyManager<MyTrueModel, int>();
    }
}

公共类MyModel{}
公共类MyTrueModel:MyModel{}
公共类MyManager，其中T:MyModel{}
公共类MyTrueManager:MyManager{}
公共类Test1
{
公共类test1
{
MyManager t=新的MyManager（）；
}
}

---

所有的问题都来自于班级经理。如果我能像这样做：

MyManager where T:MyModel

，那就太好了。

可能我误解了你的问题。但是如果你不需要int，就用D

public class B<T> { }
public class D : B<int> { }
public class A<T> where T : D { }
public class C : A<D> { }
public class Test1 { public class test1 { A<D> t = new C();    } }

公共类B{}
公共类D:B{}
公共类A，其中T:D{}
公共类C:A{}
公共类Test1{public类Test1{A t=new C（）；}}

将A声明为：

public class A<T> where T : B<S>

公共A类，其中T:B

应该可以，但我身上没有编译器，所以我不能确定将不起作用，因为您之前已声明需要两个泛型参数

您可以声明如下内容：

class A2<T> : A<T, int> {}

A2类：A{}

然后（我认为）您可以实现

a2t=newc（），但我假设编译器足够聪明，可以实现A2与C兼容。。。可能不是

这是实验吗？看起来您可能很难弄清楚6个月后（甚至2个月后：）该怎么做。
以下是您的代码：

public class B<T> {}
public class D : B<int> {}
public class A<T, S> where T : B<S> {}
public class C : A<D, int> {}
public class Test1 {
    public class test1 {
        A<D, int> t = new C();
    }
}

公共类B{}
公共类D:B{}
公共类A，其中T:B{}
公共类C:A{}
公共类Test1{
公共类test1{
A t=新的C（）；
}
}

以下是等效代码：

public class B<T> {}
public class D : B<int> {}
public class A<U, V> where U : B<V> {}
public class C : A<D, int> {}
public class Test1 {
    public class test1 {
        A<D, int> t = new C();
    }
}

公共类B{}
公共类D:B{}
公共A类，其中U:B{}
公共类C:A{}
公共类Test1{
公共类test1{
A t=新的C（）；
}
}

关键是
A
中的
U
是一个伪码。当您将
U
替换为
T
（将
V
替换为
S
）并写入
A
时，
T
在
B
中不引用相同的
T
。这就是为什么必须使用
C:A
。如果您只编写
A
，编译器不知道（也不应该这样做；请参阅下面关于自由变量和未绑定变量的评论）您想在
B
中使用
int
作为
T

所有的问题都来自于班级经理。如果我能做一些像
：MyManager
where
T:MyModel
这样的事情，那就太好了

这是不可能的<代码>MyModel

未声明为类型。只有

MyModel

是一个类型。更具体地说，它是一个无界泛型类型。当您指定一个类型参数（例如，

MyModel

）时，它将是一个构造类型

---

冒着让您进一步困惑的风险（在这个公认的困惑问题上），它可能会帮助您阅读。

我认为这不会编译：编译器无法解决S。@Anon.no。如果这是合法的，那么我可以说

A A=new A（）但是现在什么绑定了
S
？…除非我大错特错，
int
不是从
B（S）
继承的。但是编译器怎么知道呢？它甚至不知道
S
是什么。如果满足您的要求，请不要使用
int
。这里：
接口idoonothing{}
，
A类，其中T:idoonothing{}
（什么是
U
？）和
类C:idoonothing，idoonothing
。最后，
A A=新A
。那么，
C
同时实现了
idoonothing
和
idoonothing
，那么对于unbound类型变量
U
，我们使用哪种类型（
short
或
int
）呢？当我们开始讨论冲突接口时，无论您以何种方式分割它，事情都会变得棘手。假设两个接口定义的方法除了返回类型之外是相同的-实现者应该提供什么返回类型？
a2t2=（A2）（（A）new C（））
似乎适用于上面定义的A2，但肯定不是更好：感谢您的详细答案。这有助于我理解。你知道我能做些什么来实现我想做的吗？