StreamReader.ReadToEnd()未返回完整内容，XML解析报错求助

It sounds like you’re dealing with two related but distinct headaches here: incomplete XML responses breaking your parsing logic, and non-XML error content (like 500 internal server errors) crashing your code when you try to load it as XML. Let’s break down how to fix both issues robustly:

1. Catch Non-Success HTTP Status Codes First #

The HttpWebRequest.GetResponse() method throws a WebException whenever the server returns a non-2xx status code (like 500). If you don’t handle this, your code will never get a chance to read the error content—and it’ll crash before you can gracefully recover.

Here’s how to extract and handle error responses:

HttpWebResponse response = null;
try
{
    response = (HttpWebResponse)httpWebRequest.GetResponse();
}
catch (WebException ex)
{
    // Extract the error response from the exception
    if (ex.Response is HttpWebResponse errorResponse)
    {
        using (var reader = new StreamReader(errorResponse.GetResponseStream(), Encoding.UTF8))
        {
            string errorContent = reader.ReadToEnd();
            // Log the error details for debugging, then exit early
            Console.WriteLine($"API Error ({errorResponse.StatusCode}): {errorContent}");
            return null; // Or return a fallback value based on your needs
        }
    }
    throw; // Re-throw only if it's an unexpected web exception
}

2. Guarantee Full Response Reading #

Sometimes StreamReader.ReadToEnd() fails to capture the entire response due to network glitches or unflushed streams. A more reliable approach is to read the stream into a byte array first, then convert it to a string—this ensures you get every byte sent by the server:

string responseContent;
using (var stream = response.GetResponseStream())
{
    using (var memoryStream = new MemoryStream())
    {
        stream.CopyTo(memoryStream);
        responseContent = Encoding.UTF8.GetString(memoryStream.ToArray());
    }
}

3. Parse XML Safely with Error Handling #

Even after getting the full content, you need to handle cases where the data isn’t valid XML (either incomplete or an error response). Wrap your XmlDocument.LoadXml() call in a dedicated try-catch block, and log the problematic content to debug production issues:

XmlDocument xmlDoc = new XmlDocument();
try
{
    xmlDoc.LoadXml(responseContent);
    // Process your valid XML here
}
catch (XmlException ex)
{
    // Log the invalid content and error details for debugging
    Console.WriteLine($"Invalid XML content: {responseContent}");
    Console.WriteLine($"XML Parsing Error: {ex.Message}");
    // Return a fallback value or handle the error appropriately
    return null;
}

Complete Robust Code Example #

Putting all these steps together, here’s a polished version of your code that handles both edge cases:

XmlDocument GetValidatedApiResponse(HttpWebRequest httpWebRequest)
{
    HttpWebResponse response = null;
    try
    {
        // Handle non-success status codes
        response = (HttpWebResponse)httpWebRequest.GetResponse();
        
        // Read full response content reliably
        string responseContent;
        using (var stream = response.GetResponseStream())
        {
            using (var memoryStream = new MemoryStream())
            {
                stream.CopyTo(memoryStream);
                responseContent = Encoding.UTF8.GetString(memoryStream.ToArray());
            }
        }
        
        // Parse XML with error handling
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.LoadXml(responseContent);
        return xmlDoc;
    }
    catch (WebException ex)
    {
        if (ex.Response is HttpWebResponse errorResponse)
        {
            using (var reader = new StreamReader(errorResponse.GetResponseStream(), Encoding.UTF8))
            {
                string errorContent = reader.ReadToEnd();
                Console.WriteLine($"API Error ({errorResponse.StatusCode}): {errorContent}");
            }
        }
        return null; // Or handle gracefully instead of returning null
    }
    catch (XmlException ex)
    {
        Console.WriteLine($"XML Parsing Failed: {ex.Message}");
        // Optionally log the problematic content here if you stored it earlier
        return null;
    }
    finally
    {
        response?.Close();
    }
}

Key Takeaways #

• Don’t assume valid XML: Always check HTTP status codes before parsing—errors will rarely return valid XML.
• Read streams reliably: Using a byte array ensures you capture every bit of the response, avoiding incomplete content issues.
• Log everything: When errors occur, log the raw content so you can debug exactly what the API sent back in production.

内容的提问来源于stack exchange，提问作者kidra.pazzo