C# HttpWebRequest正确的异常处理

因此，我在System.Net程序集中使用了

HttpWebRequest

API，但由于C#没有检查过的异常，我不确定应该将try-catch块放在哪里，以正确处理由网络错误等常见问题导致的不可避免的异常。您知道，在Java中，我们将这些简单的旧checked

IOExceptions

。

这就是我目前所拥有的。我的try-catch块是否正确设置以处理网络错误？我是否包装了正确的方法调用？看着文档，我认为他们是对的，但我需要另一双眼睛。

---

首先，除非出于某种原因需要使用

HttpWebRequest

，否则最好使用

WebClient.UploadString

，或者使用WebClient的任何其他

UploadXXX

重载来上载名称/值对、文件、二进制数据等。这对您来说会容易得多，并且更容易进行故障排除和调试。另外，另一个问题是，您将JSON解析期间或onResult处理程序错误期间的异常视为网络错误

下面是您可能想尝试使用WebClient的三个示例：同步版本、“旧式”异步版本和使用

async

/

wait

的“新式”异步版本。这三个版本都试图修复我上面提到的异常处理问题。如果您不需要异步支持，那么第一个版本将是最简单的

static void PostSync (string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded"; // or "application/json" or ...
        try
        {
            string htmlResult = wc.UploadString(url, parametersData);  // or UploadValues, UploadFile, ... 
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(htmlResult);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);

        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}

static void PostAsync(string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.UploadStringCompleted += (Object sender, UploadStringCompletedEventArgs e) =>
        {
            if (e.Error != null)
                onResult(StatusCode.NetworkError);
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(e.Result);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);
        };
        try
        {
            wc.UploadStringAsync(new Uri(url, UriKind.Absolute), parametersData);
        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}

static async void PostTaskAsync(string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded"; // or "application/json" or ...
        try
        {
            string htmlResult = await wc.UploadStringTaskAsync(url, parametersData);  // or UploadValues, UploadFile, ... 
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(htmlResult);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);

        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}

---

在我看来是正确的，至少在异常处理方面是这样。不过，作为旁注，在键入单词

Dispose

时，应始终使用

using

。因此，您应该在

responseStream

和

reader

上使用

执行
操作，而不是手动调用
Dispose（）
。我知道
using
语句，但现在决定跳过它，因为我已经有足够的开始和结束括号了。使用
Dispose（）
而不是
using
语句是否存在某种风险？
using
会打开它自己的范围，并且只有在此范围内相应的变量才有效。如果手动调用
Dispose
，则没有任何东西可以阻止您以后使用该变量。简而言之，正确使用，初始化变量，然后对其调用
Dispose
，然后不再使用它，就像使用
一样<但是，代码>使用
，人为错误的可能性较小。明白了。谢谢你的提示。
static void PostSync (string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded"; // or "application/json" or ...
        try
        {
            string htmlResult = wc.UploadString(url, parametersData);  // or UploadValues, UploadFile, ... 
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(htmlResult);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);

        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}

static void PostAsync(string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.UploadStringCompleted += (Object sender, UploadStringCompletedEventArgs e) =>
        {
            if (e.Error != null)
                onResult(StatusCode.NetworkError);
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(e.Result);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);
        };
        try
        {
            wc.UploadStringAsync(new Uri(url, UriKind.Absolute), parametersData);
        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}

static async void PostTaskAsync(string url, string parametersData)
{
    using (WebClient wc = new WebClient())
    {
        wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded"; // or "application/json" or ...
        try
        {
            string htmlResult = await wc.UploadStringTaskAsync(url, parametersData);  // or UploadValues, UploadFile, ... 
            JObject jsonObject = null;
            try
            {
                jsonObject = JObject.Parse(htmlResult);
            }
            catch (JsonException ex)
            {
                onResult(StatusCode.JsonError);
            }
            onResult(StatusCode.Ok, jsonObject);

        }
        catch (System.Net.WebException ex)
        {
            onResult(StatusCode.NetworkError);
        }
    }
}