检查与HttpClient的互联网连接 [英] checking Internet connection with HttpClient

问题描述

我有困难，了解在波纹管的代码可以如何处理偶发的网络连接丢失。理想情况下，我想暂停的应用程序，一旦连接丢失，并恢复它的时候又到了。是否有关于如何做到这一点的指引？

  HttpClientHandler ClientHandler的=新HttpClientHandler（）; 
 clientHandler.UseDefaultCredentials = TRUE; 
 HttpClient的客户端=新的HttpClient（ClientHandler的）{MaxResponseContentBufferSize = 1000000}; 
 
 HttpResponseMessage响应=等待client.GetAsync（URL，CT）; 
  

解决方案

下面的例子不是一个直接的解决方案，但它是我建，以显示如何返回预罐装的内容，同时下线的请求，然后在连接恢复联机时回返回一个例子。如果你能得到我在做什么在这里，建筑你想应该是相当容易的。

  [事实] 
酒店的公共异步任务Getting_a_response_when_offline（）
 {
变种offlineHandler =新offlineHandler（新HttpClientHandler（），新的URI（HTTP：//橡木：1001 /状态））; 
 offlineHandler.AddOfflineResponse（新的URI（HTTP：//橡木：1001 / ServerNotRunning），
新HttpResponseMessage（HttpStatusCode.NonAuthoritativeInformation）
 {
含量=新的StringContent（下面是信息的旧版本，而我们是离线）
}）。 
 
变种的HttpClient =新的HttpClient（offlineHandler）; 
 
无功重试= TRUE; 
 
，而（重试）
 {
 VAR响应=等待httpClient.GetAsync（新的URI（HTTP：//橡木：1001 / ServerNotRunning））; 
 
如果（response.StatusCode == HttpStatusCode.OK）重试= FALSE; 
 Thread.sleep代码（10000）; 
} 
} 
 
 
公共类OfflineHandler：DelegatingHandler 
 {
私人只读乌里_statusMonitorUri; 
私人只读字典<乌里HttpResponseMessage> _offlineResponses =新词典<乌里HttpResponseMessage>（）; 
私人布尔_isOffline = FALSE; 
私人定时器_timer; 
 
公共OfflineHandler（HttpMessageHandler innerHandler，乌里statusMonitorUri）
 {
 _statusMonitorUri = statusMonitorUri; 
 InnerHandler = innerHandler; 
} 
 
公共无效AddOfflineResponse（URI URI，HttpResponseMessage响应）
 {
 _offlineResponses.Add（URI，响应）; 
} 
 
保护的异步覆盖任务< HttpResponseMessage> SendAsync（HttpRequestMessage请求的CancellationToken的CancellationToken）
 {
如果（_isOffline ==真）返回OfflineResponse（请求）; 
 
试
 {
 VAR响应=等待base.SendAsync（请求的CancellationToken）; 
如果（response.StatusCode == || HttpStatusCode.ServiceUnavailable == response.StatusCode HttpStatusCode.BadGateway）
 {
 MonitorOfflineState（）; 
返回OfflineResponse（请求）; 
} 
返回响应; 
} 
赶上（引发WebException前）
 {
 MonitorOfflineState（）; 
返回OfflineResponse（请求）; 
} 
 
} 
 
私人无效MonitorOfflineState（）
 {
 _isOffline = TRUE; 
 _timer =新的Timer（异步状态=> 
 {
变种要求=新HttpRequestMessage（）{RequestUri = _statusMonitorUri}; 
试
 {
 VAR响应=等待base.SendAsync（的要求，新的CancellationToken（））; 
如果（response.StatusCode == HttpStatusCode.OK）
 {
 _isOffline = FALSE; 
 _timer。的Dispose（）; 
} 
} 
抓
 {
 
} 
}，空，新的时间跨度（0,0,0） ，新的TimeSpan（0,1,0））; 
 
} 
 
私人HttpResponseMessage OfflineResponse（HttpRequestMessage要求）
 {
如果（_offlineResponses.ContainsKey（request.RequestUri））
 $ { b $ b返回_offlineResponses [request.RequestUri] 
} 
返回新HttpResponseMessage（HttpStatusCode.ServiceUnavailable）; 
} 
} 
} 
  

I am having difficulties to understand on how the bellow code could handle occasional internet connection loss. Ideally I would like to pause the app, once the connection is lost, and resume when it is up again. Is there any guideline on how to do it?

HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.UseDefaultCredentials = true;
HttpClient client = new HttpClient(clientHandler) { MaxResponseContentBufferSize = 1000000 };

HttpResponseMessage response = await client.GetAsync(Url, ct);

解决方案

The following example is not a direct solution, but it is an example I built to show how to return "pre-canned" content to requests whilst offline and then return back online when connectivity is restored. If you can get what I'm doing here, building what you want should be fairly easy.

        [Fact]
        public async Task Getting_a_response_when_offline()
        {
            var offlineHandler = new OfflineHandler(new HttpClientHandler(), new Uri("http://oak:1001/status"));
            offlineHandler.AddOfflineResponse(new Uri("http://oak:1001/ServerNotRunning"), 
                new HttpResponseMessage(HttpStatusCode.NonAuthoritativeInformation)
                {
                    Content = new StringContent("Here's an old copy of the information while we are offline.")
                });

            var httpClient = new HttpClient(offlineHandler);

            var retry = true;

            while (retry)
            {
                var response = await httpClient.GetAsync(new Uri("http://oak:1001/ServerNotRunning"));

                if (response.StatusCode == HttpStatusCode.OK) retry = false;
                Thread.Sleep(10000);
            }
        }


        public class OfflineHandler : DelegatingHandler
        {
            private readonly Uri _statusMonitorUri;
            private readonly Dictionary<Uri, HttpResponseMessage> _offlineResponses = new Dictionary<Uri, HttpResponseMessage>();
            private bool _isOffline = false;
            private Timer _timer;

            public OfflineHandler(HttpMessageHandler innerHandler, Uri statusMonitorUri)
            {
                _statusMonitorUri = statusMonitorUri;
                InnerHandler = innerHandler;
            }

            public void AddOfflineResponse(Uri uri, HttpResponseMessage response)
            {
                _offlineResponses.Add(uri,response);
            }

            protected  async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                if (_isOffline == true) return OfflineResponse(request);

                try
                {
                    var response = await base.SendAsync(request, cancellationToken);
                    if (response.StatusCode == HttpStatusCode.ServiceUnavailable || response.StatusCode == HttpStatusCode.BadGateway)
                    {
                        MonitorOfflineState();
                        return OfflineResponse(request);
                    }
                    return response;
                }
                catch (WebException ex)
                {
                    MonitorOfflineState();
                    return OfflineResponse(request);
                }

            }

            private void MonitorOfflineState()
            {
                _isOffline = true;
                _timer = new Timer( async state =>
                {
                    var request = new HttpRequestMessage() {RequestUri = _statusMonitorUri};
                    try
                    {
                        var response = await base.SendAsync(request, new CancellationToken());
                        if (response.StatusCode == HttpStatusCode.OK)
                        {
                            _isOffline = false;
                            _timer.Dispose();
                        } 
                    }
                    catch
                    {

                    }
                }, null, new TimeSpan(0,0,0),new TimeSpan(0,1,0));

            }

            private HttpResponseMessage OfflineResponse(HttpRequestMessage request)
            {
                if (_offlineResponses.ContainsKey(request.RequestUri))
                {
                    return _offlineResponses[request.RequestUri];
                }
                return new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
            }
        }
    }

这篇关于检查与HttpClient的互联网连接的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！