Introduction

WebResponse.GetResponseStream() returns a Stream, which is just a sequence of bytes. To turn it into text, you wrap it in a StreamReader and read it. The important details are disposal, null handling, and encoding. If any of those are wrong, the code compiles but the resulting string may be broken or the response may leak resources.

The Standard Pattern

For ordinary text or JSON responses, StreamReader is the normal solution.

1using System;
2using System.IO;
3using System.Net;
4
5var request = WebRequest.Create("https://example.com");
6using var response = request.GetResponse();
7using var stream = response.GetResponseStream();
8using var reader = new StreamReader(stream!);
9
10string body = reader.ReadToEnd();
11Console.WriteLine(body);

This works because StreamReader converts bytes from the stream into characters.

Guard Against a Null Stream

GetResponseStream() can return null, so robust code should check for that before creating the reader.

1using System;
2using System.IO;
3using System.Net;
4
5var request = WebRequest.Create("https://example.com");
6using var response = request.GetResponse();
7using var stream = response.GetResponseStream();
8
9if (stream is null)
10{
11    throw new InvalidOperationException("No readable response stream was returned.");
12}
13
14using var reader = new StreamReader(stream);
15string body = reader.ReadToEnd();

That is a small check, but it is the correct defensive pattern.

Encoding Matters

If the text looks corrupted, the usual problem is encoding. StreamReader defaults to UTF-8 unless you specify otherwise.

1using System.Text;
2
3using var reader = new StreamReader(stream, Encoding.UTF8);
4string body = reader.ReadToEnd();

If the server uses a different encoding, match that explicitly. Otherwise the byte-to-text conversion may produce garbage even though the response bytes are correct.

Async Code Should Read Asynchronously

If the surrounding code is asynchronous, use ReadToEndAsync().

1using System;
2using System.IO;
3using System.Net;
4using System.Threading.Tasks;
5
6public static async Task<string> ReadBodyAsync(WebResponse response)
7{
8    using var stream = response.GetResponseStream();
9    if (stream is null)
10    {
11        throw new InvalidOperationException("No response stream.");
12    }
13
14    using var reader = new StreamReader(stream);
15    return await reader.ReadToEndAsync();
16}

That avoids blocking a thread unnecessarily in async workflows.

Prefer HttpClient in Newer Code

If you are writing new .NET code, HttpClient is usually the better API than WebRequest and WebResponse.

1using System;
2using System.Net.Http;
3using System.Threading.Tasks;
4
5public static async Task Main()
6{
7    using var client = new HttpClient();
8    string body = await client.GetStringAsync("https://example.com");
9    Console.WriteLine(body);
10}

That does not change how streams work, but it matters if you can choose the surrounding HTTP API.

Do Not Read Huge Responses Blindly

Reading the entire stream into one string is convenient, but it is not always the right design. For very large responses, consider processing the stream incrementally or deserializing directly from it instead of buffering everything into memory first.

For example, if the response is JSON and your next step is parsing it, reading from the stream directly into a JSON deserializer is often cleaner than creating an intermediate string only to parse it immediately afterward.

That is often cleaner architecturally as well, because it avoids a large temporary string and one extra conversion step.

Common Pitfalls

• Forgetting to dispose the response, stream, or reader.
• Assuming the stream cannot be null.
• Reading text with the wrong encoding.
• Using blocking ReadToEnd() in otherwise asynchronous code.

Summary

• 'GetResponseStream() returns a byte stream, not text.'
• Use StreamReader to read that stream into a string.
• Check for a null stream before reading.
• Specify encoding when needed.
• Prefer HttpClient for new .NET code even though legacy WebResponse streams can still be handled correctly.