/*
* Responsible for creating a success result of some sort.
*/
async Task <Response <TOut> > GetSuccessResult <TOut>(
net.HttpContent content,
Response <TOut> responseResult)
{
if (typeof(TOut) == typeof(byte[]) || typeof(TOut) == typeof(object))
{
var contentType = content.Headers.ContentType?.MediaType ?? "application/json";
switch (contentType)
{
case "application/json":
case "application/hyperlambda":
responseResult.Content = (TOut)(object)await content.ReadAsStringAsync();
break;
default:
if (contentType.StartsWith("text/"))
{
responseResult.Content = (TOut)(object)await content.ReadAsStringAsync();
}
else
{
responseResult.Content = (TOut)(object)await content.ReadAsByteArrayAsync();
}
break;
}
}
else if (typeof(TOut) == typeof(string))
{
responseResult.Content = (TOut)(object)await content.ReadAsStringAsync();
}
else if (typeof(IConvertible).IsAssignableFrom(typeof(TOut)))
{
var txtContent = await content.ReadAsStringAsync();
responseResult.Content = (TOut)Convert.ChangeType(txtContent, typeof(TOut));
}
else
{
var txtContent = await content.ReadAsStringAsync();
var objResult = JToken.Parse(txtContent);
responseResult.Content = objResult.ToObject <TOut>();
}
return(responseResult);
}
private async Task <byte[]> GetByteArrayAsyncCore(Task <HttpResponseMessage> getTask)
{
// Wait for the response message.
using (HttpResponseMessage responseMessage = await getTask.ConfigureAwait(false))
{
// Make sure it completed successfully.
responseMessage.EnsureSuccessStatusCode();
// Get the response content.
HttpContent c = responseMessage.Content;
if (c != null)
{
#if NET46
return(await c.ReadAsByteArrayAsync().ConfigureAwait(false));
#else
HttpContentHeaders headers = c.Headers;
using (Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync().ConfigureAwait(false))
{
long? contentLength = headers.ContentLength;
Stream buffer; // declared here to share the state machine field across both if/else branches
if (contentLength.HasValue)
{
// If we got a content length, then we assume that it's correct and create a MemoryStream
// to which the content will be transferred. That way, assuming we actually get the exact
// amount we were expecting, we can simply return the MemoryStream's underlying buffer.
buffer = new HttpContent.LimitMemoryStream(_maxResponseContentBufferSize, (int)contentLength.GetValueOrDefault());
await responseStream.CopyToAsync(buffer).ConfigureAwait(false);
if (buffer.Length > 0)
{
return(((HttpContent.LimitMemoryStream)buffer).GetSizedBuffer());
}
}
else
{
// If we didn't get a content length, then we assume we're going to have to grow
// the buffer potentially several times and that it's unlikely the underlying buffer
// at the end will be the exact size needed, in which case it's more beneficial to use
// ArrayPool buffers and copy out to a new array at the end.
buffer = new HttpContent.LimitArrayPoolWriteStream(_maxResponseContentBufferSize);
try
{
await responseStream.CopyToAsync(buffer).ConfigureAwait(false);
if (buffer.Length > 0)
{
return(((HttpContent.LimitArrayPoolWriteStream)buffer).ToArray());
}
}
finally { buffer.Dispose(); }
}
}
#endif
}
// No content to return.
return(Array.Empty <byte>());
}
}
private static async Task AssertContentLengthHeaderValueAsync(HttpContent content)
{
long contentLength = (await content.ReadAsByteArrayAsync()).LongLength;
long contentLengthHeaderValue = content.Headers.ContentLength.GetValueOrDefault();
Assert.Equal(contentLength, contentLengthHeaderValue);
}
private static void AssertContentLengthHeaderValue(HttpContent content)
{
long contentLength = content.ReadAsByteArrayAsync().Result.LongLength;
long contentLengthHeaderValue = content.Headers.ContentLength.GetValueOrDefault();
Assert.Equal(contentLength, contentLengthHeaderValue);
}
public virtual void Write(JsonWriter writer, HttpContent content)
{
if (content == null)
return;
var bytes = content.ReadAsByteArrayAsync().ConfigureAwait(false).GetAwaiter().GetResult();
IEnumerable<string> contentTypeValues;
string contentTypeHeaderValue;
if (content.Headers.TryGetValues("Content-Type", out contentTypeValues))
contentTypeHeaderValue = contentTypeValues.Last();
else
contentTypeHeaderValue = "text/html; charset=utf-8";
writer.WritePropertyName("format");
var contentType = new ContentType(contentTypeHeaderValue);
bool formatAsBinary = false;
var encoding = Encoding.ASCII;
if (contentType.CharSet != null)
encoding = Encoding.GetEncoding(contentType.CharSet);
else
formatAsBinary = bytes.Any(c => c == 0 || c > 127);
if (formatAsBinary)
{
writer.WriteValue("binary");
writer.WritePropertyName("body");
writer.WriteValue(Convert.ToBase64String(bytes));
}
else
{
// Need to use memory stream to avoid UTF-8 BOM weirdness
string str;
using (var ms = new MemoryStream(bytes))
{
using (var sr = new StreamReader(ms, encoding))
{
str = sr.ReadToEnd();
}
}
if (contentType.MediaType == "application/json" || contentType.MediaType.EndsWith("+json"))
{
var jtoken = JToken.Parse(str);
writer.WriteValue("json");
writer.WritePropertyName("body");
jtoken.WriteTo(writer);
}
else
{
writer.WriteValue("text");
writer.WritePropertyName("body");
//writer.WriteValue(str);
// Represent the text as an array of strings split at \r\n to make long text content easier to read.
WriteStringFomat(writer, contentType, str);
}
}
}
public static async Task<byte[]> ComputeHash(HttpContent httpContent)
{
using (var md5 = MD5.Create())
{
var content = await httpContent.ReadAsByteArrayAsync();
byte[] hash = md5.ComputeHash(content);
return hash;
}
}
/// <inheritdoc />
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="content"/> parameter is <c>null</c>.
/// </exception>
protected internal override void SetContent(HttpContent content)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
_content = content.ReadAsByteArrayAsync().Result;
}
public byte[] ComputeHash(HttpContent httpContent)
{
using (var md5 = MD5.Create())
{
var content = httpContent.ReadAsByteArrayAsync().Result;
var hash = md5.ComputeHash(content);
return hash;
}
}
/// <summary>
/// 读取为二进制数组并转换为指定的编码
/// </summary>
/// <param name="httpContent"></param>
/// <param name="dstEncoding">目标编码</param>
/// <exception cref="ArgumentException"></exception>
/// <returns></returns>
public static async Task <byte[]> ReadAsByteArrayAsync(this HttpContent httpContent, Encoding dstEncoding)
{
var encoding = httpContent.GetEncoding();
var byteArray = await httpContent.ReadAsByteArrayAsync().ConfigureAwait(false);
return(encoding.Equals(dstEncoding)
? byteArray
: Encoding.Convert(encoding, dstEncoding, byteArray));
}
private static string ExtractBody(HttpContent content)
{
if (content == null)
{
return string.Empty;
}
var task = content.ReadAsByteArrayAsync();
return Encoding.UTF8.GetString(task.Result);
}
/// <inheritdoc />
public async Task<object> ConvertFromHttpContentAsync(Type resultType, HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
{
if (!CanConvertFromHttpContent(resultType, httpContent))
{
throw new NotSupportedException("CanConvertFromHttpContent resulted in false, this is not supposed to be called.");
}
Log.Debug().WriteLine("Retrieving the content as byte[], Content-Type: {0}", httpContent.Headers.ContentType);
return await httpContent.ReadAsByteArrayAsync().ConfigureAwait(false);
}
public static async Task<string> ComputeContentHashAsync(HttpContent httpContent)
{
if (httpContent == null)
return null;
using (SHA256 sha256 = SHA256.Create())
{
byte[] content = await httpContent.ReadAsByteArrayAsync().ConfigureAwait(false);
return content.Length != 0
? Convert.ToBase64String(sha256.ComputeHash(content))
: null;
}
}
public static async Task<PreventDisposeContentWrapper> CreateWrapperAsync(HttpContent wrappedContent)
{
if (wrappedContent == null)
{
return new PreventDisposeContentWrapper(new byte[0], null);
}
var bytes = await wrappedContent.ReadAsByteArrayAsync();
var wrapper = new PreventDisposeContentWrapper(bytes, wrappedContent.GetType());
foreach (var header in wrappedContent.Headers)
{
wrapper.Headers.Add(header.Key, header.Value);
}
return wrapper;
}
/// <summary>
/// Decompresses the compressed HTTP content.
/// </summary>
/// <param name="compressedContent">The compressed HTTP content.</param>
/// <param name="compressor">The compressor.</param>
/// <returns>The decompressed content.</returns>
public async Task<HttpContent> DecompressContent(HttpContent compressedContent, ICompressor compressor)
{
var decompressedContentStream = new MemoryStream();
// Decompress buffered content
using (var ms = new MemoryStream(await compressedContent.ReadAsByteArrayAsync()))
{
await compressor.Decompress(ms, decompressedContentStream).ConfigureAwait(false);
}
// Set position back to 0 so it can be read again
decompressedContentStream.Position = 0;
var decompressedContent = new StreamContent(decompressedContentStream);
// Copy content headers so we know what got sent back
this.CopyHeaders(compressedContent, decompressedContent);
return decompressedContent;
}
/// <summary>
/// Creates an array copy of the <paramref name="content"/> without affecting the <see cref="Stream.Position"/> of the original object.
/// </summary>
private static async Task<byte[]> CloneArrayAsync(HttpContent content)
{
var result = await content.ReadAsByteArrayAsync();
var stream = await content.ReadAsStreamAsync();
if (stream.CanSeek) stream.Position = 0;
return result;
}
/// <summary>
/// Serialize the HTTP content to a byte array as a synchronous operation.
/// </summary>
public static byte[] ReadAsByteArray(this HttpContent content)
{
return(Task.Run(() => content.ReadAsByteArrayAsync()).Result);
}
/// <summary>
/// 读取为二进制数组并转换为utf8编码
/// </summary>
/// <param name="httpContent"></param>
/// <exception cref="ArgumentException"></exception>
/// <returns></returns>
public static Task <byte[]> ReadAsUtf8ByteArrayAsync(this HttpContent httpContent)
{
return(httpContent.ReadAsByteArrayAsync(Encoding.UTF8));
}
internal static HttpContent CreateBufferedCopyOfContent(HttpContent content)
{
if (content != null)
{
SharedByteArrayContent shareableContent = content as SharedByteArrayContent;
byte[] contentBytes = shareableContent == null ?
content.ReadAsByteArrayAsync().Result :
shareableContent.ContentBytes;
HttpContent bufferedContent = new SharedByteArrayContent(contentBytes);
foreach (KeyValuePair<string, IEnumerable<string>> header in content.Headers)
{
bufferedContent.Headers.AddHeaderWithoutValidation(header);
}
return bufferedContent;
}
return null;
}
private static void AssertContentLengthHeaderValue(HttpContent content)
{
long contentLength = content.ReadAsByteArrayAsync().Result.LongLength;
long contentLengthHeaderValue = content.Headers.ContentLength.GetValueOrDefault();
Assert.Equal(contentLength, contentLengthHeaderValue);
}
private static async Task<byte[]> ComputeHash(HttpContent httpContent)
{
using (MD5 md5 = MD5.Create())
{
byte[] hash = null;
var content = await httpContent.ReadAsByteArrayAsync();
if (content.Length != 0)
{
hash = md5.ComputeHash(content);
}
return hash;
}
}
/// <summary>
/// Serialize the HTTP content to a string as a synchronous operation.
/// </summary>
public static string ReadAsString(this HttpContent content, Encoding encoding)
{
return(encoding.GetString(Task.Run(() => content.ReadAsByteArrayAsync()).Result));
}
/// <summary>
/// Serialize the HTTP content to a string as an asynchronous operation.
/// </summary>
public async static Task <string> ReadAsStringAsync(this HttpContent content, Encoding encoding)
{
var bytes = await content.ReadAsByteArrayAsync();
return(encoding.GetString(bytes));
}
