Saw this signature today:
public interface ISomeInterface<in T>
What impact does the in
parameter have?
Generic Methods A type parameter, also known as a type variable, is an identifier that specifies a generic type name. The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments.
Declaring Variant Generic Interfaces You can declare variant generic interfaces by using the in and out keywords for generic type parameters. ref , in , and out parameters in C# cannot be variant. Value types also do not support variance. You can declare a generic type parameter covariant by using the out keyword.
A generic type is declared by specifying a type parameter in an angle brackets after a type name, e.g. TypeName<T> where T is a type parameter.
It is a Generic Type Parameter. A generic type parameter allows you to specify an arbitrary type T to a method at compile-time, without specifying a concrete type in the method or class declaration.
You could read about generic variance and contravariance introduced in .NET 4.0. The impact that the in
keyword has on the interface is that it declares it as contravariant meaning that T
can only be used as input method type. You cannot use it as return type on the methods of this interface. The benefit of this is that you will be able to do things like this (as shown in the aforementioned article):
interface IProcessor<in T> { void Process(IEnumerable<T> ts); } List<Giraffe> giraffes = new List<Giraffe> { new Giraffe() }; List<Whale> whales = new List<Whale> { new Whale() }; IProcessor<IAnimal> animalProc = new Processor<IAnimal>(); IProcessor<Giraffe> giraffeProcessor = animalProc; IProcessor<Whale> whaleProcessor = animalProc; giraffeProcessor.Process(giraffes); whaleProcessor.Process(whales);
That signifies generic contravariance. The opposite is covariance (keyword out
).
What this means is that when an interface is contravariant (in
), then the interface can be implicitly converted to a generic type when the type parameter inherits T.
Conversely for covariance out
, the interface can be implicitly converted to a generic type where the type parameter is a 'lesser' type in the type hierarchy.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With