Merge pull request #581 from danielmarbach/performance-breaking

Avoid Task.Run and Factory.StartNew with async

Author: erezvani1529

Lib/AspNet/Microsoft.WindowsAzure.Storage/Extensions/StreamExtension.cs

@@ -71,9 +71,9 @@ public static Stream AsStreamForWrite(this Stream stream)
         /// <param name="stream">input stream</param>
         /// <param name="buffer">buffer to write to the stream</param>
         /// <returns>Async task</returns>
-        public static async Task WriteAsync(this Stream stream, byte[] buffer)
+        public static Task WriteAsync(this Stream stream, byte[] buffer)
         {
-            await stream.WriteAsync(buffer, 0, buffer.Length);
+            return stream.WriteAsync(buffer, 0, buffer.Length);
         }
 
         /// <summary>

Lib/ClassLibraryCommon/Table/Protocol/HttpResponseAdapterMessage.cs

@@ -27,7 +27,7 @@ namespace Microsoft.WindowsAzure.Storage.Table.Protocol
     internal class HttpResponseAdapterMessage : IODataResponseMessage
     {
         private HttpWebResponse resp = null;
-        private Stream str = null;
+        private Task<Stream> strAsCachedTask = null;
         private string responseContentType = null;
 
         public HttpResponseAdapterMessage(HttpWebResponse resp, Stream str)
@@ -38,13 +38,13 @@ public HttpResponseAdapterMessage(HttpWebResponse resp, Stream str)
         public HttpResponseAdapterMessage(HttpWebResponse resp, Stream str, string responseContentType)
         {
             this.resp = resp;
-            this.str = str;
+            this.strAsCachedTask = Task.FromResult(str);
             this.responseContentType = responseContentType;
         }
 
         public Task<Stream> GetStreamAsync()
         {
-            return Task.Factory.StartNew(() => this.str);
+            return this.strAsCachedTask;
         }
 
         public string GetHeader(string headerName)
@@ -73,7 +73,7 @@ public string GetHeader(string headerName)
 
         public Stream GetStream()
         {
-            return this.str;
+            return this.strAsCachedTask.Result; // safe since completed task and avoids additional field for stream
         }
 
         public IEnumerable<KeyValuePair<string, string>> Headers

Lib/Common/Core/MultiBufferMemoryStream.cs

@@ -572,7 +572,7 @@ public async Task FastCopyToAsync(Stream destination, DateTime? expiryTime)
 
                     // Copy the block
                     int blockReadLength = (int)Math.Min(leftToRead, currentBlock.Count);
-                    await destination.WriteAsync(currentBlock.Array, currentBlock.Offset, blockReadLength);
+                    await destination.WriteAsync(currentBlock.Array, currentBlock.Offset, blockReadLength).ConfigureAwait(false);
 
                     this.AdvancePosition(ref leftToRead, blockReadLength);
                 }

Lib/Common/Core/NullType.cs

@@ -15,6 +15,8 @@
 // </copyright>
 //-----------------------------------------------------------------------
 
+using System.Threading.Tasks;
+
 namespace Microsoft.WindowsAzure.Storage.Core
 {
     /// <summary>
@@ -27,6 +29,11 @@ public sealed class NullType
         /// </summary>
         internal static readonly NullType Value = new NullType();
 
+        /// <summary>
+        /// Represents a no-return from a task.
+        /// </summary>
+        internal static readonly Task<NullType> ValueTask = Task.FromResult(Value);
+
         /// <summary>
         /// Prevents a default instance of the <see cref="NullType"/> class from being created.
         /// </summary>

Lib/Common/Core/Util/Exceptions.cs

@@ -68,7 +68,7 @@ internal async static Task<StorageException> PopulateStorageExceptionFromHttpRes
                     }
                     else
                     {
-                        currentResult.ExtendedErrorInformation = await StorageExtendedErrorInformation.ReadFromStreamAsync(errStream.AsInputStream());
+                        currentResult.ExtendedErrorInformation = await StorageExtendedErrorInformation.ReadFromStreamAsync(errStream.AsInputStream()).ConfigureAwait(false);
                     }
                 }
                 catch (Exception)

Lib/Common/StorageExtendedErrorInformation.cs

@@ -77,9 +77,9 @@ public static StorageExtendedErrorInformation ReadFromStream(IInputStream inputS
             return ReadFromStream(inputStream.AsStreamForRead());
         }
 
