Difference Between Span and Memory in C# with Examples?

Introduction

In modern C# development, especially when building high-performance applications like ASP.NET Core Web APIs, file processors, or real-time systems, memory management plays a very important role. If your application frequently allocates and releases memory, it can slow down performance and increase pressure on the garbage collector.

To solve these problems, C# introduced Span and Memory. These types help developers work with data efficiently without creating unnecessary copies. They allow you to handle slices of arrays, strings, or buffers in a faster and cleaner way.

In this article, you will clearly understand the difference between Span and Memory in C#, how they work internally, and when to use each one with simple, real-world examples.

What is Span in C#?

Understanding Span in Simple Words

Span is a special type in C# that represents a continuous block of memory. Instead of copying data, it creates a view over existing data like arrays, strings, or stack memory.

This means you can work with parts of data without creating new objects.

Key Features of Span

It does not allocate new memory
It directly works on existing data
It is extremely fast and efficient
It is a ref struct, which means it can only live on the stack

Example of Span

int[] numbers = { 1, 2, 3, 4, 5 };

Span<int> span = numbers;

span[0] = 100;

Console.WriteLine(numbers[0]);

In this example, Span is directly modifying the original array. No new memory is created, which improves performance.

Why Span is Fast

Span works on stack memory and avoids heap allocations. Because of this, it reduces garbage collection and improves execution speed in performance-critical applications.

What is Memory in C#?

Understanding Memory in Simple Words

Memory is similar to Span, but it is more flexible. It can live on the heap and can be used in asynchronous programming.

If your data needs to survive beyond a single method or needs to be used with async/await, Memory is the right choice.

Key Features of Memory

Can be stored on the heap
Can be used in async methods
Can be passed across different layers
Slightly slower than Span but more flexible

Example of Memory

int[] numbers = { 1, 2, 3, 4, 5 };

Memory<int> memory = numbers;

Span<int> span = memory.Span;
span[1] = 200;

Console.WriteLine(numbers[1]);

Here, Memory is used to hold the data, and Span is used to access it efficiently.

Why Do We Need Span and Memory in C#?

Problem with Traditional Approach

Earlier, developers used methods like Substring or Array.Copy to work with parts of data.

string text = "HelloWorld";
string sub = text.Substring(0, 5);

This creates a new string in memory, which increases memory usage.

How Span and Memory Solve This

With Span:

string text = "HelloWorld";
ReadOnlySpan<char> span = text.AsSpan(0, 5);

Now, no new memory is created. It simply creates a view over existing data.

This makes your application faster and more memory-efficient, which is very important in scalable .NET applications.

Key Differences Between Span and Memory in C#

Feature	Span	Memory
Type	ref struct	struct
Memory Location	Stack	Heap
Async Support	Not supported	Supported
Performance	Very fast	Slightly slower
Lifetime	Short-lived	Long-lived
Use Case	Synchronous operations	Async and persistent data

This table is very important for interviews and real-world understanding of C# memory management.

Understanding Stack vs Heap Behavior

Span and Stack Memory

Span lives on the stack, which means:

It is automatically removed after method execution
It cannot be returned from methods in unsafe ways
It cannot be stored in class fields

Example of invalid usage:

Span<int> GetSpan()
{
    int[] data = { 1, 2, 3 };
    return data;
}

Memory and Heap Memory

Memory lives on the heap, which allows:

Returning from methods
Storing in class properties
Using in async workflows

Example:

Memory<int> GetMemory()
{
    int[] data = { 1, 2, 3 };
    return data;
}

Working with Slices (Without Copying Data)

Using Span for Slicing

int[] numbers = { 10, 20, 30, 40, 50 };

Span<int> slice = numbers.AsSpan(1, 3);

foreach (var item in slice)
{
    Console.WriteLine(item);
}

This prints part of the array without creating a new array.

Why Slicing is Important

Slicing helps in scenarios like:

Processing large files
Working with buffers
Network data handling

Real-World Example: String Processing in C#

Without Span (Inefficient)

string text = "HelloWorld";
string result = text.Substring(0, 5);

This creates a new string in memory.

With Span (Efficient)

string text = "HelloWorld";
ReadOnlySpan<char> span = text.AsSpan(0, 5);

Console.WriteLine(span.ToString());

This avoids memory allocation and improves performance.

When to Use Span

Use Span in These Cases

When working with synchronous code
When performance is critical
When data is short-lived
When you want zero memory allocation

Span is ideal for high-performance computing and low-level operations in C#.

When to Use Memory

Use Memory in These Cases

When using async/await
When data needs to persist
When passing data between methods or layers
When storing data in class properties

Memory is ideal for scalable and long-running applications.

Common Mistakes Developers Make

Mistake 1: Using Span in Async Methods

Span cannot be used across await calls.

Mistake 2: Storing Span in Class Fields

This is not allowed because Span is stack-only.

Mistake 3: Assuming Span Copies Data

Span only creates a view, it does not copy data.

Performance Considerations in C#

Span is faster because:

No heap allocation
No garbage collection
Direct memory access

Memory is slightly slower but provides flexibility for real-world applications.

Best Practices for Using Span and Memory

Follow These Best Practices

Use Span for performance-critical code
Use ReadOnlySpan for read-only data
Use Memory for async operations
Avoid unnecessary conversions
Measure performance using benchmarks

Summary

Span and Memory in C# are designed to improve performance by reducing memory allocations and avoiding unnecessary data copying. Span works on stack memory and is best suited for fast, short-lived, synchronous operations, while Memory works on heap memory and is ideal for asynchronous and long-lived scenarios. By choosing the right type based on your use case, you can significantly optimize your application's performance, reduce garbage collection overhead, and build efficient, scalable ASP.NET Core and .NET applications.