Stream vs async stream behavior in C Sharp (C#) - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of synchronous stream iteration

What is the output of this C# code that uses a synchronous stream?

C Sharp (C#)

using System;
using System.Collections.Generic;

class Program {
    static IEnumerable<int> GetNumbers() {
        for (int i = 1; i <= 3; i++) {
            yield return i;
        }
    }

    static void Main() {
        foreach (var num in GetNumbers()) {
            Console.Write(num + " ");
        }
    }
}

A 1 2 3

B 1 2

C 3 2 1

D Compilation error

💡 Hint

Remember that yield return produces values one by one in order.

The synchronous iterator yields numbers 1, 2, and 3 in order, so the output is '1 2 3 '.

❓ Predict Output

intermediate

Output of asynchronous stream iteration

What is the output of this C# code that uses an asynchronous stream?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program {
    static async IAsyncEnumerable<int> GetNumbersAsync() {
        for (int i = 1; i <= 3; i++) {
            await Task.Delay(10);
            yield return i;
        }
    }

    static async Task Main() {
        await foreach (var num in GetNumbersAsync()) {
            Console.Write(num + " ");
        }
    }
}

A No output

B 3 2 1

C Compilation error due to missing await

D 1 2 3

💡 Hint

Async streams yield values asynchronously but preserve order.

The async iterator yields numbers 1, 2, and 3 in order with delays, so output is '1 2 3 '.

❓ Predict Output

advanced

Behavior difference between stream and async stream

What will be the output of this program that mixes synchronous and asynchronous streams?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program {
    static IEnumerable<int> GetSyncNumbers() {
        yield return 1;
        yield return 2;
    }

    static async IAsyncEnumerable<int> GetAsyncNumbers() {
        yield return 3;
        await Task.Delay(10);
        yield return 4;
    }

    static async Task Main() {
        foreach (var n in GetSyncNumbers()) {
            Console.Write(n + " ");
        }
        await foreach (var n in GetAsyncNumbers()) {
            Console.Write(n + " ");
        }
    }
}

A 1 2 3 4

B 3 4 1 2

C 1 2

D Compilation error due to mixing sync and async

💡 Hint

Synchronous streams run first, then asynchronous streams run with await.

The synchronous stream yields 1 and 2 immediately, then the async stream yields 3 and 4 asynchronously, so output is '1 2 3 4 '.

❓ Predict Output

advanced

Error when using foreach on async stream without await

What error does this code produce when trying to iterate an async stream with a normal foreach?

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program {
    static async IAsyncEnumerable<int> GetAsyncNumbers() {
        yield return 1;
        await Task.Delay(10);
        yield return 2;
    }

    static void Main() {
        foreach (var n in GetAsyncNumbers()) {
            Console.Write(n + " ");
        }
    }
}

A No output, program hangs

B Runtime error: InvalidOperationException

C Compilation error: cannot convert IAsyncEnumerable<int> to IEnumerable<int>

D Output: 1 2

💡 Hint

Async streams require await foreach, not normal foreach.

The compiler cannot use normal foreach on IAsyncEnumerable, so it raises a compilation error.

🧠 Conceptual

expert

Why use async streams over synchronous streams?

Which of the following best explains why async streams are preferred over synchronous streams when dealing with data that arrives over time?

A Async streams always run faster than synchronous streams because they use multiple threads automatically.

B Async streams allow processing data as it arrives without blocking the thread, improving responsiveness.

C Synchronous streams cannot yield more than 10 items, async streams have no limit.

D Async streams do not require the use of await, making code simpler.

💡 Hint

Think about waiting for data and thread blocking.

Async streams let you wait for data asynchronously, so the program stays responsive and doesn't block while waiting.