.Net Core 3.0后台使用httpclient请求网络网页和图片_使用Core3.

public class DomainMappingMiddleware : BaseMiddleware
    {
        public ConfigSetting ConfigSetting { get; set; }

        public ILogger<DomainMappingMiddleware> Logger { public HttpClient HttpClient = null;

        private static object _Obj = new object();
        public DomainMappingMiddleware(RequestDelegate next,IConfiguration configuration,IMemoryCache memoryCache,ConfigSetting configSetting,ILogger<DomainMappingMiddleware> logger,IHttpClientFactory clientFactory) : base(next,configuration,memoryCache)
        {
            this.ConfigSetting = configSetting;
            this.Logger = logger;
            this.HttpClient = clientFactory.CreateClient(domainServiceClient);
        }


        async Task Invoke(HttpContext httpContext)
        {
            string requestUrl = ;
            string requestHost = ;

            string dateFlag = DateTime.Now.ToString(yyyy-MM-dd hh:mm:ss:fff);

            requestUrl = httpContext.Request.GetDisplayUrl();

            bool isExistDomain = bool isLocalWebsite = this.ConfigSetting.GetValue(IsLocalDomainService") == trueif (httpContext.Request.Query.ContainsKey(returnurl))
            {
                requestUrl = httpContext.Request.Query[].ToString();
                requestUrl = HttpUtility.UrlDecode(requestUrl);
                isLocalWebsite = ;
            }

            Match match = Regex.Match(requestUrl,DomainHostRegex));
            if (match.Success)
            {
                isExistDomain = ;
                requestHost = match.Value;
            }

#if DEBUG
            requestUrl = http://139.199.128.86:444/?returnurl=https%3A%2F%2F3w.huanqiu.com%2Fa%2Fc36dc8%2F9CaKrnKnonm;
#endif

             (isExistDomain)
            {
                this.Logger.LogInformation(${dateFlag}_记录请求地址：{requestUrl},是否存在当前域：{isExistDomain},是否是本地环境：{isLocalWebsite});

                bool isFile = ;

                //1-设置响应的内容类型
                MediaTypeHeaderValue mediaType = if (requestUrl.Contains(.js))
                {
                    mediaType = new MediaTypeHeaderValue(application/x-javascript);
                    mediaType.Encoding = System.Text.Encoding.UTF8;
                }
                else .csstext/css.pngimage/png);
                    isFile = ;
                }
                .jpgimage/jpeg.icoimage/x-icon.gifimage/gif/api/") && !requestUrl.Contains(/viewsapplication/json);
                }
                else
                {
                    mediaType = text/html);
                    mediaType.Encoding = System.Text.Encoding.UTF8;
                }

                2-获取响应结果

                 (isLocalWebsite)
                {
                    本地服务器将请求转发到远程服务器
                    requestUrl = MyDomainAgentHost") + ?returnurl=" + HttpUtility.UrlEncode(requestUrl);
                }

                if (isFile == )
                {
                    string result = await this.HttpClient.MyGet(requestUrl);

                    if (httpContext.Response.HasStarted == )
                    {
                        {dateFlag}_请求结束_{requestUrl}_长度{result.Length});

                        请求结果展示在客户端，需要重新请求本地服务器，因此需要将https转为http
                        result = result.Replace(https://",http://);
                        替换"/a.ico" 为："http://www.baidu.com/a.ico"
                        result = Regex.Replace(result,1)">"/(?=[a-zA-Z0-9]+)"{requestHost}/替换"www.baidu.com/a.ico" 为：""//(?=[a-zA-Z0-9]+)"http://必须有请求结果才能给内容类型赋值；如果请求过程出了异常再赋值，会报错：The response headers cannot be modified because the response has already started.
                        httpContext.Response.ContentType = mediaType.ToString();

                        await httpContext.Response.WriteAsync(result ?? "");
                    }
                    
                    {
                        {dateFlag}_请求结束_{requestUrl}_图片字节流长度{result.Length}_Response已启动);
                    }
                }
                
                {
                    byte[] result = .HttpClient.MyGetFile(requestUrl);

                    {dateFlag}_请求结束_{requestUrl}_图片字节流长度{result.Length});

                        httpContext.Response.ContentType = mediaType.ToString();
                        await httpContext.Response.Body.WriteAsync(result,1)">0);
                    }
                }
            }
        }
    }

/// <summary>
    /// 中间件基类
    </summary>
    abstract  BaseMiddleware
    {
        <summary>
         等同于ASP.NET里面的WebCache(HttpRuntime.Cache)
        </summary>
        protected IMemoryCache MemoryCache { ; }

         获取配置文件里面的配置内容
        protected IConfiguration Configuration { public BaseMiddleware(RequestDelegate next,1)">params [] @params)
        {
            foreach (var item in @params)
            {
                if (item is IMemoryCache)
                {
                    this.MemoryCache = (IMemoryCache)item;
                }
                 IConfiguration)
                {
                    this.Configuration = (IConfiguration)item;
                }
            }
        }

    }

 HttpClientSingleston
    {
        async static Task<string> MyGet(this HttpClient httpClient,1)">string url)
        {
            using (HttpRequestMessage request =  HttpRequestMessage(HttpMethod.Get,url))
            {
                using (var response = await httpClient.SendAsync(request))
                {
                     (response.IsSuccessStatusCode)
                    {
                        using (Stream stream =  response.Content.ReadAsStreamAsync())
                        {
                            using (StreamReader streamReader =  StreamReader(stream,Encoding.UTF8))
                            {
                                result =  streamReader.ReadToEndAsync();
                            }
                        }

                    }
                }
            }
            return result ?? ;
        }

        byte[]> MyGetFile( (response.IsSuccessStatusCode)
                    {
                        result =  response.Content.ReadAsByteArrayAsync();
                    }
                }
            }
            return result ?? byte[];
        }

    }