Contravariance with in keyword in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Contravariance with in keyword

Define interface with 'in' keyword

↓

Create base and derived classes

↓

Assign derived type to base type variable

↓

Call method accepting base type

↓

Contravariance allows safe assignment

Contravariance lets you use a less derived type where a more derived type is expected, enabled by the 'in' keyword in generic interfaces.

Execution Sample

C Sharp (C#)

interface IContravariant<in T> { void Set(T item); }
class Animal {}
class Dog : Animal {}
class ContravariantSetter<T> : IContravariant<T> { public void Set(T item) { } }
IContravariant<Animal> animalSetter = new ContravariantSetter<Dog>();
animalSetter.Set(new Animal());

Shows how contravariance allows assigning IContravariant<Dog> to IContravariant<Animal> using 'in' keyword.

Execution Table

Step	Action	Type involved	Assignment Valid?	Reason
1	Define interface IContravariant<in T>	T is contravariant	N/A	Allows T to be used as input parameter type
2	Create classes Animal and Dog : Animal	Dog inherits Animal	N/A	Dog is subtype of Animal
3	Create instance of ContravariantSetter<Dog>	IContravariant<Dog>	N/A	Concrete implementation for Dog
4	Assign to IContravariant<Animal> variable	IContravariant<Dog> to IContravariant<Animal>	No	'in' keyword allows contravariance but assignment is from less derived to more derived, which is invalid
5	Call Set(new Animal()) on variable	Set(Animal)	Runtime error	Dog setter expects Dog, Animal passed (contravariance only safe for input types, but method expects Dog)
6	Call Set(new Dog()) on variable	Set(Dog)	Success	Dog instance matches expected type

💡 Execution stops after method calls; contravariance allows assignment from more derived to less derived generic types, but method parameter types must be compatible at runtime.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5
animalSetter	null	ContravariantSetter<Dog> instance	Assignment invalid, no assignment occurs	Method called with Animal or Dog instance

Key Moments - 2 Insights

Why can I assign IContravariant<Dog> to IContravariant<Animal> but not vice versa?

Because the 'in' keyword makes T contravariant, allowing assignment from more derived to less derived types (Animal to Dog), but not the other way around.

Why does calling Set(new Animal()) cause a runtime problem?

Because the actual implementation expects Dog, but Animal is passed, which is not safe. Contravariance applies to assignment compatibility, but method calls must respect actual parameter types.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what does the 'in' keyword allow?

A Assign unrelated types

B Assign IContravariant<Dog> to IContravariant<Animal>

C Assign IContravariant<Animal> to IContravariant<Dog>

D No assignment allowed

💡 Hint

Check the 'Assignment Valid?' column at step 4 in execution_table

At which step does calling Set with an Animal instance cause a problem?

A Step 5

B Step 3

C Step 4

D Step 6

💡 Hint

Look at the 'Reason' column for runtime errors in execution_table

If we remove the 'in' keyword, what happens to the assignment in step 4?

A It causes runtime error

B It becomes invalid

C It remains valid

D It compiles but fails at runtime

💡 Hint

Recall that 'in' enables contravariance; without it assignment is invalid (see step 4)

Concept Snapshot

Contravariance with 'in' keyword:
- Use 'in' on generic type parameter to allow contravariance
- Allows assignment from more derived to less derived generic types
- Safe only for input (method parameter) types
- Enables flexible and type-safe assignments
- Method calls must respect actual parameter types

Full Transcript

This visual execution shows how contravariance works in C# using the 'in' keyword on generic interfaces. First, an interface IContravariant with 'in T' is defined, allowing T to be used only as input. Then, classes Animal and Dog (which inherits Animal) are created. An instance of ContravariantSetter<Dog> is assigned to a variable of type IContravariant<Animal> thanks to contravariance. Calling Set with a Dog instance works fine, but calling Set with an Animal instance causes a runtime problem because the implementation expects Dog. The key is that contravariance allows assignment compatibility but method calls must respect actual parameter types. This helps write flexible and safe code when dealing with inheritance and generics.