nested-generics

Note: purely out of curiosity and not for any actual use case. I'm wondering if there is a way to declare the Class Class object with valid type parameters: Class cc1 = Class.class; //raw type Class<Class> cc2 = Class.class; //now parameter is raw type Class<Class<?>> cc3 = Class.class; //compile error: inconvertible types If Class and Class<?> are interchangeable, why are Class<Class> and Class<Class<?>> not? EDIT: the question can be generalized to an issue of nested raw type parameters. For example: ArrayList<ArrayList<?>> lst = new ArrayList<ArrayList>(); //same compile error EDIT2: I

I have the following Classes / Interfaces: // Model public class A : IA { } // ModelLogic public class B : IB<A> { } // Model Interface public interface IA { } // ModelLogic Interface public interface IB<T> where T : IA { } I try to create a new instance using the following code: IB<IA> foo = new B(); I am getting the following error: Cannot implicitly convert type 'B' to 'IB<IA>'. An explicit conversion exists (are you missing a cast?) Can someone please explain why this is not possible? OK, let's replace A with Fish , IA with IAnimal , B with Aquarium , and IB<T> with IContainer<T> . And we

UPDATE: As of C# 7.3, this should no longer be an issue. From the release notes: When a method group contains some generic methods whose type arguments do not satisfy their constraints, these members are removed from the candidate set. Pre C# 7.3: So I read Eric Lippert's 'Constraints are not part of the signature' , and now I understand that the spec specifies that type constraints are checked AFTER overload resolution, but I'm still not clear on why this MUST be the case. Below is Eric's example: static void Foo<T>(T t) where T : Reptile { } static void Foo(Animal animal) { } static void

Given the following classes... public abstract class FooBase<TBar> where TBar : BarBase{} public abstract class BarBase{} public class Bar1 : BarBase{} public class Foo1 : FooBase<Bar1> {} ...and the following method... public TBar DoSomething<TFoo, TBar>(TFoo theFoo) where TFoo : FooBase<TBar> where TBar : BarBase { return default(TBar); } Why can't the following line of code imply the return type? Bar1 myBar = DoSomething(new Foo1()); Instead I have to specify the generic types like this... Bar1 myBar = DoSomething<Foo1, Bar1>(new Foo1()); Method type inference ignores generic constraints on

In the following example: public static void main(String[] args) { List<String> b = new ArrayList<String>(); first(b); second(b); List<List<String>> a = new ArrayList<List<String>>(); third(a); fourth(a); // doesnt work } private static <T> void first(List<T> a){ System.out.println("List of T"); } private static void second(List<?> a){ System.out.println("List of anything "); } private static <T> void third(List<List<T>> a){ System.out.println("List of a List of T "); } private static void fourth(List<List<?>> a){ System.out.println("List of a List of anything "); } Why does the call to second