Difference Between yield return and return in C# with Examples?

Saurav Kumar
16h
1.5k
0
0

Article

Introduction

When working with collections and data in C#, developers often come across two important keywords: return and yield return. At first glance, both seem to do the same job — sending data back from a method. However, their behavior is completely different, especially when dealing with large datasets, memory optimization, and performance.

Understanding the difference between yield return and return in C# is very important for writing efficient and scalable applications. In this article, we will explain both concepts in simple words, with practical examples and real-world use cases.

What is return in C#?

The return keyword in C# is used to exit a method and send a value back to the caller. Once the return statement is executed, the method stops immediately, and no further code runs inside that method.

In simple terms, return gives the complete result at once.

Example of return

public List<int> GetNumbers()
{
    List<int> numbers = new List<int>();

    for (int i = 1; i <= 5; i++)
    {
        numbers.Add(i);
    }

    return numbers;
}

In this example:

All numbers are created and stored in a list
The full list is returned at once
Memory is used to store all values before returning

What is yield return in C#?

The yield return keyword is used to return elements one at a time instead of returning the entire collection at once.

It is mainly used with IEnumerable or IEnumerator.

In simple words, yield return generates values one by one, only when needed.

Example of yield return

public IEnumerable<int> GetNumbers()
{
    for (int i = 1; i <= 5; i++)
    {
        yield return i;
    }
}

In this example:

Values are not stored in a list
Each value is returned one at a time
Memory usage is lower

Key Difference Between yield return and return

Feature	return	yield return
Execution	Ends method immediately	Pauses and resumes method
Data Return	Returns complete collection	Returns one item at a time
Memory Usage	Higher (stores all data)	Lower (lazy loading)
Performance	Slower for large data	Better for large datasets
Use Case	Small datasets	Large or streaming data

How yield return Works Internally

When you use yield return, C# creates a state machine behind the scenes. This means:

The method does not run completely at once
It runs step-by-step
It remembers its position between calls

This behavior is called lazy execution.

Example: Comparing Both Approaches

Using return

public List<int> GetEvenNumbers()
{
    List<int> numbers = new List<int>();

    for (int i = 1; i <= 10; i++)
    {
        if (i % 2 == 0)
        {
            numbers.Add(i);
        }
    }

    return numbers;
}

Using yield return

public IEnumerable<int> GetEvenNumbers()
{
    for (int i = 1; i <= 10; i++)
    {
        if (i % 2 == 0)
        {
            yield return i;
        }
    }
}

Explanation

In the return version:

All even numbers are calculated first
Stored in memory
Then returned together

In the yield return version:

Each even number is generated only when requested
No list is created
More efficient for large data

When Should You Use return?

Use return when:

You need all data at once
Data size is small
You need fast access to the entire collection
You are performing operations like sorting or indexing

When Should You Use yield return?

Use yield return when:

You are working with large datasets
You want to reduce memory usage
You need lazy loading
You are streaming data

Real-World Example

Imagine reading a large file:

Using return:

Reads entire file into memory
High memory usage

Using yield return:

Reads line by line
Much more efficient

public IEnumerable<string> ReadLines(string path)
{
    using (var reader = new StreamReader(path))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

Advantages of yield return

Better memory efficiency
Supports lazy execution
Cleaner and simpler code for iteration
Useful for large or infinite data sequences

Limitations of yield return

Cannot use ref or out parameters
Cannot use inside async methods (directly with yield return)
Slightly complex debugging

Common Mistakes

Using yield return when full data is needed
Forgetting that execution is deferred
Not understanding multiple enumeration behavior

Summary

The main difference between yield return and return in C# is how data is returned from a method. The return keyword returns the complete result at once, while yield return returns data one item at a time using lazy execution. For small datasets, return works well, but for large or streaming data, yield return is more efficient and memory-friendly. Understanding this difference helps you write better, optimized, and scalable C# applications.