diff --git a/src/Microsoft.OData.Client/Microsoft.OData.Client.csproj b/src/Microsoft.OData.Client/Microsoft.OData.Client.csproj
index bb410b077e..fa607c9b26 100644
--- a/src/Microsoft.OData.Client/Microsoft.OData.Client.csproj
+++ b/src/Microsoft.OData.Client/Microsoft.OData.Client.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <AssemblyName>Microsoft.OData.Client</AssemblyName>
     <RootNamespace>Microsoft.OData.Client</RootNamespace>
     <DocumentationFile>$(AssemblyName).xml</DocumentationFile>
diff --git a/src/Microsoft.OData.Core/Json/BufferingJsonReader.cs b/src/Microsoft.OData.Core/Json/BufferingJsonReader.cs
index 4a977af36b..5b8074f594 100644
--- a/src/Microsoft.OData.Core/Json/BufferingJsonReader.cs
+++ b/src/Microsoft.OData.Core/Json/BufferingJsonReader.cs
@@ -248,7 +248,7 @@ public bool Read()
         /// <returns>A task that represents the asynchronous read operation.
         /// The value of the TResult parameter contains the node value of the last buffered read if buffering is on or off;
         /// otherwise the node value of the last unbuffered read.</returns>
-        public Task<object> GetValueAsync()
+        public ValueTask<object> GetValueAsync()
         {
             this.AssertAsynchronous();
 
@@ -257,11 +257,11 @@ public Task<object> GetValueAsync()
                 if (this.isBuffering)
                 {
                     Debug.Assert(this.currentBufferedNode != null, "this.currentBufferedNode != null");
-                    return Task.FromResult(this.currentBufferedNode.Value);
+                    return ValueTask.FromResult(this.currentBufferedNode.Value);
                 }
 
                 // In non-buffering mode if we have buffered nodes satisfy the request from the first node there
-                return Task.FromResult(this.bufferedNodesHead.Value);
+                return ValueTask.FromResult(this.bufferedNodesHead.Value);
             }
 
             return this.innerReader.GetValueAsync();
@@ -272,7 +272,7 @@ public Task<object> GetValueAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous read operation.
         /// The value of the TResult parameter contains true if a new node was found, or false if end of input was reached.</returns>
-        public Task<bool> ReadAsync()
+        public ValueTask<bool> ReadAsync()
         {
             Debug.Assert(!this.parsingInStreamError, "!this.parsingInStreamError");
             this.AssertAsynchronous();
@@ -286,7 +286,7 @@ public Task<bool> ReadAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// true if the current value can be streamed; otherwise false.</returns>
-        public virtual async Task<bool> CanStreamAsync()
+        public virtual async ValueTask<bool> CanStreamAsync()
         {
             this.AssertAsynchronous();
 
@@ -307,7 +307,7 @@ public virtual async Task<bool> CanStreamAsync()
         /// <returns>A task that represents the asynchronous read operation.
         /// The value of the TResult parameter contains a <see cref="Stream"/> used to read a stream value.</returns>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1825:Avoid zero-length array allocations.", Justification = "<Pending>")]
-        public virtual async Task<Stream> CreateReadStreamAsync()
+        public virtual async ValueTask<Stream> CreateReadStreamAsync()
         {
             this.AssertAsynchronous();
 
@@ -342,7 +342,7 @@ await this.innerReader.ReadAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous read operation.
         /// The value of the TResult parameter contains a <see cref="TextReader"/> for reading the text value.</returns>
-        public virtual async Task<TextReader> CreateTextReaderAsync()
+        public virtual async ValueTask<TextReader> CreateTextReaderAsync()
         {
             this.AssertAsynchronous();
 
@@ -682,7 +682,7 @@ protected virtual void ProcessObjectValue()
         /// represents an in-stream error. If so, it throws an <see cref="ODataErrorException"/>. If false, this check will not happen.
         /// This parsingInStremError field is set to true when trying to parse an in-stream error; in normal operation it is false.
         /// </remarks>
-        protected async Task<bool> ReadInternalAsync()
+        protected async ValueTask<bool> ReadInternalAsync()
         {
             this.AssertAsynchronous();
 
diff --git a/src/Microsoft.OData.Core/Json/IJsonReader.cs b/src/Microsoft.OData.Core/Json/IJsonReader.cs
index cee3136a1f..4553f0cf17 100644
--- a/src/Microsoft.OData.Core/Json/IJsonReader.cs
+++ b/src/Microsoft.OData.Core/Json/IJsonReader.cs
@@ -68,7 +68,7 @@ public interface IJsonReader
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains true if a new node was found, or false if end of input was reached.</returns>
-        Task<bool> ReadAsync();
+        ValueTask<bool> ReadAsync();
 
         /// <summary>
         /// Asynchronously returns the value of the last reported node.
@@ -85,27 +85,27 @@ public interface IJsonReader
         /// - Double if a number which doesn't fit into Int32 was found.
         /// If the last node is a Property this property returns a string which is the name of the property.
         /// </remarks>
-        Task<object> GetValueAsync();
+        ValueTask<object> GetValueAsync();
 
         /// <summary>
         /// Asynchronously creates a Stream for reading a binary value.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="Stream"/> for reading the binary value.</returns>
-        Task<Stream> CreateReadStreamAsync();
+        ValueTask<Stream> CreateReadStreamAsync();
 
         /// <summary>
         /// Asynchronously creates a TextReader for reading a string value.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="TextReader"/> for reading the string value.</returns>
-        Task<TextReader> CreateTextReaderAsync();
+        ValueTask<TextReader> CreateTextReaderAsync();
 
         /// <summary>
         /// Asynchronously checks whether or not the current value can be streamed.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// true if the current value can be streamed; otherwise false.</returns>
-        Task<bool> CanStreamAsync();
+        ValueTask<bool> CanStreamAsync();
     }
 }
diff --git a/src/Microsoft.OData.Core/Json/IJsonWriter.cs b/src/Microsoft.OData.Core/Json/IJsonWriter.cs
index fd4b3f0d92..5eb2c4636b 100644
--- a/src/Microsoft.OData.Core/Json/IJsonWriter.cs
+++ b/src/Microsoft.OData.Core/Json/IJsonWriter.cs
@@ -213,45 +213,45 @@ public interface IJsonWriter
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
         [Obsolete("This will be dropped in the 9.x release.")]
-        Task StartPaddingFunctionScopeAsync();
+        ValueTask StartPaddingFunctionScopeAsync();
 
         /// <summary>
         /// Asynchronously ends the padding function scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
         [Obsolete("This will be dropped in the 9.x release.")]
-        Task EndPaddingFunctionScopeAsync();
+        ValueTask EndPaddingFunctionScopeAsync();
 
         /// <summary>
         /// Asynchronously starts the object scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task StartObjectScopeAsync();
+        ValueTask StartObjectScopeAsync();
 
         /// <summary>
         /// Asynchronously ends the current object scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EndObjectScopeAsync();
+        ValueTask EndObjectScopeAsync();
 
         /// <summary>
         /// Asynchronously starts the array scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task StartArrayScopeAsync();
+        ValueTask StartArrayScopeAsync();
 
         /// <summary>
         /// Asynchronously ends the current array scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EndArrayScopeAsync();
+        ValueTask EndArrayScopeAsync();
 
         /// <summary>
         /// Asynchronously writes the name for the object property.
         /// </summary>
         /// <param name="name">Name of the object property.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteNameAsync(string name);
+        ValueTask WriteNameAsync(string name);
 
         /// <summary>
         /// Asynchronously writes a function name for JSON padding.
@@ -259,119 +259,119 @@ public interface IJsonWriter
         /// <param name="functionName">Name of the padding function to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
         [Obsolete("This will be dropped in the 9.x release.")]
-        Task WritePaddingFunctionNameAsync(string functionName);
+        ValueTask WritePaddingFunctionNameAsync(string functionName);
 
         /// <summary>
         /// Asynchronously writes a boolean value.
         /// </summary>
         /// <param name="value">Boolean value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(bool value);
+        ValueTask WriteValueAsync(bool value);
 
         /// <summary>
         /// Asynchronously writes an integer value.
         /// </summary>
         /// <param name="value">Integer value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(int value);
+        ValueTask WriteValueAsync(int value);
 
         /// <summary>
         /// Asynchronously writes a float value.
         /// </summary>
         /// <param name="value">Float value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(float value);
+        ValueTask WriteValueAsync(float value);
 
         /// <summary>
         /// Asynchronously writes a short value.
         /// </summary>
         /// <param name="value">Short value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(short value);
+        ValueTask WriteValueAsync(short value);
 
         /// <summary>
         /// Asynchronously writes a long value.
         /// </summary>
         /// <param name="value">Long value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(long value);
+        ValueTask WriteValueAsync(long value);
 
         /// <summary>
         /// Asynchronously writes a double value.
         /// </summary>
         /// <param name="value">Double value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(double value);
+        ValueTask WriteValueAsync(double value);
 
         /// <summary>
         /// Asynchronously writes a Guid value.
         /// </summary>
         /// <param name="value">Guid value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(Guid value);
+        ValueTask WriteValueAsync(Guid value);
 
         /// <summary>
         /// Asynchronously writes a decimal value
         /// </summary>
         /// <param name="value">Decimal value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(decimal value);
+        ValueTask WriteValueAsync(decimal value);
 
         /// <summary>
         /// Asynchronously writes a DateTimeOffset value
         /// </summary>
         /// <param name="value">DateTimeOffset value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(DateTimeOffset value);
+        ValueTask WriteValueAsync(DateTimeOffset value);
 
         /// <summary>
         /// Asynchronously writes a TimeSpan value
         /// </summary>
         /// <param name="value">TimeSpan value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(TimeSpan value);
+        ValueTask WriteValueAsync(TimeSpan value);
 
         /// <summary>
         /// Asynchronously writes a byte value.
         /// </summary>
         /// <param name="value">Byte value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(byte value);
+        ValueTask WriteValueAsync(byte value);
 
         /// <summary>
         /// Asynchronously writes an sbyte value.
         /// </summary>
         /// <param name="value">SByte value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(sbyte value);
+        ValueTask WriteValueAsync(sbyte value);
 
         /// <summary>
         /// Asynchronously writes a string value.
         /// </summary>
         /// <param name="value">String value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(string value);
+        ValueTask WriteValueAsync(string value);
 
         /// <summary>
         /// Asynchronously writes a byte array.
         /// </summary>
         /// <param name="value">Byte array to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(byte[] value);
+        ValueTask WriteValueAsync(byte[] value);
 
         /// <summary>
         /// Asynchronously writes a Date value
         /// </summary>
         /// <param name="value">Date value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(Date value);
+        ValueTask WriteValueAsync(Date value);
 
         /// <summary>
         /// Asynchronously writes a TimeOfDay value
         /// </summary>
         /// <param name="value">TimeOfDay value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(TimeOfDay value);
+        ValueTask WriteValueAsync(TimeOfDay value);
 
 #if NETCOREAPP
 
@@ -380,7 +380,7 @@ public interface IJsonWriter
         /// </summary>
         /// <param name="value">The <see cref="JsonElement"/> value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteValueAsync(JsonElement value);
+        ValueTask WriteValueAsync(JsonElement value);
 #endif
 
         /// <summary>
@@ -388,7 +388,7 @@ public interface IJsonWriter
         /// </summary>
         /// <param name="rawValue">Raw value to be written.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        Task WriteRawValueAsync(string rawValue);
+        ValueTask WriteRawValueAsync(string rawValue);
 
         /// <summary>
         /// Asynchronously clears all buffers for the current writer.
@@ -401,7 +401,7 @@ public interface IJsonWriter
         /// </summary>
         /// <returns>A task that represents the asynchronous operation. 
         /// The value of the TResult parameter contains the stream to write the property value to.</returns>
-        Task<Stream> StartStreamValueScopeAsync();
+        ValueTask<Stream> StartStreamValueScopeAsync();
 
         /// <summary>
         /// Asynchronously starts the TextWriter value scope.
@@ -409,18 +409,18 @@ public interface IJsonWriter
         /// <param name="contentType">ContentType of the string being written.</param>
         /// <returns>A task that represents the asynchronous operation. 
         /// The value of the TResult parameter contains the textwriter to write the text property value to.</returns>
-        Task<TextWriter> StartTextWriterValueScopeAsync(string contentType);
+        ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType);
 
         /// <summary>
         /// Asynchronously ends the current stream property value scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EndStreamValueScopeAsync();
+        ValueTask EndStreamValueScopeAsync();
 
         /// <summary>
         /// Asynchronously ends the TextWriter value scope.
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.</returns>
-        Task EndTextWriterValueScopeAsync();
+        ValueTask EndTextWriterValueScopeAsync();
     }
 }
