Covariance with out keyword in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of covariance with interface using out keyword

What is the output of this C# code using covariance with the out keyword in interfaces?

C Sharp (C#)

interface IProducer<out T> { T Produce(); }
class Animal { public override string ToString() => "Animal"; }
class Dog : Animal { public override string ToString() => "Dog"; }
class DogProducer : IProducer<Dog> {
    public Dog Produce() => new Dog();
}

class Program {
    static void Main() {
        IProducer<Dog> dogProducer = new DogProducer();
        IProducer<Animal> animalProducer = dogProducer; // Covariance allows this
        Animal animal = animalProducer.Produce();
        System.Console.WriteLine(animal);
    }
}

A Runtime exception

B Animal

C Compilation error due to covariance

D Dog

💡 Hint

Remember that covariance with out allows assignment from more derived to less derived types.

The interface IProducer<out T> is covariant in T. This means you can assign IProducer<Dog> to IProducer<Animal>. The Produce() method returns a Dog instance, which is an Animal. So the output is Dog.

❓ Predict Output

intermediate

Covariance with delegates and out keyword

What will this C# program print when using covariance with delegates and the out keyword?

C Sharp (C#)

delegate T Factory<out T>();
class Fruit { public override string ToString() => "Fruit"; }
class Apple : Fruit { public override string ToString() => "Apple"; }

class Program {
    static Apple CreateApple() => new Apple();
    static void Main() {
        Factory<Apple> appleFactory = CreateApple;
        Factory<Fruit> fruitFactory = appleFactory; // Covariance
        System.Console.WriteLine(fruitFactory());
    }
}

A Apple

B Fruit

C Compilation error due to delegate variance

D NullReferenceException at runtime

💡 Hint

Delegates with out type parameters support covariance.

The delegate Factory<out T> is covariant in T. Assigning Factory<Apple> to Factory<Fruit> is allowed. The method returns an Apple, so the output is Apple.

🔧 Debug

advanced

Why does this covariance assignment fail?

Consider this code snippet. Why does the assignment cause a compilation error despite using out keyword?

C Sharp (C#)

interface IContainer<out T> { T GetItem(); void AddItem(T item); }
class Container<T> : IContainer<T> {
    private T item;
    public T GetItem() => item;
    public void AddItem(T item) { this.item = item; }
}

class Program {
    static void Main() {
        IContainer<string> stringContainer = new Container<string>();
        IContainer<object> objectContainer = stringContainer; // Error here
    }
}

A Because <code>IContainer&lt;out T&gt;</code> cannot have input parameters like <code>AddItem(T item)</code>.

B Because <code>string</code> cannot be assigned to <code>object</code>.

C Because covariance only works with classes, not interfaces.

D Because <code>Container&lt;T&gt;</code> does not implement <code>IContainer&lt;T&gt;</code> correctly.

💡 Hint

Check the variance rules for out type parameters and method input parameters.

Interfaces marked with out for a type parameter can only use that type as a return type (output). They cannot use it as a method input parameter. The method AddItem(T item) uses T as input, which is not allowed for covariance. Hence, the compiler error.

📝 Syntax

advanced

Identify the syntax error with covariance and out keyword

Which option contains the syntax error when declaring a covariant interface with the out keyword?

C Sharp (C#)

interface IReadOnlyList<out T> {
    T Get(int index);
    void Add(T item);
}

A The method <code>Get(int index)</code> cannot return <code>T</code> in a covariant interface.

B The interface cannot have a method <code>Add(T item)</code> because <code>T</code> is covariant (out).

C The <code>out</code> keyword must be placed after the interface name, not before <code>T</code>.

D The interface must be declared as <code>interface IReadOnlyList&lt;in T&gt;</code> for covariance.

💡 Hint

Covariant type parameters can only be used as return types, not input parameters.

The out keyword means the type parameter is covariant and can only be used as output (return types). The method Add(T item) uses T as input, which is not allowed and causes a syntax error.

🚀 Application

expert

Using covariance with LINQ and out keyword

Given the following code, what is the output when using covariance with out keyword and LINQ?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Linq;

interface ISource<out T> {
    IEnumerable<T> GetItems();
}

class NumberSource : ISource<int> {
    public IEnumerable<int> GetItems() => new List<int> {1, 2, 3};
}

class Program {
    static void Main() {
        ISource<int> intSource = new NumberSource();
        ISource<object> objSource = intSource; // Covariance
        foreach (var item in objSource.GetItems().Select(x => x.ToString())) {
            Console.Write(item + " ");
        }
    }
}

A Compilation error due to covariance with IEnumerable

B 1 2 3 4

C 1 2 3

D Runtime exception due to invalid cast

💡 Hint

Remember that IEnumerable<out T> supports covariance and LINQ works on IEnumerable.

The interface ISource<out T> is covariant, so ISource<int> can be assigned to ISource<object>. The GetItems() returns IEnumerable<int>, which is covariant to IEnumerable<object>. The LINQ Select converts each int to string, printing "1 2 3 ".