-        public static async Task<StorageExtendedErrorInformation> ReadFromStreamAsync(IInputStream inputStream)
+        public static Task<StorageExtendedErrorInformation> ReadFromStreamAsync(IInputStream inputStream)
         {
-            return await ReadFromStreamAsync(inputStream.AsStreamForRead());
+            return ReadFromStreamAsync(inputStream.AsStreamForRead());
         }
 #endif
 
@@ -139,7 +139,7 @@ public static async Task<StorageExtendedErrorInformation> ReadFromStreamAsync(St
 
                 using (XmlReader reader = XmlReader.Create(inputStream, settings))
                 {
-                    await reader.ReadAsync();
+                    await reader.ReadAsync().ConfigureAwait(false);
                     extendedErrorInfo.ReadXml(reader);
                 }
 

Lib/WindowsDesktop/Table/DataServices/DataServicesResponseAdapterMessage.cs

@@ -26,7 +26,7 @@ namespace Microsoft.WindowsAzure.Storage.Table.DataServices
     internal class DataServicesResponseAdapterMessage : IODataResponseMessage
     {
         private IDictionary<string, string> responseHeaders;
-        private Stream inputStream = null;
+        private Task<Stream> inputStreamAsCachedTask = null;
         private string responseContentType = null;
 
         public DataServicesResponseAdapterMessage(Dictionary<string, string> responseHeaders, Stream inputStream)
@@ -37,13 +37,13 @@ public DataServicesResponseAdapterMessage(Dictionary<string, string> responseHea
         public DataServicesResponseAdapterMessage(IDictionary<string, string> responseHeaders, Stream inputStream, string responseContentType)
         {
             this.responseHeaders = responseHeaders;
-            this.inputStream = inputStream;
+            this.inputStreamAsCachedTask = Task.FromResult(inputStream);
             this.responseContentType = responseContentType;
         }
 
         public Task<Stream> GetStreamAsync()
         {
-            return Task.Factory.StartNew(() => this.inputStream);
+            return inputStreamAsCachedTask;
         }
 
         public string GetHeader(string headerName)
@@ -77,7 +77,7 @@ public string GetHeader(string headerName)
 
         public Stream GetStream()
         {
-            return this.inputStream;
+            return this.inputStreamAsCachedTask.Result; // safe since completed task and avoids additional field for stream
         }
 
         public IEnumerable<KeyValuePair<string, string>> Headers

Lib/WindowsRuntime/Blob/BlobReadStream.cs

@@ -95,7 +95,7 @@ public override int Read(byte[] buffer, int offset, int count)
         /// <param name="count">The maximum number of bytes to read.</param>
         /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A task that represents the asynchronous read operation.</returns>
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             CommonUtility.AssertNotNull("buffer", buffer);
             CommonUtility.AssertInBounds("offset", offset, 0, buffer.Length);
@@ -108,16 +108,16 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
 
             if ((this.currentOffset == this.Length) || (count == 0))
             {
-                return 0;
+                return Task.FromResult(0);
             }
 
             int readCount = this.ConsumeBuffer(buffer, offset, count);
             if (readCount > 0)
             {
-                return readCount;
+                return Task.FromResult(readCount);
             }
 
-            return await this.DispatchReadAsync(buffer, offset, count);
+            return this.DispatchReadAsync(buffer, offset, count);
         }
 
         /// <summary>
@@ -140,7 +140,7 @@ await this.blob.DownloadRangeToStreamAsync(
                     this.GetReadSize(),
                     this.accessCondition,
                     this.options,
-                    this.operationContext);
+                    this.operationContext).ConfigureAwait(false);
 
                 this.internalBuffer.Seek(0, SeekOrigin.Begin);
                 return this.ConsumeBuffer(buffer, offset, count);

Lib/WindowsRuntime/Blob/BlobWriteStream.cs

@@ -158,7 +158,7 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
 
                 if (bytesToWrite == maxBytesToWrite)
                 {
-                    await this.DispatchWriteAsync();
+                    await this.DispatchWriteAsync().ConfigureAwait(false);
                 }
             }
         }
@@ -188,7 +188,7 @@ public override async Task FlushAsync(CancellationToken cancellationToken)
                 throw new InvalidOperationException(SR.BlobStreamAlreadyCommitted);
             }
 
