示例#1
0
        /// <summary>
        /// post a data to server
        /// </summary>
        /// <param name="url"></param>
        /// <param name="parameterInfoes"></param>
        /// <param name="streamInfo"></param>
        /// <returns></returns>
        public HttpClientResponse Post(string url, ParameterInfo[] parameterInfoes, BaseStreamInfo streamInfo = null)
        {
#if (NETSTANDARD1_6)
            throw new NotSupportedException();
#else
            HttpClientResponseBase response = PostHead(url, parameterInfoes, streamInfo);
            try
            {
                HttpClientResponse httpClientResponse = new HttpClientResponse
                {
                    Status          = response.Status,
                    ResponseHeaders = response.ResponseHeaders,
                    Stream          = response.Stream,
                    TcpClient       = response.TcpClient,
                };
                int    length    = int.Parse(httpClientResponse.ResponseHeaders["content-length"]);
                byte[] result    = new byte[length];
                int    readCount = 0;
                while (readCount < length)
                {
                    byte[] bytes       = new byte[512];
                    int    readedCount = 0;
                    readedCount = response.Stream.Read(bytes, bytes.Length);

                    for (int i = 0; i < readedCount; i++)
                    {
                        result[i + readCount] = bytes[i];
                    }
                    readCount += readedCount;
                }
                httpClientResponse.Data = Encoding.GetString(result);
                response = httpClientResponse;
                return(httpClientResponse);
            }
            finally
            {
                response.TcpClient.Close();
            }
#endif
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="url"></param>
        /// <param name="parameterInfoes"></param>
        /// <returns></returns>
        public async Task <HttpClientResponse> PostAsync(string url, ParameterInfo[] parameterInfoes, BaseStreamInfo streamInfo = null)
        {
            HttpClientResponseBase response = await PostHeadAsync(url, parameterInfoes, streamInfo);

            try
            {
                HttpClientResponse httpClientResponse = new HttpClientResponse
                {
                    Status          = response.Status,
                    ResponseHeaders = response.ResponseHeaders,
                    Stream          = response.Stream,
                    TcpClient       = response.TcpClient,
                };
                int    length    = int.Parse(httpClientResponse.ResponseHeaders["content-length"]);
                byte[] result    = new byte[length];
                int    readCount = 0;
                while (readCount < length)
                {
                    byte[] bytes       = new byte[512];
                    int    readedCount = 0;
                    readedCount = await response.Stream.ReadAsync(bytes, bytes.Length);

                    for (int i = 0; i < readedCount; i++)
                    {
                        result[i + readCount] = bytes[i];
                    }
                    readCount += readedCount;
                }
                httpClientResponse.Data = Encoding.GetString(result);
                response = httpClientResponse;
                return(httpClientResponse);
            }
            finally
            {
                response.TcpClient.Close();
            }
        }
示例#3
0
        public async Task <HttpClientResponseBase> PostHeadAsync(string url, ParameterInfo[] parameterInfoes, BaseStreamInfo streamInfo = null)
        {
            string    newLine   = TextHelper.NewLine;
            Uri       uri       = new Uri(url);
            TcpClient tcpClient = new TcpClient(uri.Host, uri.Port);

            try
            {
                if (streamInfo != null && (!streamInfo.Length.HasValue || streamInfo.Length <= 0))
                {
                    throw new Exception("Please set streamInfo.Length before upload your stream!");
                }
                string boundary = "----------------------------" + DateTime.Now.Ticks.ToString("x");
                string headData = $"POST {uri.AbsolutePath} HTTP/1.1" + newLine + $"Host: {uri.Host}" + newLine + $"Content-Type: multipart/form-data; boundary={boundary}" + newLine;
                if (RequestHeaders != null && RequestHeaders.Count > 0)
                {
                    foreach (KeyValuePair <string, string[]> item in RequestHeaders)
                    {
                        if (!item.Key.Equals("host", StringComparison.OrdinalIgnoreCase) && !item.Key.Equals("content-type", StringComparison.OrdinalIgnoreCase) && !item.Key.Equals("content-length", StringComparison.OrdinalIgnoreCase))
                        {
                            if (item.Value == null || item.Value.Length == 0)
                            {
                                continue;
                            }
                            headData += item.Key + ": " + string.Join(",", item.Value) + newLine;
                        }
                    }
                }
                StringBuilder valueData = new StringBuilder();
                if (parameterInfoes != null)
                {
                    string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";
                    string boundaryinsert   = TextHelper.NewLine + "--" + boundary + TextHelper.NewLine;
                    foreach (ParameterInfo item in parameterInfoes)
                    {
                        valueData.AppendLine(boundaryinsert);
                        valueData.Append(string.Format(formdataTemplate, item.Name, item.Value));
                    }
                }

                byte[] dataBytes = Encoding.GetBytes(valueData.ToString());
                headData += $"Content-Length: {dataBytes.Length}" + newLine + newLine;

                byte[] headBytes = Encoding.GetBytes(headData);

                Stream stream = uri.Port == 443 ? (Stream) new SslStream(tcpClient.GetStream()) : tcpClient.GetStream();

                if (uri.Port == 443)
                {
                    SslStream sslStream = (SslStream)stream;
                    await sslStream.AuthenticateAsClientAsync(uri.Host);
                }
                stream.Write(headBytes, 0, headBytes.Length);
                stream.Write(dataBytes, 0, dataBytes.Length);

                if (streamInfo != null)
                {
                    int sentBytesCount = 0;
                    int wantReadCount  = 1024 * 512;
                    while (streamInfo.Length > sentBytesCount)
                    {
                        if (wantReadCount > streamInfo.Length - sentBytesCount)
                        {
                            wantReadCount = (int)(streamInfo.Length - sentBytesCount);
                        }
                        byte[] result    = new byte[wantReadCount];
                        int    readCount = await streamInfo.Stream.ReadAsync(result, wantReadCount);

                        await stream.WriteAsync(result, 0, readCount);

                        sentBytesCount += readCount;
                    }
                }

                PipeNetworkStream pipelineReader = new PipeNetworkStream(new NormalStream(stream), 30000);

                List <string> lines = new List <string>();
                string        line  = null;
                do
                {
                    if (line != null)
                    {
                        lines.Add(line.TrimEnd());
                    }
                    line = await pipelineReader.ReadLineAsync();
                }while (line != newLine);
                HttpClientResponseBase httpClientResponse = new HttpClientResponseBase
                {
                    Status          = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), lines[0].Split(' ')[1]),
                    ResponseHeaders = SignalGo.Shared.Http.WebHeaderCollection.GetHttpHeaders(lines.Skip(1).ToArray()),
                    Stream          = pipelineReader,
                    TcpClient       = tcpClient
                };
                Response = httpClientResponse;
                return(httpClientResponse);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }