public WriteAsync ( Byte buffer, int offset, int count, CancellationToken cancellationToken ) : Task | ||
buffer | Byte | |
offset | int | |
count | int | |
cancellationToken | CancellationToken | |
Результат | Task |
private async Task WriteSection(int offsetPointer, int sizePointer, uint offset, uint size, byte[] section) { byte[] data = this.SafeGetBuffer(); uint oldSize = size; using (var ms = new IO.MemoryStream()) using (var bw = new IO.BinaryWriter(ms)) { // Write up to offset pointer await ms.WriteAsync(data, 0, offsetPointer); // Write new section coordinates bw.Write(offset); bw.Write((uint)section.Length); // Write up to beginning of section await ms.WriteAsync(data, sizePointer + SizeOfPointer, (int)(offset - (sizePointer + SizeOfPointer))); // Write new section await ms.WriteAsync(section, 0, section.Length); // Write stuff after old section await ms.WriteAsync(data, (int)(offset + oldSize), (int)(data.Length - (offset + oldSize))); this.buffer = ms.ToArray(); } }
private static async Task <byte[]> GetMultipartFormDataAsync(string boundary, byte[] imageBytes) { var encoding = Encoding.UTF8; Stream formDataStream = new System.IO.MemoryStream(); var fileName = Guid.NewGuid().ToString() + ".png"; // Add just the first part of this param, since we will write the file data directly to the Stream string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\"\r\nContent-Type: {3}\r\n\r\n", boundary, "source", fileName, "image/png"); await formDataStream.WriteAsync(encoding.GetBytes(header), 0, encoding.GetByteCount(header)); // Write the file data directly to the Stream, rather than serializing it to a string. await formDataStream.WriteAsync(imageBytes, 0, imageBytes.Length); // Add the end of the request. Start with a newline string footer = "\r\n--" + boundary + "--\r\n"; await formDataStream.WriteAsync(encoding.GetBytes(footer), 0, encoding.GetByteCount(footer)); // Dump the Stream into a byte[] formDataStream.Position = 0; byte[] formData = new byte[formDataStream.Length]; await formDataStream.ReadAsync(formData, 0, formData.Length); formDataStream.Close(); return(formData); }
public async Task<byte[]> ReceieveMessageAsync() { if (IsDisposed) throw new ObjectDisposedException(nameof(Connection)); if (!ConnectionStream.CanRead) throw new AccessViolationException(nameof(ConnectionStream)); int size; using (var stream = new MemoryStream()) { var message = new byte[4]; while (stream.Length < 4 && ConnectionStream.CanRead) { int receieved = await ConnectionStream.ReadAsync(message, 0, 4 - Convert.ToInt32(stream.Length)); await stream.WriteAsync(message, 0, receieved); } size = BitConverter.ToInt32(stream.ToArray(), 0); } if (!ConnectionStream.CanRead) throw new AccessViolationException(nameof(ConnectionStream)); if (size > MaxSize) return null; using (var stream = new MemoryStream()) { var buffer = new byte[512]; while (stream.Length < size) { if (!ConnectionStream.CanRead) throw new AccessViolationException(nameof(ConnectionStream)); var receieved = await ConnectionStream.ReadAsync(buffer, 0, size - Convert.ToInt32(stream.Length)); await stream.WriteAsync(buffer, 0, receieved); } return stream.ToArray(); } }
public async Task<string> LoadFirstLinesFromDiskAsync(string fileName, int lineCount, SecureString passphrase) { using (var inputStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) { using (var outputStream = new MemoryStream()) { var password = SecureStringCredentialStore.SecureStringToString(passphrase); using (var cryptoStream = CipherStream.Open(inputStream, password)) { while (cryptoStream.CanRead) { var buffer = new byte[4096]; await cryptoStream.ReadAsync(buffer, 0, 4096); await outputStream.WriteAsync(buffer, 0, 4096); char[] chunk = Encoding.UTF8.GetChars(buffer); var occurances = chunk.Count(c => c == '\n'); if (occurances >= lineCount) break; } } outputStream.Position = 0; using (var reader = new StreamReader(outputStream)) { return await reader.ReadToEndAsync(); } } } }
public async Task ReadStateAsync(string grainType, GrainReference grainReference, IGrainState grainState) { var tableResult = await _table.ExecuteAsync(TableOperation.Retrieve<DynamicTableEntity>(grainReference.ToKeyString(), grainType)); if (tableResult.Result == null) { return; } var entity = tableResult.Result as DynamicTableEntity; var serializer = new JsonSerializer(); using (var memoryStream = new MemoryStream()) { foreach (var propertyName in entity.Properties.Keys.Where(p => p.StartsWith("d")).OrderBy(p => p)) { var dataPart = entity.Properties[propertyName]; await memoryStream.WriteAsync(dataPart.BinaryValue, 0, dataPart.BinaryValue.Length); } memoryStream.Position = 0; using (var bsonReader = new BsonReader(memoryStream)) { var data = serializer.Deserialize<Dictionary<string, object>>(bsonReader); grainState.SetAll(data); } } }
private async static Task<byte[]> AliceSendsData(string message) { Console.WriteLine("Alice send message {0}", message); byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using(var aliceAlgo = new ECDiffieHellmanCng(aliceKey)) { using(CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.GenericPublicBlob)) { byte[] symmKey = aliceAlgo.DeriveKeyMaterial(bobPubKey); Console.WriteLine("Alice create this symm key with Bobs public key information : {0}", Convert.ToBase64String(symmKey)); using(var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using(ICryptoTransform encryptor = aes.CreateEncryptor()) { using(MemoryStream ms = new MemoryStream()) { var cs = new CryptoStream(ms, encryptor,CryptoStreamMode.Write); await ms.WriteAsync(aes.IV, 0, aes.IV.Length); cs.Write(rawData, 0, rawData.Length); cs.Close(); encryptedData = ms.ToArray(); } } aes.Clear(); } } } Console.WriteLine("Alice message is encrypted : {0}", Convert.ToBase64String(encryptedData)); return encryptedData; }
public async Task<byte[]> PackAsync(ICollection<ClientFile> files) { if (files == null) throw new ArgumentNullException("files"); if (files.Count == 0) throw new ArgumentOutOfRangeException("files"); var header = new StringBuilder(); var totalBuffer = new byte[files.Select(f => f.Data.Length).Sum()]; using (var output = new MemoryStream(totalBuffer)) { foreach (var f in files) { var data = f.Data; await output.WriteAsync(data, 0, data.Length); if (header.Length > 0) { header.Append(FileSeparator); } header.Append(f.Name); header.Append(SizeSeparator); header.Append(data.Length); } var headerData = Encoding.Unicode.GetBytes(header.ToString()); var headerSize = BitConverter.GetBytes(headerData.Length); return Utilities.Concat(headerSize, headerData, totalBuffer); } }
public async Task<HttpResponseMessage> Get(string key) { var cachedItem = MemoryCache.Default.Get(key) as byte[]; if(cachedItem == null) { return new HttpResponseMessage(HttpStatusCode.NoContent); } Stream stream = null; if (cachedItem != null) { stream = new MemoryStream(); await stream.WriteAsync(cachedItem, 0, cachedItem.Length); stream.Position = 0; } //var content = new PushStreamContent(async (stream, httpContent, transportContext) => //{ // await stream.WriteAsync(cachedItem, 0, cachedItem.Length); // stream.Close(); //}); var content = new StreamContent(stream); return new HttpResponseMessage() { Content = content }; }
/// <summary> /// Read a thumbnail in metadata from byte array. /// </summary> /// <param name="bytes">Byte array</param> /// <returns>BitmapImage of thumbnail</returns> internal static async Task<BitmapImage> ReadThumbnailAsync(byte[] bytes) { if ((bytes == null) || !bytes.Any()) throw new ArgumentNullException("bytes"); try { using (var ms = new MemoryStream()) { await ms.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false); // If continued by ContinueWith, an exception will not be caught by try-catch block in debug mode. return ReadThumbnailFromExifByImaging(ms); } } catch (Exception ex) { Debug.WriteLine("Failed to read a thumbnail. {0}", ex); if (IsImageNotSupported(ex)) throw new ImageNotSupportedException(); throw; } }
private static async Task<byte[]> AssembleFile(string filePath) { byte[] buffer; using (var resultStream = new MemoryStream()) { var content = string.Format("Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"{2}", Guid.NewGuid(), Path.GetFileName(filePath), Environment.NewLine); buffer = Encoding.UTF8.GetBytes(content); await resultStream.WriteAsync(buffer, 0, buffer.Length); content = "Content-Type: application/octet-stream" + Environment.NewLine + Environment.NewLine; buffer = Encoding.UTF8.GetBytes(content); await resultStream.WriteAsync(buffer, 0, buffer.Length); buffer = IOFile.ReadAllBytes(filePath); await resultStream.WriteAsync(buffer, 0, buffer.Length); buffer = Encoding.UTF8.GetBytes(Environment.NewLine); await resultStream.WriteAsync(buffer, 0, buffer.Length); await resultStream.FlushAsync(); buffer = resultStream.ToArray(); } return buffer; }
public static async Task<byte[]> ToByteArrayAsync(this ArraySegment<byte> source) { byte[] data = null; using (MemoryStream ms = new MemoryStream()) { await ms.WriteAsync(source.Array, source.Offset, source.Count); await ms.FlushAsync(); data = ms.ToArray(); } return data; }
public static async Task UploadTextAsync(ICloudBlob blob, string text, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { byte[] textAsBytes = encoding.GetBytes(text); using (MemoryStream stream = new MemoryStream()) { await stream.WriteAsync(textAsBytes, 0, textAsBytes.Length); if (blob.BlobType == BlobType.PageBlob) { int lastPageSize = (int)(stream.Length % 512); if (lastPageSize != 0) { byte[] padding = new byte[512 - lastPageSize]; await stream.WriteAsync(padding, 0, padding.Length); } } stream.Seek(0, SeekOrigin.Begin); await blob.UploadFromStreamAsync(stream.AsInputStream(), accessCondition, options, operationContext); } }
private async Task<DataHeader> GetDataHeader(byte[] btarrHeader) { BinaryFormatter objFormatter = new BinaryFormatter(); DataHeader objHeader; using(MemoryStream objStream = new MemoryStream()) { await objStream.WriteAsync(btarrHeader, 0, btarrHeader.Length); objStream.Position = 0; objHeader = (DataHeader)objFormatter.Deserialize(objStream); } return objHeader; }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> public static async Task<byte[]> ReadToEndAsByteAsync(this Stream stream) { var buffer = new byte[16 * 1024]; using (var ms = new MemoryStream()) { int read; while ((read = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0) { await ms.WriteAsync(buffer, 0, read); } return ms.ToArray(); } }
private async Task ProcessingStreets(byte[] btarrResponse) { BinaryFormatter objFormatter = new BinaryFormatter(); using(MemoryStream objStream = new MemoryStream()) { await objStream.WriteAsync(btarrResponse, 0, btarrResponse.Length); objStream.Position = 0; List<Street> objStreets = (List<Street>)objFormatter.Deserialize(objStream); ShowStreets(objStreets); } }
private async Task ProcessingImage(byte[] btarrResponse) { Bitmap objBitMap; BinaryFormatter objFormatter = new BinaryFormatter(); using(MemoryStream objStream = new MemoryStream()) { await objStream.WriteAsync(btarrResponse, 0, btarrResponse.Length); objStream.Position = 0; objBitMap = (Bitmap)objFormatter.Deserialize(objStream); objBitMap.Save(@"D:\screenshot.jpg"); } }
public static async Task<Stream> CreateTempCopyStream(String path) { var bytes = File.ReadAllBytes(path); var ms = new MemoryStream(); await ms.WriteAsync(bytes, 0, bytes.Length); ms.Position = 0; return ms; }
private async Task <byte[]> GetSection(uint offset, uint size) { byte[] data = this.SafeGetBuffer(); using (var ms = new IO.MemoryStream()) { await ms.WriteAsync(data, (int)offset, (int)size); return(ms.ToArray()); } }
public static async Task<Stream> ReadStream(this IStorageFile file) { using (var stream = await file.OpenStreamForReadAsync()) { var bytes = new byte[stream.Length]; await stream.ReadAsync(bytes, 0, (int)stream.Length); var memoryStream = new MemoryStream(); await memoryStream.WriteAsync(bytes, 0, bytes.Length); return memoryStream; } }
public async Task<Stream> GetStream(string key) { var file = await GetStorageFile(key); using (var stream = await file.OpenStreamForReadAsync()) { var bytes = new byte[stream.Length]; await stream.ReadAsync(bytes, 0, (int)stream.Length); var memoryStream = new MemoryStream(); await memoryStream.WriteAsync(bytes, 0, bytes.Length); return memoryStream; } }
public static byte[] ReadFully(Stream input) { byte[] buffer = new byte[16 * 1024]; using (MemoryStream ms = new MemoryStream()) { int read; while ((read = input.Read(buffer, 0, buffer.Length)) > 0) { ms.WriteAsync(buffer, 0, read); } return ms.ToArray(); } }
private static async Task<byte[]> ReadAllBytes(Stream input) { byte[] buffer = new byte[16 * 1024]; using (MemoryStream ms = new MemoryStream()) { int read; while ((read = await input.ReadAsync(buffer, 0, buffer.Length)) > 0) { await ms.WriteAsync(buffer, 0, read); } return ms.ToArray(); } }
internal System.IO.MemoryStream Save <T>(T data) { string json = JsonConvert.SerializeObject(data); return(Task.Run <System.IO.MemoryStream>(() => { System.IO.MemoryStream stream = new System.IO.MemoryStream(); byte[] d = Serialization.WriteString(json); stream.WriteAsync(d, 0, d.Length); return stream; }).Result); }
public async Task<IHttpActionResult> S3UploadTest() { IS3Provider<S3ApiModel> amazon = new S3Client(); Stream testStream = new MemoryStream(); byte[] data = File.ReadAllBytes(HttpContext.Current.Server.MapPath("~/test.pdf")); await testStream.WriteAsync(data, 0, data.Count()); var obj = await amazon.CreateRequest(testStream, ".pdf").SaveObject(); return this.Ok(new ApiResponse(200, obj)); }
public static async Task UploadTextAsync(CloudBlob blob, string text, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { byte[] textAsBytes = encoding.GetBytes(text); using (MemoryStream stream = new MemoryStream()) { await stream.WriteAsync(textAsBytes, 0, textAsBytes.Length); if (blob.BlobType == BlobType.PageBlob) { int lastPageSize = (int)(stream.Length % 512); if (lastPageSize != 0) { byte[] padding = new byte[512 - lastPageSize]; await stream.WriteAsync(padding, 0, padding.Length); } } stream.Seek(0, SeekOrigin.Begin); blob.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; if (blob.BlobType == BlobType.AppendBlob) { CloudAppendBlob blob1 = blob as CloudAppendBlob; await blob1.CreateOrReplaceAsync(); await blob1.AppendBlockAsync(stream, null); } else if (blob.BlobType == BlobType.PageBlob) { CloudPageBlob pageBlob = blob as CloudPageBlob; await pageBlob.UploadFromStreamAsync(stream, accessCondition, options, operationContext); } else { CloudBlockBlob blockBlob = blob as CloudBlockBlob; await blockBlob.UploadFromStreamAsync(stream, accessCondition, options, operationContext); } } }
public async Task<byte[]> SendReceiveAsync(byte[] payload) { byte[] receiveBytes = new byte[10240]; // Send request operation await this.clientWebSocket.SendAsync(new ArraySegment<byte>(payload), WebSocketMessageType.Binary, true, CancellationToken.None); WebSocketReceiveResult receiveResult = await this.clientWebSocket.ReceiveAsync(new ArraySegment<byte>(receiveBytes), CancellationToken.None); using (MemoryStream ms = new MemoryStream()) { await ms.WriteAsync(receiveBytes, 0, receiveResult.Count); return ms.ToArray(); } }
public async Task<byte[]> Run(int port) { var listener = new TcpListener(IPAddress.Any, port); listener.Start(); var client = await listener.AcceptTcpClientAsync(); var ms = new MemoryStream(); using (var stream = client.GetStream()) { var data = new byte[4096]; var x = await stream.ReadAsync(data, 0, data.Length); await ms.WriteAsync(data, 0, x); } return ms.ToArray(); }
public static async Task<byte[]> ReadToEndAsync(this Stream stream) { var buffer = new byte[1024 * 1024]; using (var memoryStream = new MemoryStream()) { while (true) { var read = await stream.ReadAsync(buffer, 0, buffer.Length); if (read <= 0) break; await memoryStream.WriteAsync(buffer, 0, read); } return memoryStream.ToArray(); } }
public static async Task<MemoryStream> UnEncode(MemoryStream encodedContent, string transferEncoding) { var unEncodedContent = new MemoryStream(); try { switch (transferEncoding.ToLower()) { case "7bit": case "8bit": case "binary": unEncodedContent = encodedContent; break; case "quoted-printable": unEncodedContent = MailMethods.FromQuotedPrintable(encodedContent); break; case "base64": var base64String = Encoding.ASCII.GetString(encodedContent.ToArray()); var bytes = Convert.FromBase64String(base64String); await unEncodedContent.WriteAsync(bytes, 0, bytes.Length); break; default: using (var writer = new StreamWriter(unEncodedContent, Encoding.ASCII)) { writer.WriteLine("Unknown 'Content-transfer-encoding' encounterd: {0}", transferEncoding); writer.WriteLine("------Encoded Content-------"); await writer.FlushAsync(); await encodedContent.CopyToAsync(unEncodedContent); } break; } return unEncodedContent; } catch (Exception ex) { using (var writer = new StreamWriter(unEncodedContent, Encoding.ASCII)) { writer.WriteLine(ex.Message); writer.WriteLine("------Encoded Content-------"); await writer.FlushAsync(); await encodedContent.CopyToAsync(unEncodedContent); return unEncodedContent; } } }
public async Task LoadAlbumsFromMediaLibraryAsync(PictureAlbum album, CancellationToken token) { ObservableCollection<CollectionControlModel> newItems = new ObservableCollection<CollectionControlModel>(); foreach (var photo in album.Pictures) { Log(photo.Name); // await Task.Delay(new TimeSpan(0,0,0,0,10)); token.ThrowIfCancellationRequested(); Log(photo.Name + "50"); newItems.Add(new CollectionControlModel() { FileName = Path.GetFileNameWithoutExtension(photo.Name), Data = photo }); Log(photo.Name); token.ThrowIfCancellationRequested(); using (Stream str = photo.GetThumbnail()) { Log(photo.Name + "60"); byte[] buffer = new byte[str.Length]; await str.ReadAsync(buffer, 0, buffer.Length); Log(photo.Name + "63"); token.ThrowIfCancellationRequested(); using (MemoryStream ms = new MemoryStream()) { Log(photo.Name + "67"); await ms.WriteAsync(buffer, 0, buffer.Length); token.ThrowIfCancellationRequested(); newItems.Last().Thumbnail = new BitmapImage(); newItems.Last().Thumbnail.SetSource(ms); Log(photo.Name + "72"); } //await Task.Delay(new TimeSpan(0, 0, 0, 0, 10)); //Thread.Sleep(1000); } } foreach (var item in newItems) { Items.Add(item); } }
public void SetImage(BiometricType bio) { if (bio == null) return; byte[] photo = bio.data; if (photo == null || photo.Length == 0) { return; } var memStream = new MemoryStream(); Task t = memStream.WriteAsync(photo, 0, photo.Length); t.ContinueWith(result => { memStream.Position = 0; this.photo.Image = Image.FromStream(memStream, true, true); this.photo.SizeMode = PictureBoxSizeMode.StretchImage; }); }
private async Task<BandImage> CreateMeTileAsync(CancellationToken cancel) { byte[] imgData = Convert.FromBase64String(base64ImageString); byte[] rgb565 = null; // convert image data to bgr 565 format... // first write data to a memory stream.. using (var ms = new MemoryStream()) { await ms.WriteAsync(imgData, 0, imgData.Length, cancel); ms.Position = 0; rgb565 = ms.GetPixelArrayBgr565(); } var ti = typeof(BandImage).GetTypeInfo(); var ctor = ti.DeclaredConstructors.First(); var bi = (BandImage)ctor.Invoke(new object[] { 310, 102, rgb565 }); return bi; }
private void InitSamples() { samples = new List<MemoryStream>(); for(int i = 0; i < KeyCount; i++) { string address = "Assets/Piano Keys/Piano" + i.ToString(); using (FileStream fStream = new FileStream(address, FileMode.Open)) { using (MemoryStream ms = new MemoryStream()) { byte[] buffer = new byte[fStream.Length]; fStream.ReadAsync(buffer,0, buffer.Length); ms.WriteAsync(buffer,0,buffer.Length); ms.Seek(0, SeekOrigin.Begin); ms.Close(); samples.Add(ms); } fStream.Close(); } } }
private async Task<byte[]> AliceSendsDataAsync(string message) { WriteLine($"Alice sends message: {message}"); byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using (var aliceAlgorithm = new ECDiffieHellmanCng(_aliceKey)) using (CngKey bobPubKey = CngKey.Import(_bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob)) { byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey); WriteLine("Alice creates this symmetric key with " + $"Bobs public key information: { Convert.ToBase64String(symmKey)}"); using (var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using (ICryptoTransform encryptor = aes.CreateEncryptor()) using (var ms = new MemoryStream()) { // create CryptoStream and encrypt data to send using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { // write initialization vector not encrypted await ms.WriteAsync(aes.IV, 0, aes.IV.Length); await cs.WriteAsync(rawData, 0, rawData.Length); } encryptedData = ms.ToArray(); } aes.Clear(); } } WriteLine($"Alice: message is encrypted: {Convert.ToBase64String(encryptedData)}"); ; WriteLine(); return encryptedData; }
private static async Task <byte[]> GetMultipartMixedFormDataAsync(string boundary, byte[] postQueryData = null, byte[] postData = null, bool isOctet = false) { var encoding = Encoding.UTF8; Stream formDataStream = new System.IO.MemoryStream(); if (postQueryData != null && postQueryData.Length > 0) { // adds url query to the body // https://docs.microsoft.com/en-us/linkedin/shared/api-guide/concepts/query-tunneling string queryHeader = $"--{boundary}\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n"; await formDataStream.WriteAsync(encoding.GetBytes(queryHeader), 0, encoding.GetByteCount(queryHeader)); await formDataStream.WriteAsync(postQueryData, 0, postQueryData.Length); string queryBoundary = $"\r\n--{boundary}\r\n"; await formDataStream.WriteAsync(encoding.GetBytes(queryBoundary), 0, encoding.GetByteCount(queryBoundary)); } if (postData != null && postData.Length > 0) { // adds post data to the body string postHeader = $"--{boundary}\r\nContent-Type: application/json\r\n\r\n"; if (isOctet) { // adds asset data to the body postHeader = $"--{boundary}\r\nContent-Type: application/octet-stream\r\n\r\n"; } await formDataStream.WriteAsync(encoding.GetBytes(postHeader), 0, encoding.GetByteCount(postHeader)); // Write the file data directly to the Stream, rather than serializing it to a string. await formDataStream.WriteAsync(postData, 0, postData.Length); string postBoundary = $"\r\n--{boundary}--\r\n"; await formDataStream.WriteAsync(encoding.GetBytes(postBoundary), 0, encoding.GetByteCount(postBoundary)); } // Dump the Stream into a byte[] formDataStream.Position = 0; byte[] formData = new byte[formDataStream.Length]; await formDataStream.ReadAsync(formData, 0, formData.Length); formDataStream.Close(); return(formData); }
static private async Task <Stream> GetFileStream(string authHeader, string destinationFileName, FileContextInfo fileContextInfo) { var filePath = new Uri(destinationFileName).AbsolutePath; var stream = new System.IO.MemoryStream(); try { using (var client = new WebClient()) { client.Headers.Add(HttpRequestHeader.Authorization, authHeader); var fileUri = new Uri(destinationFileName); var downloadData = await client.DownloadDataTaskAsync($"{fileContextInfo.WebUrl}/_api/web/getfilebyserverrelativeurl('{filePath}')/$value"); await stream.WriteAsync(downloadData, 0, downloadData.Length); return(stream); } } catch (Exception ex) { stream.Dispose(); throw ex; } }
async private void WriteMemoryStream(System.IO.MemoryStream stream, byte[] data) { await stream.WriteAsync(data, 0, data.Length); }