No.4 dotnetcore&docker--创建多平台使用SDK

新建一个类库项目，命名ASdk

 

 

 新建好之后，右键->编辑项目文件

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFrameworks>netstandard2.0;net45</TargetFrameworks>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(TargetFramework)' == 'net40' OR '$(TargetFramework)' == 'net45'">
    <DefineConstants>NETFULL;NET</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
  </ItemGroup>

  <ItemGroup Condition="'$(TargetFramework)' == 'net45'">
    <Reference Include="System.Net" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Web" />
    <Reference Include="System.IO.Compression" />

  </ItemGroup>
</Project>

 

<PropertyGroup Condition=" '$(TargetFramework)' == 'net40' OR '$(TargetFramework)' == 'net45'">
    <DefineConstants>NETFULL;NET</DefineConstants>
  </PropertyGroup>
这一段的意思是 NETFULL;NET 代表.net 4.5，而不是 dotnet core 。

这里由于httppost代码又一些较大的区别，我们就按照httppost来编写区别。

 /// <summary>
    ///     文件元数据。
    ///     可以使用以下几种构造方法：
    ///     本地路径：new FileItem("C:/temp.jpg");
    ///     本地文件：new FileItem(new FileInfo("C:/temp.jpg"));
    ///     字节流：new FileItem("abc.jpg", bytes);
    /// </summary>
    public class FileItem
    {
        private byte[] content;
        private readonly FileInfo fileInfo;
        private string fileName;
        private string mimeType;

        /// <summary>
        ///     基于本地文件的构造器。
        /// </summary>
        /// <param name="fileInfo">本地文件</param>
        public FileItem(FileInfo fileInfo)
        {
            if (fileInfo == null || !fileInfo.Exists)
                throw new ArgumentException("fileInfo is null or not exists!");
            this.fileInfo = fileInfo;
        }

        /// <summary>
        ///     基于本地文件全路径的构造器。
        /// </summary>
        /// <param name="filePath">本地文件全路径</param>
        public FileItem(string filePath)
            : this(new FileInfo(filePath))
        {
        }

        /// <summary>
        ///     基于文件名和字节流的构造器。
        /// </summary>
        /// <param name="fileName">文件名称（服务端持久化字节流到磁盘时的文件名）</param>
        /// <param name="content">文件字节流</param>
        public FileItem(string fileName, byte[] content)
        {
            if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException("fileName");
            if (content == null || content.Length == 0) throw new ArgumentNullException("content");

            this.fileName = fileName;
            this.content = content;
        }

        /// <summary>
        ///     基于文件名、字节流和媒体类型的构造器。
        /// </summary>
        /// <param name="fileName">文件名（服务端持久化字节流到磁盘时的文件名）</param>
        /// <param name="content">文件字节流</param>
        /// <param name="mimeType">媒体类型</param>
        public FileItem(string fileName, byte[] content, string mimeType)
            : this(fileName, content)
        {
            if (string.IsNullOrEmpty(mimeType)) throw new ArgumentNullException("mimeType");
            this.mimeType = mimeType;
        }

        public string GetFileName()
        {
            if (fileName == null && fileInfo != null && fileInfo.Exists)
                fileName = fileInfo.FullName;
            return fileName;
        }

        public string GetMimeType()
        {
            if (mimeType == null)
                mimeType = GetMimeType(GetContent());
            return mimeType;
        }

        public byte[] GetContent()
        {
            if (content == null && fileInfo != null && fileInfo.Exists)
                using (Stream fileStream = fileInfo.OpenRead())
                {
                    content = new byte[fileStream.Length];
                    fileStream.Read(content, 0, content.Length);
                }

            return content;
        }

        /// <summary>
        ///     清除字典中值为空的项。
        /// </summary>
        /// <param name="dict">待清除的字典</param>
        /// <returns>清除后的字典</returns>
        public static IDictionary<string, T> CleanupDictionary<T>(IDictionary<string, T> dict)
        {
            IDictionary<string, T> newDict = new Dictionary<string, T>(dict.Count);
            var dem = dict.GetEnumerator();

            while (dem.MoveNext())
            {
                var name = dem.Current.Key;
                var value = dem.Current.Value;
                if (value != null)
                    newDict.Add(name, value);
            }

            return newDict;
        }

        /// <summary>
        ///     获取文件的真实后缀名。目前只支持JPG, GIF, PNG, BMP四种图片文件。
        /// </summary>
        /// <param name="fileData">文件字节流</param>
        /// <returns>JPG, GIF, PNG or null</returns>
        public static string GetFileSuffix(byte[] fileData)
        {
            if (fileData == null || fileData.Length < 10)
                return null;

            if (fileData[0] == 'G' && fileData[1] == 'I' && fileData[2] == 'F')
                return "GIF";
            if (fileData[1] == 'P' && fileData[2] == 'N' && fileData[3] == 'G')
                return "PNG";
            if (fileData[6] == 'J' && fileData[7] == 'F' && fileData[8] == 'I' && fileData[9] == 'F')
                return "JPG";
            if (fileData[0] == 'B' && fileData[1] == 'M')
                return "BMP";
            return null;
        }

        /// <summary>
        ///     获取文件的真实媒体类型。目前只支持JPG, GIF, PNG, BMP四种图片文件。
        /// </summary>
        /// <param name="fileData">文件字节流</param>
        /// <returns>媒体类型</returns>
        public static string GetMimeType(byte[] fileData)
        {
            var suffix = GetFileSuffix(fileData);
            string mimeType;

            switch (suffix)
            {
                case "JPG":
                    mimeType = "image/jpeg";
                    break;
                case "GIF":
                    mimeType = "image/gif";
                    break;
                case "PNG":
                    mimeType = "image/png";
                    break;
                case "BMP":
                    mimeType = "image/bmp";
                    break;
                default:
                    mimeType = "application/octet-stream";
                    break;
            }

            return mimeType;
        }

        /// <summary>
        ///     根据文件后缀名获取文件的媒体类型。
        /// </summary>
        /// <param name="fileName">带后缀的文件名或文件全名</param>
        /// <returns>媒体类型</returns>
        public static string GetMimeType(string fileName)
        {
            string mimeType;
            fileName = fileName.ToLower();

            if (fileName.EndsWith(".bmp", StringComparison.CurrentCulture))
                mimeType = "image/bmp";
            else if (fileName.EndsWith(".gif", StringComparison.CurrentCulture))
                mimeType = "image/gif";
            else if (fileName.EndsWith(".jpg", StringComparison.CurrentCulture) ||
                     fileName.EndsWith(".jpeg", StringComparison.CurrentCulture))
                mimeType = "image/jpeg";
            else if (fileName.EndsWith(".png", StringComparison.CurrentCulture))
                mimeType = "image/png";
            else
                mimeType = "application/octet-stream";

            return mimeType;
        }

        /// <summary>
        ///     根据API名称获取响应根节点名称。
        /// </summary>
        /// <param name="api">API名称</param>
        /// <returns></returns>
        public static string GetRootElement(string api)
        {
            var pos = api.IndexOf(".");
            if (pos != -1 && api.Length > pos)
                api = api.Substring(pos + 1).Replace('.', '_');
            return api + "_response";
        }

    }

 

