public void CopyToAsync_Twice()
{
var ms = new MemoryStream();
ms.WriteByte(4);
ms.WriteByte(12);
ms.WriteByte(7);
ms.Seek(1, SeekOrigin.Begin);
var sc = new StreamContent(ms);
var dest = new MemoryStream();
var task = sc.CopyToAsync(dest);
Assert.True(task.Wait(3000), "#0");
Assert.AreEqual(2, dest.Length, "#1");
dest.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(12, dest.ReadByte(), "#2");
dest = new MemoryStream();
task = sc.CopyToAsync(dest);
Assert.True(task.Wait(3000), "#10");
Assert.AreEqual(2, dest.Length, "#11");
dest.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(12, dest.ReadByte(), "#12");
}
public async Task CopyToAsync_CallMultipleTimesWithStreamSupportingSeeking_ContentIsSerializedMultipleTimes()
{
var source = new MockStream(new byte[10], true, true); // Supports seeking.
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
Assert.Equal(source.Length, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(source.Length, destination2.Length);
}
public async Task DonationController_AddGivenImage_SuccessfullyAsync()
{
//Arrange
var login = await GetLoginUserAsync(2);
var given = listGivens[0];
using (var sc = new StreamContent(File.OpenRead("Img/analgesico.jpg")))
using (var ms = new MemoryStream())
{
await sc.CopyToAsync(ms);
given.Img = ms.ToArray();
}
//Act
using (var postContent = new StringContent(JsonConvert.SerializeObject(given), Encoding.UTF8, "application/json"))
using (var response = await Environment.ServerApiDonate
.CreateRequest("Donation/AddGivenImageAsync")
.AddHeader("Authorization", "Bearer " + login.access_token)
.And(request => request.Content = postContent)
.And(request => request.Method = HttpMethod.Post)
.PostAsync())
{
//Assert
response.EnsureSuccessStatusCode();
}
}
public async Task CopyToAsync_CallMultipleTimesWithStreamNotSupportingSeeking_ThrowsInvalidOperationException()
{
var source = new MockStream(new byte[10], false, true); // doesn't support seeking.
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
// Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable).
Assert.Equal(10, destination1.Length);
// Note that the InvalidOperationException is thrown in CopyToAsync(). It is not thrown inside the task.
var destination2 = new MemoryStream();
Assert.Throws <InvalidOperationException>(() => { Task t = content.CopyToAsync(destination2); });
}
private static async Task <HttpContent> CreateBufferedRequestContentAsync(
IOwinRequest owinRequest,
CancellationToken cancellationToken
)
{
// We need to replace the request body with a buffered stream so that other components can read the stream.
// For this stream to be useful, it must NOT be diposed along with the request. Streams created by
// StreamContent do get disposed along with the request, so use MemoryStream to buffer separately.
MemoryStream buffer;
int? contentLength = owinRequest.GetContentLength();
if (!contentLength.HasValue)
{
buffer = new MemoryStream();
}
else
{
buffer = new MemoryStream(contentLength.Value);
}
cancellationToken.ThrowIfCancellationRequested();
using (StreamContent copier = new StreamContent(owinRequest.Body))
{
await copier.CopyToAsync(buffer);
}
// Provide the non-disposing, buffered stream to later OWIN components (set to the stream's beginning).
buffer.Position = 0;
owinRequest.Body = buffer;
// For MemoryStream, Length is guaranteed to be an int.
return(new ByteArrayContent(buffer.GetBuffer(), 0, (int)buffer.Length));
}
public void CopyToAsync_NullDestination_ThrowsArgumentnullException()
{
var source = new MockStream(new byte[10]);
var content = new StreamContent(source);
Assert.Throws <ArgumentNullException>(() => { Task t = content.CopyToAsync(null); });
}
private async Task AddPersonFace(int idPerson)
{
foreach (string personFaceFilePath in Directory.EnumerateFiles(
$"Img/Faces/{idPerson}", "*", SearchOption.AllDirectories)
)
{
using (var sc = new StreamContent(File.OpenRead(personFaceFilePath)))
using (var ms = new MemoryStream())
{
await sc.CopyToAsync(ms);
var faceViewModel = new FaceViewModel()
{
IdPersons = idPerson,
Image = ms.ToArray()
};
using (var postContent = new StringContent(JsonConvert.SerializeObject(faceViewModel), Encoding.UTF8, "application/json"))
using (var response = await Environment.ServerApiSecurity
.CreateRequest("Person/AddPersonFaceAsync")
.AddHeader("Authorization", "Bearer " + _login.access_token)
.And(request => request.Content = postContent)
.And(request => request.Method = HttpMethod.Post)
.PostAsync())
{
response.EnsureSuccessStatusCode();
}
}
}
}
public void CopyToAsync_Invalid()
{
var m = new MemoryStream();
var sc = new StreamContent(new MemoryStream());
try {
sc.CopyToAsync(null);
Assert.Fail("#1");
} catch (ArgumentNullException) {
}
//
// For some reason does not work on .net
//
/*
* sc = new StreamContent (new ExceptionStream ());
* try {
* sc.CopyToAsync (m).Wait ();
* Assert.Fail ("#2");
* } catch (AggregateException) {
* }
*/
}
public void CopyToAsync()
{
var ms = new MemoryStream();
ms.WriteByte(4);
ms.WriteByte(2);
ms.Seek(0, SeekOrigin.Begin);
var sc = new StreamContent(ms);
var dest = new MemoryStream();
var task = sc.CopyToAsync(dest);
task.Wait();
Assert.AreEqual(2, dest.Length, "#1");
bool hit = false;
dest = new MemoryStream();
var scm = new StreamContentMock(new ExceptionStream());
scm.OnSerializeToStreamAsync = () => { hit = true; };
task = scm.CopyToAsync(dest);
try {
task.Wait();
Assert.Fail("#9");
} catch (AggregateException) {
}
Assert.IsTrue(hit, "#10");
}
public async Task ImageProcessController_AddByVideoCameraAsync_Successfully()
{
//Arrange
var imageProcess = new ImageProcessViewModel()
{
IdVideoCameras = 1,
IdReference = Guid.NewGuid(),
ImageName = "out000090.png",
IpUserRequest = "200.111.222.33",
VideoPath = "/user/danieldangeloresendebarros/opt",
SecondsToStart = 15,
DtProcess = DateTime.Now
};
using (var sc = new StreamContent(File.OpenRead($"Img/Thumbnail/{imageProcess.ImageName}")))
using (var ms = new MemoryStream())
{
await sc.CopyToAsync(ms);
imageProcess.ImageFile = ms.ToArray();
}
//Act
using (var postContent = new StringContent(JsonConvert.SerializeObject(imageProcess), Encoding.UTF8, "application/json"))
using (var response = await Environment.ServerApiSecurity
.CreateRequest("ImageProcess/AddByVideoCameraAsync")
.AddHeader("Authorization", "Bearer " + _loginAdm.access_token)
.And(request => request.Content = postContent)
.And(request => request.Method = HttpMethod.Post)
.PostAsync())
{
//Assert
response.EnsureSuccessStatusCode();
}
}
/// <inheritdoc/>
public async Task <DataElement> InsertBinaryData(string org, string app, int instanceOwnerId, Guid instanceGuid, string attachmentType, string attachmentName, StreamContent content)
{
string developer = AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext);
Guid dataId = Guid.NewGuid();
long filesize;
string pathToSaveTo = $"{_settings.GetTestdataForPartyPath(org, app, developer)}{instanceOwnerId}/{instanceGuid}/data";
Directory.CreateDirectory(pathToSaveTo);
string fileToWriteTo = $"{pathToSaveTo}/{dataId}";
using (Stream streamToWriteTo = File.Open(fileToWriteTo, FileMode.OpenOrCreate))
{
await content.CopyToAsync(streamToWriteTo);
await streamToWriteTo.FlushAsync();
filesize = streamToWriteTo.Length;
}
string testDataForParty = _settings.GetTestdataForPartyPath(org, app, developer);
string instanceFilePath = $"{testDataForParty}{instanceOwnerId}/{instanceGuid}/{instanceGuid}.json";
FileExtensionContentTypeProvider provider = new FileExtensionContentTypeProvider();
provider.TryGetContentType(attachmentName, out string contentType);
lock (Guard(instanceGuid))
{
string instanceData = File.ReadAllText(instanceFilePath);
Instance instance = JsonConvert.DeserializeObject <Instance>(instanceData);
DataElement data = new DataElement
{
Id = dataId.ToString(),
ElementType = attachmentType,
ContentType = contentType,
FileName = attachmentName,
StorageUrl = $"{app}/{instanceGuid}/data/{dataId}",
CreatedBy = instanceOwnerId.ToString(),
CreatedDateTime = DateTime.UtcNow,
LastChangedBy = instanceOwnerId.ToString(),
LastChangedDateTime = DateTime.UtcNow,
FileSize = filesize
};
if (instance.Data == null)
{
instance.Data = new List <DataElement>();
}
instance.Data.Add(data);
string instanceDataAsString = JsonConvert.SerializeObject(instance);
File.WriteAllText(instanceFilePath, instanceDataAsString);
return(data);
}
}
public async Task CopyToAsync_CallMultipleTimesWithStreamSupportingSeekingPartiallyConsumed_ContentIsSerializedMultipleTimesFromInitialPoint()
{
int consumed = 4;
var source = new MockStream(new byte[10], true, true); // supports seeking.
source.Read(new byte[consumed], 0, consumed);
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
Assert.Equal(source.Length - consumed, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(source.Length - consumed, destination2.Length);
}
public static async Task <DownloadRequest> DownloadAsync <T>(this string url, IActionContext context, object queryString = null, object model = null, bool isMethodGet = true)
{
try
{
if (queryString != null && !url.EndsWith("?"))
{
url += "?"; //append querystring delmiter
}
DownloadRequest download = new DownloadRequest();
var request = ToQueryStringInternal(url, queryString).WithStandardHeaders(context);
var httpMethod = HttpMethod.Get;
if (!isMethodGet)
{
httpMethod = HttpMethod.Post;
}
CapturedJsonContent capturedJsonContent = new CapturedJsonContent(request.Settings.JsonSerializer.Serialize(model));
HttpResponseMessage httpResponseMessage = await request.SendAsync(httpMethod, isMethodGet == true?null : capturedJsonContent,
new CancellationToken?(), HttpCompletionOption.ResponseHeadersRead);
HttpContent content = httpResponseMessage.Content;
if (content.Headers.ContentDisposition != null)
{
download.FileName = content.Headers.ContentDisposition.FileName.StripQuotes();
download.ContentType = content.Headers.ContentType.MediaType;
download.DispositionType = content.Headers.ContentDisposition.DispositionType;
}
download.PushStreamFunction = async(stream) =>
{
using (var downloadStream = await httpResponseMessage.Content.ReadAsStreamAsync())
using (var reader = new StreamContent(downloadStream))
using (stream) //this has to be called in order to signal caller that we have finished
{
await reader.CopyToAsync(stream);
}
};
return(download);
}
catch (FlurlHttpException ex)
{
if (ex.Call?.HttpStatus == HttpStatusCode.BadRequest)
{
var validationResult = ex.GetResponseJson <ValidationResult>();
if (validationResult != null)
{
throw new ValidationException(validationResult);
}
}
throw;
}
}
public async Task CopyToAsync_CallMultipleTimesWithStreamNotSupportingSeekingButBufferedStream_ContentSerializedOnceToBuffer()
{
var source = new MockStream(new byte[10], false, true); // doesn't support seeking.
var content = new StreamContent(source);
// After loading the content into a buffer, we should be able to copy the content to a destination stream
// multiple times, even though the stream doesn't support seeking.
await content.LoadIntoBufferAsync();
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
// Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable)
Assert.Equal(10, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(10, destination2.Length);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var compressedStream = _encoding.Encode(stream);
return(_original.CopyToAsync(compressedStream).ContinueWith(tsk =>
{
if (compressedStream != null)
{
compressedStream.Dispose();
}
}));
}
public void CopyToAsync_ClosedInput()
{
var stream = new MemoryStream(new byte[] { 1 });
var content = new StreamContent(stream);
Assert.IsTrue(content.LoadIntoBufferAsync().Wait(3000), "#1");
stream.Close();
var stream_out = new MemoryStream(10);
Assert.IsTrue(content.CopyToAsync(stream_out).Wait(3000), "#2");
}
public async Task <IActionResult> Edit(short id, [Bind("Id,Titre,Description,file,Link")] AdInput ad)
{
if (id != ad.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
string accessToken = await HttpContext.GetTokenAsync("access_token");
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
client.BaseAddress = new Uri(Configuration["URLAPI"] + "api/Ads/" + ad.Id);
var imageContent = new StreamContent(ad.file.OpenReadStream());
StreamContent streamContent = new StreamContent(ad.file.OpenReadStream());
var memoryStream = new MemoryStream();
await streamContent.CopyToAsync(memoryStream);
var bytes = memoryStream.ToArray();
string base64 = Convert.ToBase64String(bytes);
double d = base64.Length;
AdPost adPost = new AdPost();
adPost.Id = ad.Id;
adPost.Titre = ad.Titre;
adPost.Description = ad.Description;
adPost.file = base64;
adPost.fileName = ad.file.FileName;
adPost.name = ad.file.Name;
adPost.ContentDisposition = ad.file.ContentDisposition;
adPost.ContentType = ad.file.ContentType;
adPost.Link = ad.Link;
string json = await Task.Run(() => JsonConvert.SerializeObject(adPost));
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
await client.PutAsync(client.BaseAddress, httpContent);
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
return(View(ad));
}
public override async Task ExecuteResultAsync(IWebDavResponse response, CancellationToken ct)
{
await base.ExecuteResultAsync(response, ct).ConfigureAwait(false);
if (_document.FileSystem.SupportsRangedRead)
{
response.Headers["Accept-Ranges"] = new[] { "bytes" }
}
;
var properties = await _document.GetProperties(response.Dispatcher).ToList(ct).ConfigureAwait(false);
var etagProperty = properties.OfType <GetETagProperty>().FirstOrDefault();
if (etagProperty != null)
{
var propValue = await etagProperty.GetValueAsync(ct).ConfigureAwait(false);
response.Headers["ETag"] = new[] { propValue.ToString() };
}
if (!_returnFile)
{
var lastModifiedProp = properties.OfType <LastModifiedProperty>().FirstOrDefault();
if (lastModifiedProp != null)
{
var propValue = await lastModifiedProp.GetValueAsync(ct).ConfigureAwait(false);
response.Headers["Last-Modified"] = new[] { propValue.ToString("R") };
}
return;
}
using (var stream = await _document.OpenReadAsync(ct).ConfigureAwait(false))
{
var content = new StreamContent(stream);
await SetPropertiesToContentHeaderAsync(content, properties, ct).ConfigureAwait(false);
foreach (var header in content.Headers)
{
response.Headers.Add(header.Key, header.Value.ToArray());
}
await content.CopyToAsync(response.Body).ConfigureAwait(false);
}
}
public static StreamContent CloneStreamContent(StreamContent content)
{
try
{
MemoryStream ms = new MemoryStream();
using (System.Threading.Tasks.Task task = content.CopyToAsync(ms))
{
task.Wait();
}
ms.Seek(0, SeekOrigin.Begin);
return(new StreamContent(ms));
}
catch { }
return(content);
}
public async Task <IHttpActionResult> AltUploadAsync()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.UnsupportedMediaType));
}
MultipartMemoryStreamProvider provider = await Request.Content.ReadAsMultipartAsync();
if (provider.Contents.Count != 1)
{
return(BadRequest("Request should contain exactly one pieces of content."));
}
StreamContent fileContent = provider.Contents[0] as StreamContent;
var headers = fileContent.Headers;
var fileName = headers.ContentDisposition.FileNameStar;
if (string.IsNullOrEmpty(fileName))
{
fileName = headers.ContentDisposition.FileName;
fileName = fileName.TrimStart('\"');
fileName = fileName.TrimEnd('\"');
}
string fullFileName = Directory + fileName;
using (FileStream fs = new FileStream(fullFileName, FileMode.Create))
{
await fileContent.CopyToAsync(fs);
await fs.FlushAsync();
Console.WriteLine("Successfully saved file: {0}", fullFileName);
}
Process.Start("explorer.exe", Path.GetDirectoryName(fullFileName));
var text = File.ReadAllText(fullFileName);
return(CreatedAtRoute(Route_Download, new { file = fileName }, text));
}
public async Task CopyToAsync_CallMultipleTimesWithStreamSupportingSeekingPartiallyConsumed_ContentIsSerializedMultipleTimesFromInitialPoint()
{
int consumed = 4;
var source = new MockStream(new byte[10], true, true); // supports seeking.
source.Read(new byte[consumed], 0, consumed);
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
Assert.Equal(source.Length - consumed, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(source.Length - consumed, destination2.Length);
}
/*
* 发送POST请求
*/
public static async Task <string> sendAsrPost(byte[] audioData, String audioFormat, int sampleRate, String url, String ak_id, String ak_secret)
{
String result = "";
Uri realUrl = new Uri(url);
/*
* http header 参数
*/
String method = "POST";
String accept = "application/json";
String content_type = "audio/" + audioFormat;// + ";samplerate=" + sampleRate;
int length = audioData.Length;
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
//注册GBK编码
Encoding encodingGbk = Encoding.GetEncoding("GBK");
DateTime time = DateTime.UtcNow;
String date = ToGMTString(time);
// 1.对body做MD5+BASE64加密
String bodyMd5 = MD5Base64(audioData);
String md52 = MD5Base64(encodingGbk.GetBytes(bodyMd5));
String stringToSign = method + "\n" + accept + "\n" + md52 + "\n" + content_type + "\n" + date;
// 2.计算 HMAC-SHA1
String signature = HMACSha1(stringToSign, ak_secret);
// 3.得到 authorization header
String authHeader = "Dataplus " + ak_id + ":" + signature;
using (var handler = new HttpClientHandler())
{
using (var client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Add("Method", method);
client.DefaultRequestHeaders.Add("Accept", accept);
client.DefaultRequestHeaders.Add("ContentType", content_type);
client.DefaultRequestHeaders.Add("ContentLength", audioData.Length.ToString());
client.DefaultRequestHeaders.Add("Authorization", authHeader);
client.DefaultRequestHeaders.Date = time;
using (Stream sr = new MemoryStream())
{
HttpContent httpContent = new StreamContent(sr);
httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content_type);
httpContent.Headers.ContentLength = audioData.Length;
sr.Write(audioData, 0, audioData.Length);
await httpContent.CopyToAsync(sr);
sr.Seek(0, SeekOrigin.Begin);
await sr.FlushAsync();
var httpResponseMessage = client.PostAsync(realUrl, httpContent).Result;
var contentType = httpResponseMessage.Content.Headers.ContentType.CharSet = "utf-8";
if (httpResponseMessage.EnsureSuccessStatusCode().StatusCode.ToString().ToLower() == "ok")
{
result = httpResponseMessage.Content.ReadAsStringAsync().Result;
}
}
client.Dispose();
}
}
return(result);
}
/*
* 发送POST请求
*/
public static async Task <string> sendTtsPost(String textData, String audioType, String audioName, String url, String ak_id, String ak_secret)
{
String result = "";
Uri realUrl = new Uri(url);
/*
* http header 参数
*/
String method = "POST";
String content_type = "text/plain";
String accept = "audio/" + audioType;// + ",application/json";
int length = textData.Length;
DateTime time = DateTime.UtcNow;
string date = ToGMTString(time);
// 1.对body做MD5+BASE64加密
String bodyMd5 = MD5Base64(Encoding.UTF8.GetBytes(textData));
String stringToSign = method + "\n" + accept + "\n" + bodyMd5 + "\n" + content_type + "\n" + date;
// 2.计算 HMAC-SHA1
String signature = HMACSha1(stringToSign, ak_secret);
// 3.得到 authorization header
String authHeader = "Dataplus " + ak_id + ":" + signature;
using (var handler = new HttpClientHandler())
{
using (var client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Add("Method", method);
client.DefaultRequestHeaders.Add("Accept", accept);
client.DefaultRequestHeaders.Add("ContentType", content_type);
client.DefaultRequestHeaders.Add("ContentLength", Encoding.UTF8.GetBytes(textData).Length.ToString());
client.DefaultRequestHeaders.Add("Authorization", authHeader);
client.DefaultRequestHeaders.Date = time;
using (Stream sr = new MemoryStream())
{
HttpContent httpContent = new StreamContent(sr);
httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content_type);
httpContent.Headers.ContentLength = Encoding.UTF8.GetBytes(textData).Length;
sr.Write(Encoding.UTF8.GetBytes(textData), 0, Encoding.UTF8.GetBytes(textData).Length);
await httpContent.CopyToAsync(sr);
sr.Seek(0, SeekOrigin.Begin);
await sr.FlushAsync();
var httpResponseMessage = client.PostAsync(realUrl, httpContent).Result;
var contentType = httpResponseMessage.Content.Headers.ContentType.CharSet = "utf-16";
if (httpResponseMessage.EnsureSuccessStatusCode().StatusCode.ToString().ToLower() == "ok")
{
string responseBody = httpResponseMessage.Content.ReadAsStringAsync().Result;
if (null != responseBody && 0 < responseBody.Length)
{
result = ApplicationData.Current.LocalFolder.Path + "/" + audioName + "." + audioType; //本地保存路径
using (FileStream fs = new FileStream(result, FileMode.Append))
{
var buff = Encoding.Unicode.GetBytes(responseBody);
fs.Write(buff, 0, buff.Length);
}
}
}
}
client.Dispose();
}
}
return(result);
}
/*
* 发送POST请求
*/
public static async void sendTtsPost(String textData, String audioType, String audioName, String url, String ak_id, String ak_secret)
{
HttpResponse response = new HttpResponse();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
//注册GBK编码
Encoding encodingGbk = Encoding.GetEncoding("GBK");
Encoding encodingUtf8 = Encoding.UTF8;
Encoding encodingUtf16 = Encoding.Unicode;
try
{
Uri realUrl = new Uri(url);
/*
* http header 参数
*/
String method = "POST";
String content_type = "text/plain";
String accept = "audio/" + audioType;// + ",application/json";
DateTime time = DateTime.UtcNow;
string date = ToGMTString(time);
// 1.对body做MD5+BASE64加密
String bodyMd5 = MD5Base64(encodingUtf8.GetBytes(textData));
String stringToSign = method + "\n" + accept + "\n" + bodyMd5 + "\n" + content_type + "\n" + date;
// 2.计算 HMAC-SHA1
String signature = HMACSha1(stringToSign, ak_secret);
// 3.得到 authorization header
String authHeader = "Dataplus " + ak_id + ":" + signature;
String authHeaders = ak_id + ":" + signature;
// Create a New HttpClient object.
using (var handler = new HttpClientHandler())
{
handler.ClientCertificateOptions = ClientCertificateOption.Automatic;
using (var client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Add("Method", method);
client.DefaultRequestHeaders.Add("Accept", accept);
client.DefaultRequestHeaders.Add("ContentType", content_type);
client.DefaultRequestHeaders.Add("ContentLength", encodingUtf8.GetBytes(textData).Length.ToString());
client.DefaultRequestHeaders.Add("Authorization", authHeader);
client.DefaultRequestHeaders.Date = time;
client.DefaultRequestHeaders.ExpectContinue = true;
client.Timeout = new TimeSpan(1, 0, 0);
using (Stream sr = new MemoryStream())
{
HttpContent httpContent = new StreamContent(sr);
httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(content_type);
httpContent.Headers.ContentLength = encodingUtf8.GetBytes(textData).Length;
sr.Write(encodingUtf8.GetBytes(textData), 0, encodingUtf8.GetBytes(textData).Length);
await httpContent.CopyToAsync(sr);
sr.Seek(0, SeekOrigin.Begin);
await sr.FlushAsync();
var httpResponseMessage = await client.PostAsync(realUrl, httpContent);
if (httpResponseMessage.EnsureSuccessStatusCode().StatusCode.ToString().ToLower() == "ok")
{
string responseBody = await httpResponseMessage.Content.ReadAsStringAsync();
LogTest.LogWrite("responseBody: ");
}
}
client.Dispose();
}
}
}
catch (Exception e)
{
int a = 0;
}
}
public async Task CopyToAsync_CallMultipleTimesWithStreamNotSupportingSeeking_ThrowsInvalidOperationException()
{
var source = new MockStream(new byte[10], false, true); // doesn't support seeking.
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
// Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable).
Assert.Equal(10, destination1.Length);
// Note that the InvalidOperationException is thrown in CopyToAsync(). It is not thrown inside the task.
var destination2 = new MemoryStream();
Assert.Throws<InvalidOperationException>(() => { Task t = content.CopyToAsync(destination2); });
}
public async Task CopyToAsync_CallMultipleTimesWithStreamNotSupportingSeekingButBufferedStreamPartiallyConsumed_ContentSerializedOnceToBuffer()
{
int consumed = 4;
var source = new MockStream(new byte[10], false, true); // doesn't support seeking.
source.Read(new byte[consumed], 0, consumed);
var content = new StreamContent(source);
// After loading the content into a buffer, we should be able to copy the content to a destination stream
// multiple times, even though the stream doesn't support seeking.
await content.LoadIntoBufferAsync();
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
// Use hardcoded expected length, since source.Length would throw (source stream gets disposed if non-seekable).
Assert.Equal(10 - consumed, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(10 - consumed, destination2.Length);
}
public void CopyToAsync_NullDestination_ThrowsArgumentnullException()
{
var source = new MockStream(new byte[10]);
var content = new StreamContent(source);
Assert.Throws<ArgumentNullException>(() => { Task t = content.CopyToAsync(null); });
}
public async Task CopyToAsync_CallMultipleTimesWithStreamSupportingSeeking_ContentIsSerializedMultipleTimes()
{
var source = new MockStream(new byte[10], true, true); // Supports seeking.
var content = new StreamContent(source);
var destination1 = new MemoryStream();
await content.CopyToAsync(destination1);
Assert.Equal(source.Length, destination1.Length);
var destination2 = new MemoryStream();
await content.CopyToAsync(destination2);
Assert.Equal(source.Length, destination2.Length);
}
