C# does not support this. Hejlsberg has described the reasons for not implementing the feature in an interview with Bruce Eckel: And it’s not clear that the added complexity is worth the small yield that you get. If something you want to do is not directly supported in the constraint system, you can do it … Read more
extends The wildcard declaration of List<? extends Number> foo3 means that any of these are legal assignments: List<? extends Number> foo3 = new ArrayList<Number>(); // Number “extends” Number (in this context) List<? extends Number> foo3 = new ArrayList<Integer>(); // Integer extends Number List<? extends Number> foo3 = new ArrayList<Double>(); // Double extends Number Reading – … Read more
The issue with List<String> list = new LinkedList(); is that on the left hand side, you are using the generic type List<String> where on the right side you are using the raw type LinkedList. Raw types in Java effectively only exist for compatibility with pre-generics code and should never be used in new code unless … Read more
As others mentioned, it’s only possible via reflection in certain circumstances. If you really need the type, this is the usual (type-safe) workaround pattern: public class GenericClass<T> { private final Class<T> type; public GenericClass(Class<T> type) { this.type = type; } public Class<T> getMyType() { return this.type; } }
Why don’t protocols conform to themselves? Allowing protocols to conform to themselves in the general case is unsound. The problem lies with static protocol requirements. These include: static methods and properties Initialisers Associated types (although these currently prevent the use of a protocol as an actual type) We can access these requirements on a generic … Read more
Type erasure applies to the use of generics. There’s definitely metadata in the class file to say whether or not a method/type is generic, and what the constraints are etc. But when generics are used, they’re converted into compile-time checks and execution-time casts. So this code: List<String> list = new ArrayList<String>(); list.add(“Hi”); String x = … Read more
You need to use reflection to get the method to start with, then “construct” it by supplying type arguments with MakeGenericMethod: MethodInfo method = typeof(Sample).GetMethod(nameof(Sample.GenericMethod)); MethodInfo generic = method.MakeGenericMethod(myType); generic.Invoke(this, null); For a static method, pass null as the first argument to Invoke. That’s nothing to do with generic methods – it’s just normal reflection. … Read more
tl;dr: “PECS” is from the collection’s point of view. If you are only pulling items from a generic collection, it is a producer and you should use extends; if you are only stuffing items in, it is a consumer and you should use super. If you do both with the same collection, you shouldn’t use … Read more
No, a List<Dog> is not a List<Animal>. Consider what you can do with a List<Animal> – you can add any animal to it… including a cat. Now, can you logically add a cat to a litter of puppies? Absolutely not. // Illegal code – because otherwise life would be Bad List<Dog> dogs = new ArrayList<Dog>(); … Read more
What is a raw type? The Java Language Specification defines a raw type as follows: JLS 4.8 Raw Types A raw type is defined to be one of: The reference type that is formed by taking the name of a generic type declaration without an accompanying type argument list. An array type whose element type … Read more