inference happens when the compiler can infer the type from the context
public void DoSomething<T1,T2>(T1 key,T2 value)
{
...
}
when called as
string a;
int b;
DoSomething(a,b);
this will work because a & b's types are defined in the context of the call so T1 has to be a string and T2 has to be an int because that is what a and b are
in your example
class A<T>
{
}
class B<T1, T2>
where T1 : A<T2>
{
}
when called as
var b = new B();
what is T1? what is T2? the compiler has no idea
and even if you did
var b = new B<A<string>>();
your where clause says that A has to implement A but what is T unless you specify it the compiler has no clue? maybe T2 is an int and in which A<string>
clearly fails the where clause and a error needs to be thrown
if you defined your B class as
class B<T1, T2>:A<T2>
{
}
then the compiler will know that whatever T2 is, is passed to A
Edit:
if all you care about is that the T1 is an example of A and you don't care what the type is use an interface
interface IA{
}
class A<T>:IA
{
}
class B<T>:
where T:IA
{
}