C# 正在检查与HttpClient的Internet连接

我很难理解下面的代码如何处理偶尔的互联网连接丢失。理想情况下，我希望在连接断开后暂停应用程序，然后在再次启动时继续。关于如何做，有什么指导方针吗

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

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

---

下面的示例不是一个直接的解决方案，但它是我创建的一个示例，用于演示如何在脱机时将“预屏蔽”内容返回到请求，然后在恢复连接时返回到联机状态。如果你能得到我在这里所做的，构建你想要的应该是相当容易的

        [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);
            }
        }
    }

[事实]
公共异步任务在脱机时获取响应（）
{
var offlineHandler=新的offlineHandler（新的HttpClientHandler（），新的Uri（“http://oak:1001/status"));
offlineHandler.AddOfflineResponse（新Uri（“http://oak:1001/ServerNotRunning"), 
新的HttpResponseMessage（HttpStatusCode.非授权信息）
{
Content=new-StringContent（“这是我们脱机时信息的旧副本。”）
});
var httpClient=新的httpClient（离线处理程序）；
var retry=true；
while（重试）
{
var response=wait httpClient.GetAsync（新Uri（“http://oak:1001/ServerNotRunning"));
如果（response.StatusCode==HttpStatusCode.OK）retry=false；
睡眠（10000）；
}
}
公共类脱机处理程序：DelegatingHandler
{
私有只读Uri _statusMonitorUri；
专用只读词典_offlineResponses=新词典（）；
private bool_Isofline=假；
私人定时器；
公共脱机处理程序（HttpMessageHandler innerHandler，Uri statusMonitorUri）
{
_statusMonitorUri=statusMonitorUri；
InnerHandler=InnerHandler；
}
public void AddOfflineResponse（Uri、HttpResponseMessage响应）
{
_添加（uri，响应）；
}
受保护的异步覆盖任务SendAsync（HttpRequestMessage请求，CancellationToken CancellationToken）
{
如果（_isOffline==true）返回脱机响应（请求）；
尝试
{
var response=await base.sendaync（请求、取消令牌）；
if（response.StatusCode==HttpStatusCode.serviceinavailable | | response.StatusCode==HttpStatusCode.BadGateway）
{
监视器脱机状态（）；
返回离线响应（请求）；
}
返回响应；
}
捕获（WebException ex）
{
监视器脱机状态（）；
返回离线响应（请求）；
}
}
私有void监视器脱机状态（）
{
_异弗林=真；
_计时器=新计时器（异步状态=>
{
var request=new-HttpRequestMessage（）{RequestUri=\u statusMonitorUri}；
尝试
{
var response=await base.sendaync（请求，new CancellationToken（））；
if（response.StatusCode==HttpStatusCode.OK）
{
_异黄酮=假；
_timer.Dispose（）；
} 
}
抓住
{
}
}，null，新时间跨度（0,0,0），新时间跨度（0,1,0））；
}
专用HttpResponseMessageOfflineResponse（HttpRequestMessage请求）
{
if（_offlineResponses.ContainsKey（request.RequestUri））
{
返回_offlineResponses[request.RequestUri]；
}
返回新的HttpResponseMessage（HttpStatusCode.ServiceUnavailable）；
}
}
}