HttpClient池

#if NETFULL

#else

using System;
using System.Text;
using System.Net.Http;
using System.Collections.Concurrent;

namespace ASdk
{
    internal class WebUtilsHttpConnectionPool
    {
        private readonly ConcurrentStack<HttpClient> _clients = new ConcurrentStack<HttpClient>();
        private string _url = string.Empty;
        private int _size = 1;
        private readonly object _lockObject = new object();
        private double _timeout = 60000;

        /// <summary>
        /// 初始化 HttpClient 池
        /// </summary>
        /// <param name="url">目标域名，不带路径 比如 http://www.baidu.com </param>
        /// <param name="num">池里Client数量</param>
        public WebUtilsHttpConnectionPool(string url, int num)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new ArgumentException(nameof(url));
            }

            if (num <= 0)
            {
                throw new ArgumentException(nameof(num));
            }
            _clients.Clear();
            _url = url;
            _size = num;

        }

        public HttpClient GetClient()
        {
            if (_clients.TryPop(out var client))
            {
                return client;
            }
            else
            {
                HttpMessageHandler handler = new HttpClientHandler()
                {
                    AutomaticDecompression = System.Net.DecompressionMethods.GZip,
                    UseProxy = false,
                    ServerCertificateCustomValidationCallback = (message, certificate2, arg3, arg4) => true,
                    ClientCertificateOptions = ClientCertificateOption.Manual,
                    ClientCertificates =
                {

                }
                };


                var newClient = new HttpClient(handler)
                { BaseAddress = new Uri(_url), Timeout = TimeSpan.FromMilliseconds(_timeout) };
                //newClient.DefaultRequestHeaders.Add("User-Agent", "Aop4Net");
                newClient.DefaultRequestHeaders.Add("Connection", "keep-alive");
                return newClient;
            }
        }

        public void ReturnClient(HttpClient client)
        {
            lock (_lockObject)
            {
                if (_clients.Count >= _size)
                {
                    client.Dispose();
                }
                else
                {
                    _clients.Push(client);
                }
            }
        }
    }
}
#endif

 