diff --git a/src/Microsoft.OData.Core/Json/JsonLightInstanceAnnotationWriter.cs b/src/Microsoft.OData.Core/Json/JsonLightInstanceAnnotationWriter.cs
index 052f0cea5e..f1a86f6103 100644
--- a/src/Microsoft.OData.Core/Json/JsonLightInstanceAnnotationWriter.cs
+++ b/src/Microsoft.OData.Core/Json/JsonLightInstanceAnnotationWriter.cs
@@ -254,7 +254,7 @@ internal void WriteInstanceAnnotation(
         /// <param name="ignoreFilter">Whether to ignore the filter in settings.</param>
         /// <param name="propertyName">The name of the property this instance annotation applies to</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal Task WriteInstanceAnnotationsAsync(
+        internal ValueTask WriteInstanceAnnotationsAsync(
             ICollection<ODataInstanceAnnotation> instanceAnnotations,
             InstanceAnnotationWriteTracker tracker,
             bool ignoreFilter = false,
@@ -267,7 +267,7 @@ internal Task WriteInstanceAnnotationsAsync(
 
             if (instanceAnnotations.Count == 0)
             {
-                return TaskUtils.CompletedTask;
+                return ValueTask.CompletedTask;
             }
 
             HashSet<string> instanceAnnotationNames = new HashSet<string>(StringComparer.Ordinal);
@@ -279,7 +279,7 @@ internal Task WriteInstanceAnnotationsAsync(
             {
                 return WriteInstanceAnnotationsListAsync(instanceAnnotationsList, tracker, instanceAnnotationNames, ignoreFilter, propertyName);
 
-                async Task WriteInstanceAnnotationsListAsync(
+                async ValueTask WriteInstanceAnnotationsListAsync(
                     List<ODataInstanceAnnotation> innerInstanceAnnotationsList,
                     InstanceAnnotationWriteTracker innerInstanceAnnotationWriteTracker,
                     HashSet<string> innerInstanceAnnotationNames,
@@ -301,7 +301,7 @@ await this.WriteAndTrackInstanceAnnotationAsync(
             {
                 return WriteInstanceAnnotationsInnerAsync(instanceAnnotations, tracker, instanceAnnotationNames, ignoreFilter, propertyName);
 
-                async Task WriteInstanceAnnotationsInnerAsync(
+                async ValueTask WriteInstanceAnnotationsInnerAsync(
                     ICollection<ODataInstanceAnnotation> innerInstanceAnnotations,
                     InstanceAnnotationWriteTracker innerInstanceAnnotationWriteTracker,
                     HashSet<string> innerInstanceAnnotationNames,
@@ -328,7 +328,7 @@ await this.WriteAndTrackInstanceAnnotationAsync(
         /// <param name="instanceAnnotations">Collection of instance annotations to write.</param>
         /// <param name="propertyName">The name of the property this instance annotation applies to</param>
         /// <param name="isUndeclaredProperty">If writing an undeclared property.</param>
-        internal Task WriteInstanceAnnotationsAsync(
+        internal ValueTask WriteInstanceAnnotationsAsync(
             ICollection<ODataInstanceAnnotation> instanceAnnotations,
             string propertyName = null,
             bool isUndeclaredProperty = false)
@@ -349,7 +349,7 @@ internal Task WriteInstanceAnnotationsAsync(
         /// Asynchronously writes all the instance annotations specified in <paramref name="instanceAnnotations"/> of error.
         /// </summary>
         /// <param name="instanceAnnotations">Collection of instance annotations to write.</param>
-        internal Task WriteInstanceAnnotationsForErrorAsync(ICollection<ODataInstanceAnnotation> instanceAnnotations)
+        internal ValueTask WriteInstanceAnnotationsForErrorAsync(ICollection<ODataInstanceAnnotation> instanceAnnotations)
         {
             Debug.Assert(instanceAnnotations != null, "instanceAnnotations should not be null if we called this");
             return this.WriteInstanceAnnotationsAsync(instanceAnnotations, new InstanceAnnotationWriteTracker(), true);
@@ -570,7 +570,7 @@ await this.WriteInstanceAnnotationAsync(annotation, ignoreFilter, propertyName)
         /// <param name="instanceAnnotations">The collection of instance annotations</param>
         /// <param name="propertyName">The name of the property the instance annotations apply to</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private async Task WriteInstanceAnnotationsForUndeclaredPropertyAsync(ICollection<ODataInstanceAnnotation> instanceAnnotations, string propertyName)
+        private async ValueTask WriteInstanceAnnotationsForUndeclaredPropertyAsync(ICollection<ODataInstanceAnnotation> instanceAnnotations, string propertyName)
         {
             // write undeclared property's all annotations
             // optimize the foreach when instanceAnnotations is a List to avoid enumerator allocations on the heap
@@ -614,7 +614,7 @@ private void WriteInstanceAnnotationName(string propertyName, string annotationN
         /// </summary>
         /// <param name="propertyName">The name of the property this instance annotation applied to.</param>
         /// <param name="annotationName">The name of the instance annotation.</param>
-        private Task WriteInstanceAnnotationNameAsync(string propertyName, string annotationName)
+        private ValueTask WriteInstanceAnnotationNameAsync(string propertyName, string annotationName)
         {
             if (propertyName != null)
             {
diff --git a/src/Microsoft.OData.Core/Json/JsonReader.cs b/src/Microsoft.OData.Core/Json/JsonReader.cs
index fc64b6bf23..a3c9343d03 100644
--- a/src/Microsoft.OData.Core/Json/JsonReader.cs
+++ b/src/Microsoft.OData.Core/Json/JsonReader.cs
@@ -521,7 +521,7 @@ public TextReader CreateTextReader()
         /// - Double if a number which doesn't fit into Int32 was found.
         /// If the last node is a Property this property returns a string which is the name of the property.
         /// </remarks>
-        public virtual async Task<object> GetValueAsync()
+        public virtual async ValueTask<object> GetValueAsync()
         {
             if (this.readingStream)
             {
@@ -559,15 +559,15 @@ public virtual async Task<object> GetValueAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// true if the current value can be streamed; otherwise false.</returns>
-        public Task<bool> CanStreamAsync()
+        public ValueTask<bool> CanStreamAsync()
         {
             if (this.canStream)
             {
-                return Task.FromResult(true);
+                return ValueTask.FromResult(true);
             }
             else
             {
-                return Task.FromResult(false);
+                return ValueTask.FromResult(false);
             }
         }
 
@@ -578,7 +578,7 @@ public Task<bool> CanStreamAsync()
         /// The value of the TResult parameter contains true if a new node was found,
         /// or false if end of input was reached.</returns>
         [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Not really feasible to extract code to methods without introducing unnecessary complexity.")]
-        public virtual async Task<bool> ReadAsync()
+        public virtual async ValueTask<bool> ReadAsync()
         {
             if (this.readingStream)
             {
@@ -755,7 +755,7 @@ public virtual async Task<bool> ReadAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="Stream"/> for reading a base64 URL encoded binary value.</returns>
-        public async Task<Stream> CreateReadStreamAsync()
+        public async ValueTask<Stream> CreateReadStreamAsync()
         {
             if (!this.canStream)
             {
@@ -770,7 +770,7 @@ await this.ParseNullPrimitiveValueAsync()
                 this.scopes.Peek().ValueCount++;
                 await this.ReadAsync()
                     .ConfigureAwait(false);
-                return new ODataBinaryStreamReader((a, b, c) => { return Task.FromResult(0); });
+                return new ODataBinaryStreamReader((a, b, c) => { return ValueTask.FromResult(0); });
             }
 
             this.tokenStartIndex++;
@@ -783,7 +783,7 @@ await this.ReadAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="TextReader"/> for reading a text value.</returns>
-        public async Task<TextReader> CreateTextReaderAsync()
+        public async ValueTask<TextReader> CreateTextReaderAsync()
         {
             if (!this.canStream)
             {
@@ -802,7 +802,7 @@ await this.ParseNullPrimitiveValueAsync()
                 this.scopes.Peek().ValueCount++;
                 await this.ReadAsync()
                     .ConfigureAwait(false);
-                return new ODataTextStreamReader((a, b, c) => { return Task.FromResult(0); });
+                return new ODataTextStreamReader((a, b, c) => { return ValueTask.FromResult(0); });
             }
 
             // skip over the opening quote character for a string value
@@ -1597,7 +1597,7 @@ private bool ReadInput()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains the node type to report to the user.</returns>
-        private async Task<JsonNodeType> ParseValueAsync()
+        private async ValueTask<JsonNodeType> ParseValueAsync()
         {
             Debug.Assert(
                 this.tokenStartIndex < this.storedCharacterCount && !IsWhitespaceCharacter(this.characterBuffer[this.tokenStartIndex]),
@@ -1866,7 +1866,7 @@ private async Task<Tuple<string, bool>> ParseStringPrimitiveValueAsync()
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains null if successful; otherwise throws.</returns>
         /// <remarks>Assumes that the current token position points to the 'n' character.</remarks>
-        private async Task<object> ParseNullPrimitiveValueAsync()
+        private async ValueTask<object> ParseNullPrimitiveValueAsync()
         {
             Debug.Assert(
                 this.tokenStartIndex < this.storedCharacterCount && this.characterBuffer[this.tokenStartIndex] == 'n',
@@ -1889,7 +1889,7 @@ private async Task<object> ParseNullPrimitiveValueAsync()
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains true or false if successful; otherwise throws.</returns>
         /// <remarks>Assumes that the current token position points to the 't' or 'f' character.</remarks>
-        private async Task<object> ParseBooleanPrimitiveValueAsync()
+        private async ValueTask<object> ParseBooleanPrimitiveValueAsync()
         {
             Debug.Assert(
                 this.tokenStartIndex < this.storedCharacterCount && (this.characterBuffer[this.tokenStartIndex] == 't' || this.characterBuffer[this.tokenStartIndex] == 'f'),
@@ -1917,7 +1917,7 @@ private async Task<object> ParseBooleanPrimitiveValueAsync()
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains an Int32, Decimal or Double value; otherwise throws.</returns>
         /// <remarks>Assumes that the current token position points to the first character of the number, so either digit, dot or dash.</remarks>
-        private async Task<object> ParseNumberPrimitiveValueAsync()
+        private async ValueTask<object> ParseNumberPrimitiveValueAsync()
         {
             Debug.Assert(
                 this.tokenStartIndex < this.storedCharacterCount && (this.characterBuffer[this.tokenStartIndex] == '.' || this.characterBuffer[this.tokenStartIndex] == '-' || Char.IsDigit(this.characterBuffer[this.tokenStartIndex])),
@@ -1981,7 +1981,7 @@ private async Task<object> ParseNumberPrimitiveValueAsync()
         /// - string value quoted with double quotes.
         /// - string value quoted with single quotes.
         /// - sequence of letters, digits, underscores and dollar signs (without quoted and in any order).</remarks>
-        private async Task<string> ParseNameAsync()
+        private async ValueTask<string> ParseNameAsync()
         {
             Debug.Assert(this.tokenStartIndex < this.storedCharacterCount, "Must have at least one character available.");
 
@@ -2028,7 +2028,7 @@ private async Task<string> ParseNameAsync()
         /// Note that the string parsing can never end with EndOfInput, since we're already seen the quote.
         /// So it can either return a string successfully or fail.</remarks>
         [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Splitting the function would make it hard to understand.")]
-        private async Task<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
+        private async ValueTask<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
         {
             if (!readingStream)
             {
@@ -2148,11 +2148,7 @@ private async Task<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
         /// The value of the TResult parameter contains true if a non-whitespace character was found,
         /// in which case the <see cref="tokenStartIndex"/> is pointing at that character;
         /// otherwise false if there are no non-whitespace characters left in the input.</returns>
-#if NETSTANDARD2_0 || NETCOREAPP3_1_OR_GREATER
         private async ValueTask<bool> SkipWhitespacesAsync()
-#else
-        private async Task<bool> SkipWhitespacesAsync()
-#endif
         {
             do
             {
@@ -2176,11 +2172,7 @@ private async Task<bool> SkipWhitespacesAsync()
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains true if at least the required number of characters is available; 
         /// otherwise false if end of input was reached.</returns>
-#if NETSTANDARD2_0 || NETCOREAPP3_1_OR_GREATER
         private async ValueTask<bool> EnsureAvailableCharactersAsync(int characterCountAfterTokenStart)
-#else
-        private async Task<bool> EnsureAvailableCharactersAsync(int characterCountAfterTokenStart)
-#endif
         {
             while (this.tokenStartIndex + characterCountAfterTokenStart > this.storedCharacterCount)
             {
@@ -2201,11 +2193,7 @@ private async Task<bool> EnsureAvailableCharactersAsync(int characterCountAfterT
         /// otherwise false if end of input was reached.</returns>
         /// <remarks>This may move characters in the <see cref="characterBuffer"/>, so after this is called
         /// all indices to the <see cref="characterBuffer"/> are invalid except for <see cref="tokenStartIndex"/>.</remarks>
-#if NETSTANDARD2_0 || NETCOREAPP3_1_OR_GREATER
         private async ValueTask<bool> ReadInputAsync()
-#else
-        private async Task<bool> ReadInputAsync()
-#endif
         {
             Debug.Assert(this.tokenStartIndex >= 0 && this.tokenStartIndex <= this.storedCharacterCount, "The token start is out of stored characters range.");
 
diff --git a/src/Microsoft.OData.Core/Json/JsonWriter.Async.cs b/src/Microsoft.OData.Core/Json/JsonWriter.Async.cs
index ea4fba3875..8987c79865 100644
--- a/src/Microsoft.OData.Core/Json/JsonWriter.Async.cs
+++ b/src/Microsoft.OData.Core/Json/JsonWriter.Async.cs
@@ -22,14 +22,14 @@ namespace Microsoft.OData.Json
     internal sealed partial class JsonWriter
     {
         /// <inheritdoc/>
-        public Task StartPaddingFunctionScopeAsync()
+        public ValueTask StartPaddingFunctionScopeAsync()
         {
             Debug.Assert(this.scopes.Count == 0, "Padding scope can only be the outer most scope.");
             return this.StartScopeAsync(ScopeType.Padding);
         }
 
         /// <inheritdoc/>
-        public async Task EndPaddingFunctionScopeAsync()
+        public async ValueTask EndPaddingFunctionScopeAsync()
         {
             Debug.Assert(this.scopes.Count > 0, "No scope to end.");
 
@@ -43,13 +43,13 @@ public async Task EndPaddingFunctionScopeAsync()
         }
 
         /// <inheritdoc/>
-        public Task StartObjectScopeAsync()
+        public ValueTask StartObjectScopeAsync()
         {
             return this.StartScopeAsync(ScopeType.Object);
         }
 
         /// <inheritdoc/>
-        public async Task EndObjectScopeAsync()
+        public async ValueTask EndObjectScopeAsync()
         {
             Debug.Assert(this.scopes.Count > 0, "No scope to end.");
 
@@ -63,13 +63,13 @@ public async Task EndObjectScopeAsync()
         }
 
         /// <inheritdoc/>
-        public Task StartArrayScopeAsync()
+        public ValueTask StartArrayScopeAsync()
         {
             return this.StartScopeAsync(ScopeType.Array);
         }
 
         /// <inheritdoc/>
-        public async Task EndArrayScopeAsync()
+        public async ValueTask EndArrayScopeAsync()
         {
             Debug.Assert(this.scopes.Count > 0, "No scope to end.");
 
@@ -83,7 +83,7 @@ public async Task EndArrayScopeAsync()
         }
 
         /// <inheritdoc/>
-        public async Task WriteNameAsync(string name)
+        public async ValueTask WriteNameAsync(string name)
         {
             Debug.Assert(!string.IsNullOrEmpty(name), "The name must be specified.");
             Debug.Assert(this.scopes.Count > 0, "There must be an active scope for name to be written.");
@@ -103,41 +103,41 @@ await this.writer.WriteEscapedJsonStringAsync(name, this.stringEscapeOption, thi
         }
 
         /// <inheritdoc/>
-        public Task WritePaddingFunctionNameAsync(string functionName)
+        public async ValueTask WritePaddingFunctionNameAsync(string functionName)
         {
-            return this.writer.WriteAsync(functionName);
+            await this.writer.WriteAsync(functionName);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(bool value)
+        public async ValueTask WriteValueAsync(bool value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(int value)
+        public async ValueTask WriteValueAsync(int value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(float value)
+        public async ValueTask WriteValueAsync(float value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(short value)
+        public async ValueTask WriteValueAsync(short value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(long value)
+        public async ValueTask WriteValueAsync(long value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
 
@@ -154,21 +154,21 @@ await this.writer.WriteValueAsync(value.ToString(CultureInfo.InvariantCulture),
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(double value)
+        public async ValueTask WriteValueAsync(double value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(Guid value)
+        public async ValueTask WriteValueAsync(Guid value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(decimal value)
+        public async ValueTask WriteValueAsync(decimal value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
 
@@ -185,7 +185,7 @@ await this.writer.WriteValueAsync(value.ToString(CultureInfo.InvariantCulture),
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(DateTimeOffset value)
+        public async ValueTask WriteValueAsync(DateTimeOffset value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value, ODataJsonDateTimeFormat.ISO8601DateTime)
@@ -193,42 +193,42 @@ await this.writer.WriteValueAsync(value, ODataJsonDateTimeFormat.ISO8601DateTime
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(TimeSpan value)
+        public async ValueTask WriteValueAsync(TimeSpan value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(TimeOfDay value)
+        public async ValueTask WriteValueAsync(TimeOfDay value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(Date value)
+        public async ValueTask WriteValueAsync(Date value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(byte value)
+        public async ValueTask WriteValueAsync(byte value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(sbyte value)
+        public async ValueTask WriteValueAsync(sbyte value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(string value)
+        public async ValueTask WriteValueAsync(string value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value, this.stringEscapeOption, this.wrappedBuffer, this.ArrayPool)
@@ -236,14 +236,14 @@ await this.writer.WriteValueAsync(value, this.stringEscapeOption, this.wrappedBu
         }
 
         /// <inheritdoc/>
-        public async Task WriteValueAsync(byte[] value)
+        public async ValueTask WriteValueAsync(byte[] value)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteValueAsync(value, this.wrappedBuffer, this.ArrayPool).ConfigureAwait(false);
         }
 
 #if NETCOREAPP
-        public Task WriteValueAsync(JsonElement value)
+        public ValueTask WriteValueAsync(JsonElement value)
         {
             switch (value.ValueKind)
             {
@@ -265,11 +265,11 @@ public Task WriteValueAsync(JsonElement value)
                     // we've exhausted all known JSON types, if we get
                     // to this point, then it's undefined behavior
                     Debug.Fail($"Unexpected JSON ValueKind {value.ValueKind}");
-                    return Task.CompletedTask;
+                    return ValueTask.CompletedTask;
             }
         }
 
-        private async Task WriteJsonElementArrayAsync(JsonElement value)
+        private async ValueTask WriteJsonElementArrayAsync(JsonElement value)
         {
             Debug.Assert(value.ValueKind == JsonValueKind.Array);
 
@@ -282,7 +282,7 @@ private async Task WriteJsonElementArrayAsync(JsonElement value)
             await this.EndArrayScopeAsync().ConfigureAwait(false);
         }
 
-        private async Task WriteJsonElementObjectAsync(JsonElement value)
+        private async ValueTask WriteJsonElementObjectAsync(JsonElement value)
         {
             Debug.Assert(value.ValueKind == JsonValueKind.Object);
 
@@ -296,7 +296,7 @@ private async Task WriteJsonElementObjectAsync(JsonElement value)
             await this.EndObjectScopeAsync().ConfigureAwait(false);
         }
 
-        private Task WriteJsonElementNumberAsync(JsonElement value)
+        private ValueTask WriteJsonElementNumberAsync(JsonElement value)
         {
             Debug.Assert(value.ValueKind == JsonValueKind.Number);
 
@@ -356,12 +356,12 @@ private Task WriteJsonElementNumberAsync(JsonElement value)
             }
 
             Debug.Fail($"Exhausted all known JSON number types and did not find match.");
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 #endif
 
         /// <inheritdoc/>
-        public async Task WriteRawValueAsync(string rawValue)
+        public async ValueTask WriteRawValueAsync(string rawValue)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteAsync(rawValue).ConfigureAwait(false);
@@ -398,7 +398,7 @@ public async ValueTask DisposeAsync()
 #endif
 
         /// <inheritdoc/>
-        public async Task<Stream> StartStreamValueScopeAsync()
+        public async ValueTask<Stream> StartStreamValueScopeAsync()
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             await this.writer.WriteAsync(JsonConstants.QuoteCharacter).ConfigureAwait(false);
@@ -414,7 +414,7 @@ public async Task<Stream> StartStreamValueScopeAsync()
         }
 
         /// <inheritdoc/>
-        public async Task EndStreamValueScopeAsync()
+        public async ValueTask EndStreamValueScopeAsync()
         {
             await this.binaryValueStream.FlushAsync().ConfigureAwait(false);
 #if NETCOREAPP
@@ -428,7 +428,7 @@ public async Task EndStreamValueScopeAsync()
         }
 
         /// <inheritdoc/>
-        public async Task<TextWriter> StartTextWriterValueScopeAsync(string contentType)
+        public async ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType)
         {
             await this.WriteValueSeparatorAsync().ConfigureAwait(false);
             this.currentContentType = contentType;
@@ -446,25 +446,25 @@ await this.writer.WriteAsync(JsonConstants.QuoteCharacter)
         }
 
         /// <inheritdoc/>
-        public Task EndTextWriterValueScopeAsync()
+        public async ValueTask EndTextWriterValueScopeAsync()
         {
             if (!IsWritingJson)
             {
-                return this.writer.WriteAsync(JsonConstants.QuoteCharacter);
+                await this.writer.WriteAsync(JsonConstants.QuoteCharacter).ConfigureAwait(false);
             }
 
-            return TaskUtils.CompletedTask;
+            return;
         }
 
         /// <summary>
         /// Asynchronously writes a separator of a value if it's needed for the next value to be written.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private Task WriteValueSeparatorAsync()
+        private async ValueTask WriteValueSeparatorAsync()
         {
             if (this.scopes.Count == 0)
             {
-                return TaskUtils.CompletedTask;
+                return;
             }
 
             Scope currentScope = this.scopes.Peek();
@@ -473,11 +473,11 @@ private Task WriteValueSeparatorAsync()
                 currentScope.ObjectCount++;
                 if (currentScope.ObjectCount > 1)
                 {
-                    return this.writer.WriteAsync(JsonConstants.ArrayElementSeparator);
+                    await this.writer.WriteAsync(JsonConstants.ArrayElementSeparator).ConfigureAwait(false);
                 }
             }
 
-            return TaskUtils.CompletedTask;
+            return;
         }
 
         /// <summary>
@@ -485,7 +485,7 @@ private Task WriteValueSeparatorAsync()
         /// </summary>
         /// <param name="type">The scope type to start.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private async Task StartScopeAsync(ScopeType type)
+        private async ValueTask StartScopeAsync(ScopeType type)
         {
             if (this.scopes.Count != 0 && this.scopes.Peek().Type != ScopeType.Padding)
             {
diff --git a/src/Microsoft.OData.Core/Json/JsonWriterExtensions.Async.cs b/src/Microsoft.OData.Core/Json/JsonWriterExtensions.Async.cs
index a492ddfcd3..243cca8670 100644
--- a/src/Microsoft.OData.Core/Json/JsonWriterExtensions.Async.cs
+++ b/src/Microsoft.OData.Core/Json/JsonWriterExtensions.Async.cs
@@ -26,7 +26,7 @@ internal static partial class JsonWriterExtensions
         /// <param name="jsonObjectValue">Writes the given json object value to the underlying json writer.</param>
         /// <param name="injectPropertyDelegate">Called when the top-level object is started to possibly inject first property into the object.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal static async Task WriteJsonObjectValueAsync(
+        internal static async ValueTask WriteJsonObjectValueAsync(
             this IJsonWriter jsonWriter,
             IDictionary<string, object> jsonObjectValue,
             Func<IJsonWriter, Task> injectPropertyDelegate)
@@ -56,7 +56,7 @@ internal static async Task WriteJsonObjectValueAsync(
         /// <param name="jsonWriter">The <see cref="JsonWriter"/> to write to.</param>
         /// <param name="value">The value to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal static Task WritePrimitiveValueAsync(this IJsonWriter jsonWriter, object value)
+        internal static ValueTask WritePrimitiveValueAsync(this IJsonWriter jsonWriter, object value)
         {
             if (value is bool)
             {
@@ -140,7 +140,7 @@ internal static Task WritePrimitiveValueAsync(this IJsonWriter jsonWriter, objec
                 return jsonWriter.WriteValueAsync((TimeOfDay)value);
             }
 
-            return TaskUtils.GetFaultedTask(
+            return ValueTask.FromException(
                 new ODataException(ODataErrorStrings.ODataJsonWriter_UnsupportedValueType(value.GetType().FullName)));
         }
 
@@ -150,7 +150,7 @@ internal static Task WritePrimitiveValueAsync(this IJsonWriter jsonWriter, objec
         /// <param name="jsonWriter">The <see cref="JsonWriter"/> to write to.</param>
         /// <param name="odataValue">value to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal static Task WriteODataValueAsync(this IJsonWriter jsonWriter, ODataValue odataValue)
+        internal static ValueTask WriteODataValueAsync(this IJsonWriter jsonWriter, ODataValue odataValue)
         {
             if (odataValue == null || odataValue is ODataNullValue)
             {
@@ -170,7 +170,7 @@ internal static Task WriteODataValueAsync(this IJsonWriter jsonWriter, ODataValu
             {
                 return WriteODataResourceValueAsync(jsonWriter, resourceValue);
 
-                async Task WriteODataResourceValueAsync(
+                async ValueTask WriteODataResourceValueAsync(
                     IJsonWriter innerJsonWriter,
                     ODataResourceValue innerResourceValue)
                 {
@@ -190,7 +190,7 @@ async Task WriteODataResourceValueAsync(
             {
                 return WriteODataCollectionValueAsync(jsonWriter, collectionValue);
 
-                async Task WriteODataCollectionValueAsync(
+                async ValueTask WriteODataCollectionValueAsync(
                     IJsonWriter innerJsonWriter,
                     ODataCollectionValue innerCollectionValue)
                 {
@@ -214,7 +214,7 @@ async Task WriteODataCollectionValueAsync(
                 }
             }
 
-            return TaskUtils.GetFaultedTask(
+            return ValueTask.FromException(
                 new ODataException(ODataErrorStrings.ODataJsonWriter_UnsupportedValueType(odataValue.GetType().FullName)));
         }
 
@@ -224,7 +224,7 @@ async Task WriteODataCollectionValueAsync(
         /// <param name="jsonWriter">The <see cref="JsonWriter"/> to write to.</param>
         /// <param name="arrayValue">Writes the json array value to the underlying json writer.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private static async Task WriteJsonArrayValueAsync(this IJsonWriter jsonWriter, IEnumerable arrayValue)
+        private static async ValueTask WriteJsonArrayValueAsync(this IJsonWriter jsonWriter, IEnumerable arrayValue)
         {
             Debug.Assert(arrayValue != null, "arrayValue != null");
 
@@ -244,7 +244,7 @@ private static async Task WriteJsonArrayValueAsync(this IJsonWriter jsonWriter,
         /// <param name="jsonWriter">The <see cref="JsonWriter"/> to write to.</param>
         /// <param name="propertyValue">value to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private static Task WriteJsonValueAsync(this IJsonWriter jsonWriter, object propertyValue)
+        private static ValueTask WriteJsonValueAsync(this IJsonWriter jsonWriter, object propertyValue)
         {
             if (propertyValue == null)
             {
diff --git a/src/Microsoft.OData.Core/Json/ODataJsonWriterUtils.cs b/src/Microsoft.OData.Core/Json/ODataJsonWriterUtils.cs
index 0685f5b1bf..603d3eca0b 100644
--- a/src/Microsoft.OData.Core/Json/ODataJsonWriterUtils.cs
+++ b/src/Microsoft.OData.Core/Json/ODataJsonWriterUtils.cs
@@ -135,9 +135,9 @@ internal static void ODataValueToString(StringBuilder sb, ODataValue value)
         /// <param name="includeDebugInformation">A flag indicating whether error details should be written (in debug mode only) or not.</param>
         /// <param name="maxInnerErrorDepth">The maximum number of nested inner errors to allow.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal static Task WriteErrorAsync(
+        internal static ValueTask WriteErrorAsync(
             IJsonWriter jsonWriter,
-            Func<ICollection<ODataInstanceAnnotation>, Task> writeInstanceAnnotationsDelegate,
+            Func<ICollection<ODataInstanceAnnotation>, ValueTask> writeInstanceAnnotationsDelegate,
             ODataError error,
             bool includeDebugInformation,
             int maxInnerErrorDepth)
@@ -409,7 +409,7 @@ private static void ODataResourceValueToString(StringBuilder sb, ODataResourceVa
         /// <param name="writeInstanceAnnotationsDelegate">Delegate to write the instance annotations.</param>
         /// <param name="maxInnerErrorDepth">The maximum number of nested inner errors to allow.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private static async Task WriteErrorAsync(
+        private static async ValueTask WriteErrorAsync(
             IJsonWriter jsonWriter,
             string code,
             string message,
@@ -417,7 +417,7 @@ private static async Task WriteErrorAsync(
             IEnumerable<ODataErrorDetail> details,
             ODataInnerError innerError,
             ICollection<ODataInstanceAnnotation> instanceAnnotations,
-            Func<ICollection<ODataInstanceAnnotation>, Task> writeInstanceAnnotationsDelegate,
+            Func<ICollection<ODataInstanceAnnotation>, ValueTask> writeInstanceAnnotationsDelegate,
             int maxInnerErrorDepth)
         {
             Debug.Assert(jsonWriter != null, "jsonWriter != null");
@@ -526,7 +526,7 @@ private static async Task WriteErrorDetailsAsync(IJsonWriter jsonWriter, IEnumer
         /// <param name="recursionDepth">The number of times this method has been called recursively.</param>
         /// <param name="maxInnerErrorDepth">The maximum number of nested inner errors to allow.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private static async Task WriteInnerErrorAsync(IJsonWriter jsonWriter, ODataInnerError innerError,
+        private static async ValueTask WriteInnerErrorAsync(IJsonWriter jsonWriter, ODataInnerError innerError,
             string innerErrorPropertyName, int recursionDepth, int maxInnerErrorDepth)
         {
             Debug.Assert(jsonWriter != null, "jsonWriter != null");
diff --git a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.Stream.cs b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.Stream.cs
index a173837dbe..cd23cfe19e 100644
--- a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.Stream.cs
+++ b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.Stream.cs
@@ -7,6 +7,8 @@
 #if NETCOREAPP
 namespace Microsoft.OData.Json
 {
+    using Microsoft.OData.Edm;
+    using Microsoft.OData.Metadata;
     using System;
     using System.Buffers;
     using System.Diagnostics;
@@ -58,7 +60,7 @@ public void EndStreamValueScope()
         /// Asynchronously starts a scope for writing a stream value.
         /// </summary>
         /// <returns>A task representing the asynchronous operation. The task result contains a stream for writing the stream value.</returns>
-        public async Task<Stream> StartStreamValueScopeAsync()
+        public async ValueTask<Stream> StartStreamValueScopeAsync()
         {
             this.WriteSeparatorIfNecessary();
             this.bufferWriter.Write(this.DoubleQuote.Slice(0, 1).Span);
@@ -73,7 +75,7 @@ public async Task<Stream> StartStreamValueScopeAsync()
         /// Asynchronously ends a scope for writing a stream value.
         /// </summary>
         /// <returns>A task representing the asynchronous operation.</returns>
-        public async Task EndStreamValueScopeAsync()
+        public async ValueTask EndStreamValueScopeAsync()
         {
             if (this.binaryValueStream != null)
             {
@@ -238,6 +240,19 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
                 await this.WriteByteValueInChunksAsync(value).ConfigureAwait(false);
             }
 
+            /// <summary>
+            /// Asynchronously writes a portion of a byte array to the underlying stream in chunks.
+            /// </summary>
+            /// <param name="buffer">The byte array from which data will be written.</param>
+            /// <param name="offset">The zero-based byte offset in the buffer at which to begin copying bytes to the stream.</param>
+            /// <param name="count">The maximum number of bytes to write.</param>
+            /// <param name="token">A CancellationToken to observe while waiting for the task to complete.</param>
+            /// <returns>A task representing the asynchronous write operation.</returns>
+            public override async ValueTask WriteAsync(ReadOnlyMemory<byte> value, CancellationToken token)
+            {
+                await this.WriteByteValueInChunksAsync(value).ConfigureAwait(false);
+            }
+
             /// <summary>
             /// Writes the byte value represented by the provided read-only span in chunks using Base64 encoding.
             /// </summary>
diff --git a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.TextWriter.cs b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.TextWriter.cs
index 1414222ad8..51d00fcef5 100644
--- a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.TextWriter.cs
+++ b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.TextWriter.cs
@@ -83,7 +83,7 @@ public void EndTextWriterValueScope()
         /// </summary>
         /// <param name="contentType">The content type of the TextWriter value scope.</param>
         /// <returns>A task representing the asynchronous operation. The task result is a TextWriter for writing JSON data.</returns>
-        public async Task<TextWriter> StartTextWriterValueScopeAsync(string contentType)
+        public async ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType)
         {
             await this.FlushAsync().ConfigureAwait(false);
 
@@ -109,7 +109,7 @@ public async Task<TextWriter> StartTextWriterValueScopeAsync(string contentType)
         /// Asynchronously ends a TextWriter value scope.
         /// </summary>
         /// <returns>A task representing the asynchronous operation.</returns>
-        public async Task EndTextWriterValueScopeAsync()
+        public async ValueTask EndTextWriterValueScopeAsync()
         {
             if (!this.isWritingJson)
             {
diff --git a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.cs b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.cs
index d0d8785057..6f4bc03c42 100644
--- a/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.cs
+++ b/src/Microsoft.OData.Core/Json/ODataUtf8JsonWriter.cs
@@ -861,28 +861,28 @@ public void Dispose()
 
         #region "Asynchronous API"
 
-        public async Task StartPaddingFunctionScopeAsync()
+        public async ValueTask StartPaddingFunctionScopeAsync()
         {
             this.CommitUtf8JsonWriterContentsToBuffer();
             this.bufferWriter.Write(parentheses[..1].Span);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WritePaddingFunctionNameAsync(string functionName)
+        public async ValueTask WritePaddingFunctionNameAsync(string functionName)
         {
             this.CommitUtf8JsonWriterContentsToBuffer();
             this.bufferWriter.Write(Encoding.UTF8.GetBytes(functionName));
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task EndPaddingFunctionScopeAsync()
+        public async ValueTask EndPaddingFunctionScopeAsync()
         {
             this.CommitUtf8JsonWriterContentsToBuffer();
             this.bufferWriter.Write(parentheses[1..2].Span);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task StartObjectScopeAsync()
+        public async ValueTask StartObjectScopeAsync()
         {
             this.WriteSeparatorIfNecessary();
             this.EnterObjectScope();
@@ -890,14 +890,14 @@ public async Task StartObjectScopeAsync()
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task EndObjectScopeAsync()
+        public async ValueTask EndObjectScopeAsync()
         {
             this.utf8JsonWriter.WriteEndObject();
             this.ExitScope();
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task StartArrayScopeAsync()
+        public async ValueTask StartArrayScopeAsync()
         {
             this.WriteSeparatorIfNecessary();
             this.EnterArrayScope();
@@ -905,49 +905,49 @@ public async Task StartArrayScopeAsync()
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task EndArrayScopeAsync()
+        public async ValueTask EndArrayScopeAsync()
         {
             this.utf8JsonWriter.WriteEndArray();
             this.ExitScope();
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteNameAsync(string name)
+        public async ValueTask WriteNameAsync(string name)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WritePropertyName(name);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(bool value)
+        public async ValueTask WriteValueAsync(bool value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteBooleanValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(int value)
+        public async ValueTask WriteValueAsync(int value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteNumberValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(float value)
+        public async ValueTask WriteValueAsync(float value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteNumberValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(short value)
+        public async ValueTask WriteValueAsync(short value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteNumberValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(long value)
+        public async ValueTask WriteValueAsync(long value)
         {
             this.WriteSeparatorIfNecessary();
             if (this.isIeee754Compatible)
@@ -962,7 +962,7 @@ public async Task WriteValueAsync(long value)
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(double value)
+        public async ValueTask WriteValueAsync(double value)
         {
             this.WriteSeparatorIfNecessary();
             if (double.IsNaN(value))
@@ -985,14 +985,14 @@ public async Task WriteValueAsync(double value)
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(Guid value)
+        public async ValueTask WriteValueAsync(Guid value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteStringValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(decimal value)
+        public async ValueTask WriteValueAsync(decimal value)
         {
             this.WriteSeparatorIfNecessary();
             if (this.isIeee754Compatible)
@@ -1007,7 +1007,7 @@ public async Task WriteValueAsync(decimal value)
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(DateTimeOffset value)
+        public async ValueTask WriteValueAsync(DateTimeOffset value)
         {
             this.WriteSeparatorIfNecessary();
             if (value.Offset == TimeSpan.Zero)
@@ -1029,7 +1029,7 @@ public async Task WriteValueAsync(DateTimeOffset value)
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(TimeSpan value)
+        public async ValueTask WriteValueAsync(TimeSpan value)
         {
             this.WriteSeparatorIfNecessary();
             string stringValue = EdmValueWriter.DurationAsXml(value);
@@ -1037,35 +1037,35 @@ public async Task WriteValueAsync(TimeSpan value)
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(Date value)
+        public async ValueTask WriteValueAsync(Date value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteStringValue(value.ToString());
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(TimeOfDay value)
+        public async ValueTask WriteValueAsync(TimeOfDay value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteStringValue(value.ToString());
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(byte value)
+        public async ValueTask WriteValueAsync(byte value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteNumberValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(sbyte value)
+        public async ValueTask WriteValueAsync(sbyte value)
         {
             this.WriteSeparatorIfNecessary();
             this.utf8JsonWriter.WriteNumberValue(value);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteValueAsync(string value)
+        public async ValueTask WriteValueAsync(string value)
         {
             if (value == null)
             {
@@ -1138,7 +1138,7 @@ private async ValueTask WriteStringValueInChunksAsync(ReadOnlyMemory<char> value
             CheckIfManualValueAtArrayStart();
         }
 
-        public async Task WriteValueAsync(byte[] value)
+        public async ValueTask WriteValueAsync(byte[] value)
         {
             if (value == null)
             {
@@ -1195,14 +1195,14 @@ private async ValueTask WriteByteValueInChunksAsync(ReadOnlyMemory<byte> value)
             CheckIfManualValueAtArrayStart();
         }
 
-        public async Task WriteValueAsync(JsonElement value)
+        public async ValueTask WriteValueAsync(JsonElement value)
         {
             this.WriteSeparatorIfNecessary();
             value.WriteTo(utf8JsonWriter);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
         }
 
-        public async Task WriteRawValueAsync(string rawValue)
+        public async ValueTask WriteRawValueAsync(string rawValue)
         {
             this.WriteRawValueCore(rawValue);
             await this.FlushIfBufferThresholdReachedAsync().ConfigureAwait(false);
diff --git a/src/Microsoft.OData.Core/Json/TranscodingWriteStream.cs b/src/Microsoft.OData.Core/Json/TranscodingWriteStream.cs
index 724bec43ab..d048ab39e1 100644
--- a/src/Microsoft.OData.Core/Json/TranscodingWriteStream.cs
+++ b/src/Microsoft.OData.Core/Json/TranscodingWriteStream.cs
@@ -406,23 +406,6 @@ async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> remainingOuterEncodedBytes,
 
         public override void WriteByte(byte value)
             => Write(new ReadOnlySpan<byte>(new byte[] { value }));
-
-        private static void ValidateBufferArguments(byte[] buffer, int offset, int size)
-        {
-            if (buffer == null)
-            {
-                throw new ArgumentNullException(nameof(buffer));
-            }
-
-            if ((uint)offset > (uint)buffer.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(offset));
-            }
-            if ((uint)size > (uint)(buffer.Length - offset))
-            {
-                throw new ArgumentOutOfRangeException(nameof(size));
-            }
-        }
     }
 }
  
diff --git a/src/Microsoft.OData.Core/JsonLight/JsonLightODataAnnotationWriter.cs b/src/Microsoft.OData.Core/JsonLight/JsonLightODataAnnotationWriter.cs
index e2967218a7..635230c396 100644
--- a/src/Microsoft.OData.Core/JsonLight/JsonLightODataAnnotationWriter.cs
+++ b/src/Microsoft.OData.Core/JsonLight/JsonLightODataAnnotationWriter.cs
@@ -173,7 +173,7 @@ await this.jsonWriter.WriteValueAsync(WriterUtils.PrefixTypeNameForWriting(typeN
         /// <param name="propertyName">The name of the property to annotate.</param>
         /// <param name="annotationName">The name of the annotation to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        public Task WritePropertyAnnotationNameAsync(string propertyName, string annotationName)
+        public async Task WritePropertyAnnotationNameAsync(string propertyName, string annotationName)
         {
             Debug.Assert(this.jsonWriter != null, "this.jsonWriter != null");
             Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
@@ -181,7 +181,7 @@ public Task WritePropertyAnnotationNameAsync(string propertyName, string annotat
             Debug.Assert(annotationName.StartsWith(JsonLightConstants.ODataAnnotationNamespacePrefix,
                 StringComparison.Ordinal), "annotationName.StartsWith(\"odata.\")");
 
-            return this.jsonWriter.WritePropertyAnnotationNameAsync(propertyName, SimplifyODataAnnotationName(annotationName));
+            await this.jsonWriter.WritePropertyAnnotationNameAsync(propertyName, SimplifyODataAnnotationName(annotationName));
         }
 
         /// <summary>
@@ -189,14 +189,14 @@ public Task WritePropertyAnnotationNameAsync(string propertyName, string annotat
         /// </summary>
         /// <param name="annotationName">The name of the instance annotation to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        public Task WriteInstanceAnnotationNameAsync(string annotationName)
+        public async Task WriteInstanceAnnotationNameAsync(string annotationName)
         {
             Debug.Assert(this.jsonWriter != null, "this.jsonWriter != null");
             Debug.Assert(!string.IsNullOrEmpty(annotationName), "!string.IsNullOrEmpty(annotationName)");
             Debug.Assert(annotationName.StartsWith(JsonLightConstants.ODataAnnotationNamespacePrefix,
                 StringComparison.Ordinal), "annotationName.StartsWith(\"odata.\")");
 
-            return this.jsonWriter.WriteInstanceAnnotationNameAsync(SimplifyODataAnnotationName(annotationName));
+            await this.jsonWriter.WriteInstanceAnnotationNameAsync(SimplifyODataAnnotationName(annotationName));
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightBatchWriter.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightBatchWriter.cs
index ce96e0a3ed..23419d7f72 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightBatchWriter.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightBatchWriter.cs
@@ -909,7 +909,7 @@ private void WriteRequestUri(Uri uri, BatchPayloadUriOption payloadUriOption)
         /// Asynchronously writes the start boundary for an operation. This is Json start object.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private Task WriteStartBoundaryForOperationAsync()
+        private ValueTask WriteStartBoundaryForOperationAsync()
         {
             // Start the individual message object
             return this.jsonWriter.StartObjectScopeAsync();
@@ -981,7 +981,7 @@ await this.EnsurePrecedingMessageIsClosedAsync()
         /// Asynchronously closes preceding message Json object if any.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private Task EnsurePrecedingMessageIsClosedAsync()
+        private ValueTask EnsurePrecedingMessageIsClosedAsync()
         {
             // There shouldn't be any pending message object.
             Debug.Assert(this.CurrentOperationMessage == null, "this.CurrentOperationMessage == null");
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightCollectionWriter.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightCollectionWriter.cs
index e05616d83b..e101e5e0bb 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightCollectionWriter.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightCollectionWriter.cs
@@ -179,9 +179,9 @@ protected override Task StartPayloadAsync()
         /// Asynchronously finish writing an OData payload.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected override Task EndPayloadAsync()
+        protected async override Task EndPayloadAsync()
         {
-            return this.jsonLightCollectionSerializer.WritePayloadEndAsync();
+            await this.jsonLightCollectionSerializer.WritePayloadEndAsync();
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightDeltaWriter.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightDeltaWriter.cs
index 1ca2ed129d..fdce5e2a8e 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightDeltaWriter.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightDeltaWriter.cs
@@ -121,7 +121,7 @@ public override void WriteStart(ODataDeltaResourceSet deltaResourceSet)
         /// </summary>
         /// <param name="deltaResourceSet">Delta resource set/collection to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
+        public override ValueTask WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
         {
             return this.resourceWriter.WriteStartAsync(deltaResourceSet);
         }
@@ -138,7 +138,7 @@ public override void WriteEnd()
         /// Asynchronously finish writing a delta resource set.
         /// </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteEndAsync()
+        public override ValueTask WriteEndAsync()
         {
             return this.resourceWriter.WriteEndAsync();
         }
@@ -157,7 +157,7 @@ public override void WriteStart(ODataNestedResourceInfo nestedResourceInfo)
         /// </summary>
         /// <param name="nestedResourceInfo">The nested resource info to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
+        public override ValueTask WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
         {
             return this.resourceWriter.WriteStartAsync(nestedResourceInfo);
         }
@@ -176,7 +176,7 @@ public override void WriteStart(ODataResourceSet expandedResourceSet)
         /// </summary>
         /// <param name="expandedResourceSet">The expanded resource set to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteStartAsync(ODataResourceSet expandedResourceSet)
+        public override ValueTask WriteStartAsync(ODataResourceSet expandedResourceSet)
         {
             return this.resourceWriter.WriteStartAsync(expandedResourceSet);
         }
@@ -195,7 +195,7 @@ public override void WriteStart(ODataResource deltaResource)
         /// </summary>
         /// <param name="deltaResource">The delta resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteStartAsync(ODataResource deltaResource)
+        public override ValueTask WriteStartAsync(ODataResource deltaResource)
         {
             return this.resourceWriter.WriteStartAsync(deltaResource);
         }
@@ -215,7 +215,7 @@ public override void WriteDeltaDeletedEntry(ODataDeltaDeletedEntry deltaDeletedE
         /// </summary>
         /// <param name="deltaDeletedEntry">The delta deleted resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteDeltaDeletedEntryAsync(ODataDeltaDeletedEntry deltaDeletedEntry)
+        public override ValueTask WriteDeltaDeletedEntryAsync(ODataDeltaDeletedEntry deltaDeletedEntry)
         {
             return this.resourceWriter.WriteStartAsync(ODataDeltaDeletedEntry.GetDeletedResource(deltaDeletedEntry));
         }
@@ -234,7 +234,7 @@ public override void WriteDeltaLink(ODataDeltaLink deltaLink)
         /// </summary>
         /// <param name="deltaLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
+        public override ValueTask WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
         {
             return this.resourceWriter.WriteDeltaLinkAsync(deltaLink);
         }
@@ -253,7 +253,7 @@ public override void WriteDeltaDeletedLink(ODataDeltaDeletedLink deltaDeletedLin
         /// </summary>
         /// <param name="deltaDeletedLink">The delta deleted link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink)
+        public override ValueTask WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink)
         {
             return this.resourceWriter.WriteDeltaDeletedLinkAsync(deltaDeletedLink);
         }
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightInputContext.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightInputContext.cs
index d6e601d3c1..ed2894d314 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightInputContext.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightInputContext.cs
@@ -188,13 +188,14 @@ public override ODataReader CreateResourceSetReader(IEdmEntitySetBase entitySet,
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public override Task<ODataReader> CreateResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async override ValueTask<ODataReader> CreateResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateODataReader(entitySet, expectedResourceType);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ false, /*readingDelta*/ false));
+            ODataReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ false, /*readingDelta*/ false));
+            return reader;
         }
 
         /// <summary>
@@ -217,13 +218,14 @@ public override ODataReader CreateDeltaResourceSetReader(IEdmEntitySetBase entit
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public override Task<ODataReader> CreateDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async override ValueTask<ODataReader> CreateDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateODataReader(entitySet, expectedResourceType);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ false, /*readingDelta*/ true));
+            ODataReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ false, /*readingDelta*/ true));
+            return reader;
         }
 
         /// <summary>
@@ -246,13 +248,14 @@ public override ODataReader CreateResourceReader(IEdmNavigationSource navigation
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the resource to be read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public override Task<ODataReader> CreateResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
+        public async override ValueTask<ODataReader> CreateResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateODataReader(navigationSource, expectedResourceType);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceReaderImplementation(navigationSource, expectedResourceType));
+            ODataReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceReaderImplementation(navigationSource, expectedResourceType));
+            return reader;
         }
 
         /// <summary>
@@ -273,13 +276,14 @@ public override ODataCollectionReader CreateCollectionReader(IEdmTypeReference e
         /// </summary>
         /// <param name="expectedItemTypeReference">The expected type reference for the items in the collection.</param>
         /// <returns>Task which when completed returns the newly create <see cref="ODataCollectionReader"/>.</returns>
-        public override Task<ODataCollectionReader> CreateCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
+        public async override ValueTask<ODataCollectionReader> CreateCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateCollectionReader(expectedItemTypeReference);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateCollectionReaderImplementation(expectedItemTypeReference));
+            ODataCollectionReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateCollectionReaderImplementation(expectedItemTypeReference));
+            return reader;
         }
 
         /// <summary>
@@ -305,13 +309,14 @@ public override ODataProperty ReadProperty(IEdmStructuralProperty property, IEdm
         /// <param name="property">The <see cref="IEdmProperty"/> producing the property to be read.</param>
         /// <param name="expectedPropertyTypeReference">The expected type reference of the property to read.</param>
         /// <returns>Task which when completed returns an <see cref="ODataProperty"/> representing the read property.</returns>
-        public override Task<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty property, IEdmTypeReference expectedPropertyTypeReference)
+        public async override ValueTask<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty property, IEdmTypeReference expectedPropertyTypeReference)
         {
             this.AssertAsynchronous();
             this.VerifyCanReadProperty();
 
             ODataJsonLightPropertyAndValueDeserializer jsonLightPropertyAndValueDeserializer = new ODataJsonLightPropertyAndValueDeserializer(this);
-            return jsonLightPropertyAndValueDeserializer.ReadTopLevelPropertyAsync(expectedPropertyTypeReference);
+            ODataProperty oDataProperty = await jsonLightPropertyAndValueDeserializer.ReadTopLevelPropertyAsync(expectedPropertyTypeReference);
+            return oDataProperty;
         }
 
 
@@ -331,12 +336,13 @@ public override ODataError ReadError()
         /// Asynchronously read a top-level error.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataError"/> representing the read error.</returns>
-        public override Task<ODataError> ReadErrorAsync()
+        public async override ValueTask<ODataError> ReadErrorAsync()
         {
             this.AssertAsynchronous();
 
             ODataJsonLightErrorDeserializer jsonLightErrorDeserializer = new ODataJsonLightErrorDeserializer(this);
-            return jsonLightErrorDeserializer.ReadTopLevelErrorAsync();
+            ODataError error = await jsonLightErrorDeserializer.ReadTopLevelErrorAsync();
+            return error;
         }
 
         /// <summary>
@@ -359,12 +365,13 @@ public override ODataReader CreateUriParameterResourceSetReader(IEdmEntitySetBas
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public override Task<ODataReader> CreateUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async override ValueTask<ODataReader> CreateUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateODataReader(entitySet, expectedResourceType);
 
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ true, /*readingDelta*/ false));
+            ODataReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateResourceSetReaderImplementation(entitySet, expectedResourceType, /*readingParameter*/ true, /*readingDelta*/ false));
+            return reader;
         }
 
         /// <summary>
@@ -384,9 +391,10 @@ public override ODataReader CreateUriParameterResourceReader(IEdmNavigationSourc
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the resource to be read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public override Task<ODataReader> CreateUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
+        public async override ValueTask<ODataReader> CreateUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
         {
-            return this.CreateResourceReaderAsync(navigationSource, expectedResourceType);
+            ODataReader reader = await this.CreateResourceReaderAsync(navigationSource, expectedResourceType);
+            return reader;
         }
 
         /// <summary>
@@ -407,13 +415,14 @@ public override ODataParameterReader CreateParameterReader(IEdmOperation operati
         /// </summary>
         /// <param name="operation">The operation whose parameters are being read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataParameterReader"/>.</returns>
-        public override Task<ODataParameterReader> CreateParameterReaderAsync(IEdmOperation operation)
+        public async override ValueTask<ODataParameterReader> CreateParameterReaderAsync(IEdmOperation operation)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateParameterReader(operation);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateParameterReaderImplementation(operation));
+            ODataParameterReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateParameterReaderImplementation(operation));
+            return reader;
         }
 
         /// <summary>
@@ -464,13 +473,14 @@ internal override ODataDeltaReader CreateDeltaReader(IEdmEntitySetBase entitySet
         /// <param name="entitySet">The entity set we are going to read entities for.</param>
         /// <param name="expectedBaseEntityType">The expected base entity type for the entries in the delta response.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataDeltaReader"/>.</returns>
-        internal override Task<ODataDeltaReader> CreateDeltaReaderAsync(IEdmEntitySetBase entitySet, IEdmEntityType expectedBaseEntityType)
+        internal async override ValueTask<ODataDeltaReader> CreateDeltaReaderAsync(IEdmEntitySetBase entitySet, IEdmEntityType expectedBaseEntityType)
         {
             this.AssertAsynchronous();
             this.VerifyCanCreateODataReader(entitySet, expectedBaseEntityType);
 
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateDeltaReaderImplementation(entitySet, expectedBaseEntityType));
+            ODataDeltaReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateDeltaReaderImplementation(entitySet, expectedBaseEntityType));
+            return reader;
         }
 
         /// <summary>
@@ -486,10 +496,11 @@ internal override ODataBatchReader CreateBatchReader()
         /// Asynchronously create a <see cref="ODataBatchReader"/>.
         /// </summary>
         /// <returns>Task which when completed returns the newly created <see cref="ODataCollectionReader"/>.</returns>
-        internal override Task<ODataBatchReader> CreateBatchReaderAsync()
+        internal async override ValueTask<ODataBatchReader> CreateBatchReaderAsync()
         {
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateBatchReaderImplementation(/*synchronous*/ false));
+            ODataBatchReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateBatchReaderImplementation(/*synchronous*/ false));
+            return reader;
         }
 
         /// <summary>
@@ -512,12 +523,13 @@ internal override ODataServiceDocument ReadServiceDocument()
         /// an <see cref="ODataServiceDocument"/> that represents the read service document.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataServiceDocument"/> representing the read service document.</returns>
-        internal override Task<ODataServiceDocument> ReadServiceDocumentAsync()
+        internal async override ValueTask<ODataServiceDocument> ReadServiceDocumentAsync()
         {
             this.AssertAsynchronous();
 
             ODataJsonLightServiceDocumentDeserializer jsonLightServiceDocumentDeserializer = new ODataJsonLightServiceDocumentDeserializer(this);
-            return jsonLightServiceDocumentDeserializer.ReadServiceDocumentAsync();
+            ODataServiceDocument document = await jsonLightServiceDocumentDeserializer.ReadServiceDocumentAsync();
+            return document;
         }
 
         /// <summary>
@@ -536,12 +548,13 @@ internal override ODataEntityReferenceLinks ReadEntityReferenceLinks()
         /// Asynchronously read a set of top-level entity reference links.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataEntityReferenceLinks"/> representing the read links.</returns>
-        internal override Task<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
+        internal async override ValueTask<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
         {
             this.AssertAsynchronous();
 
             ODataJsonLightEntityReferenceLinkDeserializer jsonLightEntityReferenceLinkDeserializer = new ODataJsonLightEntityReferenceLinkDeserializer(this);
-            return jsonLightEntityReferenceLinkDeserializer.ReadEntityReferenceLinksAsync();
+            ODataEntityReferenceLinks links = await jsonLightEntityReferenceLinkDeserializer.ReadEntityReferenceLinksAsync();
+            return links;
         }
 
         /// <summary>
@@ -561,13 +574,14 @@ internal override ODataEntityReferenceLink ReadEntityReferenceLink()
         /// Asynchronously read a top-level entity reference link.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataEntityReferenceLink"/> representing the read entity reference link.</returns>
-        internal override Task<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
+        internal async override ValueTask<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
         {
             this.AssertAsynchronous();
             this.VerifyCanReadEntityReferenceLink();
 
             ODataJsonLightEntityReferenceLinkDeserializer jsonLightEntityReferenceLinkDeserializer = new ODataJsonLightEntityReferenceLinkDeserializer(this);
-            return jsonLightEntityReferenceLinkDeserializer.ReadEntityReferenceLinkAsync();
+            ODataEntityReferenceLink link = await jsonLightEntityReferenceLinkDeserializer.ReadEntityReferenceLinkAsync();
+            return link;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightOutputContext.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightOutputContext.cs
index e6c6c5f54c..7d24fef6e5 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightOutputContext.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightOutputContext.cs
@@ -221,11 +221,11 @@ public override ODataWriter CreateODataResourceSetWriter(IEdmEntitySetBase entit
         /// <param name="resourceType">The resource type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
+        public async override ValueTask<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 entitySetParam,
                 resourceTypeParam) => thisParam.CreateODataResourceSetWriterImplementation(
@@ -236,6 +236,8 @@ public override Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySe
                 this,
                 entitySet,
                 resourceType);
+
+            return writer;
         }
 
         /// <summary>
@@ -259,11 +261,11 @@ public override ODataWriter CreateODataDeltaResourceSetWriter(IEdmEntitySetBase
         /// <param name="resourceType">The resource type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
+        public async override ValueTask<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 entitySetParam,
                 resourceTypeParam) => thisParam.CreateODataResourceSetWriterImplementation(
@@ -274,6 +276,8 @@ public override Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEnt
                 this,
                 entitySet,
                 resourceType);
+
+            return writer;
         }
 
         /// <summary>
@@ -297,11 +301,11 @@ public override ODataWriter CreateODataResourceWriter(IEdmNavigationSource navig
         /// <param name="resourceType">The structured type for the resources in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public async override ValueTask<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 navigationSourceParam,
                 resourceTypeParam) => thisParam.CreateODataResourceWriterImplementation(
@@ -310,6 +314,8 @@ public override Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationS
                 this,
                 navigationSource,
                 resourceType);
+
+            return writer;
         }
 
         /// <summary>
@@ -331,16 +337,18 @@ public override ODataCollectionWriter CreateODataCollectionWriter(IEdmTypeRefere
         /// <param name="itemTypeReference">The item type of the collection being written or null if no metadata is available.</param>
         /// <returns>A running task for the created collection writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
+        public async override ValueTask<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataCollectionWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 itemTypeReferenceParam) => thisParam.CreateODataCollectionWriterImplementation(
                     itemTypeReferenceParam),
                 this,
                 itemTypeReference);
+
+            return writer;
         }
 
         /// <summary>
@@ -362,9 +370,10 @@ public override ODataWriter CreateODataUriParameterResourceWriter(IEdmNavigation
         /// <param name="resourceType">The structured type for the resources in the resource set to be written.</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public async override ValueTask<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
-            return this.CreateODataResourceWriterAsync(navigationSource, resourceType);
+            ODataWriter writer = await this.CreateODataResourceWriterAsync(navigationSource, resourceType);
+            return writer;
         }
 
         /// <summary>
@@ -388,11 +397,11 @@ public override ODataWriter CreateODataUriParameterResourceSetWriter(IEdmEntityS
         /// <param name="resourceType">The resource type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
+        public async override ValueTask<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 entitySetParam,
                 resourceTypeParam) => thisParam.CreateODataResourceSetWriterImplementation(
@@ -403,6 +412,8 @@ public override Task<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(
                 this,
                 entitySet,
                 resourceType);
+
+            return writer;
         }
 
         /// <summary>
@@ -424,16 +435,18 @@ public override ODataParameterWriter CreateODataParameterWriter(IEdmOperation op
         /// <param name="operation">The operation import whose parameters will be written.</param>
         /// <returns>A running task for the created parameter writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public override Task<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
+        public async override ValueTask<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataParameterWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 operationParam) => thisParam.CreateODataParameterWriterImplementation(
                     operationParam),
                 this,
                 operation);
+
+            return writer;
         }
 
         /// <summary>
@@ -455,7 +468,7 @@ public override void WriteProperty(ODataProperty property)
         /// <param name="property">The property to write</param>
         /// <returns>A task representing the asynchronous operation of writing the property.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        public override async Task WritePropertyAsync(ODataProperty property)
+        public override async ValueTask WritePropertyAsync(ODataProperty property)
         {
             this.AssertAsynchronous();
 
@@ -492,7 +505,7 @@ public override void WriteError(ODataError error, bool includeDebugInformation)
         /// </param>
         /// <returns>A task representing the asynchronous operation of writing the error.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        public override async Task WriteErrorAsync(ODataError error, bool includeDebugInformation)
+        public override async ValueTask WriteErrorAsync(ODataError error, bool includeDebugInformation)
         {
             this.AssertAsynchronous();
 
@@ -604,13 +617,15 @@ internal override ODataBatchWriter CreateODataBatchWriter()
         /// <returns>A running task for the created batch writer.</returns>
         /// <remarks>We don't plan to make this public!</remarks>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal override Task<ODataBatchWriter> CreateODataBatchWriterAsync()
+        internal async override ValueTask<ODataBatchWriter> CreateODataBatchWriterAsync()
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation(
+            ODataBatchWriter writer = await TaskUtils.GetTaskForSynchronousOperation(
                 thisParam => thisParam.CreateODataBatchWriterImplementation(),
                 this);
+
+            return writer;
         }
 
         /// <summary>
@@ -654,7 +669,7 @@ internal override void WriteInStreamError(ODataError error, bool includeDebugInf
         /// the in-stream error is written.
         /// It is the responsibility of this method to flush the output before the task finishes.
         /// </remarks>
-        internal override async Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
+        internal override async ValueTask WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
         {
             this.AssertAsynchronous();
 
@@ -684,11 +699,11 @@ internal override ODataDeltaWriter CreateODataDeltaWriter(IEdmEntitySetBase enti
         /// <param name="entityType">The entity type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal override Task<ODataDeltaWriter> CreateODataDeltaWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
+        internal async override ValueTask<ODataDeltaWriter> CreateODataDeltaWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation((
+            ODataDeltaWriter writer = await TaskUtils.GetTaskForSynchronousOperation((
                 thisParam,
                 entitySetParam,
                 entityTypeParam) => thisParam.CreateODataDeltaWriterImplementation(
@@ -697,6 +712,8 @@ internal override Task<ODataDeltaWriter> CreateODataDeltaWriterAsync(IEdmEntityS
                 this,
                 entitySet,
                 entityType);
+
+            return writer;
         }
 
         /// <summary>
@@ -720,7 +737,7 @@ internal override void WriteServiceDocument(ODataServiceDocument serviceDocument
         /// <param name="serviceDocument">The service document to write.</param>
         /// <returns>A task representing the asynchronous operation of writing the service document.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override async Task WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
+        internal override async ValueTask WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
         {
             this.AssertAsynchronous();
 
@@ -749,7 +766,7 @@ internal override void WriteEntityReferenceLinks(ODataEntityReferenceLinks links
         /// <param name="links">The entity reference links to write as message payload.</param>
         /// <returns>A task representing the asynchronous writing of the entity reference links.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override async Task WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
+        internal override async ValueTask WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
         {
             this.AssertAsynchronous();
 
@@ -778,7 +795,7 @@ internal override void WriteEntityReferenceLink(ODataEntityReferenceLink link)
         /// <param name="link">The link result to write as message payload.</param>
         /// <returns>A running task representing the writing of the link.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override async Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
+        internal override async ValueTask WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
         {
             this.AssertAsynchronous();
 
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightPropertySerializer.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightPropertySerializer.cs
index 59e1349367..83a69c3eaf 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightPropertySerializer.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightPropertySerializer.cs
@@ -974,7 +974,7 @@ await this.WriteStreamInfoAsync(propertyName, streamInfo)
         /// <param name="isTopLevel">If writing top level property.</param>
         /// <param name="isUndeclaredProperty">If writing an undeclared property.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private Task WriteInstanceAnnotationAsync(ODataPropertyInfo property, bool isTopLevel, bool isUndeclaredProperty)
+        private ValueTask WriteInstanceAnnotationAsync(ODataPropertyInfo property, bool isTopLevel, bool isUndeclaredProperty)
         {
             if (property.InstanceAnnotations.Count != 0)
             {
@@ -988,7 +988,7 @@ private Task WriteInstanceAnnotationAsync(ODataPropertyInfo property, bool isTop
                 }
             }
 
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightReader.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightReader.cs
index dd26083b77..d217ff2e4b 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightReader.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightReader.cs
@@ -479,9 +479,10 @@ protected override TextReader CreateTextReaderImplementation()
         /// A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="Stream"/> for reading the stream property.
         /// </returns>
-        protected override Task<Stream> CreateReadStreamImplementationAsync()
+        protected async override Task<Stream> CreateReadStreamImplementationAsync()
         {
-            return this.jsonLightInputContext.JsonReader.CreateReadStreamAsync();
+            Stream stream = await this.jsonLightInputContext.JsonReader.CreateReadStreamAsync();
+            return stream;
         }
 
         /// <summary>
@@ -491,9 +492,10 @@ protected override Task<Stream> CreateReadStreamImplementationAsync()
         /// A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="TextReader"/> for reading the string property.
         /// </returns>
-        protected override Task<TextReader> CreateTextReaderImplementationAsync()
+        protected async override Task<TextReader> CreateTextReaderImplementationAsync()
         {
-            return this.jsonLightInputContext.JsonReader.CreateTextReaderAsync();
+            TextReader reader = await this.jsonLightInputContext.JsonReader.CreateTextReaderAsync();
+            return reader;
         }
 
         #endregion
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightResourceDeserializer.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightResourceDeserializer.cs
index 9bfcf6be44..6216d778ab 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightResourceDeserializer.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightResourceDeserializer.cs
@@ -3681,14 +3681,12 @@ await this.ReadOverPropertyNameAsync()
         /// Asynchronously reads over the current property name if positioned on a property
         /// </summary>
         /// <returns>A task that represents the asynchronous read operation.</returns>
-        private Task ReadOverPropertyNameAsync()
+        private async ValueTask ReadOverPropertyNameAsync()
         {
             if (this.JsonReader.NodeType == JsonNodeType.Property)
             {
-                return this.JsonReader.ReadAsync();
+                await this.JsonReader.ReadAsync();
             }
-
-            return TaskUtils.CompletedTask;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightSerializer.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightSerializer.cs
index 4d36bf1690..d6835c37f6 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightSerializer.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightSerializer.cs
@@ -243,14 +243,14 @@ async Task WritePayloadStartInnerAsync(IJsonWriter localJsonWriter, string jsonP
         /// Asynchronously writes the end of the entire JSON payload.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal Task WritePayloadEndAsync()
+        internal ValueTask WritePayloadEndAsync()
         {
             if (this.MessageWriterSettings.HasJsonPaddingFunction())
             {
                 return this.JsonWriter.EndPaddingFunctionScopeAsync();
             }
 
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         /// <summary>
@@ -293,7 +293,7 @@ internal async Task<ODataContextUrlInfo> WriteContextUriPropertyAsync(
         /// </summary>
         /// <param name="payloadWriterFunc">The delegate that writes the actual JSON payload that is being wrapped.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal async Task WriteTopLevelPayloadAsync(Func<Task> payloadWriterFunc)
+        internal async ValueTask WriteTopLevelPayloadAsync(Func<ValueTask> payloadWriterFunc)
         {
             Debug.Assert(payloadWriterFunc != null, "payloadWriterAction != null");
 
@@ -310,7 +310,7 @@ internal async Task WriteTopLevelPayloadAsync(Func<Task> payloadWriterFunc)
         /// <param name="error">The error instance to write.</param>
         /// <param name="includeDebugInformation">A flag indicating whether error details should be written (in debug mode only) or not.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        internal Task WriteTopLevelErrorAsync(ODataError error, bool includeDebugInformation)
+        internal ValueTask WriteTopLevelErrorAsync(ODataError error, bool includeDebugInformation)
         {
             Debug.Assert(error != null, "error != null");
 
@@ -598,8 +598,8 @@ protected async Task WriteTopLevelPayloadAsync<TArg1, TArg2>(
         /// <param name="arg2">The second argument value provided to the <paramref name="payloadWriterFunc"/> delegate.</param>
         /// <param name="arg3">The third argument value provided to the <paramref name="payloadWriterFunc"/> delegate.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected async Task WriteTopLevelPayloadAsync<TArg1, TArg2, TArg3>(
-            Func<TArg1, TArg2, TArg3, Task> payloadWriterFunc,
+        protected async ValueTask WriteTopLevelPayloadAsync<TArg1, TArg2, TArg3>(
+            Func<TArg1, TArg2, TArg3, ValueTask> payloadWriterFunc,
             TArg1 arg1,
             TArg2 arg2,
             TArg3 arg3)
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightValueSerializer.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightValueSerializer.cs
index c7aa56719d..e20aa32d24 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightValueSerializer.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightValueSerializer.cs
@@ -402,9 +402,9 @@ public virtual void WriteStreamValue(ODataBinaryStreamValue streamValue)
         /// Asynchronously writes a null value to the writer.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        public virtual Task WriteNullValueAsync()
+        public async virtual Task WriteNullValueAsync()
         {
-            return this.JsonWriter.WriteValueAsync((string)null);
+            await this.JsonWriter.WriteValueAsync((string)null);
         }
 
         /// <summary>
@@ -413,17 +413,17 @@ public virtual Task WriteNullValueAsync()
         /// <param name="value">enum value</param>
         /// <param name="expectedTypeReference">expected type reference</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        public virtual Task WriteEnumValueAsync(
+        public async virtual Task WriteEnumValueAsync(
             ODataEnumValue value,
             IEdmTypeReference expectedTypeReference)
         {
             if (value.Value == null)
             {
-                return this.WriteNullValueAsync();
+                await this.WriteNullValueAsync();
             }
             else
             {
-                return this.JsonWriter.WritePrimitiveValueAsync(value.Value);
+                await this.JsonWriter.WritePrimitiveValueAsync(value.Value);
             }
         }
 
@@ -713,7 +713,7 @@ await TaskUtils.GetTaskForSynchronousOperation(
         /// </summary>
         /// <param name="value">The untyped value to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        public virtual Task WriteUntypedValueAsync(
+        public async virtual Task WriteUntypedValueAsync(
             ODataUntypedValue value)
         {
             Debug.Assert(value != null, "value != null");
@@ -723,7 +723,7 @@ public virtual Task WriteUntypedValueAsync(
                 throw new ODataException(ODataErrorStrings.ODataJsonLightValueSerializer_MissingRawValueOnUntyped);
             }
 
-            return this.JsonWriter.WriteRawValueAsync(value.RawValue);
+            await this.JsonWriter.WriteRawValueAsync(value.RawValue);
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriter.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriter.cs
index af49416fc5..0c22989e20 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriter.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriter.cs
@@ -1265,9 +1265,9 @@ protected override Task StartPayloadAsync()
         /// Asynchronously ends writing a payload (called exactly once after everything else in case of success)
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected override Task EndPayloadAsync()
+        protected async override Task EndPayloadAsync()
         {
-            return this.jsonLightResourceSerializer.WritePayloadEndAsync();
+            await this.jsonLightResourceSerializer.WritePayloadEndAsync();
         }
 
         /// <summary>
@@ -1739,13 +1739,13 @@ await this.jsonWriter.StartArrayScopeAsync()
         /// </summary>
         /// <param name="deltaResourceSet">The resource set to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected override Task EndDeltaResourceSetAsync(ODataDeltaResourceSet deltaResourceSet)
+        protected async override Task EndDeltaResourceSetAsync(ODataDeltaResourceSet deltaResourceSet)
         {
             Debug.Assert(deltaResourceSet != null, "deltaResourceSet != null");
 
             if (this.ParentNestedResourceInfo == null)
             {
-                return EndDeltaResourceSetInnerAsync(deltaResourceSet);
+                await EndDeltaResourceSetInnerAsync(deltaResourceSet);
 
                 async Task EndDeltaResourceSetInnerAsync(ODataDeltaResourceSet innerDeltaResourceSet)
                 {
@@ -1774,7 +1774,7 @@ await this.jsonWriter.EndObjectScopeAsync()
             else
             {
                 // End the array which holds the entries in the resource set.
-                return this.jsonWriter.EndArrayScopeAsync();
+                await this.jsonWriter.EndArrayScopeAsync();
             }
         }
 
@@ -1857,15 +1857,15 @@ await this.WriteDeletedEntryContentsAsync(resource)
         /// </summary>
         /// <param name="deletedResource">The resource to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected override Task EndDeletedResourceAsync(ODataDeletedResource deletedResource)
+        protected async override Task EndDeletedResourceAsync(ODataDeletedResource deletedResource)
         {
             if (deletedResource == null)
             {
-                return TaskUtils.CompletedTask;
+                return;
             }
 
             // Close the object scope
-            return this.jsonWriter.EndObjectScopeAsync();
+            await this.jsonWriter.EndObjectScopeAsync();
         }
 
         /// <summary>
@@ -1935,11 +1935,11 @@ await this.jsonWriter.FlushAsync()
         /// Asynchronously finish writing a stream value.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected sealed override Task EndBinaryStreamAsync()
+        protected async sealed override Task EndBinaryStreamAsync()
         {
             if (this.jsonWriter == null)
             {
-                return EndBinaryStreamInnerAsync();
+                await EndBinaryStreamInnerAsync();
 
                 async Task EndBinaryStreamInnerAsync()
                 {
@@ -1953,7 +1953,7 @@ await this.jsonLightOutputContext.BinaryValueStream.FlushAsync()
             }
             else
             {
-                return this.jsonWriter.EndStreamValueScopeAsync();
+                await this.jsonWriter.EndStreamValueScopeAsync();
             }
         }
 
@@ -1989,9 +1989,9 @@ await this.jsonWriter.FlushAsync()
         /// Asynchronously finish writing a text value.
         /// </summary>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        protected sealed override Task EndTextWriterAsync()
+        protected async sealed override Task EndTextWriterAsync()
         {
-            return this.jsonWriter.EndTextWriterValueScopeAsync();
+            await this.jsonWriter.EndTextWriterValueScopeAsync();
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriterUtils.cs b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriterUtils.cs
index b61fec0433..7f4ec880ec 100644
--- a/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriterUtils.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ODataJsonLightWriterUtils.cs
@@ -60,7 +60,7 @@ internal static void WriteInstanceAnnotationName(this IJsonWriter jsonWriter, st
         /// Writes the 'value' property name asynchronously.
         /// </summary>
         /// <param name="jsonWriter">The JSON writer to write to.</param>
-        internal static Task WriteValuePropertyNameAsync(this IJsonWriter jsonWriter)
+        internal static ValueTask WriteValuePropertyNameAsync(this IJsonWriter jsonWriter)
         {
             Debug.Assert(jsonWriter != null, "jsonWriter != null");
 
@@ -73,7 +73,7 @@ internal static Task WriteValuePropertyNameAsync(this IJsonWriter jsonWriter)
         /// <param name="jsonWriter">The JSON writer to write to.</param>
         /// <param name="propertyName">The name of the property to annotate.</param>
         /// <param name="annotationName">The name of the annotation to write.</param>
-        internal static Task WritePropertyAnnotationNameAsync(this IJsonWriter jsonWriter, string propertyName, string annotationName)
+        internal static ValueTask WritePropertyAnnotationNameAsync(this IJsonWriter jsonWriter, string propertyName, string annotationName)
         {
             Debug.Assert(jsonWriter != null, "jsonWriter != null");
             Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
@@ -87,7 +87,7 @@ internal static Task WritePropertyAnnotationNameAsync(this IJsonWriter jsonWrite
         /// </summary>
         /// <param name="jsonWriter">The JSON writer to write to.</param>
         /// <param name="annotationName">The name of the instance annotation to write.</param>
-        internal static Task WriteInstanceAnnotationNameAsync(this IJsonWriter jsonWriter, string annotationName)
+        internal static ValueTask WriteInstanceAnnotationNameAsync(this IJsonWriter jsonWriter, string annotationName)
         {
             Debug.Assert(jsonWriter != null, "jsonWriter != null");
             Debug.Assert(!string.IsNullOrEmpty(annotationName), "!string.IsNullOrEmpty(annotationName)");
diff --git a/src/Microsoft.OData.Core/JsonLight/ReorderingJsonReader.cs b/src/Microsoft.OData.Core/JsonLight/ReorderingJsonReader.cs
index 9c932fbfbd..e434ea10bd 100644
--- a/src/Microsoft.OData.Core/JsonLight/ReorderingJsonReader.cs
+++ b/src/Microsoft.OData.Core/JsonLight/ReorderingJsonReader.cs
@@ -92,7 +92,7 @@ public override bool CanStream()
         /// The value of the TResult parameter contains a <see cref="Stream"/> used to read a stream value.
         /// </returns>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1825:Avoid zero-length array allocations.", Justification = "<Pending>")]
-        public override async Task<Stream> CreateReadStreamAsync()
+        public override async ValueTask<Stream> CreateReadStreamAsync()
         {
             Stream result;
             object value = null;
@@ -129,7 +129,7 @@ await this.ReadAsync()
         /// A task that represents the asynchronous read operation.
         /// The value of the TResult parameter contains a <see cref="TextReader"/> for reading the text value.
         /// </returns>
-        public override async Task<TextReader> CreateTextReaderAsync()
+        public override async ValueTask<TextReader> CreateTextReaderAsync()
         {
             if (this.NodeType == JsonNodeType.Property)
             {
@@ -155,7 +155,7 @@ await this.ReadAsync()
         /// A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains true if the current value can be streamed; otherwise false.
         /// </returns>
-        public override async Task<bool> CanStreamAsync()
+        public override async ValueTask<bool> CanStreamAsync()
         {
             object value = await this.GetValueAsync()
                 .ConfigureAwait(false);
diff --git a/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj b/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj
index 4073ef8b23..6c5afa36ec 100644
--- a/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj
+++ b/src/Microsoft.OData.Core/Microsoft.OData.Core.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <AssemblyName>Microsoft.OData.Core</AssemblyName>
     <RootNamespace>Microsoft.OData.Core</RootNamespace>
 
diff --git a/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchInputContext.cs b/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchInputContext.cs
index 29ec177de1..7b6b3c4d2f 100644
--- a/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchInputContext.cs
+++ b/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchInputContext.cs
@@ -63,10 +63,11 @@ internal override ODataBatchReader CreateBatchReader()
         /// Asynchronously create a <see cref="ODataBatchReader"/>.
         /// </summary>
         /// <returns>Task which when completed returns the newly created <see cref="ODataCollectionReader"/>.</returns>
-        internal override Task<ODataBatchReader> CreateBatchReaderAsync()
+        internal async override ValueTask<ODataBatchReader> CreateBatchReaderAsync()
         {
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateBatchReaderImplementation(/*synchronous*/ false));
+            ODataBatchReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateBatchReaderImplementation(/*synchronous*/ false));
+            return reader;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchOutputContext.cs b/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchOutputContext.cs
index 751ea5ae9e..f24c09963d 100644
--- a/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchOutputContext.cs
+++ b/src/Microsoft.OData.Core/MultipartMixed/ODataMultipartMixedBatchOutputContext.cs
@@ -56,13 +56,15 @@ internal override ODataBatchWriter CreateODataBatchWriter()
         /// <returns>A running task for the created batch writer.</returns>
         /// <remarks>We don't plan to make this public!</remarks>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal override Task<ODataBatchWriter> CreateODataBatchWriterAsync()
+        internal async override ValueTask<ODataBatchWriter> CreateODataBatchWriterAsync()
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation(
+            ODataBatchWriter writer = await TaskUtils.GetTaskForSynchronousOperation(
                 thisParam => thisParam.CreateODataBatchWriterImplementation(),
                 this);
+
+            return writer;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/ODataDeltaWriter.cs b/src/Microsoft.OData.Core/ODataDeltaWriter.cs
index 38891241ca..fe871b66f4 100644
--- a/src/Microsoft.OData.Core/ODataDeltaWriter.cs
+++ b/src/Microsoft.OData.Core/ODataDeltaWriter.cs
@@ -27,7 +27,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="deltaResourceSet">Delta resource set/collection to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteStartAsync(ODataDeltaResourceSet deltaResourceSet);
+        public abstract ValueTask WriteStartAsync(ODataDeltaResourceSet deltaResourceSet);
 
         /// <summary>
         /// Finish writing a delta resource set.
@@ -38,7 +38,7 @@ public abstract class ODataDeltaWriter
         /// Asynchronously finish writing a delta resource set.
         /// </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteEndAsync();
+        public abstract ValueTask WriteEndAsync();
 
         /// <summary>
         /// Start writing a nested resource info.
@@ -51,7 +51,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="nestedResourceInfo">The nested resource info to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo);
+        public abstract ValueTask WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo);
 
         /// <summary>
         /// Start writing an expanded resource set.
@@ -64,7 +64,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="expandedResourceSet">The expanded resource set to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteStartAsync(ODataResourceSet expandedResourceSet);
+        public abstract ValueTask WriteStartAsync(ODataResourceSet expandedResourceSet);
 
         /// <summary>
         /// Start writing a delta resource.
@@ -77,7 +77,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="deltaResource">The delta resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteStartAsync(ODataResource deltaResource);
+        public abstract ValueTask WriteStartAsync(ODataResource deltaResource);
 
 
         /// <summary>
@@ -91,7 +91,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="deltaDeletedEntry">The delta deleted resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteDeltaDeletedEntryAsync(ODataDeltaDeletedEntry deltaDeletedEntry);
+        public abstract ValueTask WriteDeltaDeletedEntryAsync(ODataDeltaDeletedEntry deltaDeletedEntry);
 
         /// <summary>
         /// Writing a delta link.
@@ -104,7 +104,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="deltaLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteDeltaLinkAsync(ODataDeltaLink deltaLink);
+        public abstract ValueTask WriteDeltaLinkAsync(ODataDeltaLink deltaLink);
 
         /// <summary>
         /// Writing a delta deleted link.
@@ -117,7 +117,7 @@ public abstract class ODataDeltaWriter
         /// </summary>
         /// <param name="deltaDeletedLink">The delta deleted link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public abstract Task WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink);
+        public abstract ValueTask WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink);
 
         /// <summary>
         /// Flushes the write buffer to the underlying stream.
diff --git a/src/Microsoft.OData.Core/ODataInputContext.cs b/src/Microsoft.OData.Core/ODataInputContext.cs
index 8ed1fc6b6a..4fa1a5d497 100644
--- a/src/Microsoft.OData.Core/ODataInputContext.cs
+++ b/src/Microsoft.OData.Core/ODataInputContext.cs
@@ -193,7 +193,7 @@ public virtual ODataReader CreateResourceSetReader(IEdmEntitySetBase entitySet,
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public virtual Task<ODataReader> CreateResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public virtual ValueTask<ODataReader> CreateResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -215,7 +215,7 @@ public virtual ODataReader CreateDeltaResourceSetReader(IEdmEntitySetBase entity
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public virtual Task<ODataReader> CreateDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public virtual ValueTask<ODataReader> CreateDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -237,7 +237,7 @@ public virtual ODataReader CreateResourceReader(IEdmNavigationSource navigationS
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the resource to be read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public virtual Task<ODataReader> CreateResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
+        public virtual ValueTask<ODataReader> CreateResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Resource);
         }
@@ -257,7 +257,7 @@ public virtual ODataCollectionReader CreateCollectionReader(IEdmTypeReference ex
         /// </summary>
         /// <param name="expectedItemTypeReference">The expected type reference for the items in the collection.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataCollectionReader"/>.</returns>
-        public virtual Task<ODataCollectionReader> CreateCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
+        public virtual ValueTask<ODataCollectionReader> CreateCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Collection);
         }
@@ -281,7 +281,7 @@ public virtual ODataProperty ReadProperty(IEdmStructuralProperty edmStructuralPr
         /// <param name="edmStructuralProperty">The <see cref="IEdmProperty"/> producing the property to be read.</param>
         /// <param name="expectedPropertyTypeReference">The expected type reference of the property to read.</param>
         /// <returns>Task which when completed returns an <see cref="ODataProperty"/> representing the read property.</returns>
-        public virtual Task<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty edmStructuralProperty, IEdmTypeReference expectedPropertyTypeReference)
+        public virtual ValueTask<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty edmStructuralProperty, IEdmTypeReference expectedPropertyTypeReference)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property);
         }
@@ -299,7 +299,7 @@ public virtual ODataError ReadError()
         /// Asynchronously read a top-level error.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataError"/> representing the read error.</returns>
-        public virtual Task<ODataError> ReadErrorAsync()
+        public virtual ValueTask<ODataError> ReadErrorAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error);
         }
@@ -321,7 +321,7 @@ public virtual ODataReader CreateUriParameterResourceReader(IEdmNavigationSource
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the resource to be read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public virtual Task<ODataReader> CreateUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
+        public virtual ValueTask<ODataReader> CreateUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Parameter);
         }
@@ -343,7 +343,7 @@ public virtual ODataReader CreateUriParameterResourceSetReader(IEdmEntitySetBase
         /// <param name="entitySet">The entity set we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the items in the resource set.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataReader"/>.</returns>
-        public virtual Task<ODataReader> CreateUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public virtual ValueTask<ODataReader> CreateUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -363,7 +363,7 @@ public virtual ODataParameterReader CreateParameterReader(IEdmOperation operatio
         /// </summary>
         /// <param name="operation">The operation whose parameters are being read.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataParameterReader"/>.</returns>
-        public virtual Task<ODataParameterReader> CreateParameterReaderAsync(IEdmOperation operation)
+        public virtual ValueTask<ODataParameterReader> CreateParameterReaderAsync(IEdmOperation operation)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Parameter);
         }
@@ -381,7 +381,7 @@ internal virtual ODataAsynchronousReader CreateAsynchronousReader()
         /// Asynchronously create an <see cref="ODataAsynchronousReader"/>.
         /// </summary>
         /// <returns>Task which when completed returns the newly created <see cref="ODataAsynchronousReader"/>.</returns>
-        internal virtual Task<ODataAsynchronousReader> CreateAsynchronousReaderAsync()
+        internal virtual ValueTask<ODataAsynchronousReader> CreateAsynchronousReaderAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Asynchronous);
         }
@@ -403,7 +403,7 @@ internal virtual ODataDeltaReader CreateDeltaReader(IEdmEntitySetBase entitySet,
         /// <param name="entitySet">The entity set we are going to read entities for.</param>
         /// <param name="expectedBaseEntityType">The expected base entity type for the entries in the delta response.</param>
         /// <returns>Task which when completed returns the newly created <see cref="ODataDeltaReader"/>.</returns>
-        internal virtual Task<ODataDeltaReader> CreateDeltaReaderAsync(IEdmEntitySetBase entitySet, IEdmEntityType expectedBaseEntityType)
+        internal virtual ValueTask<ODataDeltaReader> CreateDeltaReaderAsync(IEdmEntitySetBase entitySet, IEdmEntityType expectedBaseEntityType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -427,7 +427,7 @@ internal virtual ODataBatchReader CreateBatchReader()
         /// <remarks>
         /// Since we don't want to support batch format extensibility (at least not yet) this method should remain internal.
         /// </remarks>
-        internal virtual Task<ODataBatchReader> CreateBatchReaderAsync()
+        internal virtual ValueTask<ODataBatchReader> CreateBatchReaderAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Batch);
         }
@@ -449,7 +449,7 @@ internal virtual ODataServiceDocument ReadServiceDocument()
         /// an <see cref="ODataServiceDocument"/> that represents the read service document.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataServiceDocument"/> representing the read service document.</returns>
-        internal virtual Task<ODataServiceDocument> ReadServiceDocumentAsync()
+        internal virtual ValueTask<ODataServiceDocument> ReadServiceDocumentAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ServiceDocument);
         }
@@ -502,7 +502,7 @@ internal virtual ODataEntityReferenceLinks ReadEntityReferenceLinks()
         /// Asynchronously read a set of top-level entity reference links.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataEntityReferenceLinks"/> representing the read links.</returns>
-        internal virtual Task<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
+        internal virtual ValueTask<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.EntityReferenceLinks);
         }
@@ -520,7 +520,7 @@ internal virtual ODataEntityReferenceLink ReadEntityReferenceLink()
         /// Asynchronously read a top-level entity reference link.
         /// </summary>
         /// <returns>Task which when completed returns an <see cref="ODataEntityReferenceLink"/> representing the read entity reference link.</returns>
-        internal virtual Task<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
+        internal virtual ValueTask<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.EntityReferenceLink);
         }
@@ -540,7 +540,7 @@ internal virtual object ReadValue(IEdmPrimitiveTypeReference expectedPrimitiveTy
         /// </summary>
         /// <param name="expectedPrimitiveTypeReference">The expected type reference for the value to be read; null if no expected type is available.</param>
         /// <returns>Task which when completed returns an <see cref="object"/> representing the read value.</returns>
-        internal virtual Task<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
+        internal virtual ValueTask<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Value);
         }
diff --git a/src/Microsoft.OData.Core/ODataMessageReader.cs b/src/Microsoft.OData.Core/ODataMessageReader.cs
index 5b66f67bdb..a9bcfef962 100644
--- a/src/Microsoft.OData.Core/ODataMessageReader.cs
+++ b/src/Microsoft.OData.Core/ODataMessageReader.cs
@@ -256,19 +256,19 @@ public IEnumerable<ODataPayloadKindDetectionResult> DetectPayloadKind()
         /// will always at most return a single result per payload kind.
         /// </remarks>
         [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Need to a return a task of an enumerable.")]
-        public Task<IEnumerable<ODataPayloadKindDetectionResult>> DetectPayloadKindAsync()
+        public async ValueTask<IEnumerable<ODataPayloadKindDetectionResult>> DetectPayloadKindAsync()
         {
             IEnumerable<ODataPayloadKindDetectionResult> payloadKindsFromContentType;
             if (this.TryGetSinglePayloadKindResultFromContentType(out payloadKindsFromContentType))
             {
-                return Task.FromResult(payloadKindsFromContentType);
+                return payloadKindsFromContentType;
             }
 
             // Otherwise we have to do sniffing
             List<ODataPayloadKindDetectionResult> detectedPayloadKinds = new List<ODataPayloadKindDetectionResult>();
 
             // NOTE: this relies on the lazy eval of the enumerator
-            return Task.Factory.Iterate(this.GetPayloadKindDetectionTasks(payloadKindsFromContentType, detectedPayloadKinds))
+            IEnumerable<ODataPayloadKindDetectionResult> results = await Task.Factory.Iterate(this.GetPayloadKindDetectionTasks(payloadKindsFromContentType, detectedPayloadKinds))
                 .FollowAlwaysWith(
                     t =>
                     {
@@ -284,6 +284,8 @@ public Task<IEnumerable<ODataPayloadKindDetectionResult>> DetectPayloadKindAsync
 
                         return (IEnumerable<ODataPayloadKindDetectionResult>)detectedPayloadKinds;
                     });
+
+            return results;
         }
 
         /// <summary>Creates an <see cref="Microsoft.OData.ODataAsynchronousReader" /> to read an async response.</summary>
@@ -298,12 +300,17 @@ public ODataAsynchronousReader CreateODataAsynchronousReader()
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataAsynchronousReader" /> to read an async response.</summary>
         /// <returns>A running task for the created async reader.</returns>
-        public Task<ODataAsynchronousReader> CreateODataAsynchronousReaderAsync()
+        public async ValueTask<ODataAsynchronousReader> CreateODataAsynchronousReaderAsync()
         {
             this.VerifyCanCreateODataAsynchronousReader();
-            return this.ReadFromInputAsync(
-                (context) => context.CreateAsynchronousReaderAsync(),
+            ODataAsynchronousReader reader = await this.ReadFromInputAsync(
+                (context) =>
+                {
+                    return context.CreateAsynchronousReaderAsync();
+                },
                 ODataPayloadKind.Asynchronous);
+
+            return reader;
         }
 
         /// <summary>Creates an <see cref="Microsoft.OData.ODataReader" /> to read a resource set.</summary>
@@ -340,7 +347,7 @@ public ODataReader CreateODataResourceSetReader(IEdmEntitySetBase entitySet, IEd
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataReader" /> to read a resource set.</summary>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceSetReaderAsync()
+        public ValueTask<ODataReader> CreateODataResourceSetReaderAsync()
         {
             return this.CreateODataResourceSetReaderAsync(/*entitySet*/null, /*entityType*/null);
         }
@@ -350,7 +357,7 @@ public Task<ODataReader> CreateODataResourceSetReaderAsync()
         /// </summary>
         /// <param name="expectedResourceType">The expected type for the items in the resource set.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceSetReaderAsync(IEdmStructuredType expectedResourceType)
+        public ValueTask<ODataReader> CreateODataResourceSetReaderAsync(IEdmStructuredType expectedResourceType)
         {
             return this.CreateODataResourceSetReaderAsync(/*entitySet*/null, expectedResourceType);
         }
@@ -361,13 +368,18 @@ public Task<ODataReader> CreateODataResourceSetReaderAsync(IEdmStructuredType ex
         /// <param name="entitySet">The entity set we are going to read entities for.</param>
         /// <param name="expectedResourceType">The expected type for the items in the resource set.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async ValueTask<ODataReader> CreateODataResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.VerifyCanCreateODataResourceSetReader(entitySet, expectedResourceType);
             expectedResourceType = expectedResourceType ?? this.edmTypeResolver.GetElementType(entitySet);
-            return this.ReadFromInputAsync(
-                (context) => context.CreateResourceSetReaderAsync(entitySet, expectedResourceType),
+            ODataReader reader = await this.ReadFromInputAsync(
+                (context) =>
+                {
+                    return context.CreateResourceSetReaderAsync(entitySet, expectedResourceType);
+                },
                 ODataPayloadKind.ResourceSet);
+
+            return reader;
         }
 
         /// <summary>Creates an <see cref="Microsoft.OData.ODataReader" /> to read a delta resource set.</summary>
@@ -404,7 +416,7 @@ public ODataReader CreateODataDeltaResourceSetReader(IEdmEntitySetBase entitySet
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataReader" /> to read a delta resource set.</summary>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataDeltaResourceSetReaderAsync()
+        public ValueTask<ODataReader> CreateODataDeltaResourceSetReaderAsync()
         {
             return this.CreateODataDeltaResourceSetReaderAsync(/*entitySet*/null, /*entityType*/null);
         }
@@ -414,7 +426,7 @@ public Task<ODataReader> CreateODataDeltaResourceSetReaderAsync()
         /// </summary>
         /// <param name="expectedResourceType">The expected type for the items in the resource set.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataDeltaResourceSetReaderAsync(IEdmStructuredType expectedResourceType)
+        public ValueTask<ODataReader> CreateODataDeltaResourceSetReaderAsync(IEdmStructuredType expectedResourceType)
         {
             return this.CreateODataDeltaResourceSetReaderAsync(/*entitySet*/null, expectedResourceType);
         }
@@ -425,13 +437,18 @@ public Task<ODataReader> CreateODataDeltaResourceSetReaderAsync(IEdmStructuredTy
         /// <param name="entitySet">The entity set we are going to read entities for.</param>
         /// <param name="expectedResourceType">The expected type for the items in the resource set.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async ValueTask<ODataReader> CreateODataDeltaResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.VerifyCanCreateODataResourceSetReader(entitySet, expectedResourceType);
             expectedResourceType = expectedResourceType ?? this.edmTypeResolver.GetElementType(entitySet);
-            return this.ReadFromInputAsync(
-                (context) => context.CreateDeltaResourceSetReaderAsync(entitySet, expectedResourceType),
+            ODataReader reader = await this.ReadFromInputAsync(
+                (context) =>
+                {
+                    return context.CreateDeltaResourceSetReaderAsync(entitySet, expectedResourceType);
+                },
                 ODataPayloadKind.Delta);
+
+            return reader;
         }
 
         /// <summary>Creates an <see cref="Microsoft.OData.ODataReader" /> to read a resource.</summary>
@@ -468,7 +485,7 @@ public ODataReader CreateODataResourceReader(IEdmNavigationSource navigationSour
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataReader" /> to read a resource.</summary>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceReaderAsync()
+        public ValueTask<ODataReader> CreateODataResourceReaderAsync()
         {
             return this.CreateODataResourceReaderAsync(/*entitySet*/null, /*entityType*/null);
         }
@@ -478,7 +495,7 @@ public Task<ODataReader> CreateODataResourceReaderAsync()
         /// </summary>
         /// <param name="resourceType">The expected structured type for the resource to be read.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceReaderAsync(IEdmStructuredType resourceType)
+        public ValueTask<ODataReader> CreateODataResourceReaderAsync(IEdmStructuredType resourceType)
         {
             return this.CreateODataResourceReaderAsync(/*entitySet*/null, resourceType);
         }
@@ -489,13 +506,18 @@ public Task<ODataReader> CreateODataResourceReaderAsync(IEdmStructuredType resou
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="resourceType">The expected structured type for the resource to be read.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public async ValueTask<ODataReader> CreateODataResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             this.VerifyCanCreateODataResourceReader(navigationSource, resourceType);
             resourceType = resourceType ?? this.edmTypeResolver.GetElementType(navigationSource);
-            return this.ReadFromInputAsync(
-                (context) => context.CreateResourceReaderAsync(navigationSource, resourceType),
+            ODataReader reader = await this.ReadFromInputAsync(
+                (context) =>
+                {
+                    return context.CreateResourceReaderAsync(navigationSource, resourceType);
+                },
                 ODataPayloadKind.Resource);
+
+            return reader;
         }
 
         /// <summary>Creates an <see cref="Microsoft.OData.ODataCollectionReader" /> to read a collection of primitive or complex values (as result of a service operation invocation).</summary>
@@ -520,7 +542,7 @@ public ODataCollectionReader CreateODataCollectionReader(IEdmTypeReference expec
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataCollectionReader" /> to read a collection of primitive or complex values (as result of a service operation invocation).</summary>
         /// <returns>A running task for the created collection reader.</returns>
-        public Task<ODataCollectionReader> CreateODataCollectionReaderAsync()
+        public ValueTask<ODataCollectionReader> CreateODataCollectionReaderAsync()
         {
             return this.CreateODataCollectionReaderAsync(null /*expectedItemTypeReference*/);
         }
@@ -530,12 +552,14 @@ public Task<ODataCollectionReader> CreateODataCollectionReaderAsync()
         /// </summary>
         /// <param name="expectedItemTypeReference">The expected type reference for the items in the collection.</param>
         /// <returns>A running task for the created collection reader.</returns>
-        public Task<ODataCollectionReader> CreateODataCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
+        public async ValueTask<ODataCollectionReader> CreateODataCollectionReaderAsync(IEdmTypeReference expectedItemTypeReference)
         {
             this.VerifyCanCreateODataCollectionReader(expectedItemTypeReference);
-            return this.ReadFromInputAsync(
+            ODataCollectionReader reader = await this.ReadFromInputAsync(
                 (context) => context.CreateCollectionReaderAsync(expectedItemTypeReference),
                 ODataPayloadKind.Collection);
+
+            return reader;
         }
 
 
@@ -551,12 +575,14 @@ public ODataBatchReader CreateODataBatchReader()
 
         /// <summary>Asynchronously creates an <see cref="Microsoft.OData.ODataBatchReader" /> to read a batch of requests or responses.</summary>
         /// <returns>A running task for the created batch reader.</returns>
-        public Task<ODataBatchReader> CreateODataBatchReaderAsync()
+        public async ValueTask<ODataBatchReader> CreateODataBatchReaderAsync()
         {
             this.VerifyCanCreateODataBatchReader();
-            return this.ReadFromInputAsync(
+            ODataBatchReader reader = await this.ReadFromInputAsync(
                 (context) => context.CreateBatchReaderAsync(),
                 ODataPayloadKind.Batch);
+
+            return reader;
         }
 
         /// <summary>
@@ -580,13 +606,15 @@ public ODataReader CreateODataUriParameterResourceReader(IEdmNavigationSource na
         /// <param name="navigationSource">The navigation source we are going to read resources for.</param>
         /// <param name="expectedResourceType">The expected structured type for the resource to be read.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
+        public async ValueTask<ODataReader> CreateODataUriParameterResourceReaderAsync(IEdmNavigationSource navigationSource, IEdmStructuredType expectedResourceType)
         {
             this.VerifyCanCreateODataResourceReader(navigationSource, expectedResourceType);
             expectedResourceType = expectedResourceType ?? this.edmTypeResolver.GetElementType(navigationSource);
-            return this.ReadFromInputAsync(
+            ODataReader reader = await this.ReadFromInputAsync(
                 (context) => context.CreateUriParameterResourceReaderAsync(navigationSource, expectedResourceType),
                 ODataPayloadKind.Resource);
+
+            return reader;
         }
 
         /// <summary>
@@ -610,13 +638,15 @@ public ODataReader CreateODataUriParameterResourceSetReader(IEdmEntitySetBase en
         /// <param name="entitySet">The entity set we are going to read entities for.</param>
         /// <param name="expectedResourceType">The expected type for the items in the resource set.</param>
         /// <returns>A running task for the created reader.</returns>
-        public Task<ODataReader> CreateODataUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
+        public async ValueTask<ODataReader> CreateODataUriParameterResourceSetReaderAsync(IEdmEntitySetBase entitySet, IEdmStructuredType expectedResourceType)
         {
             this.VerifyCanCreateODataResourceSetReader(entitySet, expectedResourceType);
             expectedResourceType = expectedResourceType ?? this.edmTypeResolver.GetElementType(entitySet);
-            return this.ReadFromInputAsync(
+            ODataReader reader = await this.ReadFromInputAsync(
                 (context) => context.CreateUriParameterResourceSetReaderAsync(entitySet, expectedResourceType),
                 ODataPayloadKind.ResourceSet);
+
+            return reader;
         }
 
         /// <summary>
@@ -637,12 +667,14 @@ public ODataParameterReader CreateODataParameterReader(IEdmOperation operation)
         /// </summary>
         /// <param name="operation">The operation whose parameters are being read.</param>
         /// <returns>A running task for the created parameter reader.</returns>
-        public Task<ODataParameterReader> CreateODataParameterReaderAsync(IEdmOperation operation)
+        public async ValueTask<ODataParameterReader> CreateODataParameterReaderAsync(IEdmOperation operation)
         {
             this.VerifyCanCreateODataParameterReader(operation);
-            return this.ReadFromInputAsync(
+            ODataParameterReader reader = await this.ReadFromInputAsync(
                 (context) => context.CreateParameterReaderAsync(operation),
                 ODataPayloadKind.Parameter);
+
+            return reader;
         }
 
         /// <summary>Reads a service document payload.</summary>
@@ -657,12 +689,14 @@ public ODataServiceDocument ReadServiceDocument()
 
         /// <summary>Asynchronously reads a service document payload.</summary>
         /// <returns>A task representing the asynchronous operation of reading the service document.</returns>
-        public Task<ODataServiceDocument> ReadServiceDocumentAsync()
+        public async ValueTask<ODataServiceDocument> ReadServiceDocumentAsync()
         {
             this.VerifyCanReadServiceDocument();
-            return this.ReadFromInputAsync(
+            ODataServiceDocument document = await this.ReadFromInputAsync(
                 (context) => context.ReadServiceDocumentAsync(),
                 ODataPayloadKind.ServiceDocument);
+
+            return document;
         }
 
         /// <summary>Reads an <see cref="Microsoft.OData.ODataProperty" /> as message payload.</summary>
@@ -701,7 +735,7 @@ public ODataProperty ReadProperty(IEdmStructuralProperty property)
 
         /// <summary>Asynchronously reads an <see cref="Microsoft.OData.ODataProperty" /> as message payload.</summary>
         /// <returns>A task representing the asynchronous operation of reading the property.</returns>
-        public Task<ODataProperty> ReadPropertyAsync()
+        public ValueTask<ODataProperty> ReadPropertyAsync()
         {
             return this.ReadPropertyAsync((IEdmTypeReference)null);
         }
@@ -711,12 +745,14 @@ public Task<ODataProperty> ReadPropertyAsync()
         /// </summary>
         /// <param name="expectedPropertyTypeReference">The expected type reference of the property to read.</param>
         /// <returns>A task representing the asynchronous operation of reading the property.</returns>
-        public Task<ODataProperty> ReadPropertyAsync(IEdmTypeReference expectedPropertyTypeReference)
+        public async ValueTask<ODataProperty> ReadPropertyAsync(IEdmTypeReference expectedPropertyTypeReference)
         {
             this.VerifyCanReadProperty(expectedPropertyTypeReference);
-            return this.ReadFromInputAsync(
+            ODataProperty odataProperty = await this.ReadFromInputAsync(
                 (context) => context.ReadPropertyAsync(/*propertyOrFunctionImport*/null, expectedPropertyTypeReference),
                 ODataPayloadKind.Property);
+
+            return odataProperty;
         }
 
         /// <summary>
@@ -724,12 +760,14 @@ public Task<ODataProperty> ReadPropertyAsync(IEdmTypeReference expectedPropertyT
         /// </summary>
         /// <param name="property">The metadata of the property to read.</param>
         /// <returns>A task representing the asynchronous operation of reading the property.</returns>
-        public Task<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty property)
+        public async ValueTask<ODataProperty> ReadPropertyAsync(IEdmStructuralProperty property)
         {
             this.VerifyCanReadProperty(property);
-            return this.ReadFromInputAsync(
+            ODataProperty odataProperty = await this.ReadFromInputAsync(
                 (context) => context.ReadPropertyAsync(property, property.Type),
                 ODataPayloadKind.Property);
+
+            return odataProperty;
         }
 
 
@@ -746,12 +784,14 @@ public ODataError ReadError()
 
         /// <summary>Asynchronously reads an <see cref="Microsoft.OData.ODataError" /> as the message payload.</summary>
         /// <returns>A task representing the asynchronous operation of reading the error.</returns>
-        public Task<ODataError> ReadErrorAsync()
+        public async ValueTask<ODataError> ReadErrorAsync()
         {
             this.VerifyCanReadError();
-            return this.ReadFromInputAsync(
+            ODataError odataError = await this.ReadFromInputAsync(
                 (context) => context.ReadErrorAsync(),
                 ODataPayloadKind.Error);
+
+            return odataError;
         }
 
         /// <summary>Reads the result of a $ref query (entity reference links) as the message payload.</summary>
@@ -767,12 +807,14 @@ public ODataEntityReferenceLinks ReadEntityReferenceLinks()
 
         /// <summary>Asynchronously reads the result of a $ref query as the message payload.</summary>
         /// <returns>A task representing the asynchronous reading of the entity reference links.</returns>
-        public Task<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
+        public async ValueTask<ODataEntityReferenceLinks> ReadEntityReferenceLinksAsync()
         {
             this.VerifyCanReadEntityReferenceLinks();
-            return this.ReadFromInputAsync(
+            ODataEntityReferenceLinks links = await this.ReadFromInputAsync(
                 (context) => context.ReadEntityReferenceLinksAsync(),
                 ODataPayloadKind.EntityReferenceLinks);
+
+            return links;
         }
 
         /// <summary>Reads a singleton result of a $ref query (entity reference link) as the message payload.</summary>
@@ -788,12 +830,14 @@ public ODataEntityReferenceLink ReadEntityReferenceLink()
 
         /// <summary>Asynchronously reads a singleton result of a $ref query (entity reference link) as the message payload.</summary>
         /// <returns>A running task representing the reading of the entity reference link.</returns>
-        public Task<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
+        public async ValueTask<ODataEntityReferenceLink> ReadEntityReferenceLinkAsync()
         {
             this.VerifyCanReadEntityReferenceLink();
-            return this.ReadFromInputAsync(
+            ODataEntityReferenceLink link = await this.ReadFromInputAsync(
                 (context) => context.ReadEntityReferenceLinkAsync(),
                 ODataPayloadKind.EntityReferenceLink);
+
+            return link;
         }
 
         /// <summary>
@@ -816,13 +860,15 @@ public object ReadValue(IEdmTypeReference expectedTypeReference)
         /// </summary>
         /// <param name="expectedTypeReference">The expected type reference for the value to be read; null if no expected type is available.</param>
         /// <returns>A running task representing the reading of the value.</returns>
-        public Task<object> ReadValueAsync(IEdmTypeReference expectedTypeReference)
+        public async ValueTask<object> ReadValueAsync(IEdmTypeReference expectedTypeReference)
         {
             ODataPayloadKind[] supportedPayloadKinds = this.VerifyCanReadValue(expectedTypeReference);
 
-            return this.ReadFromInputAsync(
+            object value = await this.ReadFromInputAsync(
                 (context) => context.ReadValueAsync((IEdmPrimitiveTypeReference)expectedTypeReference),
                 supportedPayloadKinds);
+
+            return value;
         }
 
         /// <summary>Reads the message body as metadata document. It can read JSON/XML CSDL based on the content type.</summary>
@@ -1457,5 +1503,25 @@ private Task<T> ReadFromInputAsync<T>(Func<ODataInputContext, Task<T>> readFunc,
                         return readFunc(this.inputContext);
                     });
         }
+
+        [Obsolete("Temporary method. Delete later.")]
+        private Task<T> ReadFromInputAsync<T>(Func<ODataInputContext, ValueTask<T>> readFunc, params ODataPayloadKind[] payloadKinds) where T : class
+        {
+            this.ProcessContentType(payloadKinds);
+            Debug.Assert(this.format != null, "By now we should have figured out which format to use.");
+
+            return this.message.GetStreamAsync()
+                .FollowOnSuccessWithTask(
+                    streamTask => this.format.CreateInputContextAsync(
+                        this.GetOrCreateMessageInfo(streamTask.Result, true),
+                        this.settings))
+                .FollowOnSuccessWithTask(
+                    async createInputContextTask =>
+                    {
+                        this.inputContext = createInputContextTask.Result;
+                        var result = await readFunc(this.inputContext);
+                        return result;
+                    });
+        }
     }
 }
diff --git a/src/Microsoft.OData.Core/ODataMessageWriter.cs b/src/Microsoft.OData.Core/ODataMessageWriter.cs
index aa3ade2f22..8741e90550 100644
--- a/src/Microsoft.OData.Core/ODataMessageWriter.cs
+++ b/src/Microsoft.OData.Core/ODataMessageWriter.cs
@@ -218,7 +218,7 @@ public ODataWriter CreateODataResourceSetWriter(IEdmEntitySetBase entitySet, IEd
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataAsynchronousWriter" /> to write an async response. </summary>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
+        public ValueTask<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
         {
             this.VerifyCanCreateODataAsyncWriter();
             return this.WriteToOutputAsync(
@@ -228,7 +228,7 @@ public Task<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataWriter" /> to write a resource set. </summary>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceSetWriterAsync()
+        public ValueTask<ODataWriter> CreateODataResourceSetWriterAsync()
         {
             return CreateODataResourceSetWriterAsync(/*entitySet*/null, /*entityType*/null);
         }
@@ -238,7 +238,7 @@ public Task<ODataWriter> CreateODataResourceSetWriterAsync()
         /// </summary>
         /// <param name="entitySet">The entity set we are going to write entities for.</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet)
+        public ValueTask<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet)
         {
             return CreateODataResourceSetWriterAsync(entitySet, /*entityType*/null);
         }
@@ -249,7 +249,7 @@ public Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase ent
         /// <param name="entitySet">The entity set we are going to write entities for.</param>
         /// <param name="structuredType">The structured type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType structuredType)
+        public ValueTask<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType structuredType)
         {
             this.VerifyCanCreateODataResourceSetWriter();
             return this.WriteToOutputAsync(
@@ -290,7 +290,7 @@ public ODataWriter CreateODataDeltaResourceSetWriter(IEdmEntitySetBase entitySet
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataWriter" /> to write a delta resource set. </summary>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync()
+        public ValueTask<ODataWriter> CreateODataDeltaResourceSetWriterAsync()
         {
             return CreateODataDeltaResourceSetWriterAsync(/*entitySet*/null, /*entityType*/null);
         }
@@ -300,7 +300,7 @@ public Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync()
         /// </summary>
         /// <param name="entitySet">The entity set we are going to write entities for.</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet)
+        public ValueTask<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet)
         {
             return CreateODataDeltaResourceSetWriterAsync(entitySet, /*entityType*/null);
         }
@@ -311,12 +311,14 @@ public Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBas
         /// <param name="entitySet">The entity set we are going to write entities for.</param>
         /// <param name="entityType">The entity type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
+        public async ValueTask<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
         {
             this.VerifyCanCreateODataResourceSetWriter();
-            return this.WriteToOutputAsync(
+            ODataWriter writer = await this.WriteToOutputAsync(
                 ODataPayloadKind.ResourceSet,
                 (context) => context.CreateODataDeltaResourceSetWriterAsync(entitySet, entityType));
+
+            return writer;
         }
 
         /// <summary> Creates an <see cref="Microsoft.OData.ODataWriter" /> to write a resource. </summary>
@@ -353,7 +355,7 @@ public ODataWriter CreateODataResourceWriter(IEdmNavigationSource navigationSour
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataWriter" /> to write a resource. </summary>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceWriterAsync()
+        public ValueTask<ODataWriter> CreateODataResourceWriterAsync()
         {
             return CreateODataResourceWriterAsync(/*entitySet*/null, /*resourceType*/null);
         }
@@ -363,7 +365,7 @@ public Task<ODataWriter> CreateODataResourceWriterAsync()
         /// </summary>
         /// <param name="navigationSource">The navigation source we are going to write entities for.</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource)
+        public ValueTask<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource)
         {
             return CreateODataResourceWriterAsync(navigationSource, /*resourceType*/null);
         }
@@ -374,7 +376,7 @@ public Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource nav
         /// <param name="navigationSource">The navigation source we are going to write resource set for.</param>
         /// <param name="resourceType">The structured type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
-        public Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public ValueTask<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             this.VerifyCanCreateODataResourceWriter();
             return this.WriteToOutputAsync(
@@ -402,7 +404,7 @@ public ODataWriter CreateODataUriParameterResourceWriter(IEdmNavigationSource na
         /// <param name="navigationSource">The navigation source we are going to write resource for.</param>
         /// <param name="resourceType">The structured type for the resources in the resource set to be written.</param>
         /// <returns>A running task for the created uri parameter writer.</returns>
-        public Task<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public ValueTask<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             this.VerifyCanCreateODataResourceWriter();
             return this.WriteToOutputAsync(
@@ -430,7 +432,7 @@ public ODataWriter CreateODataUriParameterResourceSetWriter(IEdmEntitySetBase en
         /// <param name="entitySetBase">The resource set we are going to write resources for.</param>
         /// <param name="resourceType">The structured type for the resources in the resource set to be written.</param>
         /// <returns>A running task for the created uri parameter writer.</returns>
-        public Task<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySetBase, IEdmStructuredType resourceType)
+        public ValueTask<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySetBase, IEdmStructuredType resourceType)
         {
             this.VerifyCanCreateODataResourceSetWriter();
             return this.WriteToOutputAsync(
@@ -460,7 +462,7 @@ public ODataCollectionWriter CreateODataCollectionWriter(IEdmTypeReference itemT
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataCollectionWriter" /> to write a collection of primitive or complex values (as result of a service operation invocation). </summary>
         /// <returns>A running task for the created collection writer.</returns>
-        public Task<ODataCollectionWriter> CreateODataCollectionWriterAsync()
+        public ValueTask<ODataCollectionWriter> CreateODataCollectionWriterAsync()
         {
             return this.CreateODataCollectionWriterAsync(null);
         }
@@ -470,7 +472,7 @@ public Task<ODataCollectionWriter> CreateODataCollectionWriterAsync()
         /// </summary>
         /// <param name="itemTypeReference">The item type of the collection being written or null if no metadata is available.</param>
         /// <returns>A running task for the created collection writer.</returns>
-        public Task<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
+        public ValueTask<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
         {
             this.VerifyCanCreateODataCollectionWriter(itemTypeReference);
             return this.WriteToOutputAsync(
@@ -490,7 +492,7 @@ public ODataBatchWriter CreateODataBatchWriter()
 
         /// <summary> Asynchronously creates an <see cref="Microsoft.OData.ODataBatchWriter" /> to write a batch of requests or responses. </summary>
         /// <returns>A running task for the created batch writer.</returns>
-        public Task<ODataBatchWriter> CreateODataBatchWriterAsync()
+        public ValueTask<ODataBatchWriter> CreateODataBatchWriterAsync()
         {
             this.VerifyCanCreateODataBatchWriter();
             return this.WriteToOutputAsync(
@@ -516,7 +518,7 @@ public ODataParameterWriter CreateODataParameterWriter(IEdmOperation operation)
         /// </summary>
         /// <param name="operation">The operation whose parameters will be written.</param>
         /// <returns>A running task for the created parameter writer.</returns>
-        public Task<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
+        public ValueTask<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
         {
             this.VerifyCanCreateODataParameterWriter(operation);
             return this.WriteToOutputAsync(
@@ -537,7 +539,7 @@ public void WriteServiceDocument(ODataServiceDocument serviceDocument)
         /// <summary> Asynchronously writes a service document with the specified <paramref name="serviceDocument" /> as the message payload. </summary>
         /// <returns>A task representing the asynchronous operation of writing the service document.</returns>
         /// <param name="serviceDocument">The service document to write.</param>
-        public Task WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
+        public ValueTask WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
         {
             this.VerifyCanWriteServiceDocument(serviceDocument);
             return this.WriteToOutputAsync(
@@ -558,7 +560,7 @@ public void WriteProperty(ODataProperty property)
         /// <summary> Asynchronously writes an <see cref="Microsoft.OData.ODataProperty" /> as the message payload. </summary>
         /// <returns>A task representing the asynchronous operation of writing the property.</returns>
         /// <param name="property">The property to write</param>
-        public Task WritePropertyAsync(ODataProperty property)
+        public ValueTask WritePropertyAsync(ODataProperty property)
         {
             this.VerifyCanWriteProperty(property);
             return this.WriteToOutputAsync(
@@ -594,7 +596,7 @@ public void WriteError(ODataError error, bool includeDebugInformation)
         /// <returns>A task representing the asynchronous operation of writing the error.</returns>
         /// <param name="error">The error to write.</param>
         /// <param name="includeDebugInformation"> A flag indicating whether debug information (for example, the inner error from the <paramref name="error" />) should be included in the payload. This should only be used in debug scenarios. </param>
-        public Task WriteErrorAsync(ODataError error, bool includeDebugInformation)
+        public ValueTask WriteErrorAsync(ODataError error, bool includeDebugInformation)
         {
             // We currently assume that the error is top-level if no create/write method has been called on this message writer.
             // It is possible that the user would create a Json writer, but writes nothing to it before writes the first error.
@@ -627,7 +629,7 @@ public void WriteEntityReferenceLinks(ODataEntityReferenceLinks links)
         /// <summary> Asynchronously writes the result of a $ref query as the message payload. </summary>
         /// <returns>A task representing the asynchronous writing of the entity reference links.</returns>
         /// <param name="links">The entity reference links to write as message payload.</param>
-        public Task WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
+        public ValueTask WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
         {
             this.VerifyCanWriteEntityReferenceLinks(links);
             return this.WriteToOutputAsync(
@@ -648,7 +650,7 @@ public void WriteEntityReferenceLink(ODataEntityReferenceLink link)
         /// <summary> Asynchronously writes a singleton result of a $ref query as the message payload. </summary>
         /// <returns>A running task representing the writing of the link.</returns>
         /// <param name="link">The link result to write as the message payload.</param>
-        public Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
+        public ValueTask WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
         {
             this.VerifyCanWriteEntityReferenceLink(link);
             return this.WriteToOutputAsync(
@@ -669,7 +671,7 @@ public void WriteValue(object value)
         /// <summary> Asynchronously writes a single value as the message body. </summary>
         /// <returns>A running task representing the writing of the value.</returns>
         /// <param name="value">The value to write.</param>
-        public Task WriteValueAsync(object value)
+        public ValueTask WriteValueAsync(object value)
         {
             ODataPayloadKind payloadKind = this.VerifyCanWriteValue(value);
             return this.WriteToOutputAsync(
@@ -690,7 +692,7 @@ public void WriteMetadataDocument()
         /// Asynchronously writes a metadata document as the message payload.
         /// </summary>
         /// <returns>A task representing the asynchronous operation of writing the metadata document.</returns>
-        public Task WriteMetadataDocumentAsync()
+        public ValueTask WriteMetadataDocumentAsync()
         {
             this.VerifyCanWriteMetadataDocument();
             return this.WriteToOutputAsync(
@@ -1291,7 +1293,7 @@ private TResult WriteToOutput<TResult>(ODataPayloadKind payloadKind, Func<ODataO
         /// <param name="payloadKind">The payload kind to write.</param>
         /// <param name="writeAsyncAction">The write operation to invoke on the output.</param>
         /// <returns>Task which represents the pending write operation.</returns>
-        private async Task WriteToOutputAsync(ODataPayloadKind payloadKind, Func<ODataOutputContext, Task> writeAsyncAction)
+        private async ValueTask WriteToOutputAsync(ODataPayloadKind payloadKind, Func<ODataOutputContext, ValueTask> writeAsyncAction)
         {
             // Set the content type header here since all headers have to be set before getting the stream
             this.SetOrVerifyHeaders(payloadKind);
@@ -1311,7 +1313,7 @@ private async Task WriteToOutputAsync(ODataPayloadKind payloadKind, Func<ODataOu
         /// <param name="payloadKind">The payload kind to write.</param>
         /// <param name="writeFunc">The write operation to invoke on the output.</param>
         /// <returns>Task which represents the pending write operation.</returns>
-        private async Task<TResult> WriteToOutputAsync<TResult>(ODataPayloadKind payloadKind, Func<ODataOutputContext, Task<TResult>> writeFunc)
+        private async ValueTask<TResult> WriteToOutputAsync<TResult>(ODataPayloadKind payloadKind, Func<ODataOutputContext, ValueTask<TResult>> writeFunc)
         {
             // Set the content type header here since all headers have to be set before getting the stream
             this.SetOrVerifyHeaders(payloadKind);
diff --git a/src/Microsoft.OData.Core/ODataMetadataJsonOutputContext.cs b/src/Microsoft.OData.Core/ODataMetadataJsonOutputContext.cs
index f5370f058a..c517720b5c 100644
--- a/src/Microsoft.OData.Core/ODataMetadataJsonOutputContext.cs
+++ b/src/Microsoft.OData.Core/ODataMetadataJsonOutputContext.cs
@@ -89,11 +89,11 @@ internal Task FlushAsync()
         /// </summary>
         /// <returns>A task representing the asynchronous operation of writing the metadata document.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override Task WriteMetadataDocumentAsync()
+        internal async override ValueTask WriteMetadataDocumentAsync()
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperationReturningTask(
+            await TaskUtils.GetTaskForSynchronousOperationReturningTask(
                 () =>
                 {
                     this.WriteMetadataDocumentImplementation();
diff --git a/src/Microsoft.OData.Core/ODataMetadataOutputContext.cs b/src/Microsoft.OData.Core/ODataMetadataOutputContext.cs
index ed7272ecc0..51f979c533 100644
--- a/src/Microsoft.OData.Core/ODataMetadataOutputContext.cs
+++ b/src/Microsoft.OData.Core/ODataMetadataOutputContext.cs
@@ -100,11 +100,11 @@ internal Task FlushAsync()
         /// be included in the payload. This should only be used in debug scenarios.
         /// </param>
         /// <returns>Task which represents the pending write operation.</returns>
-        internal override Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
+        internal async override ValueTask WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperationReturningTask(
+            await TaskUtils.GetTaskForSynchronousOperationReturningTask(
                 () =>
                 {
                     ODataMetadataWriterUtils.WriteError(this.xmlWriter, error, includeDebugInformation, this.MessageWriterSettings.MessageQuotas.MaxNestingDepth);
@@ -117,11 +117,11 @@ internal override Task WriteInStreamErrorAsync(ODataError error, bool includeDeb
         /// </summary>
         /// <returns>A task representing the asynchronous operation of writing the metadata document.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override Task WriteMetadataDocumentAsync()
+        internal async override ValueTask WriteMetadataDocumentAsync()
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperationReturningTask(
+            await TaskUtils.GetTaskForSynchronousOperationReturningTask(
                 () =>
                 {
                     this.WriteMetadataDocumentImplementation();
diff --git a/src/Microsoft.OData.Core/ODataOutputContext.cs b/src/Microsoft.OData.Core/ODataOutputContext.cs
index 14ff0152a1..073eb24f8c 100644
--- a/src/Microsoft.OData.Core/ODataOutputContext.cs
+++ b/src/Microsoft.OData.Core/ODataOutputContext.cs
@@ -210,7 +210,7 @@ public virtual ODataWriter CreateODataResourceSetWriter(IEdmEntitySetBase entity
         /// <param name="entityType">The entity type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType entityType)
+        public virtual ValueTask<ODataWriter> CreateODataResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType entityType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -235,7 +235,7 @@ public virtual ODataWriter CreateODataDeltaResourceSetWriter(IEdmEntitySetBase e
         /// <param name="entityType">The entity type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType entityType)
+        public virtual ValueTask<ODataWriter> CreateODataDeltaResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType entityType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -260,7 +260,7 @@ public virtual ODataWriter CreateODataResourceWriter(IEdmNavigationSource naviga
         /// <param name="resourceType">The structured type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public virtual ValueTask<ODataWriter> CreateODataResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Resource);
         }
@@ -283,7 +283,7 @@ public virtual ODataCollectionWriter CreateODataCollectionWriter(IEdmTypeReferen
         /// <param name="itemTypeReference">The item type of the collection being written or null if no metadata is available.</param>
         /// <returns>A running task for the created collection writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
+        public virtual ValueTask<ODataCollectionWriter> CreateODataCollectionWriterAsync(IEdmTypeReference itemTypeReference)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Collection);
         }
@@ -308,7 +308,7 @@ public virtual ODataWriter CreateODataUriParameterResourceWriter(IEdmNavigationS
         /// <param name="resourceType">The structured type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
+        public virtual ValueTask<ODataWriter> CreateODataUriParameterResourceWriterAsync(IEdmNavigationSource navigationSource, IEdmStructuredType resourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Resource);
         }
@@ -333,7 +333,7 @@ public virtual ODataWriter CreateODataUriParameterResourceSetWriter(IEdmEntitySe
         /// <param name="resourceType">The resource type for the items in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
+        public virtual ValueTask<ODataWriter> CreateODataUriParameterResourceSetWriterAsync(IEdmEntitySetBase entitySet, IEdmStructuredType resourceType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -356,7 +356,7 @@ public virtual ODataParameterWriter CreateODataParameterWriter(IEdmOperation ope
         /// <param name="operation">The operation whose parameters will be written.</param>
         /// <returns>A running task for the created parameter writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        public virtual Task<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
+        public virtual ValueTask<ODataParameterWriter> CreateODataParameterWriterAsync(IEdmOperation operation)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error);
         }
@@ -378,7 +378,7 @@ public virtual void WriteProperty(ODataProperty odataProperty)
         /// <param name="odataProperty">The OData property to write</param>
         /// <returns>A task representing the asynchronous operation of writing the OData property.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        public virtual Task WritePropertyAsync(ODataProperty odataProperty)
+        public virtual ValueTask WritePropertyAsync(ODataProperty odataProperty)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property);
         }
@@ -408,7 +408,7 @@ public virtual void WriteError(ODataError odataError, bool includeDebugInformati
         /// </param>
         /// <returns>A task representing the asynchronous operation of writing the error.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        public virtual Task WriteErrorAsync(ODataError odataError, bool includeDebugInformation)
+        public virtual ValueTask WriteErrorAsync(ODataError odataError, bool includeDebugInformation)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error);
         }
@@ -452,7 +452,7 @@ internal virtual void WriteInStreamError(ODataError error, bool includeDebugInfo
         /// the in-stream error is written.
         /// It is the responsibility of this method to flush the output before the task finishes.
         /// </remarks>
-        internal virtual Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
+        internal virtual ValueTask WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error);
         }
@@ -473,7 +473,7 @@ internal virtual ODataAsynchronousWriter CreateODataAsynchronousWriter()
         /// </summary>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal virtual Task<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
+        internal virtual ValueTask<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Asynchronous);
         }
@@ -498,7 +498,7 @@ internal virtual ODataDeltaWriter CreateODataDeltaWriter(IEdmEntitySetBase entit
         /// <param name="entityType">The entity type for the entries in the resource set to be written (or null if the entity set base type should be used).</param>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal virtual Task<ODataDeltaWriter> CreateODataDeltaWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
+        internal virtual ValueTask<ODataDeltaWriter> CreateODataDeltaWriterAsync(IEdmEntitySetBase entitySet, IEdmEntityType entityType)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ResourceSet);
         }
@@ -527,7 +527,7 @@ internal virtual ODataBatchWriter CreateODataBatchWriter()
         /// The write must flush the output when it's finished (inside the last Write call).
         /// Since we don't want to support batch format extensibility (at least not yet) this method should remain internal.
         /// </remarks>
-        internal virtual Task<ODataBatchWriter> CreateODataBatchWriterAsync()
+        internal virtual ValueTask<ODataBatchWriter> CreateODataBatchWriterAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Batch);
         }
@@ -551,7 +551,7 @@ internal virtual void WriteServiceDocument(ODataServiceDocument serviceDocument)
         /// <param name="serviceDocument">The service document to write in the service document.</param>
         /// <returns>A task representing the asynchronous operation of writing the service document.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal virtual Task WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
+        internal virtual ValueTask WriteServiceDocumentAsync(ODataServiceDocument serviceDocument)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.ServiceDocument);
         }
@@ -573,7 +573,7 @@ internal virtual void WriteEntityReferenceLinks(ODataEntityReferenceLinks links)
         /// <param name="links">The entity reference links to write as message payload.</param>
         /// <returns>A task representing the asynchronous writing of the entity reference links.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal virtual Task WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
+        internal virtual ValueTask WriteEntityReferenceLinksAsync(ODataEntityReferenceLinks links)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.EntityReferenceLinks);
         }
@@ -595,7 +595,7 @@ internal virtual void WriteEntityReferenceLink(ODataEntityReferenceLink link)
         /// <param name="link">The link result to write as message payload.</param>
         /// <returns>A running task representing the writing of the link.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal virtual Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
+        internal virtual ValueTask WriteEntityReferenceLinkAsync(ODataEntityReferenceLink link)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.EntityReferenceLink);
         }
@@ -617,7 +617,7 @@ internal virtual void WriteValue(object value)
         /// <param name="value">The value to write.</param>
         /// <returns>A running task representing the writing of the value.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal virtual Task WriteValueAsync(object value)
+        internal virtual ValueTask WriteValueAsync(object value)
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Value);
         }
@@ -636,7 +636,7 @@ internal virtual void WriteMetadataDocument()
         /// </summary>
         /// <returns>A task representing the asynchronous operation of writing the metadata document.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal virtual Task WriteMetadataDocumentAsync()
+        internal virtual ValueTask WriteMetadataDocumentAsync()
         {
             throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.MetadataDocument);
         }
diff --git a/src/Microsoft.OData.Core/ODataRawInputContext.cs b/src/Microsoft.OData.Core/ODataRawInputContext.cs
index bcae36f7c5..6707e7a0a4 100644
--- a/src/Microsoft.OData.Core/ODataRawInputContext.cs
+++ b/src/Microsoft.OData.Core/ODataRawInputContext.cs
@@ -94,10 +94,11 @@ internal override ODataAsynchronousReader CreateAsynchronousReader()
         /// Asynchronously create an <see cref="ODataAsynchronousReader"/>.
         /// </summary>
         /// <returns>Task which when completed returns the newly created <see cref="ODataAsynchronousReader"/>.</returns>
-        internal override Task<ODataAsynchronousReader> CreateAsynchronousReaderAsync()
+        internal async override ValueTask<ODataAsynchronousReader> CreateAsynchronousReaderAsync()
         {
             // Note that the reading is actually synchronous since we buffer the entire input when getting the stream from the message.
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateAsynchronousReaderImplementation());
+            ODataAsynchronousReader reader = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateAsynchronousReaderImplementation());
+            return reader;
         }
 
         /// <summary>
@@ -115,9 +116,10 @@ internal override object ReadValue(IEdmPrimitiveTypeReference expectedPrimitiveT
         /// </summary>
         /// <param name="expectedPrimitiveTypeReference">The expected type reference for the value to be read; null if no expected type is available.</param>
         /// <returns>Task which when completed returns an <see cref="object"/> representing the read value.</returns>
-        internal override Task<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
+        internal async override ValueTask<object> ReadValueAsync(IEdmPrimitiveTypeReference expectedPrimitiveTypeReference)
         {
-            return this.ReadValueImplementationAsync(expectedPrimitiveTypeReference);
+            object value = await this.ReadValueImplementationAsync(expectedPrimitiveTypeReference);
+            return value;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/ODataRawOutputContext.cs b/src/Microsoft.OData.Core/ODataRawOutputContext.cs
index be4ba3f99f..8b89070535 100644
--- a/src/Microsoft.OData.Core/ODataRawOutputContext.cs
+++ b/src/Microsoft.OData.Core/ODataRawOutputContext.cs
@@ -189,7 +189,7 @@ internal override void WriteInStreamError(ODataError error, bool includeDebugInf
         /// the in-stream error is written.
         /// It is the responsibility of this method to flush the output before the task finishes.
         /// </remarks>
-        internal override async Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
+        internal override async ValueTask WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation)
         {
             if (this.outputInStreamErrorListener != null)
             {
@@ -217,11 +217,12 @@ internal override ODataAsynchronousWriter CreateODataAsynchronousWriter()
         /// </summary>
         /// <returns>A running task for the created writer.</returns>
         /// <remarks>The write must flush the output when it's finished (inside the last Write call).</remarks>
-        internal override Task<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
+        internal async override ValueTask<ODataAsynchronousWriter> CreateODataAsynchronousWriterAsync()
         {
             this.AssertAsynchronous();
 
-            return TaskUtils.GetTaskForSynchronousOperation(() => this.CreateODataAsynchronousWriterImplementation());
+            ODataAsynchronousWriter writer = await TaskUtils.GetTaskForSynchronousOperation(() => this.CreateODataAsynchronousWriterImplementation());
+            return writer;
         }
 
         /// <summary>
@@ -243,7 +244,7 @@ internal override void WriteValue(object value)
         /// <param name="value">The value to write.</param>
         /// <returns>A running task representing the writing of the value.</returns>
         /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
-        internal override async Task WriteValueAsync(object value)
+        internal override async ValueTask WriteValueAsync(object value)
         {
             this.AssertAsynchronous();
 
diff --git a/src/Microsoft.OData.Core/ODataTextStreamReader.cs b/src/Microsoft.OData.Core/ODataTextStreamReader.cs
index d8aa82b535..dfea4af0c9 100644
--- a/src/Microsoft.OData.Core/ODataTextStreamReader.cs
+++ b/src/Microsoft.OData.Core/ODataTextStreamReader.cs
@@ -52,11 +52,12 @@ public override int Read(char[] buffer, int offset, int count)
             return this.reader(buffer, offset, count);
         }
 
-        public override Task<int> ReadAsync(char[] buffer, int index, int count)
+        public async override Task<int> ReadAsync(char[] buffer, int index, int count)
         {
             this.AssertAsynchronous();
 
-            return this.asyncReader(buffer, index, count);
+            int value = await this.asyncReader(buffer, index, count);
+            return value;
         }
 
         /// <summary>
diff --git a/src/Microsoft.OData.Core/ODataWriter.cs b/src/Microsoft.OData.Core/ODataWriter.cs
index 053f7937cd..af311e5714 100644
--- a/src/Microsoft.OData.Core/ODataWriter.cs
+++ b/src/Microsoft.OData.Core/ODataWriter.cs
@@ -49,9 +49,9 @@ public ODataWriter Write(ODataResourceSet resourceSet, Action nestedAction)
         /// <summary> Asynchronously start writing a resource set. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="resourceSet">The resource set or collection to write.</param>
-        public virtual Task WriteStartAsync(ODataResourceSet resourceSet)
+        public virtual ValueTask WriteStartAsync(ODataResourceSet resourceSet)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, resourceSetParam) => thisParam.WriteStart(resourceSetParam),
                 this,
                 resourceSet);
@@ -90,9 +90,9 @@ public ODataWriter Write(ODataDeltaResourceSet deltaResourceSet, Action nestedAc
         /// <summary> Asynchronously start writing a resource set. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="deltaResourceSet">The resource set or collection to write.</param>
-        public virtual Task WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
+        public virtual ValueTask WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, deltaResourceSetParam) => thisParam.WriteStart(deltaResourceSetParam),
                 this,
                 deltaResourceSet);
@@ -168,9 +168,9 @@ public ODataWriter Write(ODataDeltaDeletedLink deltaDeletedLink)
         /// <summary> Asynchronously start writing a resource. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="resource">The resource or item to write.</param>
-        public virtual Task WriteStartAsync(ODataResource resource)
+        public virtual ValueTask WriteStartAsync(ODataResource resource)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, resourceParam) => thisParam.WriteStart(resourceParam),
                 this,
                 resource);
@@ -190,9 +190,9 @@ public virtual void WriteStart(ODataDeletedResource deletedResource)
         /// </summary>
         /// <param name="deletedResource">The deleted resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public virtual Task WriteStartAsync(ODataDeletedResource deletedResource)
+        public virtual ValueTask WriteStartAsync(ODataDeletedResource deletedResource)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, deletedResourceParam) => thisParam.WriteStart(deletedResourceParam),
                 this,
                 deletedResource);
@@ -214,9 +214,9 @@ public virtual void WriteDeltaLink(ODataDeltaLink deltaLink)
         /// </summary>
         /// <param name="deltaLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public virtual Task WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
+        public virtual ValueTask WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, deltaLinkParam) => thisParam.WriteDeltaLink(deltaLinkParam),
                 this,
                 deltaLink);
@@ -238,9 +238,9 @@ public virtual void WriteDeltaDeletedLink(ODataDeltaDeletedLink deltaDeletedLink
         /// </summary>
         /// <param name="deltaDeletedLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public virtual Task WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink)
+        public virtual ValueTask WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaDeletedLink)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, deltaDeletedLinkParam) => thisParam.WriteDeltaDeletedLink(deltaDeletedLinkParam),
                 this,
                 deltaDeletedLink);
@@ -277,9 +277,9 @@ public ODataWriter Write(ODataNestedResourceInfo nestedResourceInfo, Action nest
         /// <summary> Asynchronously start writing a nested resource info. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="nestedResourceInfo">The nested resource info to writer.</param>
-        public virtual Task WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
+        public virtual ValueTask WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, nestedResourceInfoParam) => thisParam.WriteStart(nestedResourceInfoParam),
                 this,
                 nestedResourceInfo);
@@ -305,9 +305,9 @@ public ODataWriter Write(ODataPrimitiveValue primitiveValue)
         /// <summary> Asynchronously write a primitive value within an untyped collection. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="primitiveValue">The primitive value to write.</param>
-        public virtual Task WritePrimitiveAsync(ODataPrimitiveValue primitiveValue)
+        public virtual ValueTask WritePrimitiveAsync(ODataPrimitiveValue primitiveValue)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, primitiveValueParam) => thisParam.WritePrimitive(primitiveValueParam),
                 this,
                 primitiveValue);
@@ -348,9 +348,9 @@ public ODataWriter Write(ODataProperty primitiveProperty, Action nestedAction)
         /// <summary> Asynchronously write a primitive property within a resource. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="primitiveProperty">The primitive property to write.</param>
-        public virtual Task WriteStartAsync(ODataPropertyInfo primitiveProperty)
+        public virtual ValueTask WriteStartAsync(ODataPropertyInfo primitiveProperty)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, primitivePropertyParam) => thisParam.WriteStart(primitivePropertyParam),
                 this,
                 primitiveProperty);
@@ -378,9 +378,9 @@ public ODataWriter WriteStream(ODataBinaryStreamValue stream)
 
         /// <summary>Asynchronously creates a stream for writing a binary value.</summary>
         /// <returns>A stream to write a binary value to.</returns>
-        public virtual Task<Stream> CreateBinaryWriteStreamAsync()
+        public virtual ValueTask<Stream> CreateBinaryWriteStreamAsync()
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam) => thisParam.CreateBinaryWriteStream(),
                 this);
         }
@@ -395,9 +395,9 @@ public virtual TextWriter CreateTextWriter()
 
         /// <summary>Asynchronously creates a TextWriter for writing a string value.</summary>
         /// <returns>A TextWriter to write a string value.</returns>
-        public virtual Task<TextWriter> CreateTextWriterAsync()
+        public virtual ValueTask<TextWriter> CreateTextWriterAsync()
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam) => thisParam.CreateTextWriter(),
                 this);
         }
@@ -408,9 +408,9 @@ public virtual Task<TextWriter> CreateTextWriterAsync()
 
         /// <summary> Asynchronously finish writing a resource set, resource, or nested resource info. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public virtual Task WriteEndAsync()
+        public virtual ValueTask WriteEndAsync()
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam) => thisParam.WriteEnd(),
                 this);
         }
@@ -435,9 +435,9 @@ public virtual Task WriteEndAsync()
         /// The <see cref="ODataNestedResourceInfo.Url"/> will be ignored in that case and the Uri from the <see cref="ODataEntityReferenceLink.Url"/> will be used
         /// as the binding URL to be written.
         /// </remarks>
-        public virtual Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink entityReferenceLink)
+        public virtual ValueTask WriteEntityReferenceLinkAsync(ODataEntityReferenceLink entityReferenceLink)
         {
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, entityReferenceLinkParam) => thisParam.WriteEntityReferenceLink(entityReferenceLinkParam),
                 this,
                 entityReferenceLink);
diff --git a/src/Microsoft.OData.Core/ODataWriterCore.cs b/src/Microsoft.OData.Core/ODataWriterCore.cs
index b9f166154f..e54a655900 100644
--- a/src/Microsoft.OData.Core/ODataWriterCore.cs
+++ b/src/Microsoft.OData.Core/ODataWriterCore.cs
@@ -455,7 +455,7 @@ public sealed override void WriteStart(ODataResourceSet resourceSet)
         /// </summary>
         /// <param name="resourceSet">Resource Set/collection to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override async Task WriteStartAsync(ODataResourceSet resourceSet)
+        public sealed override async ValueTask WriteStartAsync(ODataResourceSet resourceSet)
         {
             await this.VerifyCanWriteStartResourceSetAsync(false, resourceSet)
                 .ConfigureAwait(false);
@@ -478,7 +478,7 @@ public sealed override void WriteStart(ODataDeltaResourceSet deltaResourceSet)
         /// </summary>
         /// <param name="deltaResourceSet">Resource Set/collection to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override async Task WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
+        public sealed override async ValueTask WriteStartAsync(ODataDeltaResourceSet deltaResourceSet)
         {
             await this.VerifyCanWriteStartDeltaResourceSetAsync(false, deltaResourceSet)
                 .ConfigureAwait(false);
@@ -501,7 +501,7 @@ public sealed override void WriteStart(ODataResource resource)
         /// </summary>
         /// <param name="resource">Resource/item to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override Task WriteStartAsync(ODataResource resource)
+        public sealed override ValueTask WriteStartAsync(ODataResource resource)
         {
             this.VerifyCanWriteStartResource(false, resource);
             return this.WriteStartResourceImplementationAsync(resource);
@@ -522,7 +522,7 @@ public sealed override void WriteStart(ODataDeletedResource deletedResource)
         /// </summary>
         /// <param name="deletedResource">The delta deleted resource to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override Task WriteStartAsync(ODataDeletedResource deletedResource)
+        public sealed override ValueTask WriteStartAsync(ODataDeletedResource deletedResource)
         {
             this.VerifyCanWriteStartDeletedResource(false, deletedResource);
             return this.WriteStartDeletedResourceImplementationAsync(deletedResource);
@@ -543,7 +543,7 @@ public override void WriteDeltaLink(ODataDeltaLink deltaLink)
         /// </summary>
         /// <param name="deltaLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
+        public override ValueTask WriteDeltaLinkAsync(ODataDeltaLink deltaLink)
         {
             this.VerifyCanWriteLink(false, deltaLink);
             return this.WriteDeltaLinkImplementationAsync(deltaLink);
@@ -564,7 +564,7 @@ public override void WriteDeltaDeletedLink(ODataDeltaDeletedLink deltaLink)
         /// </summary>
         /// <param name="deltaLink">The delta link to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public override Task WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaLink)
+        public override ValueTask WriteDeltaDeletedLinkAsync(ODataDeltaDeletedLink deltaLink)
         {
             this.VerifyCanWriteLink(false, deltaLink);
             return this.WriteDeltaLinkImplementationAsync(deltaLink);
@@ -585,7 +585,7 @@ public sealed override void WritePrimitive(ODataPrimitiveValue primitiveValue)
         /// </summary>
         /// <param name="primitiveValue"> Primitive value to write.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override Task WritePrimitiveAsync(ODataPrimitiveValue primitiveValue)
+        public sealed override ValueTask WritePrimitiveAsync(ODataPrimitiveValue primitiveValue)
         {
             this.VerifyCanWritePrimitive(false, primitiveValue);
             return this.WritePrimitiveValueImplementationAsync(primitiveValue);
@@ -602,7 +602,7 @@ public sealed override void WriteStart(ODataPropertyInfo primitiveProperty)
         /// <summary> Asynchronously write a primitive property within a resource. </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
         /// <param name="primitiveProperty">The primitive property to write.</param>
-        public sealed override Task WriteStartAsync(ODataPropertyInfo primitiveProperty)
+        public sealed override ValueTask WriteStartAsync(ODataPropertyInfo primitiveProperty)
         {
             this.VerifyCanWriteProperty(false, primitiveProperty);
             return this.WriteStartPropertyImplementationAsync(primitiveProperty);
@@ -619,7 +619,7 @@ public sealed override Stream CreateBinaryWriteStream()
         /// <summary>Asynchronously creates a stream for writing a binary value.</summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="Stream"/> to write a binary value to.</returns>
-        public sealed override Task<Stream> CreateBinaryWriteStreamAsync()
+        public sealed override ValueTask<Stream> CreateBinaryWriteStreamAsync()
         {
             this.VerifyCanCreateWriteStream(false);
             return this.CreateWriteStreamImplementationAsync();
@@ -636,7 +636,7 @@ public sealed override TextWriter CreateTextWriter()
         /// <summary>Asynchronously creates a <see cref="TextWriter"/> for writing a string value.</summary>
         /// <returns>A task that represents the asynchronous operation.
         /// The value of the TResult parameter contains a <see cref="TextWriter"/> to write a string value to.</returns>
-        public sealed override Task<TextWriter> CreateTextWriterAsync()
+        public sealed override ValueTask<TextWriter> CreateTextWriterAsync()
         {
             this.VerifyCanCreateWriteStream(false);
             return this.CreateTextWriterImplementationAsync();
@@ -658,11 +658,11 @@ public sealed override void WriteStart(ODataNestedResourceInfo nestedResourceInf
         /// </summary>
         /// <param name="nestedResourceInfo">Navigation link to writer.</param>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override Task WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
+        public sealed override ValueTask WriteStartAsync(ODataNestedResourceInfo nestedResourceInfo)
         {
             this.VerifyCanWriteStartNestedResourceInfo(false, nestedResourceInfo);
             // Currently, no asynchronous operation is involved when commencing with writing a nested resource info
-            return TaskUtils.GetTaskForSynchronousOperation(
+            return TaskUtils.GetValueTaskForSynchronousOperation(
                 (thisParam, nestedResourceInfoParam) => thisParam.WriteStartNestedResourceInfoImplementation(
                     nestedResourceInfoParam),
                 this,
@@ -688,7 +688,7 @@ public sealed override void WriteEnd()
         /// Asynchronously finish writing a resourceSet/resource/nested resource info.
         /// </summary>
         /// <returns>A task instance that represents the asynchronous write operation.</returns>
-        public sealed override async Task WriteEndAsync()
+        public sealed override async ValueTask WriteEndAsync()
         {
             this.VerifyCanWriteEnd(false);
             await this.WriteEndImplementationAsync()
@@ -729,7 +729,7 @@ public sealed override void WriteEntityReferenceLink(ODataEntityReferenceLink en
         /// The <see cref="ODataNestedResourceInfo.Url"/> will be ignored in that case and the Uri from the <see cref="ODataEntityReferenceLink.Url"/> will be used
         /// as the binding URL to be written.
         /// </remarks>
-        public sealed override Task WriteEntityReferenceLinkAsync(ODataEntityReferenceLink entityReferenceLink)
+        public sealed override ValueTask WriteEntityReferenceLinkAsync(ODataEntityReferenceLink entityReferenceLink)
         {
             this.VerifyCanWriteEntityReferenceLink(entityReferenceLink, false);
             return this.WriteEntityReferenceLinkImplementationAsync(entityReferenceLink);
@@ -1781,7 +1781,7 @@ private void WriteDeltaLinkImplementation(ODataDeltaLinkBase deltaLink)
         /// </summary>
         /// <param name="deltaLink">Delta (deleted) link to write.</param>
         /// <returns>The task.</returns>
-        private async Task WriteDeltaLinkImplementationAsync(ODataDeltaLinkBase deltaLink)
+        private async ValueTask WriteDeltaLinkImplementationAsync(ODataDeltaLinkBase deltaLink)
         {
             EnterScope(deltaLink is ODataDeltaLink ? WriterState.DeltaLink : WriterState.DeltaDeletedLink, deltaLink);
             await this.StartDeltaLinkAsync(deltaLink)
@@ -1859,12 +1859,12 @@ private void WritePrimitiveValueImplementation(ODataPrimitiveValue primitiveValu
         /// </summary>
         /// <param name="primitiveValue">Primitive value to write.</param>
         /// <returns>The task.</returns>
-        private Task WritePrimitiveValueImplementationAsync(ODataPrimitiveValue primitiveValue)
+        private ValueTask WritePrimitiveValueImplementationAsync(ODataPrimitiveValue primitiveValue)
         {
             EnterScope(WriterState.Primitive, primitiveValue);
 
-            return InterceptExceptionAsync(
-                async (thisParam, primiteValueParam) =>
+            return InterceptExceptionValueAsync(
+                async ValueTask (thisParam, primiteValueParam) =>
                 {
                     if (!(CurrentResourceSetValidator == null) && primiteValueParam != null)
                     {
@@ -2472,6 +2472,34 @@ private async Task InterceptExceptionAsync(Func<ODataWriterCore, Task> action, O
             }
         }
 
+        /// <summary>
+        /// Catch any exception thrown by the action passed in; in the exception case move the writer into
+        /// state Error and then rethrow the exception.
+        /// </summary>
+        /// <param name="action">The action to execute.</param>
+        /// <param name="currentScopeItem">The item to associate with the new scope if transitioning to state Error.</param>
+        /// <returns>The task.</returns>
+        /// <remarks>
+        /// Make sure to only use anonymous functions that don't capture state from the enclosing context, 
+        /// so the compiler optimizes the code to avoid delegate and closure allocations on every call to this method.
+        /// </remarks>
+        private async ValueTask InterceptExceptionValueAsync(Func<ODataWriterCore, ValueTask> action, ODataItem currentScopeItem)
+        {
+            try
+            {
+                await action(this).ConfigureAwait(false);
+            }
+            catch
+            {
+                if (!IsErrorState(this.State))
+                {
+                    this.EnterScope(WriterState.Error, currentScopeItem);
+                }
+
+                throw;
+            }
+        }
+
         /// <summary>
         /// Catch any exception thrown by the action passed in; in the exception case move the writer into
         /// state Error and then rethrow the exception.
@@ -2501,6 +2529,35 @@ private async Task InterceptExceptionAsync<TArg0>(Func<ODataWriterCore, TArg0, T
             }
         }
 
+        /// <summary>
+        /// Catch any exception thrown by the action passed in; in the exception case move the writer into
+        /// state Error and then rethrow the exception.
+        /// </summary>
+        /// <typeparam name="TArg0">The action argument type.</typeparam>
+        /// <param name="action">The action to execute.</param>
+        /// <param name="arg0">The argument value provided to the action.</param>
+        /// <returns>The task.</returns>
+        /// <remarks>
+        /// Make sure to only use anonymous functions that don't capture state from the enclosing context, 
+        /// so the compiler optimizes the code to avoid delegate and closure allocations on every call to this method.
+        /// </remarks>
+        private async ValueTask InterceptExceptionValueAsync<TArg0>(Func<ODataWriterCore, TArg0, ValueTask> action, TArg0 arg0)
+        {
+            try
+            {
+                await action(this, arg0).ConfigureAwait(false);
+            }
+            catch
+            {
+                if (!IsErrorState(this.State))
+                {
+                    this.EnterScope(WriterState.Error, this.CurrentScope.Item);
+                }
+
+                throw;
+            }
+        }
+
         /// <summary>
         /// Increments the nested resource count by one and fails if the new value exceeds the maximum nested resource depth limit.
         /// </summary>
@@ -3312,7 +3369,7 @@ await thisParam.StartDeltaResourceSetAsync(deltaResourceSetParam)
         /// </summary>
         /// <param name="resource">Resource/item to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private async Task WriteStartResourceImplementationAsync(ODataResource resource)
+        private async ValueTask WriteStartResourceImplementationAsync(ODataResource resource)
         {
             await this.StartPayloadInStartStateAsync()
                 .ConfigureAwait(false);
@@ -3348,7 +3405,7 @@ await thisParam.StartResourceAsync(resourceParam)
         /// </summary>
         /// <param name="resource">Resource/item to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private async Task WriteStartDeletedResourceImplementationAsync(ODataDeletedResource resource)
+        private async ValueTask WriteStartDeletedResourceImplementationAsync(ODataDeletedResource resource)
         {
             Debug.Assert(resource != null, "resource != null");
 
@@ -3380,14 +3437,14 @@ await thisParam.StartDeletedResourceAsync(resourceParam)
         /// </summary>
         /// <param name="property">Property to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private Task WriteStartPropertyImplementationAsync(ODataPropertyInfo property)
+        private ValueTask WriteStartPropertyImplementationAsync(ODataPropertyInfo property)
         {
             this.EnterScope(WriterState.Property, property);
 
             if (!this.SkipWriting)
             {
-                return this.InterceptExceptionAsync(
-                    async (thisParam, propertyParam) =>
+                return this.InterceptExceptionValueAsync(
+                    async ValueTask (thisParam, propertyParam) =>
                     {
                         await thisParam.StartPropertyAsync(propertyParam)
                             .ConfigureAwait(false);
@@ -3401,7 +3458,7 @@ await thisParam.StartPropertyAsync(propertyParam)
                     }, property);
             }
 
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         /// <summary>
@@ -3409,7 +3466,7 @@ await thisParam.StartPropertyAsync(propertyParam)
         /// </summary>
         /// <returns>A task that represents the asynchronous operation. 
         /// The value of the TResult parameter contains the stream for writing the binary.</returns>
-        private async Task<Stream> CreateWriteStreamImplementationAsync()
+        private async ValueTask<Stream> CreateWriteStreamImplementationAsync()
         {
             this.EnterScope(WriterState.Stream, null);
             Stream underlyingStream = await this.StartBinaryStreamAsync()
@@ -3423,7 +3480,7 @@ private async Task<Stream> CreateWriteStreamImplementationAsync()
         /// </summary>
         /// <returns>A task that represents the asynchronous operation. 
         /// The value of the TResult parameter contains the textwriter for writing a string value.</returns>
-        private async Task<TextWriter> CreateTextWriterImplementationAsync()
+        private async ValueTask<TextWriter> CreateTextWriterImplementationAsync()
         {
             this.EnterScope(WriterState.String, null);
             TextWriter textWriter = await this.StartTextWriterAsync()
@@ -3551,7 +3608,7 @@ await thisParam.LeaveScopeAsync()
         /// </summary>
         /// <param name="entityReferenceLink">The entity reference link to write.</param>
         /// <returns>A task that represents the asynchronous write operation.</returns>
-        private async Task WriteEntityReferenceLinkImplementationAsync(ODataEntityReferenceLink entityReferenceLink)
+        private async ValueTask WriteEntityReferenceLinkImplementationAsync(ODataEntityReferenceLink entityReferenceLink)
         {
             Debug.Assert(entityReferenceLink != null, "entityReferenceLink != null");
 
diff --git a/src/Microsoft.OData.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/src/Microsoft.OData.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt
index 9d7495947d..c8fb5a70c0 100644
--- a/src/Microsoft.OData.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.OData.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt
@@ -1,60 +1,117 @@
+abstract Microsoft.OData.ODataDeltaWriter.FlushAsync() -> System.Threading.Tasks.Task
+abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedEntryAsync(Microsoft.OData.ODataDeltaDeletedEntry deltaDeletedEntry) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedLinkAsync(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaLinkAsync(Microsoft.OData.ODataDeltaLink deltaLink) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteEndAsync() -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataNestedResourceInfo nestedResourceInfo) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataResource deltaResource) -> System.Threading.Tasks.ValueTask
+abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataResourceSet expandedResourceSet) -> System.Threading.Tasks.ValueTask
 Microsoft.Extensions.DependencyInjection.ODataServiceCollectionExtensions
 Microsoft.OData.IServiceCollectionProvider
 Microsoft.OData.IServiceCollectionProvider.ServiceProvider.get -> System.IServiceProvider
 Microsoft.OData.Json.DefaultJsonWriterFactory.CreateJsonWriter(System.IO.Stream stream, bool isIeee754Compatible, System.Text.Encoding encoding) -> Microsoft.OData.Json.IJsonWriter
-Microsoft.OData.Json.IJsonWriter.EndArrayScopeAsync() -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.EndObjectScopeAsync() -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.EndPaddingFunctionScopeAsync() -> System.Threading.Tasks.Task
+Microsoft.OData.Json.IJsonReader.CanStreamAsync() -> System.Threading.Tasks.ValueTask<bool>
+Microsoft.OData.Json.IJsonReader.CreateReadStreamAsync() -> System.Threading.Tasks.ValueTask<System.IO.Stream>
+Microsoft.OData.Json.IJsonReader.CreateTextReaderAsync() -> System.Threading.Tasks.ValueTask<System.IO.TextReader>
+Microsoft.OData.Json.IJsonReader.GetValueAsync() -> System.Threading.Tasks.ValueTask<object>
+Microsoft.OData.Json.IJsonReader.ReadAsync() -> System.Threading.Tasks.ValueTask<bool>
+Microsoft.OData.Json.IJsonWriter.EndArrayScopeAsync() -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.EndObjectScopeAsync() -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.EndPaddingFunctionScopeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.OData.Json.IJsonWriter.EndStreamValueScope() -> void
-Microsoft.OData.Json.IJsonWriter.EndStreamValueScopeAsync() -> System.Threading.Tasks.Task
+Microsoft.OData.Json.IJsonWriter.EndStreamValueScopeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.OData.Json.IJsonWriter.EndTextWriterValueScope() -> void
-Microsoft.OData.Json.IJsonWriter.EndTextWriterValueScopeAsync() -> System.Threading.Tasks.Task
+Microsoft.OData.Json.IJsonWriter.EndTextWriterValueScopeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.OData.Json.IJsonWriter.FlushAsync() -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.StartArrayScopeAsync() -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.StartObjectScopeAsync() -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.StartPaddingFunctionScopeAsync() -> System.Threading.Tasks.Task
+Microsoft.OData.Json.IJsonWriter.StartArrayScopeAsync() -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.StartObjectScopeAsync() -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.StartPaddingFunctionScopeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.OData.Json.IJsonWriter.StartStreamValueScope() -> System.IO.Stream
-Microsoft.OData.Json.IJsonWriter.StartStreamValueScopeAsync() -> System.Threading.Tasks.Task<System.IO.Stream>
+Microsoft.OData.Json.IJsonWriter.StartStreamValueScopeAsync() -> System.Threading.Tasks.ValueTask<System.IO.Stream>
 Microsoft.OData.Json.IJsonWriter.StartTextWriterValueScope(string contentType) -> System.IO.TextWriter
-Microsoft.OData.Json.IJsonWriter.StartTextWriterValueScopeAsync(string contentType) -> System.Threading.Tasks.Task<System.IO.TextWriter>
-Microsoft.OData.Json.IJsonWriter.WriteNameAsync(string name) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WritePaddingFunctionNameAsync(string functionName) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteRawValueAsync(string rawValue) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(bool value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(byte value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(byte[] value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(decimal value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(double value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(float value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(int value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(long value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(Microsoft.OData.Edm.Date value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(Microsoft.OData.Edm.TimeOfDay value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(sbyte value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(short value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(string value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.DateTimeOffset value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.Guid value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.Text.Json.JsonElement value) -> System.Threading.Tasks.Task
-Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.TimeSpan value) -> System.Threading.Tasks.Task
+Microsoft.OData.Json.IJsonWriter.StartTextWriterValueScopeAsync(string contentType) -> System.Threading.Tasks.ValueTask<System.IO.TextWriter>
+Microsoft.OData.Json.IJsonWriter.WriteNameAsync(string name) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WritePaddingFunctionNameAsync(string functionName) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteRawValueAsync(string rawValue) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(bool value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(byte value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(byte[] value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(decimal value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(double value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(float value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(int value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(long value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(Microsoft.OData.Edm.Date value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(Microsoft.OData.Edm.TimeOfDay value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(sbyte value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(short value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(string value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.DateTimeOffset value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.Guid value) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.Text.Json.JsonElement value) -> System.Threading.Tasks.ValueTask
 Microsoft.OData.Json.IJsonReader.CanStream() -> bool
-Microsoft.OData.Json.IJsonReader.CanStreamAsync() -> System.Threading.Tasks.Task<bool>
 Microsoft.OData.Json.IJsonReader.CreateReadStream() -> System.IO.Stream
-Microsoft.OData.Json.IJsonReader.CreateReadStreamAsync() -> System.Threading.Tasks.Task<System.IO.Stream>
 Microsoft.OData.Json.IJsonReader.CreateTextReader() -> System.IO.TextReader
-Microsoft.OData.Json.IJsonReader.CreateTextReaderAsync() -> System.Threading.Tasks.Task<System.IO.TextReader>
 Microsoft.OData.Json.IJsonReader.GetValue() -> object
-Microsoft.OData.Json.IJsonReader.GetValueAsync() -> System.Threading.Tasks.Task<object>
-Microsoft.OData.Json.IJsonReader.ReadAsync() -> System.Threading.Tasks.Task<bool>
+Microsoft.OData.Json.IJsonWriter.WriteValueAsync(System.TimeSpan value) -> System.Threading.Tasks.ValueTask
 Microsoft.OData.ODataAsynchronousResponseMessage.ServiceProvider.get -> System.IServiceProvider
 Microsoft.OData.ODataBatchOperationRequestMessage.ServiceProvider.get -> System.IServiceProvider
 Microsoft.OData.ODataBatchOperationResponseMessage.ServiceProvider.get -> System.IServiceProvider
 Microsoft.OData.ODataMessageInfo.ServiceProvider.get -> System.IServiceProvider
 Microsoft.OData.ODataMessageInfo.ServiceProvider.set -> void
+Microsoft.OData.ODataMessageReader.CreateODataAsynchronousReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataAsynchronousReader>
+Microsoft.OData.ODataMessageReader.CreateODataBatchReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataBatchReader>
+Microsoft.OData.ODataMessageReader.CreateODataCollectionReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionReader>
+Microsoft.OData.ODataMessageReader.CreateODataCollectionReaderAsync(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionReader>
+Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataParameterReaderAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataParameterReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync(Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
+Microsoft.OData.ODataMessageReader.DetectPayloadKindAsync() -> System.Threading.Tasks.ValueTask<System.Collections.Generic.IEnumerable<Microsoft.OData.ODataPayloadKindDetectionResult>>
+Microsoft.OData.ODataMessageReader.ReadEntityReferenceLinkAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataEntityReferenceLink>
+Microsoft.OData.ODataMessageReader.ReadEntityReferenceLinksAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataEntityReferenceLinks>
+Microsoft.OData.ODataMessageReader.ReadErrorAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataError>
+Microsoft.OData.ODataMessageReader.ReadPropertyAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataProperty>
+Microsoft.OData.ODataMessageReader.ReadPropertyAsync(Microsoft.OData.Edm.IEdmStructuralProperty property) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataProperty>
+Microsoft.OData.ODataMessageReader.ReadPropertyAsync(Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataProperty>
+Microsoft.OData.ODataMessageReader.ReadServiceDocumentAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataServiceDocument>
+Microsoft.OData.ODataMessageReader.ReadValueAsync(Microsoft.OData.Edm.IEdmTypeReference expectedTypeReference) -> System.Threading.Tasks.ValueTask<object>
 Microsoft.OData.ODataMessageReaderSettings.EnableReadingKeyAsSegment.get -> bool
 Microsoft.OData.ODataMessageReaderSettings.EnableReadingKeyAsSegment.set -> void
 Microsoft.OData.ODataMessageReaderSettings.EnableReadingODataAnnotationWithoutPrefix.get -> bool
 Microsoft.OData.ODataMessageReaderSettings.EnableReadingODataAnnotationWithoutPrefix.set -> void
+Microsoft.OData.ODataMessageWriter.CreateODataAsynchronousWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataAsynchronousWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataBatchWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataBatchWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriterAsync(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmEntityType entityType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataParameterWriterAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataParameterWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType structuredType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySetBase, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
+Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLinkAsync(Microsoft.OData.ODataEntityReferenceLink link) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLinksAsync(Microsoft.OData.ODataEntityReferenceLinks links) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WriteErrorAsync(Microsoft.OData.ODataError error, bool includeDebugInformation) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WriteMetadataDocumentAsync() -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WritePropertyAsync(Microsoft.OData.ODataProperty property) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WriteServiceDocumentAsync(Microsoft.OData.ODataServiceDocument serviceDocument) -> System.Threading.Tasks.ValueTask
+Microsoft.OData.ODataMessageWriter.WriteValueAsync(object value) -> System.Threading.Tasks.ValueTask
 Microsoft.OData.ODataMessageWriterSettings.EnableWritingKeyAsSegment.get -> bool
 Microsoft.OData.ODataMessageWriterSettings.EnableWritingKeyAsSegment.set -> void
 Microsoft.OData.ODataMessageWriterSettings.GetOmitODataPrefix() -> bool
@@ -117,23 +174,14 @@ abstract Microsoft.OData.ODataDeltaReader.ReadAsync() -> System.Threading.Tasks.
 abstract Microsoft.OData.ODataDeltaReader.State.get -> Microsoft.OData.ODataDeltaReaderState
 abstract Microsoft.OData.ODataDeltaReader.SubState.get -> Microsoft.OData.ODataReaderState
 abstract Microsoft.OData.ODataDeltaWriter.Flush() -> void
-abstract Microsoft.OData.ODataDeltaWriter.FlushAsync() -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedEntry(Microsoft.OData.ODataDeltaDeletedEntry deltaDeletedEntry) -> void
-abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedEntryAsync(Microsoft.OData.ODataDeltaDeletedEntry deltaDeletedEntry) -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedLink(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> void
-abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaDeletedLinkAsync(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaLink(Microsoft.OData.ODataDeltaLink deltaLink) -> void
-abstract Microsoft.OData.ODataDeltaWriter.WriteDeltaLinkAsync(Microsoft.OData.ODataDeltaLink deltaLink) -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataDeltaWriter.WriteEnd() -> void
-abstract Microsoft.OData.ODataDeltaWriter.WriteEndAsync() -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataDeltaWriter.WriteStart(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> void
 abstract Microsoft.OData.ODataDeltaWriter.WriteStart(Microsoft.OData.ODataNestedResourceInfo nestedResourceInfo) -> void
 abstract Microsoft.OData.ODataDeltaWriter.WriteStart(Microsoft.OData.ODataResource deltaResource) -> void
 abstract Microsoft.OData.ODataDeltaWriter.WriteStart(Microsoft.OData.ODataResourceSet expandedResourceSet) -> void
-abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> System.Threading.Tasks.Task
-abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataNestedResourceInfo nestedResourceInfo) -> System.Threading.Tasks.Task
-abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataResource deltaResource) -> System.Threading.Tasks.Task
-abstract Microsoft.OData.ODataDeltaWriter.WriteStartAsync(Microsoft.OData.ODataResourceSet expandedResourceSet) -> System.Threading.Tasks.Task
 abstract Microsoft.OData.ODataFormat.CreateInputContext(Microsoft.OData.ODataMessageInfo messageInfo, Microsoft.OData.ODataMessageReaderSettings messageReaderSettings) -> Microsoft.OData.ODataInputContext
 abstract Microsoft.OData.ODataFormat.CreateInputContextAsync(Microsoft.OData.ODataMessageInfo messageInfo, Microsoft.OData.ODataMessageReaderSettings messageReaderSettings) -> System.Threading.Tasks.Task<Microsoft.OData.ODataInputContext>
 abstract Microsoft.OData.ODataFormat.CreateOutputContext(Microsoft.OData.ODataMessageInfo messageInfo, Microsoft.OData.ODataMessageWriterSettings messageWriterSettings) -> Microsoft.OData.ODataOutputContext
@@ -626,39 +674,22 @@ Microsoft.OData.ODataMessageQuotas.ODataMessageQuotas() -> void
 Microsoft.OData.ODataMessageQuotas.ODataMessageQuotas(Microsoft.OData.ODataMessageQuotas other) -> void
 Microsoft.OData.ODataMessageReader
 Microsoft.OData.ODataMessageReader.CreateODataAsynchronousReader() -> Microsoft.OData.ODataAsynchronousReader
-Microsoft.OData.ODataMessageReader.CreateODataAsynchronousReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataAsynchronousReader>
 Microsoft.OData.ODataMessageReader.CreateODataBatchReader() -> Microsoft.OData.ODataBatchReader
-Microsoft.OData.ODataMessageReader.CreateODataBatchReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataBatchReader>
 Microsoft.OData.ODataMessageReader.CreateODataCollectionReader() -> Microsoft.OData.ODataCollectionReader
 Microsoft.OData.ODataMessageReader.CreateODataCollectionReader(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> Microsoft.OData.ODataCollectionReader
-Microsoft.OData.ODataMessageReader.CreateODataCollectionReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionReader>
-Microsoft.OData.ODataMessageReader.CreateODataCollectionReaderAsync(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionReader>
 Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReader() -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReader(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 Microsoft.OData.ODataMessageReader.CreateODataParameterReader(Microsoft.OData.Edm.IEdmOperation operation) -> Microsoft.OData.ODataParameterReader
-Microsoft.OData.ODataMessageReader.CreateODataParameterReaderAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.Task<Microsoft.OData.ODataParameterReader>
 Microsoft.OData.ODataMessageReader.CreateODataResourceReader() -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataResourceReader(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataResourceReader(Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataReader
-Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataResourceReaderAsync(Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 Microsoft.OData.ODataMessageReader.CreateODataResourceSetReader() -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
 Microsoft.OData.ODataMessageReader.CreateODataResourceSetReader(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
-Microsoft.OData.ODataMessageReader.CreateODataResourceSetReaderAsync(Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceReader(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-Microsoft.OData.ODataMessageReader.CreateODataUriParameterResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 Microsoft.OData.ODataMessageReader.DetectPayloadKind() -> System.Collections.Generic.IEnumerable<Microsoft.OData.ODataPayloadKindDetectionResult>
-Microsoft.OData.ODataMessageReader.DetectPayloadKindAsync() -> System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<Microsoft.OData.ODataPayloadKindDetectionResult>>
 Microsoft.OData.ODataMessageReader.Dispose() -> void
 Microsoft.OData.ODataMessageReader.ODataMessageReader(Microsoft.OData.IODataRequestMessage requestMessage) -> void
 Microsoft.OData.ODataMessageReader.ODataMessageReader(Microsoft.OData.IODataRequestMessage requestMessage, Microsoft.OData.ODataMessageReaderSettings settings) -> void
@@ -667,24 +698,16 @@ Microsoft.OData.ODataMessageReader.ODataMessageReader(Microsoft.OData.IODataResp
 Microsoft.OData.ODataMessageReader.ODataMessageReader(Microsoft.OData.IODataResponseMessage responseMessage, Microsoft.OData.ODataMessageReaderSettings settings) -> void
 Microsoft.OData.ODataMessageReader.ODataMessageReader(Microsoft.OData.IODataResponseMessage responseMessage, Microsoft.OData.ODataMessageReaderSettings settings, Microsoft.OData.Edm.IEdmModel model) -> void
 Microsoft.OData.ODataMessageReader.ReadEntityReferenceLink() -> Microsoft.OData.ODataEntityReferenceLink
-Microsoft.OData.ODataMessageReader.ReadEntityReferenceLinkAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataEntityReferenceLink>
 Microsoft.OData.ODataMessageReader.ReadEntityReferenceLinks() -> Microsoft.OData.ODataEntityReferenceLinks
-Microsoft.OData.ODataMessageReader.ReadEntityReferenceLinksAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataEntityReferenceLinks>
 Microsoft.OData.ODataMessageReader.ReadError() -> Microsoft.OData.ODataError
-Microsoft.OData.ODataMessageReader.ReadErrorAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataError>
 Microsoft.OData.ODataMessageReader.ReadMetadataDocument() -> Microsoft.OData.Edm.IEdmModel
 Microsoft.OData.ODataMessageReader.ReadMetadataDocument(Microsoft.OData.Edm.Csdl.CsdlReaderSettingsBase csdlReaderSettings) -> Microsoft.OData.Edm.IEdmModel
 Microsoft.OData.ODataMessageReader.ReadMetadataDocument(System.Func<System.Uri, System.Xml.XmlReader> getReferencedModelReaderFunc) -> Microsoft.OData.Edm.IEdmModel
 Microsoft.OData.ODataMessageReader.ReadProperty() -> Microsoft.OData.ODataProperty
 Microsoft.OData.ODataMessageReader.ReadProperty(Microsoft.OData.Edm.IEdmStructuralProperty property) -> Microsoft.OData.ODataProperty
 Microsoft.OData.ODataMessageReader.ReadProperty(Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> Microsoft.OData.ODataProperty
-Microsoft.OData.ODataMessageReader.ReadPropertyAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataProperty>
-Microsoft.OData.ODataMessageReader.ReadPropertyAsync(Microsoft.OData.Edm.IEdmStructuralProperty property) -> System.Threading.Tasks.Task<Microsoft.OData.ODataProperty>
-Microsoft.OData.ODataMessageReader.ReadPropertyAsync(Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataProperty>
 Microsoft.OData.ODataMessageReader.ReadServiceDocument() -> Microsoft.OData.ODataServiceDocument
-Microsoft.OData.ODataMessageReader.ReadServiceDocumentAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataServiceDocument>
 Microsoft.OData.ODataMessageReader.ReadValue(Microsoft.OData.Edm.IEdmTypeReference expectedTypeReference) -> object
-Microsoft.OData.ODataMessageReader.ReadValueAsync(Microsoft.OData.Edm.IEdmTypeReference expectedTypeReference) -> System.Threading.Tasks.Task<object>
 Microsoft.OData.ODataMessageReaderSettings
 Microsoft.OData.ODataMessageReaderSettings.ArrayPool.get -> Microsoft.OData.Buffers.ICharArrayPool
 Microsoft.OData.ODataMessageReaderSettings.ArrayPool.set -> void
@@ -723,37 +746,21 @@ Microsoft.OData.ODataMessageReaderSettings.Version.get -> Microsoft.OData.ODataV
 Microsoft.OData.ODataMessageReaderSettings.Version.set -> void
 Microsoft.OData.ODataMessageWriter
 Microsoft.OData.ODataMessageWriter.CreateODataAsynchronousWriter() -> Microsoft.OData.ODataAsynchronousWriter
-Microsoft.OData.ODataMessageWriter.CreateODataAsynchronousWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataAsynchronousWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataBatchWriter() -> Microsoft.OData.ODataBatchWriter
-Microsoft.OData.ODataMessageWriter.CreateODataBatchWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataBatchWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriter() -> Microsoft.OData.ODataCollectionWriter
 Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriter(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> Microsoft.OData.ODataCollectionWriter
-Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataCollectionWriterAsync(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriter() -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmEntityType entityType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataParameterWriter(Microsoft.OData.Edm.IEdmOperation operation) -> Microsoft.OData.ODataParameterWriter
-Microsoft.OData.ODataMessageWriter.CreateODataParameterWriterAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.Task<Microsoft.OData.ODataParameterWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriter() -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType structuredType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataResourceWriter() -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataResourceWriter(Microsoft.OData.Edm.IEdmNavigationSource navigationSource) -> Microsoft.OData.ODataWriter
 Microsoft.OData.ODataMessageWriter.CreateODataResourceWriter(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
-Microsoft.OData.ODataMessageWriter.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySetBase, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySetBase, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
 Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceWriter(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-Microsoft.OData.ODataMessageWriter.CreateODataUriParameterResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
 Microsoft.OData.ODataMessageWriter.Dispose() -> void
 Microsoft.OData.ODataMessageWriter.DisposeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.OData.ODataOutputContext.DisposeAsync() -> System.Threading.Tasks.ValueTask
@@ -764,19 +771,12 @@ Microsoft.OData.ODataMessageWriter.ODataMessageWriter(Microsoft.OData.IODataResp
 Microsoft.OData.ODataMessageWriter.ODataMessageWriter(Microsoft.OData.IODataResponseMessage responseMessage, Microsoft.OData.ODataMessageWriterSettings settings) -> void
 Microsoft.OData.ODataMessageWriter.ODataMessageWriter(Microsoft.OData.IODataResponseMessage responseMessage, Microsoft.OData.ODataMessageWriterSettings settings, Microsoft.OData.Edm.IEdmModel model) -> void
 Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLink(Microsoft.OData.ODataEntityReferenceLink link) -> void
-Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLinkAsync(Microsoft.OData.ODataEntityReferenceLink link) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLinks(Microsoft.OData.ODataEntityReferenceLinks links) -> void
-Microsoft.OData.ODataMessageWriter.WriteEntityReferenceLinksAsync(Microsoft.OData.ODataEntityReferenceLinks links) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteError(Microsoft.OData.ODataError error, bool includeDebugInformation) -> void
-Microsoft.OData.ODataMessageWriter.WriteErrorAsync(Microsoft.OData.ODataError error, bool includeDebugInformation) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteMetadataDocument() -> void
-Microsoft.OData.ODataMessageWriter.WriteMetadataDocumentAsync() -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteProperty(Microsoft.OData.ODataProperty property) -> void
-Microsoft.OData.ODataMessageWriter.WritePropertyAsync(Microsoft.OData.ODataProperty property) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteServiceDocument(Microsoft.OData.ODataServiceDocument serviceDocument) -> void
-Microsoft.OData.ODataMessageWriter.WriteServiceDocumentAsync(Microsoft.OData.ODataServiceDocument serviceDocument) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriter.WriteValue(object value) -> void
-Microsoft.OData.ODataMessageWriter.WriteValueAsync(object value) -> System.Threading.Tasks.Task
 Microsoft.OData.ODataMessageWriterSettings
 Microsoft.OData.ODataMessageWriterSettings.AlwaysAddTypeAnnotationsForDerivedTypes.get -> bool
 Microsoft.OData.ODataMessageWriterSettings.AlwaysAddTypeAnnotationsForDerivedTypes.set -> void
@@ -2306,45 +2306,45 @@ virtual Microsoft.OData.ODataBatchReader.ReadAtStartImplementationAsync() -> Sys
 virtual Microsoft.OData.ODataBatchWriter.OnInStreamErrorAsync() -> System.Threading.Tasks.Task
 virtual Microsoft.OData.ODataBatchWriter.StreamDisposedAsync() -> System.Threading.Tasks.Task
 virtual Microsoft.OData.ODataInputContext.CreateCollectionReader(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> Microsoft.OData.ODataCollectionReader
-virtual Microsoft.OData.ODataInputContext.CreateCollectionReaderAsync(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionReader>
+virtual Microsoft.OData.ODataInputContext.CreateCollectionReaderAsync(Microsoft.OData.Edm.IEdmTypeReference expectedItemTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionReader>
 virtual Microsoft.OData.ODataInputContext.CreateDeltaResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-virtual Microsoft.OData.ODataInputContext.CreateDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
+virtual Microsoft.OData.ODataInputContext.CreateDeltaResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataInputContext.CreateParameterReader(Microsoft.OData.Edm.IEdmOperation operation) -> Microsoft.OData.ODataParameterReader
-virtual Microsoft.OData.ODataInputContext.CreateParameterReaderAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.Task<Microsoft.OData.ODataParameterReader>
+virtual Microsoft.OData.ODataInputContext.CreateParameterReaderAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataParameterReader>
 virtual Microsoft.OData.ODataInputContext.CreateResourceReader(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-virtual Microsoft.OData.ODataInputContext.CreateResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
+virtual Microsoft.OData.ODataInputContext.CreateResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataInputContext.CreateResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-virtual Microsoft.OData.ODataInputContext.CreateResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
+virtual Microsoft.OData.ODataInputContext.CreateResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceReader(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
+virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceReaderAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceSetReader(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> Microsoft.OData.ODataReader
-virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
+virtual Microsoft.OData.ODataInputContext.CreateUriParameterResourceSetReaderAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType expectedResourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataInputContext.Dispose(bool disposing) -> void
 virtual Microsoft.OData.ODataInputContext.ReadError() -> Microsoft.OData.ODataError
-virtual Microsoft.OData.ODataInputContext.ReadErrorAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataError>
+virtual Microsoft.OData.ODataInputContext.ReadErrorAsync() -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataError>
 virtual Microsoft.OData.ODataInputContext.ReadProperty(Microsoft.OData.Edm.IEdmStructuralProperty edmStructuralProperty, Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> Microsoft.OData.ODataProperty
-virtual Microsoft.OData.ODataInputContext.ReadPropertyAsync(Microsoft.OData.Edm.IEdmStructuralProperty edmStructuralProperty, Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataProperty>
+virtual Microsoft.OData.ODataInputContext.ReadPropertyAsync(Microsoft.OData.Edm.IEdmStructuralProperty edmStructuralProperty, Microsoft.OData.Edm.IEdmTypeReference expectedPropertyTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataProperty>
 virtual Microsoft.OData.ODataMediaTypeResolver.GetMediaTypeFormats(Microsoft.OData.ODataPayloadKind payloadKind) -> System.Collections.Generic.IEnumerable<Microsoft.OData.ODataMediaTypeFormat>
 virtual Microsoft.OData.ODataOutputContext.CreateODataCollectionWriter(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> Microsoft.OData.ODataCollectionWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataCollectionWriterAsync(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataCollectionWriterAsync(Microsoft.OData.Edm.IEdmTypeReference itemTypeReference) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataCollectionWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataDeltaResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType entityType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataDeltaResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType entityType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataParameterWriter(Microsoft.OData.Edm.IEdmOperation operation) -> Microsoft.OData.ODataParameterWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataParameterWriterAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.Task<Microsoft.OData.ODataParameterWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataParameterWriterAsync(Microsoft.OData.Edm.IEdmOperation operation) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataParameterWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType entityType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType entityType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataResourceWriter(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceSetWriter(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceSetWriterAsync(Microsoft.OData.Edm.IEdmEntitySetBase entitySet, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
 virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceWriter(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> Microsoft.OData.ODataWriter
-virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.Task<Microsoft.OData.ODataWriter>
+virtual Microsoft.OData.ODataOutputContext.CreateODataUriParameterResourceWriterAsync(Microsoft.OData.Edm.IEdmNavigationSource navigationSource, Microsoft.OData.Edm.IEdmStructuredType resourceType) -> System.Threading.Tasks.ValueTask<Microsoft.OData.ODataWriter>
 virtual Microsoft.OData.ODataOutputContext.Dispose(bool disposing) -> void
 virtual Microsoft.OData.ODataOutputContext.DisposeAsyncCore() -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataOutputContext.WriteError(Microsoft.OData.ODataError odataError, bool includeDebugInformation) -> void
-virtual Microsoft.OData.ODataOutputContext.WriteErrorAsync(Microsoft.OData.ODataError odataError, bool includeDebugInformation) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataOutputContext.WriteErrorAsync(Microsoft.OData.ODataError odataError, bool includeDebugInformation) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataOutputContext.WriteProperty(Microsoft.OData.ODataProperty odataProperty) -> void
-virtual Microsoft.OData.ODataOutputContext.WritePropertyAsync(Microsoft.OData.ODataProperty odataProperty) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataOutputContext.WritePropertyAsync(Microsoft.OData.ODataProperty odataProperty) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataParameterReader.CreateCollectionReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataCollectionReader>
 virtual Microsoft.OData.ODataParameterReader.CreateResourceReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
 virtual Microsoft.OData.ODataParameterReader.CreateResourceSetReaderAsync() -> System.Threading.Tasks.Task<Microsoft.OData.ODataReader>
@@ -2357,27 +2357,27 @@ virtual Microsoft.OData.ODataReader.CreateReadStreamAsync() -> System.Threading.
 virtual Microsoft.OData.ODataReader.CreateTextReader() -> System.IO.TextReader
 virtual Microsoft.OData.ODataReader.CreateTextReaderAsync() -> System.Threading.Tasks.Task<System.IO.TextReader>
 virtual Microsoft.OData.ODataWriter.CreateBinaryWriteStream() -> System.IO.Stream
-virtual Microsoft.OData.ODataWriter.CreateBinaryWriteStreamAsync() -> System.Threading.Tasks.Task<System.IO.Stream>
+virtual Microsoft.OData.ODataWriter.CreateBinaryWriteStreamAsync() -> System.Threading.Tasks.ValueTask<System.IO.Stream>
 virtual Microsoft.OData.ODataWriter.CreateTextWriter() -> System.IO.TextWriter
-virtual Microsoft.OData.ODataWriter.CreateTextWriterAsync() -> System.Threading.Tasks.Task<System.IO.TextWriter>
+virtual Microsoft.OData.ODataWriter.CreateTextWriterAsync() -> System.Threading.Tasks.ValueTask<System.IO.TextWriter>
 virtual Microsoft.OData.ODataWriter.FlushAsync() -> System.Threading.Tasks.Task
 virtual Microsoft.OData.ODataWriter.WriteDeltaDeletedLink(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> void
-virtual Microsoft.OData.ODataWriter.WriteDeltaDeletedLinkAsync(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataWriter.WriteDeltaDeletedLinkAsync(Microsoft.OData.ODataDeltaDeletedLink deltaDeletedLink) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataWriter.WriteDeltaLink(Microsoft.OData.ODataDeltaLink deltaLink) -> void
-virtual Microsoft.OData.ODataWriter.WriteDeltaLinkAsync(Microsoft.OData.ODataDeltaLink deltaLink) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteEndAsync() -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteEntityReferenceLinkAsync(Microsoft.OData.ODataEntityReferenceLink entityReferenceLink) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataWriter.WriteDeltaLinkAsync(Microsoft.OData.ODataDeltaLink deltaLink) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteEndAsync() -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteEntityReferenceLinkAsync(Microsoft.OData.ODataEntityReferenceLink entityReferenceLink) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataWriter.WritePrimitive(Microsoft.OData.ODataPrimitiveValue primitiveValue) -> void
-virtual Microsoft.OData.ODataWriter.WritePrimitiveAsync(Microsoft.OData.ODataPrimitiveValue primitiveValue) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataWriter.WritePrimitiveAsync(Microsoft.OData.ODataPrimitiveValue primitiveValue) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.ODataWriter.WriteStart(Microsoft.OData.ODataDeletedResource deletedResource) -> void
 virtual Microsoft.OData.ODataWriter.WriteStart(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> void
 virtual Microsoft.OData.ODataWriter.WriteStart(Microsoft.OData.ODataPropertyInfo primitiveProperty) -> void
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataDeletedResource deletedResource) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataNestedResourceInfo nestedResourceInfo) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataPropertyInfo primitiveProperty) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataResource resource) -> System.Threading.Tasks.Task
-virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataResourceSet resourceSet) -> System.Threading.Tasks.Task
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataDeletedResource deletedResource) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataDeltaResourceSet deltaResourceSet) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataNestedResourceInfo nestedResourceInfo) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataPropertyInfo primitiveProperty) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataResource resource) -> System.Threading.Tasks.ValueTask
+virtual Microsoft.OData.ODataWriter.WriteStartAsync(Microsoft.OData.ODataResourceSet resourceSet) -> System.Threading.Tasks.ValueTask
 virtual Microsoft.OData.UriParser.ODataUriResolver.EnableCaseInsensitive.get -> bool
 virtual Microsoft.OData.UriParser.ODataUriResolver.EnableCaseInsensitive.set -> void
 virtual Microsoft.OData.UriParser.ODataUriResolver.EnableNoDollarQueryOptions.get -> bool
diff --git a/src/Microsoft.OData.Core/StreamReaderDelegate.cs b/src/Microsoft.OData.Core/StreamReaderDelegate.cs
index ec3b9d11e0..0f3e6f3ba0 100644
--- a/src/Microsoft.OData.Core/StreamReaderDelegate.cs
+++ b/src/Microsoft.OData.Core/StreamReaderDelegate.cs
@@ -36,5 +36,5 @@ namespace Microsoft.OData
     /// or 0 if at the end of the stream and no data was read.
     /// The number will be less than or equal to the <paramref name="maxLength"/> parameter,
     /// depending on whether the data is available within the stream.</returns>
-    internal delegate Task<int> AsyncStreamReaderDelegate(char[] chars, int offset, int maxLength);
+    internal delegate ValueTask<int> AsyncStreamReaderDelegate(char[] chars, int offset, int maxLength);
 }
diff --git a/src/Microsoft.OData.Core/TaskUtils.cs b/src/Microsoft.OData.Core/TaskUtils.cs
index 730421fb57..afcabdf30c 100644
--- a/src/Microsoft.OData.Core/TaskUtils.cs
+++ b/src/Microsoft.OData.Core/TaskUtils.cs
@@ -421,6 +421,155 @@ internal static Task<TResult> GetTaskForSynchronousOperation<TResult, TArg>(
             }
         }
 
+        /// <summary>
+        /// Returns an already completed task for the specified synchronous operation.
+        /// </summary>
+        /// <param name="synchronousOperation">The synchronous operation to perform.</param>
+        /// <returns>An already completed task. If the <paramref name="synchronousOperation"/> succeeded this will be a successfully completed task,
+        /// otherwise it will be a faulted task holding the exception thrown.</returns>
+        /// <remarks>The advantage of this method over CompletedTask property is that if the <paramref name="synchronousOperation"/> fails
+        /// this method returns a faulted task, instead of throwing an exception.</remarks>
+        internal static ValueTask GetValueTaskForSynchronousOperation(Action synchronousOperation)
+        {
+            Debug.Assert(synchronousOperation != null, "synchronousOperation != null");
+
+            try
+            {
+                synchronousOperation();
+                return ValueTask.CompletedTask;
+            }
+            catch (Exception e)
+            {
+                if (!ExceptionUtils.IsCatchableExceptionType(e))
+                {
+                    throw;
+                }
+
+                return ValueTask.FromException(e);
+            }
+        }
+
+        /// <summary>
+        /// Returns an already completed task for the specified synchronous operation.
+        /// </summary>
+        /// <typeparam name="TArg1">The <paramref name="synchronousOperation"/> delegate first argument type.</typeparam>
+        /// <typeparam name="TArg2">The <paramref name="synchronousOperation"/> delegate second argument type.</typeparam>
+        /// <param name="synchronousOperation">The synchronous operation to perform.</param>
+        /// <param name="arg1">The first argument value provided to the <paramref name="synchronousOperation"/> delegate.</param>
+        /// <param name="arg2">The second argument value provided to the <paramref name="synchronousOperation"/> delegate.</param>
+        /// <returns>
+        /// An already completed task. If the <paramref name="synchronousOperation"/>
+        /// succeeded this will be a successfully completed task,
+        /// otherwise it will be a faulted task holding the exception thrown.
+        /// </returns>
+        /// <remarks>
+        /// The advantage of this method over <see cref="CompletedTask"/> property 
+        /// is that if the <paramref name="synchronousOperation"/> fails
+        /// this method returns a faulted task, instead of throwing an exception.
+        /// </remarks>
+        internal static ValueTask GetValueTaskForSynchronousOperation<TArg1, TArg2>(
+            Action<TArg1, TArg2> synchronousOperation,
+            TArg1 arg1,
+            TArg2 arg2)
+        {
+            Debug.Assert(synchronousOperation != null, "synchronousOperation != null");
+
+            try
+            {
+                synchronousOperation(arg1, arg2);
+                return ValueTask.CompletedTask;
+            }
+            catch (Exception e)
+            {
+                if (!ExceptionUtils.IsCatchableExceptionType(e))
+                {
+                    throw;
+                }
+
+                return ValueTask.FromException(e);
+            }
+        }
+
+        /// <summary>
+        /// Returns an already completed task for the specified synchronous operation.
+        /// </summary>
+        /// <typeparam name="TArg">The <paramref name="synchronousOperation"/> delegate argument type.</typeparam>
+        /// <param name="synchronousOperation">The synchronous operation to perform.</param>
+        /// <param name="arg">The argument value provided to the <paramref name="synchronousOperation"/> delegate.</param>
+        /// <returns>
+        /// An already completed task. If the <paramref name="synchronousOperation"/>
+        /// succeeded this will be a successfully completed task,
+        /// otherwise it will be a faulted task holding the exception thrown.
+        /// </returns>
+        /// <remarks>
+        /// The advantage of this method over <see cref="CompletedTask"/> property 
+        /// is that if the <paramref name="synchronousOperation"/> fails
+        /// this method returns a faulted task, instead of throwing an exception.
+        /// </remarks>
+        internal static ValueTask GetValueTaskForSynchronousOperation<TArg>(
+            Action<TArg> synchronousOperation,
+            TArg arg)
+        {
+            Debug.Assert(synchronousOperation != null, "synchronousOperation != null");
+
+            try
+            {
+                synchronousOperation(arg);
+                return ValueTask.CompletedTask;
+            }
+            catch (Exception e)
+            {
+                if (!ExceptionUtils.IsCatchableExceptionType(e))
+                {
+                    throw;
+                }
+
+                return ValueTask.FromException(e);
+            }
+        }
+
+        /// <summary>
+        /// Returns an already completed task for the specified synchronous operation.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result returned by the operation. This MUST NOT be a Task type.</typeparam>
+        /// <typeparam name="TArg">The <paramref name="synchronousOperation"/> delegate first argument type.</typeparam>
+        /// <param name="synchronousOperation">The synchronous operation to perform.</param>
+        /// <param name="arg">The first argument value provided to the <paramref name="synchronousOperation"/> delegate.</param>
+        /// <returns>
+        /// An already completed task. If the <paramref name="synchronousOperation"/>
+        /// succeeded this will be a successfully completed task,
+        /// otherwise it will be a faulted task holding the exception thrown.
+        /// </returns>
+        /// <remarks>
+        /// The advantage of this method over <see cref="CompletedTask"/> property
+        /// is that if the <paramref name="synchronousOperation"/> fails
+        /// this method returns a faulted task, instead of throwing an exception.
+        /// </remarks>
+        internal static ValueTask<TResult> GetValueTaskForSynchronousOperation<TResult, TArg>(
+            Func<TArg, TResult> synchronousOperation,
+            TArg arg)
+        {
+            Debug.Assert(synchronousOperation != null, "synchronousOperation != null");
+            Debug.Assert(!typeof(Task).IsAssignableFrom(typeof(TResult)),
+                "This method doesn't support operations returning Task instances.");
+
+            try
+            {
+                TResult result = synchronousOperation(arg);
+                return ValueTask.FromResult(result);
+            }
+            catch (Exception e)
+            {
+                if (!ExceptionUtils.IsCatchableExceptionType(e))
+                {
+                    throw;
+                }
+
+                return ValueTask.FromException<TResult>(e);
+            }
+        }
+
+
         /// <summary>
         /// Returns an already completed task for the specified synchronous operation.
         /// </summary>
diff --git a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.csproj b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.csproj
index f9f6b95195..33cfd0aba7 100644
--- a/src/Microsoft.OData.Edm/Microsoft.OData.Edm.csproj
+++ b/src/Microsoft.OData.Edm/Microsoft.OData.Edm.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <AssemblyName>Microsoft.OData.Edm</AssemblyName>
     <RootNamespace>Microsoft.OData.Edm</RootNamespace>
     <DocumentationFile>$(AssemblyName).xml</DocumentationFile>
diff --git a/src/Microsoft.Spatial/Microsoft.Spatial.csproj b/src/Microsoft.Spatial/Microsoft.Spatial.csproj
index ef616b13b5..cd7b3a0361 100644
--- a/src/Microsoft.Spatial/Microsoft.Spatial.csproj
+++ b/src/Microsoft.Spatial/Microsoft.Spatial.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <AssemblyName>Microsoft.Spatial</AssemblyName>
     <RootNamespace>Microsoft.Spatial</RootNamespace>
 
diff --git a/test/Common/Microsoft.Test.OData.DependencyInjection/Microsoft.Test.OData.DependencyInjection.csproj b/test/Common/Microsoft.Test.OData.DependencyInjection/Microsoft.Test.OData.DependencyInjection.csproj
index 7fe1e22d22..c40c5027c6 100644
--- a/test/Common/Microsoft.Test.OData.DependencyInjection/Microsoft.Test.OData.DependencyInjection.csproj
+++ b/test/Common/Microsoft.Test.OData.DependencyInjection/Microsoft.Test.OData.DependencyInjection.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AssemblyName>Microsoft.Test.OData.DependencyInjection</AssemblyName> 
-    <TargetFramework>net8.0</TargetFramework> 
+    <TargetFrameworks>net8.0</TargetFrameworks> 
     <TestType Condition=" '$(TestType)' == '' ">Private</TestType>
     <RestorePackages>true</RestorePackages>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
diff --git a/test/FunctionalTests/Microsoft.OData.Client.Tests/Microsoft.OData.Client.Tests.csproj b/test/FunctionalTests/Microsoft.OData.Client.Tests/Microsoft.OData.Client.Tests.csproj
index b1b942ea00..d4abb3248b 100644
--- a/test/FunctionalTests/Microsoft.OData.Client.Tests/Microsoft.OData.Client.Tests.csproj
+++ b/test/FunctionalTests/Microsoft.OData.Client.Tests/Microsoft.OData.Client.Tests.csproj
@@ -4,7 +4,7 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <Optimize>false</Optimize>
     <AssemblyName>Microsoft.OData.Client.Tests</AssemblyName>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\..\..\sln\</SolutionDir>
     <RestorePackages>true</RestorePackages>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/BufferingJsonReaderTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/BufferingJsonReaderTests.cs
index acbedd406e..d5b885a1f4 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/BufferingJsonReaderTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/BufferingJsonReaderTests.cs
@@ -136,7 +136,7 @@ public async Task ReadInStreamErrorPropertyAsync_ThrowsExceptionForODataErrorRea
 
                 // Act
                 var exception = await Assert.ThrowsAsync<ODataErrorException>(
-                    () => bufferingReader.ReadAsync());
+                    async () => await bufferingReader.ReadAsync());
 
                 // Assert
                 var error = exception.Error;
@@ -361,7 +361,7 @@ public async Task ReadInStreamErrorPropertyAsync_SkipsNonSupportedPropertiesInIn
 
                 // Act
                 var exception = await Assert.ThrowsAsync<ODataErrorException>(
-                    () => bufferingReader.ReadAsync());
+                    async () => await bufferingReader.ReadAsync());
 
                 // Assert
                 var error = exception.Error;
@@ -393,7 +393,7 @@ public async Task ReadInStreamErrorPropertyAsync_SkipsNonSupportedPropertiesInEr
 
                 // Act
                 var exception = await Assert.ThrowsAsync<ODataErrorException>(
-                    () => bufferingReader.ReadAsync());
+                    async () => await bufferingReader.ReadAsync());
 
                 // Assert
                 var error = exception.Error;
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/JsonWriterAsyncTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/JsonWriterAsyncTests.cs
index 66dd3983ad..f4eeacd1ea 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/JsonWriterAsyncTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/JsonWriterAsyncTests.cs
@@ -391,14 +391,14 @@ public Task WriteNameAsyncUsesProvidedCharArrayPool()
             // Note: CharArrayPool is used if string has special chars
             // This test is mostly theoretical since special characters are not allowed in names
             return SetupJsonWriterRunTestAndVerifyRentAsync(
-                (jsonWriter) => jsonWriter.WriteNameAsync("foo\tbar"));
+                async (jsonWriter) => await jsonWriter.WriteNameAsync("foo\tbar"));
         }
 
         [Fact]
         public Task WriteStringValueUsesProvidedCharArrayPool()
         {
             return SetupJsonWriterRunTestAndVerifyRentAsync(
-                (jsonWriter) => jsonWriter.WriteValueAsync("foo\tbar"));
+                async (jsonWriter) => await jsonWriter.WriteValueAsync("foo\tbar"));
         }
 
         private async Task SetupJsonWriterRunTestAndVerifyRentAsync(Func<JsonWriter, Task> func)
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/MockJsonWriter.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/MockJsonWriter.cs
index 1f685c05d2..91999589cc 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/MockJsonWriter.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/Json/MockJsonWriter.cs
@@ -99,80 +99,80 @@ public void WriteRawValue(string rawValue)
 
         public void Flush() => throw new NotImplementedException();
 
-        public Task StartPaddingFunctionScopeAsync() => throw new NotImplementedException();
+        public ValueTask StartPaddingFunctionScopeAsync() => throw new NotImplementedException();
 
-        public Task EndPaddingFunctionScopeAsync() => throw new NotImplementedException();
+        public ValueTask EndPaddingFunctionScopeAsync() => throw new NotImplementedException();
 
-        public Task StartObjectScopeAsync() => throw new NotImplementedException();
+        public ValueTask StartObjectScopeAsync() => throw new NotImplementedException();
 
-        public Task EndObjectScopeAsync() => throw new NotImplementedException();
+        public ValueTask EndObjectScopeAsync() => throw new NotImplementedException();
 
-        public Task StartArrayScopeAsync() => throw new NotImplementedException();
+        public ValueTask StartArrayScopeAsync() => throw new NotImplementedException();
 
-        public Task EndArrayScopeAsync() => throw new NotImplementedException();
+        public ValueTask EndArrayScopeAsync() => throw new NotImplementedException();
 
-        public Task WriteNameAsync(string name)
+        public ValueTask WriteNameAsync(string name)
         {
             Assert.NotNull(this.WriteNameVerifier);
             this.WriteNameVerifier(name);
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WritePaddingFunctionNameAsync(string functionName) => throw new NotImplementedException();
+        public ValueTask WritePaddingFunctionNameAsync(string functionName) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(bool value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(bool value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(int value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(int value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(float value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(float value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(short value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(short value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(long value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(long value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(double value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(double value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(Guid value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(Guid value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(decimal value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(decimal value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(DateTimeOffset value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(DateTimeOffset value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(TimeSpan value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(TimeSpan value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(byte value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(byte value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(sbyte value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(sbyte value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(string value)
+        public ValueTask WriteValueAsync(string value)
         {
             Assert.NotNull(this.WriteValueVerifier);
             this.WriteValueVerifier(value);
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(byte[] value)
+        public ValueTask WriteValueAsync(byte[] value)
         {
             Assert.NotNull(this.WriteValueVerifier);
             this.WriteValueVerifier(Convert.ToBase64String(value));
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(Date value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(Date value) => throw new NotImplementedException();
 
-        public Task WriteValueAsync(TimeOfDay value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(TimeOfDay value) => throw new NotImplementedException();
 
-        public Task WriteRawValueAsync(string rawValue)
+        public ValueTask WriteRawValueAsync(string rawValue)
         {
             Assert.NotNull(this.WriteValueVerifier);
             this.WriteValueVerifier(rawValue);
-            return TaskUtils.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public Task FlushAsync() => throw new NotImplementedException();
 
 #if NETCOREAPP
-        public Task WriteValueAsync(JsonElement value) => throw new NotImplementedException();
+        public ValueTask WriteValueAsync(JsonElement value) => throw new NotImplementedException();
 #endif
 
         public Stream StartStreamValueScope() => throw new NotImplementedException();
@@ -183,12 +183,12 @@ public Task WriteRawValueAsync(string rawValue)
 
         public void EndTextWriterValueScope() => throw new NotImplementedException();
 
-        public Task<Stream> StartStreamValueScopeAsync() => throw new NotImplementedException();
+        public ValueTask<Stream> StartStreamValueScopeAsync() => throw new NotImplementedException();
 
-        public Task<TextWriter> StartTextWriterValueScopeAsync(string contentType) => throw new NotImplementedException();
+        public ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType) => throw new NotImplementedException();
 
-        public Task EndStreamValueScopeAsync() => throw new NotImplementedException();
+        public ValueTask EndStreamValueScopeAsync() => throw new NotImplementedException();
 
-        public Task EndTextWriterValueScopeAsync() => throw new NotImplementedException();
+        public ValueTask EndTextWriterValueScopeAsync() => throw new NotImplementedException();
     }
 }
\ No newline at end of file
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightOutputContextTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightOutputContextTests.cs
index aed94e2d0e..360dc6da3d 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightOutputContextTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightOutputContextTests.cs
@@ -480,7 +480,7 @@ public async Task WritePropertyAsync()
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WritePropertyAsync(property));
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WritePropertyAsync(property));
 
             Assert.Equal(
                 "{\"@odata.context\":\"http://tempuri.org/$metadata#Edm.Int32\",\"@Is.LuckyNumber\":true,\"value\":13}",
@@ -499,7 +499,7 @@ public async Task WriteSpatialPropertyAsync()
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WritePropertyAsync(geographyProperty));
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WritePropertyAsync(geographyProperty));
 
             Assert.Equal(
                 "{\"@odata.context\":\"http://tempuri.org/$metadata#Edm.GeographyPoint\"," +
@@ -533,7 +533,7 @@ public async Task WriteSpatialCollectionPropertyAsync()
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WritePropertyAsync(geographyCollectionProperty));
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WritePropertyAsync(geographyCollectionProperty));
 
             Assert.Equal(
                 "{\"@odata.context\":\"http://tempuri.org/$metadata#Collection(Edm.Geography)\"," +
@@ -604,7 +604,7 @@ public async Task WriteEntityReferenceLinkAsync(bool writingResponse)
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WriteEntityReferenceLinkAsync(entityReferenceLink),
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WriteEntityReferenceLinkAsync(entityReferenceLink),
                 writingResponse);
 
             Assert.Equal(
@@ -627,7 +627,7 @@ public async Task WriteEntityReferenceLinksAsync(bool writingResponse)
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WriteEntityReferenceLinksAsync(entityReferenceLinks),
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WriteEntityReferenceLinksAsync(entityReferenceLinks),
                 writingResponse);
 
             Assert.Equal(
@@ -649,7 +649,7 @@ public async Task WriteServiceDocumentAsync()
             };
 
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WriteServiceDocumentAsync(serviceDocument));
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WriteServiceDocumentAsync(serviceDocument));
 
             Assert.Equal(
                 "{\"@odata.context\":\"http://tempuri.org/$metadata\"," +
@@ -663,7 +663,7 @@ public async Task WriteServiceDocumentAsync()
         public async Task WriteErrorAsync()
         {
             var result = await SetupJsonLightOutputContextAndRunTestAsync(
-                (jsonLightOutputContext) => jsonLightOutputContext.WriteErrorAsync(this.nullReferenceError, /*includeDebugInformation*/ false));
+                async (jsonLightOutputContext) => await jsonLightOutputContext.WriteErrorAsync(this.nullReferenceError, /*includeDebugInformation*/ false));
 
             Assert.Equal(
                 "{\"error\":{\"code\":\"NRE\",\"message\":\"Object reference not set to an instance of an object\",\"@Is.Error\":true}}",
@@ -818,6 +818,20 @@ private async Task<string> SetupJsonLightOutputContextAndRunTestAsync(
             return await new StreamReader(this.stream).ReadToEndAsync();
         }
 
+        //private async ValueTask<string> SetupJsonLightOutputContextAndRunTestAsync(
+        //    Func<ODataJsonLightOutputContext, ValueTask> func,
+        //    bool writingResponse = true)
+        //{
+        //    this.stream = new AsyncStream(this.stream);
+        //    var messageInfo = CreateMessageInfo(this.model, asynchronous: true, writingResponse: writingResponse);
+        //    var jsonLightOutputContext = new ODataJsonLightOutputContext(messageInfo, this.messageWriterSettings);
+
+        //    await func(jsonLightOutputContext);
+
+        //    this.stream.Position = 0;
+        //    return await new StreamReader(this.stream).ReadToEndAsync();
+        //}
+
         private ODataMessageInfo CreateMessageInfo(IEdmModel model, bool asynchronous = true, bool writingResponse = true)
         {
             return new ODataMessageInfo
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightSerializerTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightSerializerTests.cs
index 4fea060317..d2c956013f 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightSerializerTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightSerializerTests.cs
@@ -368,9 +368,9 @@ public async Task WriteTopLevelPayloadAsync_WritesTopLevelPayload()
                 (jsonLightSerializer) =>
                 {
                     return jsonLightSerializer.WriteTopLevelPayloadAsync(
-                        () =>
+                        async () =>
                         {
-                            return jsonLightSerializer.JsonWriter.WriteValueAsync(13);
+                            await jsonLightSerializer.JsonWriter.WriteValueAsync(13);
                         });
                 });
 
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightWriterTests.cs
index 13cf06c22f..da3f3ab63c 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightWriterTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ODataJsonLightWriterTests.cs
@@ -2194,7 +2194,7 @@ public async Task WriteEndAsync_ThrowsExceptionForBinaryStreamNotDisposed()
         /// then flushes and reads the stream back as a string for customized verification.
         /// </summary>
         private async Task<string> SetupJsonLightWriterAndRunTestAsync(
-            Func<ODataJsonLightWriter, Task> func,
+            Func<ODataJsonLightWriter, ValueTask> func,
             IEdmNavigationSource navigationSource,
             IEdmStructuredType resourceType,
             bool writingResourceSet = false,
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ReorderingJsonReaderTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ReorderingJsonReaderTests.cs
index 681c19d72e..6cb2712758 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ReorderingJsonReaderTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/JsonLight/ReorderingJsonReaderTests.cs
@@ -502,7 +502,7 @@ public async Task CreateTextStreamAsync_ThrowsExceptionForReaderNotOnPropertyNod
             var exception = await Assert.ThrowsAsync<ODataException>(
                 () => SetupReorderingJsonReaderAndRunTestAsync(
                     payload,
-                    (reorderingReader) => reorderingReader.CreateTextReaderAsync()));
+                    async (reorderingReader) => await reorderingReader.CreateTextReaderAsync()));
 
             Assert.Equal(
                 ErrorStrings.JsonReader_CannotCreateTextReader,
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/Microsoft.OData.Core.Tests.csproj b/test/FunctionalTests/Microsoft.OData.Core.Tests/Microsoft.OData.Core.Tests.csproj
index cb3034cf0d..31f9e884b5 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/Microsoft.OData.Core.Tests.csproj
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/Microsoft.OData.Core.Tests.csproj
@@ -3,7 +3,7 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <AssemblyName>Microsoft.OData.Core.Tests</AssemblyName>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <FileUpgradeFlags>40</FileUpgradeFlags>
     <OldToolsVersion>2.0</OldToolsVersion>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataBinaryStreamReaderTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataBinaryStreamReaderTests.cs
index 1d2ab752af..39eb88536e 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataBinaryStreamReaderTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataBinaryStreamReaderTests.cs
@@ -35,7 +35,7 @@ private int ReadChars(char[] chars, int offset, int maxLength)
             return bytesRead;
         }
 
-        private async Task<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
+        private async ValueTask<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
         {
             var buffer = new byte[maxLength];
             int bytesRead = await this.stream.ReadAsync(buffer, offset, maxLength);
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataMessageWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataMessageWriterTests.cs
index 77e0c7541f..859939cbc3 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataMessageWriterTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataMessageWriterTests.cs
@@ -300,7 +300,7 @@ public async Task SupportsODataUtf8JsonWriterAsync()
             string output = await WriteAndGetPayloadAsync(
                 model,
                 "application/json",
-                (writer) => writer.WritePropertyAsync(new ODataProperty()
+                async (writer) => await writer.WritePropertyAsync(new ODataProperty()
                 {
                     Name = "Name",
                     Value = "This is a test ия"
@@ -326,7 +326,7 @@ public async Task WhenInjectingODataUtf8JsonWriterFactoryAsync_CreatesWriterUsin
             EdmModel model = new EdmModel();
 
             // Act
-            Func<ODataMessageWriter, Task> writePropertyAsync = (writer) => writer.WritePropertyAsync(new ODataProperty()
+            Func<ODataMessageWriter, Task> writePropertyAsync = async (writer) => await writer.WritePropertyAsync(new ODataProperty()
             {
                 Name = "Name",
                 Value = "This is a test ия"
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataRawOutputContextTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataRawOutputContextTests.cs
index 33c1915621..bcab02110c 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataRawOutputContextTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataRawOutputContextTests.cs
@@ -45,7 +45,7 @@ public ODataRawOutputContextTests()
         public async Task WriteValueAsync()
         {
             var result = await SetupRawOutputContextAndRunTestAsync(
-                (rawOutputContext) => rawOutputContext.WriteValueAsync("foobar"));
+                async (rawOutputContext) => await rawOutputContext.WriteValueAsync("foobar"));
 
             Assert.Equal("foobar", result);
         }
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataTextStreamReaderTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataTextStreamReaderTests.cs
index 5adbe1ca7d..1b8ace6bf2 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataTextStreamReaderTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ODataTextStreamReaderTests.cs
@@ -35,7 +35,7 @@ private int ReadChars(char[] chars, int offset, int maxLength)
             return bytesRead;
         }
 
-        private async Task<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
+        private async ValueTask<int> ReadCharsAsync(char[] chars, int offset, int maxLength)
         {
             var buffer = new byte[maxLength];
             int bytesRead = await this.stream.ReadAsync(buffer, offset, maxLength);
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Roundtrip/JsonReaderWriterInjectionTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Roundtrip/JsonReaderWriterInjectionTests.cs
index a09dc2d3f5..82e0930eeb 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Roundtrip/JsonReaderWriterInjectionTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Roundtrip/JsonReaderWriterInjectionTests.cs
@@ -473,25 +473,25 @@ public void Flush()
                 this.textWriter.Flush();
             }
 
-            public Task StartPaddingFunctionScopeAsync() => throw new NotImplementedException();
+            public ValueTask StartPaddingFunctionScopeAsync() => throw new NotImplementedException();
 
-            public Task EndPaddingFunctionScopeAsync() => throw new NotImplementedException();
+            public ValueTask EndPaddingFunctionScopeAsync() => throw new NotImplementedException();
 
-            public Task StartObjectScopeAsync()
+            public async ValueTask StartObjectScopeAsync()
             {
-                return this.textWriter.WriteAsync('<');
+                await this.textWriter.WriteAsync('<');
             }
 
-            public Task EndObjectScopeAsync()
+            public async ValueTask EndObjectScopeAsync()
             {
-                return this.textWriter.WriteAsync('>');
+                await this.textWriter.WriteAsync('>');
             }
 
-            public Task StartArrayScopeAsync() => throw new NotImplementedException();
+            public ValueTask StartArrayScopeAsync() => throw new NotImplementedException();
 
-            public Task EndArrayScopeAsync() => throw new NotImplementedException();
+            public ValueTask EndArrayScopeAsync() => throw new NotImplementedException();
 
-            public async Task WriteNameAsync(string name)
+            public async ValueTask WriteNameAsync(string name)
             {
                 if (name.StartsWith("@odata."))
                 {
@@ -501,47 +501,47 @@ public async Task WriteNameAsync(string name)
                 await this.textWriter.WriteAsync(string.Format("\"{0}\":", name));
             }
 
-            public Task WritePaddingFunctionNameAsync(string functionName) => throw new NotImplementedException();
+            public ValueTask WritePaddingFunctionNameAsync(string functionName) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(bool value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(bool value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(int value)
+            public async ValueTask WriteValueAsync(int value)
             {
-                return this.textWriter.WriteAsync(string.Format("{0},", value));
+                await this.textWriter.WriteAsync(string.Format("{0},", value));
             }
 
-            public Task WriteValueAsync(float value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(float value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(short value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(short value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(long value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(long value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(double value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(double value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(Guid value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(Guid value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(decimal value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(decimal value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(DateTimeOffset value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(DateTimeOffset value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(TimeSpan value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(TimeSpan value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(byte value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(byte value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(sbyte value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(sbyte value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(string value)
+            public async ValueTask WriteValueAsync(string value)
             {
-                return this.textWriter.WriteAsync(string.Format("\"{0}\",", value));
+                await this.textWriter.WriteAsync(string.Format("\"{0}\",", value));
             }
 
-            public Task WriteValueAsync(byte[] value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(byte[] value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(Date value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(Date value) => throw new NotImplementedException();
 
-            public Task WriteValueAsync(TimeOfDay value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(TimeOfDay value) => throw new NotImplementedException();
 
-            public Task WriteRawValueAsync(string rawValue) => throw new NotImplementedException();
+            public ValueTask WriteRawValueAsync(string rawValue) => throw new NotImplementedException();
 
             public Task FlushAsync()
             {
@@ -549,7 +549,7 @@ public Task FlushAsync()
             }
 
 #if NETCOREAPP
-            public Task WriteValueAsync(JsonElement value) => throw new NotImplementedException();
+            public ValueTask WriteValueAsync(JsonElement value) => throw new NotImplementedException();
 #endif
 
             public Stream StartStreamValueScope() => throw new NotImplementedException();
@@ -560,13 +560,13 @@ public Task FlushAsync()
 
             public void EndTextWriterValueScope() => throw new NotImplementedException();
 
-            public Task<Stream> StartStreamValueScopeAsync() => throw new NotImplementedException();
+            public ValueTask<Stream> StartStreamValueScopeAsync() => throw new NotImplementedException();
 
-            public Task<TextWriter> StartTextWriterValueScopeAsync(string contentType) => throw new NotImplementedException();
+            public ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType) => throw new NotImplementedException();
 
-            public Task EndStreamValueScopeAsync() => throw new NotImplementedException();
+            public ValueTask EndStreamValueScopeAsync() => throw new NotImplementedException();
 
-            public Task EndTextWriterValueScopeAsync() => throw new NotImplementedException();
+            public ValueTask EndTextWriterValueScopeAsync() => throw new NotImplementedException();
         }
 
         private class TestJsonReader : IJsonReader
@@ -638,21 +638,21 @@ public bool Read()
                 return true;
             }
 
-            public Task<bool> ReadAsync() => throw new NotImplementedException();
+            public ValueTask<bool> ReadAsync() => throw new NotImplementedException();
 
             public bool CanStream() => throw new NotImplementedException();
 
-            public Task<bool> CanStreamAsync() => throw new NotImplementedException();
+            public ValueTask<bool> CanStreamAsync() => throw new NotImplementedException();
 
             public Stream CreateReadStream() => throw new NotImplementedException();
 
-            public Task<Stream> CreateReadStreamAsync() => throw new NotImplementedException();
+            public ValueTask<Stream> CreateReadStreamAsync() => throw new NotImplementedException();
 
             public TextReader CreateTextReader() => throw new NotImplementedException();
 
-            public Task<TextReader> CreateTextReaderAsync() => throw new NotImplementedException();
+            public ValueTask<TextReader> CreateTextReaderAsync() => throw new NotImplementedException();
 
-            public Task<object> GetValueAsync() => throw new NotImplementedException();
+            public ValueTask<object> GetValueAsync() => throw new NotImplementedException();
         }
     }
 }
diff --git a/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Writer/JsonLight/ODataJsonLightInheritComplexCollectionWriterTests.cs b/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Writer/JsonLight/ODataJsonLightInheritComplexCollectionWriterTests.cs
index 14fbcd4e41..f887a1e80d 100644
--- a/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Writer/JsonLight/ODataJsonLightInheritComplexCollectionWriterTests.cs
+++ b/test/FunctionalTests/Microsoft.OData.Core.Tests/ScenarioTests/Writer/JsonLight/ODataJsonLightInheritComplexCollectionWriterTests.cs
@@ -11,6 +11,7 @@
 using Microsoft.OData.JsonLight;
 using Microsoft.OData.Edm;
 using Xunit;
+using System.Threading.Tasks;
 
 namespace Microsoft.OData.Tests.ScenarioTests.Writer.JsonLight
 {
@@ -223,21 +224,20 @@ private static void WriteAndValidateSync(IEdmTypeReference itemTypeReference, OD
             ValidateWrittenPayload(stream, expectedPayload);
         }
 
-        private static void WriteAndValidateAsync(IEdmTypeReference itemTypeReference, ODataResourceSet collectionStart, IEnumerable<ODataResource> items, string expectedPayload, bool writingResponse)
+        private static async Task WriteAndValidateAsync(IEdmTypeReference itemTypeReference, ODataResourceSet collectionStart, IEnumerable<ODataResource> items, string expectedPayload, bool writingResponse)
         {
             MemoryStream stream = new MemoryStream();
             var outputContext = CreateJsonLightOutputContext(stream, writingResponse, synchronous: false);
-            var createODataWriterTask = outputContext.CreateODataResourceSetWriterAsync(null, itemTypeReference == null ? null : itemTypeReference.ToStructuredType());
-            createODataWriterTask.Wait();
-            var odataWriter = createODataWriterTask.Result;
-            odataWriter.WriteStartAsync(collectionStart).Wait();
+
+            var odataWriter = await outputContext.CreateODataResourceSetWriterAsync(null, itemTypeReference == null ? null : itemTypeReference.ToStructuredType());
+            await odataWriter.WriteStartAsync(collectionStart);
             foreach (ODataResource item in items)
             {
-                odataWriter.WriteStartAsync(item).Wait();
-                odataWriter.WriteEndAsync().Wait();
+                await odataWriter.WriteStartAsync(item);
+                await odataWriter.WriteEndAsync();
             }
 
-            odataWriter.WriteEndAsync().Wait();
+            await odataWriter.WriteEndAsync();
             ValidateWrittenPayload(stream, expectedPayload);
         }
 
diff --git a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.csproj b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.csproj
index c8abb9bcc8..3c57f69d9d 100644
--- a/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.csproj
+++ b/test/FunctionalTests/Microsoft.OData.Edm.Tests/Microsoft.OData.Edm.Tests.csproj
@@ -4,7 +4,7 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <Optimize>true</Optimize>
     <AssemblyName>Microsoft.OData.Edm.Tests</AssemblyName>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <RestorePackages>true</RestorePackages>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute> <!--check this in attributes-->
diff --git a/test/FunctionalTests/Microsoft.OData.TestCommon/Microsoft.OData.TestCommon.csproj b/test/FunctionalTests/Microsoft.OData.TestCommon/Microsoft.OData.TestCommon.csproj
index 263ff072be..e11c5719d2 100644
--- a/test/FunctionalTests/Microsoft.OData.TestCommon/Microsoft.OData.TestCommon.csproj
+++ b/test/FunctionalTests/Microsoft.OData.TestCommon/Microsoft.OData.TestCommon.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AssemblyName>Microsoft.OData.TestCommon</AssemblyName>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <RestorePackages>true</RestorePackages>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
diff --git a/test/FunctionalTests/Microsoft.Spatial.Tests/Microsoft.Spatial.Tests.csproj b/test/FunctionalTests/Microsoft.Spatial.Tests/Microsoft.Spatial.Tests.csproj
index 23b6800ffb..74e6e8d3c2 100644
--- a/test/FunctionalTests/Microsoft.Spatial.Tests/Microsoft.Spatial.Tests.csproj
+++ b/test/FunctionalTests/Microsoft.Spatial.Tests/Microsoft.Spatial.Tests.csproj
@@ -4,7 +4,7 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <Optimize>true</Optimize>
     <AssemblyName>Microsoft.Spatial.Tests</AssemblyName>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <RestorePackages>true</RestorePackages>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
diff --git a/test/PerformanceTests/ComponentTests/Common/InMemoryMessage.cs b/test/PerformanceTests/ComponentTests/Common/InMemoryMessage.cs
index 029bf4eb45..6142cb0d47 100644
--- a/test/PerformanceTests/ComponentTests/Common/InMemoryMessage.cs
+++ b/test/PerformanceTests/ComponentTests/Common/InMemoryMessage.cs
@@ -15,7 +15,7 @@ namespace Microsoft.OData.Performance
     /// Based on file with same name in test\FunctionalTests\Microsoft.OData.Core.Tests directory, which
     /// is not part of the ComponentTests project.
     /// </summary>
-    public class InMemoryMessage : IODataRequestMessage, IODataResponseMessage, IContainerProvider, IDisposable
+    public class InMemoryMessage : IODataRequestMessage, IODataResponseMessage, IServiceCollectionProvider, IDisposable
     {
         private readonly Dictionary<string, string> headers;
 
@@ -37,7 +37,7 @@ public IEnumerable<KeyValuePair<string, string>> Headers
 
         public Stream Stream { get; set; }
 
-        public IServiceProvider Container { get; set; }
+        public IServiceProvider ServiceProvider { get; set; }
 
         public string GetHeader(string headerName)
         {
diff --git a/test/PerformanceTests/ComponentTests/Common/ODataMessageHelper.cs b/test/PerformanceTests/ComponentTests/Common/ODataMessageHelper.cs
index d15f27efae..7127445c19 100644
--- a/test/PerformanceTests/ComponentTests/Common/ODataMessageHelper.cs
+++ b/test/PerformanceTests/ComponentTests/Common/ODataMessageHelper.cs
@@ -8,9 +8,9 @@ namespace Microsoft.OData.Performance
 {
     using System;
     using System.IO;
+    using Microsoft.Extensions.DependencyInjection;
     using Microsoft.OData;
     using Microsoft.OData.Edm;
-    using Microsoft.OData.Performance.Common;
 
     /// <summary>
     /// Helper class to create ODataMessageReader and ODataMessageWriter
@@ -34,18 +34,18 @@ public static class ODataMessageHelper
         /// </summary>
         /// <param name="configureServices">Action callback to configure DI services.</param>
         /// <returns>Instance of the DI container</returns>
-        private static IServiceProvider GetSharedContainer(Action<IContainerBuilder> configureServices = null)
+        private static IServiceProvider GetSharedContainer(Action<IServiceCollection> configureServices = null)
         {
             if (container == null)
             {
-                var builder = new TestContainerBuilder();
-                builder.AddDefaultODataServices();
+                var serviceCollection = new ServiceCollection();
+                serviceCollection.AddDefaultODataServices();
                 if (configureServices != null)
                 {
-                    configureServices(builder);
+                    configureServices(serviceCollection);
                 }
 
-                container = builder.BuildContainer();
+                container = serviceCollection.BuildServiceProvider();
             }
 
             return container;
@@ -95,14 +95,14 @@ public static ODataMessageReader CreateMessageReader(Stream messageStream, IEdmM
             if (messageKind == ODataMessageKind.Request)
             {
                 var message = new StreamBasedRequestMessage(messageStream);
-                message.Container = GetSharedContainer();
+                message.ServiceProvider = GetSharedContainer();
                 message.SetHeader(ODataConstants.ContentTypeHeader, ContentType);
                 return new ODataMessageReader(message, settings, model);
             }
             else
             {
                 var message = new StreamBasedResponseMessage(messageStream);
-                message.Container = GetSharedContainer();
+                message.ServiceProvider = GetSharedContainer();
                 message.SetHeader(ODataConstants.ContentTypeHeader, ContentType);
                 return new ODataMessageReader(message, settings, model);
             }
@@ -118,7 +118,7 @@ public static ODataMessageReader CreateMessageReader(Stream messageStream, IEdmM
         {
             var settings = CreateMessageReaderSettings(true);
             var message = new StreamBasedRequestMessage(messageStream);
-            message.Container = GetSharedContainer();
+            message.ServiceProvider = GetSharedContainer();
             message.SetHeader(ODataConstants.ContentTypeHeader, ContentType);
             return new ODataMessageReader(message, settings, model);
         }
@@ -162,16 +162,16 @@ private static ODataMessageWriterSettings CreateMessageWriterSettings(bool isFul
         /// <param name="isFullValidation">Whether turn on FullValidation</param>
         /// <param name="configureServices">Action callback to configure DI services.</param>
         /// <returns>Instance of ODataMessageWriter</returns>
-        public static ODataMessageWriter CreateMessageWriter(Stream stream, IEdmModel model, ODataMessageKind messageKind, bool isFullValidation, Action<IContainerBuilder> configureServices = null)
+        public static ODataMessageWriter CreateMessageWriter(Stream stream, IEdmModel model, ODataMessageKind messageKind, bool isFullValidation, Action<IServiceCollection> configureServices = null)
         {
             var settings = CreateMessageWriterSettings(isFullValidation);
 
             if (messageKind == ODataMessageKind.Request)
             {
-                return new ODataMessageWriter(new StreamBasedRequestMessage(stream) { Container = GetSharedContainer(configureServices) }, settings, model);
+                return new ODataMessageWriter(new StreamBasedRequestMessage(stream) { ServiceProvider = GetSharedContainer(configureServices) }, settings, model);
             }
 
-            return new ODataMessageWriter(new StreamBasedResponseMessage(stream) { Container = GetSharedContainer(configureServices) }, settings, model);
+            return new ODataMessageWriter(new StreamBasedResponseMessage(stream) { ServiceProvider = GetSharedContainer(configureServices) }, settings, model);
         }
 
         /// <summary>
@@ -181,10 +181,10 @@ public static ODataMessageWriter CreateMessageWriter(Stream stream, IEdmModel mo
         /// <param name="model">Edm model</param>
         /// <param name="configureServices">Action callback to configure DI services.</param>
         /// <returns>Instance of ODataMessageWriter</returns>
-        public static ODataMessageWriter CreateMessageWriter(Stream stream, IEdmModel model, Action<IContainerBuilder> configureServices = null)
+        public static ODataMessageWriter CreateMessageWriter(Stream stream, IEdmModel model, Action<IServiceCollection> configureServices = null)
         {
             var settings = CreateMessageWriterSettings(true);
-            return new ODataMessageWriter(new StreamBasedRequestMessage(stream) { Container = GetSharedContainer(configureServices) }, settings, model);
+            return new ODataMessageWriter(new StreamBasedRequestMessage(stream) { ServiceProvider = GetSharedContainer(configureServices) }, settings, model);
         }
         #endregion
     }
diff --git a/test/PerformanceTests/ComponentTests/Common/StreamBasedRequestMessage.cs b/test/PerformanceTests/ComponentTests/Common/StreamBasedRequestMessage.cs
index a7f967d381..3e54ae8199 100644
--- a/test/PerformanceTests/ComponentTests/Common/StreamBasedRequestMessage.cs
+++ b/test/PerformanceTests/ComponentTests/Common/StreamBasedRequestMessage.cs
@@ -15,7 +15,7 @@ namespace Microsoft.OData.Performance
     /// <summary>
     /// An OData Request Message backed by a Stream.
     /// </summary>
-    public class StreamBasedRequestMessage : IODataRequestMessageAsync, IContainerProvider
+    public class StreamBasedRequestMessage : IODataRequestMessageAsync, IServiceCollectionProvider
     {
         private readonly Stream _stream;
         private readonly IDictionary<string, string> _headers;
@@ -88,6 +88,6 @@ public Uri Url
             }
         }
 
-        public IServiceProvider Container { get; set; }
+        public IServiceProvider ServiceProvider { get; set; }
     }
 }
diff --git a/test/PerformanceTests/ComponentTests/Common/StreamBasedResponseMessage.cs b/test/PerformanceTests/ComponentTests/Common/StreamBasedResponseMessage.cs
index e9df68a9af..ee4ae658f2 100644
--- a/test/PerformanceTests/ComponentTests/Common/StreamBasedResponseMessage.cs
+++ b/test/PerformanceTests/ComponentTests/Common/StreamBasedResponseMessage.cs
@@ -15,7 +15,7 @@ namespace Microsoft.OData.Performance
     /// <summary>
     /// An OData Response Message backed by a Stream.
     /// </summary>
-    public class StreamBasedResponseMessage : IODataResponseMessageAsync, IContainerProvider
+    public class StreamBasedResponseMessage : IODataResponseMessageAsync, IServiceCollectionProvider
     {
         private readonly Stream _stream;
         private readonly IDictionary<string, string> _headers;
@@ -66,6 +66,6 @@ public Stream GetStream()
             return _stream;
         }
 
-        public IServiceProvider Container { get; set; }
+        public IServiceProvider ServiceProvider { get; set; }
     }
 }
diff --git a/test/PerformanceTests/ComponentTests/Common/TestContainerBuilder.cs b/test/PerformanceTests/ComponentTests/Common/TestContainerBuilder.cs
deleted file mode 100644
index 37006a2a92..0000000000
--- a/test/PerformanceTests/ComponentTests/Common/TestContainerBuilder.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-//---------------------------------------------------------------------
-// <copyright file="TestContainerBuilder.cs" company="Microsoft">
-//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
-// </copyright>
-//---------------------------------------------------------------------
-
-namespace Microsoft.OData.Performance.Common
-{
-    using System;
-    using System.Diagnostics;
-    using Microsoft.Extensions.DependencyInjection;
-
-    public class TestContainerBuilder : IContainerBuilder
-    {
-        private readonly IServiceCollection services = new ServiceCollection();
-
-        public IContainerBuilder AddService(
-            OData.ServiceLifetime lifetime,
-            Type serviceType,
-            Type implementationType)
-        {
-            Debug.Assert(serviceType != null, "serviceType != null");
-            Debug.Assert(implementationType != null, "implementationType != null");
-
-            services.Add(new ServiceDescriptor(
-                serviceType, implementationType, TranslateServiceLifetime(lifetime)));
-
-            return this;
-        }
-
-        public IContainerBuilder AddService(
-            OData.ServiceLifetime lifetime,
-            Type serviceType,
-            Func<IServiceProvider, object> implementationFactory)
-        {
-            Debug.Assert(serviceType != null, "serviceType != null");
-            Debug.Assert(implementationFactory != null, "implementationFactory != null");
-
-            services.Add(new ServiceDescriptor(
-                serviceType, implementationFactory, TranslateServiceLifetime(lifetime)));
-
-            return this;
-        }
-
-        public IServiceProvider BuildContainer()
-        {
-            return services.BuildServiceProvider();
-        }
-
-        private static ServiceLifetime TranslateServiceLifetime(
-            OData.ServiceLifetime lifetime)
-        {
-            switch (lifetime)
-            {
-                case OData.ServiceLifetime.Scoped:
-                    return ServiceLifetime.Scoped;
-                case OData.ServiceLifetime.Singleton:
-                    return ServiceLifetime.Singleton;
-                default:
-                    return ServiceLifetime.Transient;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.csproj b/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.csproj
index 306a4e9f7a..30c60c48c7 100644
--- a/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.csproj
+++ b/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -29,8 +29,8 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.sln b/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.sln
new file mode 100644
index 0000000000..cf975c1650
--- /dev/null
+++ b/test/PerformanceTests/ComponentTests/Microsoft.OData.Performance.ComponentTests.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.9.34728.123
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.OData.Performance.ComponentTests", "Microsoft.OData.Performance.ComponentTests.csproj", "{9EBA72FF-AC4D-44FF-A91F-0E7807900613}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9EBA72FF-AC4D-44FF-A91F-0E7807900613}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9EBA72FF-AC4D-44FF-A91F-0E7807900613}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9EBA72FF-AC4D-44FF-A91F-0E7807900613}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9EBA72FF-AC4D-44FF-A91F-0E7807900613}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {551F3CD4-51B0-4E2B-82CC-7860F9F1DB45}
+	EndGlobalSection
+EndGlobal
diff --git a/test/PerformanceTests/ComponentTests/ODataWriter/JsonElementPropertyTests.cs b/test/PerformanceTests/ComponentTests/ODataWriter/JsonElementPropertyTests.cs
index 038bb68bcd..b4b18596cc 100644
--- a/test/PerformanceTests/ComponentTests/ODataWriter/JsonElementPropertyTests.cs
+++ b/test/PerformanceTests/ComponentTests/ODataWriter/JsonElementPropertyTests.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Xml;
 using Microsoft.OData.Json;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.OData.Performance.Writer
 {
@@ -73,10 +74,10 @@ public void WriteParsedJsonWithoutJsonElementValues_Utf8JsonWriter()
             WriteParsedJsonWithoutJsonElementValues(ConfigureUtf8JsonWriter);
         }
 
-        private static void ConfigureUtf8JsonWriter(IContainerBuilder builder) =>
-            builder.AddService<IStreamBasedJsonWriterFactory>(ServiceLifetime.Singleton, _ => DefaultStreamBasedJsonWriterFactory.Default);
+        private static void ConfigureUtf8JsonWriter(IServiceCollection builder) =>
+            builder.AddSingleton<IJsonWriterFactory>(ODataUtf8JsonWriterFactory.Default);
 
-        private void WriteParsedJsonWithJsonElementValues(Action<IContainerBuilder> configureServices = null)
+        private void WriteParsedJsonWithJsonElementValues(Action<IServiceCollection> configureServices = null)
         {
             using (var messageWriter = ODataMessageHelper.CreateMessageWriter(WriteStream, Model, ODataMessageKind.Response, enableValidation, configureServices))
             {
@@ -129,7 +130,7 @@ private void WriteParsedJsonWithJsonElementValues(Action<IContainerBuilder> conf
             }
         }
 
-        private void WriteParsedJsonWithoutJsonElementValues(Action<IContainerBuilder> configureServices = null)
+        private void WriteParsedJsonWithoutJsonElementValues(Action<IServiceCollection> configureServices = null)
         {
             using (var messageWriter = ODataMessageHelper.CreateMessageWriter(WriteStream, Model, ODataMessageKind.Response, enableValidation, configureServices))
             {
diff --git a/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/ExperimentTests.csproj b/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/ExperimentTests.csproj
index 38c7e3bca5..37d2241aa4 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/ExperimentTests.csproj
+++ b/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/ExperimentTests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net6.0;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
diff --git a/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/WriterTests.cs b/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/WriterTests.cs
index b51dd75884..ad136cfe53 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/WriterTests.cs
+++ b/test/PerformanceTests/SerializationComparisonsTests/ExperimentTests/WriterTests.cs
@@ -19,11 +19,6 @@ public class WriterTests
         private readonly static IEnumerable<Customer> customerData = CustomerDataSet.GetCustomers(4);
         private readonly static WriterCollection<IEnumerable<Customer>> writers = DefaultWriterCollection.Create();
         public static IEnumerable<object[]> WriterNames { get; } = writers.GetWriterNames()
-            .Where(n => !n.Contains("NoOp"))
-            .Select(n => new string[] { n });
-
-        public static IEnumerable<object[]> NoOpWriterNames { get; } = writers.GetWriterNames()
-            .Where(n => n.Contains("NoOp"))
             .Select(n => new string[] { n });
 
         [Theory]
@@ -44,21 +39,6 @@ public async Task WriterWritesCustomersCollectionPayload(string writerName)
             Assert.Equal(NormalizeJsonText(expectedOutput), NormalizeJsonText(actualOutput));
         }
 
-        [Theory]
-        [MemberData(nameof(NoOpWriterNames))]
-        public async Task NoOpWritersShouldNotWriteContent(string writerName)
-        {
-            using var stream = new MemoryStream();
-            var writer = writers.GetWriter(writerName);
-
-            await writer.WritePayloadAsync(customerData, stream, includeRawValues: true);
-
-            stream.Seek(0, SeekOrigin.Begin);
-            using var reader = new StreamReader(stream);
-            string output = await reader.ReadToEndAsync();
-            Assert.Equal(string.Empty, output);
-        }
-
         /// <summary>
         /// Normalizes the differences between JSON text encoded
         /// by Utf8JsonWriter and OData's JsonWriter, to make
diff --git a/test/PerformanceTests/SerializationComparisonsTests/JsonWriterBenchmarks/JsonWriterBenchmarks.csproj b/test/PerformanceTests/SerializationComparisonsTests/JsonWriterBenchmarks/JsonWriterBenchmarks.csproj
index af755234fb..deea2ed10a 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/JsonWriterBenchmarks/JsonWriterBenchmarks.csproj
+++ b/test/PerformanceTests/SerializationComparisonsTests/JsonWriterBenchmarks/JsonWriterBenchmarks.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net8.0;net6.0;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/ContainerBuilder.cs b/test/PerformanceTests/SerializationComparisonsTests/Lib/ContainerBuilder.cs
deleted file mode 100644
index 6808abef01..0000000000
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/ContainerBuilder.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-//---------------------------------------------------------------------
-// <copyright file="ContainerBuilder.cs" company="Microsoft">
-//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
-// </copyright>
-//---------------------------------------------------------------------
-
-using System;
-using Microsoft.Extensions.DependencyInjection;
-using OData = Microsoft.OData;
-
-namespace ExperimentsLib
-{
-    /// <summary>
-    /// Implementation of <see cref="OData.IContainerBuilder"/> for
-    /// dependency injection.
-    /// </summary>
-    internal class ContainerBuilder : OData.IContainerBuilder
-    {
-        private readonly ServiceCollection services = new ServiceCollection();
-
-        /// <inheritdoc/>
-        public OData.IContainerBuilder AddService(OData.ServiceLifetime lifetime, Type serviceType, Type implementationType)
-        {
-            switch (lifetime)
-            {
-                case OData.ServiceLifetime.Transient:
-                    this.services.AddTransient(serviceType, implementationType);
-                    break;
-                case OData.ServiceLifetime.Singleton:
-                    this.services.AddSingleton(serviceType, implementationType);
-                    break;
-                case OData.ServiceLifetime.Scoped:
-                    this.services.AddScoped(serviceType, implementationType);
-                    break;
-            }
-
-            return this;
-        }
-
-        /// <inheritdoc/>
-        public OData.IContainerBuilder AddService(OData.ServiceLifetime lifetime, Type serviceType, Func<IServiceProvider, object> implementationFactory)
-        {
-            switch (lifetime)
-            {
-                case OData.ServiceLifetime.Transient:
-                    this.services.AddTransient(serviceType, implementationFactory);
-                    break;
-                case OData.ServiceLifetime.Singleton:
-                    this.services.AddSingleton(serviceType, implementationFactory);
-                    break;
-                case OData.ServiceLifetime.Scoped:
-                    this.services.AddScoped(serviceType, implementationFactory);
-                    break;
-            }
-
-            return this;
-        }
-
-        /// <inheritdoc/>
-        public IServiceProvider BuildContainer()
-        {
-            return this.services.BuildServiceProvider();
-        }
-    }
-}
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/ExperimentsLib.csproj b/test/PerformanceTests/SerializationComparisonsTests/Lib/ExperimentsLib.csproj
index f2bf8a8fcd..6736e824cd 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/ExperimentsLib.csproj
+++ b/test/PerformanceTests/SerializationComparisonsTests/Lib/ExperimentsLib.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net6.0;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriter.cs b/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriter.cs
index 390c3ac5e2..1eb71bc8f6 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriter.cs
+++ b/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriter.cs
@@ -5,6 +5,7 @@
 //---------------------------------------------------------------------
 
 using System;
+using System.IO;
 using System.Text.Json;
 using System.Threading.Tasks;
 using Microsoft.OData.Edm;
@@ -17,33 +18,51 @@ namespace ExperimentsLib
     /// It does not write any output. It's meant to help evaluate
     /// the overhead of higher-level libraries without the cost of JsonWriter.
     /// </summary>
-    public class NoopJsonWriter : IJsonWriter, IJsonWriterAsync
+    public class NoopJsonWriter : IJsonWriter
     {
         public void EndArrayScope()
         {
         }
 
-        public Task EndArrayScopeAsync()
+        public ValueTask EndArrayScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void EndObjectScope()
         {
         }
 
-        public Task EndObjectScopeAsync()
+        public ValueTask EndObjectScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void EndPaddingFunctionScope()
         {
         }
 
-        public Task EndPaddingFunctionScopeAsync()
+        public ValueTask EndPaddingFunctionScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
+        }
+
+        public void EndStreamValueScope()
+        {
+        }
+
+        public ValueTask EndStreamValueScopeAsync()
+        {
+            return ValueTask.CompletedTask;
+        }
+
+        public void EndTextWriterValueScope()
+        {
+        }
+
+        public ValueTask EndTextWriterValueScopeAsync()
+        {
+            return ValueTask.CompletedTask;
         }
 
         public void Flush()
@@ -59,54 +78,74 @@ public void StartArrayScope()
         {
         }
 
-        public Task StartArrayScopeAsync()
+        public ValueTask StartArrayScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void StartObjectScope()
         {
         }
 
-        public Task StartObjectScopeAsync()
+        public ValueTask StartObjectScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void StartPaddingFunctionScope()
         {
         }
 
-        public Task StartPaddingFunctionScopeAsync()
+        public ValueTask StartPaddingFunctionScopeAsync()
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
+        }
+
+        public Stream StartStreamValueScope()
+        {
+            throw new NotImplementedException();
+        }
+
+        public ValueTask<Stream> StartStreamValueScopeAsync()
+        {
+            throw new NotImplementedException();
+        }
+
+        public TextWriter StartTextWriterValueScope(string contentType)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ValueTask<TextWriter> StartTextWriterValueScopeAsync(string contentType)
+        {
+            throw new NotImplementedException();
         }
 
         public void WriteName(string name)
         {
         }
 
-        public Task WriteNameAsync(string name)
+        public ValueTask WriteNameAsync(string name)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void WritePaddingFunctionName(string functionName)
         {
         }
 
-        public Task WritePaddingFunctionNameAsync(string functionName)
+        public ValueTask WritePaddingFunctionNameAsync(string functionName)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void WriteRawValue(string rawValue)
         {
         }
 
-        public Task WriteRawValueAsync(string rawValue)
+        public ValueTask WriteRawValueAsync(string rawValue)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
         public void WriteValue(bool value)
@@ -178,89 +217,89 @@ public void WriteValue(JsonElement value)
         {
         }
 
-        public Task WriteValueAsync(bool value)
+        public ValueTask WriteValueAsync(bool value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(int value)
+        public ValueTask WriteValueAsync(int value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(float value)
+        public ValueTask WriteValueAsync(float value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(short value)
+        public ValueTask WriteValueAsync(short value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(long value)
+        public ValueTask WriteValueAsync(long value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(double value)
+        public ValueTask WriteValueAsync(double value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(Guid value)
+        public ValueTask WriteValueAsync(Guid value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(decimal value)
+        public ValueTask WriteValueAsync(decimal value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(DateTimeOffset value)
+        public ValueTask WriteValueAsync(DateTimeOffset value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(TimeSpan value)
+        public ValueTask WriteValueAsync(TimeSpan value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(byte value)
+        public ValueTask WriteValueAsync(byte value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(sbyte value)
+        public ValueTask WriteValueAsync(sbyte value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(string value)
+        public ValueTask WriteValueAsync(string value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(byte[] value)
+        public ValueTask WriteValueAsync(byte[] value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(Date value)
+        public ValueTask WriteValueAsync(Date value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(TimeOfDay value)
+        public ValueTask WriteValueAsync(TimeOfDay value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
 
-        public Task WriteValueAsync(JsonElement value)
+        public ValueTask WriteValueAsync(JsonElement value)
         {
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         }
     }
 }
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriterFactory.cs b/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriterFactory.cs
index 90a516ac0b..946dd82f73 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriterFactory.cs
+++ b/test/PerformanceTests/SerializationComparisonsTests/Lib/NoopJsonWriterFactory.cs
@@ -5,6 +5,7 @@
 //---------------------------------------------------------------------
 
 using System.IO;
+using System.Text;
 using Microsoft.OData.Json;
 
 namespace ExperimentsLib
@@ -13,16 +14,11 @@ namespace ExperimentsLib
     /// Implementation of <see cref="IJsonWriterFactory"/> that returns
     /// a <see cref="NoopJsonWriter"/> that does nothing.
     /// </summary>
-    public class NoopJsonWriterFactory : IJsonWriterFactory, IJsonWriterFactoryAsync
+    public class NoopJsonWriterFactory : IJsonWriterFactory
     {
-        public IJsonWriterAsync CreateAsynchronousJsonWriter(TextWriter textWriter, bool isIeee754Compatible)
+        public IJsonWriter CreateJsonWriter(Stream stream, bool isIeee754Compatible, Encoding encoding)
         {
-            return new NoopJsonWriter();
-        }
-
-        public IJsonWriter CreateJsonWriter(TextWriter textWriter, bool isIeee754Compatible)
-        {
-            return new NoopJsonWriter();
+            throw new System.NotImplementedException();
         }
     }
 }
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/ODataMessage.cs b/test/PerformanceTests/SerializationComparisonsTests/Lib/ODataMessage.cs
index 5611d1c0cb..013cf22cba 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/ODataMessage.cs
+++ b/test/PerformanceTests/SerializationComparisonsTests/Lib/ODataMessage.cs
@@ -16,7 +16,7 @@ namespace ExperimentsLib
     /// Implementation of <see cref="IODataResponseMessageAsync"/> used to pass
     /// the response message to the <see cref="ODataMessageWriter"/>.
     /// </summary>
-    public class ODataMessage : IODataResponseMessageAsync, IContainerProvider, IDisposable
+    public class ODataMessage : IODataResponseMessageAsync, IServiceCollectionProvider, IDisposable
     {
         private readonly Dictionary<string, string> headers;
 
@@ -38,7 +38,7 @@ public IEnumerable<KeyValuePair<string, string>> Headers
 
         public Stream Stream { get; set; }
 
-        public IServiceProvider Container { get; set; }
+        public IServiceProvider ServiceProvider { get; set; }
 
         public string GetHeader(string headerName)
         {
diff --git a/test/PerformanceTests/SerializationComparisonsTests/Lib/WriterHelpers.cs b/test/PerformanceTests/SerializationComparisonsTests/Lib/WriterHelpers.cs
index ea066fccf2..8ac233dd9f 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/Lib/WriterHelpers.cs
+++ b/test/PerformanceTests/SerializationComparisonsTests/Lib/WriterHelpers.cs
@@ -7,6 +7,7 @@
 using System;
 using System.IO;
 using System.Text;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.OData;
 using Microsoft.OData.Json;
 
@@ -19,25 +20,25 @@ public static class WriterHelpers
         public static IJsonWriter CreateODataJsonWriter(this Stream stream, Encoding encoding = null)
         {
             return jsonWriterFactory.CreateJsonWriter(
-                new StreamWriter(stream, encoding ?? Encoding.UTF8), false);
+                stream, false, encoding ?? Encoding.UTF8);
         }
 
-        public static IJsonWriterAsync CreateODataJsonWriterAsync(this Stream stream, Encoding encoding = null)
+        public static IJsonWriter CreateODataJsonWriterAsync(this Stream stream, Encoding encoding = null)
         {
-            return jsonWriterFactory.CreateAsynchronousJsonWriter(
-                new StreamWriter(stream, encoding ?? Encoding.UTF8), false);
+            return jsonWriterFactory.CreateJsonWriter(
+                stream, false, encoding ?? Encoding.UTF8);
         }
 
         public static IJsonWriter CreateODataUtf8JsonWriter(this Stream stream, Encoding encoding = null)
         {
-            DefaultStreamBasedJsonWriterFactory factory = DefaultStreamBasedJsonWriterFactory.Default;
+            ODataUtf8JsonWriterFactory factory = ODataUtf8JsonWriterFactory.Default;
             return factory.CreateJsonWriter(stream, false, encoding ?? Encoding.UTF8);
         }
 
-        public static IJsonWriterAsync CreateODataUtf8JsonWriterAsync(this Stream stream, Encoding encoding = null)
+        public static IJsonWriter CreateODataUtf8JsonWriterAsync(this Stream stream, Encoding encoding = null)
         {
-            DefaultStreamBasedJsonWriterFactory factory = DefaultStreamBasedJsonWriterFactory.Default;
-            return factory.CreateAsynchronousJsonWriter(stream, false, encoding ?? Encoding.UTF8);
+            ODataUtf8JsonWriterFactory factory = ODataUtf8JsonWriterFactory.Default;
+            return factory.CreateJsonWriter(stream, false, encoding ?? Encoding.UTF8);
         }
 
         public static IODataResponseMessage CreateJsonWriterMessage(this Stream stream, string charset = "UTF-8")
@@ -51,35 +52,33 @@ public static IODataResponseMessage CreateNoopMessage(this Stream stream)
 
             return stream.CreateODataMessage(services =>
             {
-                services.AddService<IJsonWriterFactory>(ServiceLifetime.Singleton, _ => factory);
-                services.AddService<IJsonWriterFactoryAsync>(ServiceLifetime.Singleton, _ => factory);
+                services.AddSingleton<IJsonWriterFactory>(factory);
             });
         }
 
         public static IODataResponseMessage CreateUtf8JsonWriterMessage(this Stream stream, string charset="UTF-8")
         {
-            DefaultStreamBasedJsonWriterFactory factory = DefaultStreamBasedJsonWriterFactory.Default;
+            IJsonWriterFactory factory = ODataUtf8JsonWriterFactory.Default;
+
 
-            IContainerBuilder services = new ContainerBuilder();
-            services.AddDefaultODataServices();
             return stream.CreateODataMessage(services =>
             {
-                services.AddService<IStreamBasedJsonWriterFactory>(ServiceLifetime.Singleton, _ => factory);
+                services.AddSingleton<IJsonWriterFactory>(factory);
             }, charset);
         }
 
-        public static IODataResponseMessage CreateODataMessage(this Stream stream, Action<IContainerBuilder> configure = null, string charset = "UTF-8")
+        public static IODataResponseMessage CreateODataMessage(this Stream stream, Action<IServiceCollection> configure = null, string charset = "UTF-8")
         {
-            DefaultStreamBasedJsonWriterFactory factory = DefaultStreamBasedJsonWriterFactory.Default;
-
-            IContainerBuilder services = new ContainerBuilder();
+            ServiceCollection services = new ServiceCollection();
             services.AddDefaultODataServices();
+            
+
             configure?.Invoke(services);
 
             ODataMessage message = new ODataMessage
             {
                 Stream = stream,
-                Container = services.BuildContainer()
+                ServiceProvider = services.BuildServiceProvider()
             };
 
             message.SetHeader("Content-Type", $"application/json; charset={charset}");
diff --git a/test/PerformanceTests/SerializationComparisonsTests/TestServer/TestServer.csproj b/test/PerformanceTests/SerializationComparisonsTests/TestServer/TestServer.csproj
index f2aa3aa28f..303ce10a53 100644
--- a/test/PerformanceTests/SerializationComparisonsTests/TestServer/TestServer.csproj
+++ b/test/PerformanceTests/SerializationComparisonsTests/TestServer/TestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tools/perf/ResultsComparer/src/ResultsComparer/ResultsComparer.csproj b/tools/perf/ResultsComparer/src/ResultsComparer/ResultsComparer.csproj
index 270b1fa7ca..13993c55f2 100644
--- a/tools/perf/ResultsComparer/src/ResultsComparer/ResultsComparer.csproj
+++ b/tools/perf/ResultsComparer/src/ResultsComparer/ResultsComparer.csproj
@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>$(PERFLAB_TARGET_FRAMEWORKS)</TargetFrameworks>
-    <TargetFramework Condition="'$(TargetFrameworks)' == ''">net5.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
diff --git a/tools/perf/ResultsComparer/test/ResultsComparer.Tests/ResultsComparer.Tests.csproj b/tools/perf/ResultsComparer/test/ResultsComparer.Tests/ResultsComparer.Tests.csproj
index cc9fedeaf2..d53128ca67 100644
--- a/tools/perf/ResultsComparer/test/ResultsComparer.Tests/ResultsComparer.Tests.csproj
+++ b/tools/perf/ResultsComparer/test/ResultsComparer.Tests/ResultsComparer.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>