-            await this.DispatchWriteAsync();
+            await this.DispatchWriteAsync().ConfigureAwait(false);
             await Task.Run(() => this.noPendingWritesEvent.Wait(), cancellationToken);
 
             if (this.lastException != null)
@@ -225,7 +225,7 @@ protected override void Dispose(bool disposing)
         /// <returns>A task that represents the asynchronous commit operation.</returns>
         public override async Task CommitAsync()
         {
-            await this.FlushAsync();
+            await this.FlushAsync().ConfigureAwait(false);
             this.committed = true;
 
             try
@@ -237,14 +237,14 @@ public override async Task CommitAsync()
                         this.blockBlob.Properties.ContentMD5 = this.blobMD5.ComputeHash();
                     }
 
-                    await this.blockBlob.PutBlockListAsync(this.blockList, this.accessCondition, this.options, this.operationContext);
+                    await this.blockBlob.PutBlockListAsync(this.blockList, this.accessCondition, this.options, this.operationContext).ConfigureAwait(false);
                 }
                 else
                 {
                     if (this.blobMD5 != null)
                     {
                         this.Blob.Properties.ContentMD5 = this.blobMD5.ComputeHash();
-                        await this.Blob.SetPropertiesAsync(this.accessCondition, this.options, this.operationContext);
+                        await this.Blob.SetPropertiesAsync(this.accessCondition, this.options, this.operationContext).ConfigureAwait(false);
                     }
                 }
             }
@@ -282,7 +282,7 @@ private async Task DispatchWriteAsync()
             {
                 string blockId = this.GetCurrentBlockId();
                 this.blockList.Add(blockId);
-                await this.WriteBlockAsync(bufferToUpload, blockId, bufferMD5);
+                await this.WriteBlockAsync(bufferToUpload, blockId, bufferMD5).ConfigureAwait(false);
             }
             else if (this.pageBlob != null)
             {
@@ -294,7 +294,7 @@ private async Task DispatchWriteAsync()
 
                 long offset = this.currentBlobOffset;
                 this.currentBlobOffset += bufferToUpload.Length;
-                await this.WritePagesAsync(bufferToUpload, offset, bufferMD5);
+                await this.WritePagesAsync(bufferToUpload, offset, bufferMD5).ConfigureAwait(false);
             }
             else
             {
@@ -310,7 +310,7 @@ private async Task DispatchWriteAsync()
                     throw this.lastException;
                 }
 
-                await this.WriteAppendBlockAsync(bufferToUpload, offset, bufferMD5);
+                await this.WriteAppendBlockAsync(bufferToUpload, offset, bufferMD5).ConfigureAwait(false);
             }
         }
 
@@ -324,7 +324,7 @@ private async Task DispatchWriteAsync()
         private async Task WriteBlockAsync(Stream blockData, string blockId, string blockMD5)
         {
             this.noPendingWritesEvent.Increment();
-            await this.parallelOperationSemaphore.WaitAsync();
+            await this.parallelOperationSemaphore.WaitAsync().ConfigureAwait(false);
             Task putBlockTask = this.blockBlob.PutBlockAsync(blockId, blockData, blockMD5, this.accessCondition, this.options, this.operationContext).ContinueWith(task =>
             {
                 if (task.Exception != null)
@@ -347,7 +347,7 @@ private async Task WriteBlockAsync(Stream blockData, string blockId, string bloc
         private async Task WritePagesAsync(Stream pageData, long offset, string contentMD5)
         {
             this.noPendingWritesEvent.Increment();
-            await this.parallelOperationSemaphore.WaitAsync();
+            await this.parallelOperationSemaphore.WaitAsync().ConfigureAwait(false);
             Task writePagesTask = this.pageBlob.WritePagesAsync(pageData, offset, contentMD5, this.accessCondition, this.options, this.operationContext).ContinueWith(task =>
             {
                 if (task.Exception != null)
@@ -372,7 +372,7 @@ private async Task WritePagesAsync(Stream pageData, long offset, string contentM
         private async Task WriteAppendBlockAsync(Stream blockData, long offset, string blockMD5)
         {
             this.noPendingWritesEvent.Increment();
-            await this.parallelOperationSemaphore.WaitAsync();
+            await this.parallelOperationSemaphore.WaitAsync().ConfigureAwait(false);
 
             this.accessCondition.IfAppendPositionEqual = offset;