最上面的   表示进入dotnet core 才生效的代码

 

 

 

 

#if NETFULL

#else

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web;

namespace ASdk
{
    /// <summary>
    /// 网络工具类。
    /// </summary>
    public sealed class WebUtils
    {





        internal readonly WebUtilsHttpConnectionPool ConnectionPool;

        public WebUtils(string server, int poolSize = 30)
        {

            ConnectionPool = new WebUtilsHttpConnectionPool(server, poolSize);
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPost(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            return DoPostAsync(url, parameters, charset).Result;
        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="json">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>z
        public string DoPost(string url, string json, string charset = "utf-8")
        {
            return DoPostAsync(url, json, charset).Result;
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task<string> DoPostAsync(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            try
            {

                var encoding = Encoding.GetEncoding(charset);
                var client = ConnectionPool.GetClient();
                var query = new Uri(url).Query;
                var content = new StringContent(BuildQuery(parameters, charset), encoding, "application/x-www-form-urlencoded");

                var resp = await client.PostAsync(query, content);
                var result = await resp.Content.ReadAsStringAsync();

                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

        public string DoGet(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            return DoGetAsync(url, parameters, charset).Result;
        }

        /// <summary>
        ///  执行HTTP GET请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task<string> DoGetAsync(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            try
            {

                if (parameters != null && parameters.Count > 0)
                    if (url.Contains("?"))
                        url = url + "&" + BuildQuery(parameters, charset);
                    else
                        url = url + "?" + BuildQuery(parameters, charset);

                var query = new Uri(url).Query;
                var client = ConnectionPool.GetClient();
                var result = await client.GetStringAsync(url);
                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task<string> DoPostAsync(string url, string json, string charset = "utf-8")
        {
            try
            {

                var encoding = Encoding.GetEncoding(charset);
                var client = ConnectionPool.GetClient();


                HttpContent content = new StringContent(json);
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                content.Headers.ContentType.CharSet = charset;
                var resp = await client.PostAsync(url, content);
                var result = await resp.Content.ReadAsStringAsync();

                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPost(string url, IDictionary<string, string> textParams,
            IDictionary<string, FileItem> fileParams,
            string charset)
        {
            return DoPostAsync(url, textParams, fileParams, charset).Result;
        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task<string> DoPostAsync(string url, IDictionary<string, string> textParams, IDictionary<string, FileItem> fileParams,
            string charset)
        {
            // 如果没有文件参数，则走普通POST请求
            if (fileParams == null || fileParams.Count == 0)
                return await DoPostAsync(url, textParams, charset);

            var encoding = Encoding.GetEncoding(charset);

            var client = ConnectionPool.GetClient();


            using (var content = new MultipartFormDataContent("Upload----" + DateTime.Now.ToString(CultureInfo.InvariantCulture)))
            {
                // 组装文本请求参数
                using (var textEnum = textParams.GetEnumerator())
                {
                    while (textEnum.MoveNext())
                    {
                        var streamContent = new StreamContent(new MemoryStream(encoding.GetBytes(textEnum.Current.Value)));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"logo.jpg\"");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"{textEnum.Current.Key}\"");
                        content.Add(streamContent, textEnum.Current.Key);
                    }
                }


                // 组装文件请求参数
                using (var fileEnum = fileParams.GetEnumerator())
                {
                    while (fileEnum.MoveNext())
                    {
                        var key = fileEnum.Current.Key;
                        var fileItem = fileEnum.Current.Value;
                        byte[] bts = fileItem.GetContent();
                        var streamContent = new StreamContent(new MemoryStream(bts));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue(fileItem.GetMimeType());
                        //                        streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue($"form-data;name=\"{key}\";filename=\"{fileItem.GetFileName()}\"");
                        content.Add(streamContent, key, fileItem.GetFileName());
                    }
                }

                var resp = await client.PostAsync(url, content);
                var result = await resp.Content.ReadAsStringAsync();
                ConnectionPool.ReturnClient(client);
                return result;
            }
        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task<string> DoPostAsync2(string url, IDictionary<string, string> textParams, IDictionary<string, FileItem> fileParams,
            string charset)
        {
            // 如果没有文件参数，则走普通POST请求
            if (fileParams == null || fileParams.Count == 0)
                return await DoPostAsync(url, textParams, charset);

            var encoding = Encoding.GetEncoding(charset);

            var client = ConnectionPool.GetClient();
            // var query = new Uri(url).Query;

            using (var content = new MultipartFormDataContent())
            {
                // 组装文本请求参数
                using (var textEnum = textParams.GetEnumerator())
                {
                    while (textEnum.MoveNext())
                    {
                        var streamContent = new StreamContent(new MemoryStream(encoding.GetBytes(textEnum.Current.Value)));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"logo.jpg\"");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"{textEnum.Current.Key}\"");
                        content.Add(streamContent, textEnum.Current.Key);
                    }
                }


                // 组装文件请求参数
                using (var fileEnum = fileParams.GetEnumerator())
                {
                    while (fileEnum.MoveNext())
                    {
                        var key = fileEnum.Current.Key;
                        var fileItem = fileEnum.Current.Value;
                        byte[] bts = fileItem.GetContent();
                        var streamContent = new StreamContent(new MemoryStream(bts));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue(fileItem.GetMimeType());
                        //                        streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue($"form-data;name=\"{key}\";filename=\"{fileItem.GetFileName()}\"");
                        content.Add(streamContent, key, fileItem.GetFileName());
                    }
                }

                var resp = await client.PostAsync(url, content);
                var result = await resp.Content.ReadAsStringAsync();
                ConnectionPool.ReturnClient(client);
                return result;
            }
        }

        /// <summary>
        ///     组装普通文本请求参数。
        /// </summary>
        /// <param name="parameters">Key-Value形式请求参数字典</param>
        /// <param name="charset">编码</param>
        /// <returns>URL编码后的请求数据</returns>
        public static string BuildQuery(IDictionary<string, string> parameters, string charset = "utf-8")
        {
            var postData = new StringBuilder();
            var hasParam = false;

            using (var dem = parameters.GetEnumerator())
            {
                while (dem.MoveNext())
                {
                    var name = dem.Current.Key;
                    var value = dem.Current.Value;
                    // 忽略参数名或参数值为空的参数
                    if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(value))
                    {
                        if (hasParam)
                            postData.Append("&");

                        postData.Append(name);
                        postData.Append("=");

                        var encodedValue = HttpUtility.UrlEncode(value, Encoding.GetEncoding(charset));

                        postData.Append(encodedValue);
                        hasParam = true;
                    }
                }

                return postData.ToString();
            }
        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="json">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public void DownFile(string url, string savePath)
        {
            var t = DownFileAsync(url, savePath);
            t.Wait();
        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public async Task DownFileAsync(string url, string savePath)
        {
            try
            {

                var client = ConnectionPool.GetClient();
                var resp = await client.GetByteArrayAsync(url);
                using (Stream responseStream = new MemoryStream(resp))
                {
                    using (Stream stream = new FileStream(savePath, FileMode.Create))
                    {
                        byte[] bArr = new byte[1024];
                        int size = responseStream.Read(bArr, 0, bArr.Length);
                        while (size > 0)
                        {
                            stream.Write(bArr, 0, size);
                            size = responseStream.Read(bArr, 0, bArr.Length);
                        }
                        stream.Close();
                    }
                    responseStream.Close();
                };

                ConnectionPool.ReturnClient(client);

            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

    }

}
#endif

 

 

接下来写.net4.5版本的代码

#if NETFULL



using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;

namespace CY.SDK.JDPAY.Net45
{

    internal class NWebUtilsHttpConnectionPool
    {
        private readonly ConcurrentStack<HttpClient> _clients = new ConcurrentStack<HttpClient>();
        private string _url = string.Empty;
        private int _size = 1;
        private readonly object _lockObject = new object();
        private double _timeout = 60000;

        /// <summary>
        /// 初始化 HttpClient 池
        /// </summary>
        /// <param name="url">目标域名，不带路径 比如 http://www.baidu.com </param>
        /// <param name="num">池里Client数量</param>
        public NWebUtilsHttpConnectionPool(string url, int num)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new ArgumentException(nameof(url));
            }

            if (num <= 0)
            {
                throw new ArgumentException(nameof(num));
            }
            _clients.Clear();
            _url = url;
            _size = num;

        }

        public HttpClient GetClient()
        {
            if (_clients.TryPop(out var client))
            {
                return client;
            }
            else
            {
                var newClient = new HttpClient()
                { BaseAddress = new Uri(_url), Timeout = TimeSpan.FromMilliseconds(_timeout) };
                //newClient.DefaultRequestHeaders.Add("User-Agent", "Aop4Net");
                newClient.DefaultRequestHeaders.Add("Connection", "keep-alive");
                return newClient;
            }
        }

        public void ReturnClient(HttpClient client)
        {
            lock (_lockObject)
            {
                if (_clients.Count >= _size)
                {
                    client.Dispose();
                }
                else
                {
                    _clients.Push(client);
                }
            }
        }
    }

}
#else

#endif

 

#if NETFULL



using CY.SDK.JDPAY.Utils;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web;

namespace CY.SDK.JDPAY.Net45
{



    /// <summary>
    /// 网络工具类。
    /// </summary>
    public sealed class NWebUtils
    {





        internal readonly NWebUtilsHttpConnectionPool ConnectionPool;

        public NWebUtils(string server, int poolSize = 30)
        {

            ConnectionPool = new NWebUtilsHttpConnectionPool(server, poolSize);
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPost(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            return DoPostAsync(url, parameters, charset);
        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="json">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPost(string url, string json, string charset = "utf-8")
        {
            return DoPostAsync(url, json, charset);
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPostAsync(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            try
            {

                var encoding = Encoding.GetEncoding(charset);
                var client = ConnectionPool.GetClient();
                var query = new Uri(url).Query;
                var content = new StringContent(BuildQuery(parameters, charset), encoding, "application/x-www-form-urlencoded");

                var resp = client.PostAsync(query, content).Result;
                var result = resp.Content.ReadAsStringAsync().Result;

                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

        public string DoGet(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            return DoGetAsync(url, parameters, charset);
        }

        /// <summary>
        ///  执行HTTP GET请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoGetAsync(string url, IDictionary<string, string> parameters, string charset = "utf-8")
        {
            try
            {

                if (parameters != null && parameters.Count > 0)
                    if (url.Contains("?"))
                        url = url + "&" + BuildQuery(parameters, charset);
                    else
                        url = url + "?" + BuildQuery(parameters, charset);

                var query = new Uri(url).Query;
                var client = ConnectionPool.GetClient();
                var result = client.GetStringAsync(url).Result;
                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }


        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPostAsync(string url, string json, string charset = "utf-8")
        {
            try
            {

                var encoding = Encoding.GetEncoding(charset);
                var client = ConnectionPool.GetClient();


                HttpContent content = new StringContent(json);
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                content.Headers.ContentType.CharSet = charset;
                var resp = client.PostAsync(url, content).Result;
                var result = resp.Content.ReadAsStringAsync().Result;

                ConnectionPool.ReturnClient(client);
                return result;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPost(string url, IDictionary<string, string> textParams,
            IDictionary<string, FileItem> fileParams,
            string charset)
        {
            return DoPostAsync(url, textParams, fileParams, charset);
        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPostAsync(string url, IDictionary<string, string> textParams, IDictionary<string, FileItem> fileParams,
            string charset)
        {
            // 如果没有文件参数，则走普通POST请求
            if (fileParams == null || fileParams.Count == 0)
                return DoPostAsync(url, textParams, charset);

            var encoding = Encoding.GetEncoding(charset);

            var client = ConnectionPool.GetClient();


            using (var content = new MultipartFormDataContent("Upload----" + DateTime.Now.ToString(CultureInfo.InvariantCulture)))
            {
                // 组装文本请求参数
                using (var textEnum = textParams.GetEnumerator())
                {
                    while (textEnum.MoveNext())
                    {
                        var streamContent = new StreamContent(new MemoryStream(encoding.GetBytes(textEnum.Current.Value)));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"logo.jpg\"");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"{textEnum.Current.Key}\"");
                        content.Add(streamContent, textEnum.Current.Key);
                    }
                }


                // 组装文件请求参数
                using (var fileEnum = fileParams.GetEnumerator())
                {
                    while (fileEnum.MoveNext())
                    {
                        var key = fileEnum.Current.Key;
                        var fileItem = fileEnum.Current.Value;
                        byte[] bts = fileItem.GetContent();
                        var streamContent = new StreamContent(new MemoryStream(bts));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue(fileItem.GetMimeType());
                        //                        streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue($"form-data;name=\"{key}\";filename=\"{fileItem.GetFileName()}\"");
                        content.Add(streamContent, key, fileItem.GetFileName());
                    }
                }

                var resp = client.PostAsync(url, content).Result;
                var result = resp.Content.ReadAsStringAsync().Result;
                ConnectionPool.ReturnClient(client);
                return result;
            }
        }

        /// <summary>
        /// 执行带文件上传的HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="textParams">请求文本参数</param>
        /// <param name="fileParams">请求文件参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public string DoPostAsync2(string url, IDictionary<string, string> textParams, IDictionary<string, FileItem> fileParams,
            string charset)
        {
            // 如果没有文件参数，则走普通POST请求
            if (fileParams == null || fileParams.Count == 0)
                return DoPostAsync(url, textParams, charset);

            var encoding = Encoding.GetEncoding(charset);

            var client = ConnectionPool.GetClient();
            // var query = new Uri(url).Query;

            using (var content = new MultipartFormDataContent())
            {
                // 组装文本请求参数
                using (var textEnum = textParams.GetEnumerator())
                {
                    while (textEnum.MoveNext())
                    {
                        var streamContent = new StreamContent(new MemoryStream(encoding.GetBytes(textEnum.Current.Value)));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"logo.jpg\"");
                        //                        streamContent.Headers.ContentDisposition=new ContentDispositionHeaderValue($"form-data;name=\"{textEnum.Current.Key}\"");
                        content.Add(streamContent, textEnum.Current.Key);
                    }
                }


                // 组装文件请求参数
                using (var fileEnum = fileParams.GetEnumerator())
                {
                    while (fileEnum.MoveNext())
                    {
                        var key = fileEnum.Current.Key;
                        var fileItem = fileEnum.Current.Value;
                        byte[] bts = fileItem.GetContent();
                        var streamContent = new StreamContent(new MemoryStream(bts));
                        streamContent.Headers.ContentType = new MediaTypeHeaderValue(fileItem.GetMimeType());
                        //                        streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue($"form-data;name=\"{key}\";filename=\"{fileItem.GetFileName()}\"");
                        content.Add(streamContent, key, fileItem.GetFileName());
                    }
                }

                var resp = client.PostAsync(url, content).Result;
                var result = resp.Content.ReadAsStringAsync().Result;
                ConnectionPool.ReturnClient(client);
                return result;
            }
        }

        /// <summary>
        ///     组装普通文本请求参数。
        /// </summary>
        /// <param name="parameters">Key-Value形式请求参数字典</param>
        /// <param name="charset">编码</param>
        /// <returns>URL编码后的请求数据</returns>
        public static string BuildQuery(IDictionary<string, string> parameters, string charset = "utf-8")
        {
            var postData = new StringBuilder();
            var hasParam = false;

            using (var dem = parameters.GetEnumerator())
            {
                while (dem.MoveNext())
                {
                    var name = dem.Current.Key;
                    var value = dem.Current.Value;
                    // 忽略参数名或参数值为空的参数
                    if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(value))
                    {
                        if (hasParam)
                            postData.Append("&");

                        postData.Append(name);
                        postData.Append("=");

                        var encodedValue = HttpUtility.UrlEncode(value, Encoding.GetEncoding(charset));

                        postData.Append(encodedValue);
                        hasParam = true;
                    }
                }

                return postData.ToString();
            }
        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="json">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public void DownFile(string url, string savePath)
        {
            DownFileAsync(url, savePath);

        }

        /// <summary>
        ///     执行HTTP POST请求。
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="parameters">请求参数</param>
        /// <param name="charset">编码字符集</param>
        /// <returns>HTTP响应</returns>
        public void DownFileAsync(string url, string savePath)
        {
            try
            {

                var client = ConnectionPool.GetClient();
                var resp = client.GetByteArrayAsync(url).Result;
                using (Stream responseStream = new MemoryStream(resp))
                {
                    using (Stream stream = new FileStream(savePath, FileMode.Create))
                    {
                        byte[] bArr = new byte[1024];
                        int size = responseStream.Read(bArr, 0, bArr.Length);
                        while (size > 0)
                        {
                            stream.Write(bArr, 0, size);
                            size = responseStream.Read(bArr, 0, bArr.Length);
                        }
                        stream.Close();
                    }
                    responseStream.Close();
                };

                ConnectionPool.ReturnClient(client);

            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                throw e;
            }

        }

    }


}
#else

#endif

 

 

在dotnet core 3.1版本的 控制台打印程序里面引用ASdk项目，然后调用post方法

 

            ASdk.WebUtils web = new ASdk.WebUtils("http://www.baidu.com");
            var response = web.DoPost("/get", "");

　　

 

在.net 4.6.1的控制台程序里面引用ASdk项目。然后调用Post方法

你会发现，上面只能找到 ASdk.WebUtils 类，这里则只能找到 ASdk.NWebUtils 类。这就是因为在生成的时候就已经屏蔽了不属于条件里面的类。

            ASdk.NWebUtils web = new ASdk.NWebUtils("http://www.baidu.com");
            var response = web.DoPost("/get", "");

　　

然后接下来怎么打包nuget放到nuget服务器上去，最后将项目引用改成nuget安装。

 

　　

然后进入右键->属性->打包，进行修改版本操作

 

 

 

 

 

 

 

 

 

 

  

 

这个勾选不勾选，无所谓，因为没有版本号生成，还是要完成一步pack操作

 

 

 

 

 

 

执行dotnet pack命令