Fill the incomplete usage of async methods.

A9G-Data-Droid · A9G-Data-Droid · commit d35f5c7ba83e · 2023-12-26T16:19:12.000-08:00
- Prefer Task.Run over Task.Factory.StartNew
 - Compile in release mode with overflow checks for safety.
 - Implement `await using` when available.
 - Remove unused `result.GetType();`
- CA1835: Prefer the memory-based overloads of ReadAsync/WriteAsync
diff --git a/RazorEngineCore.Tests/TestCompileAndRun.cs b/RazorEngineCore.Tests/TestCompileAndRun.cs
@@ -739,7 +739,7 @@ public void TestCompileCancellation_DynamicModel()
 
                 Assert.ThrowsException<OperationCanceledException>(() =>
                 {
-                    IRazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name", cancellationToken: cancellationSource.Token);
+                    _ = razorEngine.Compile("Hello @Model.Name", cancellationToken: cancellationSource.Token);
                 });
             }
         }
@@ -754,7 +754,7 @@ public async Task TestCompileCancellation_DynamicModelAsync()
 
                 await Assert.ThrowsExceptionAsync<OperationCanceledException>(async () =>
                 {
-                    IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name", cancellationToken: cancellationSource.Token);
+                    _ = await razorEngine.CompileAsync("Hello @Model.Name", cancellationToken: cancellationSource.Token);
                 });
             }
         }
@@ -769,7 +769,7 @@ public void TestCompileCancellation_TypedModel1()
 
                 Assert.ThrowsException<OperationCanceledException>(() =>
                 {
-                    IRazorEngineCompiledTemplate<TestTemplate1> template = razorEngine.Compile<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);
+                    _ = razorEngine.Compile<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);
                 });
             }
         }
@@ -784,7 +784,7 @@ public async Task TestCompileCancellation_TypedModel1Async()
 
                 await Assert.ThrowsExceptionAsync<OperationCanceledException>(async () =>
                 {
-                    IRazorEngineCompiledTemplate<TestTemplate1> template = await razorEngine.CompileAsync<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);
+                    _ = await razorEngine.CompileAsync<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);
                 });
             }
         }
diff --git a/RazorEngineCore/AnonymousTypeWrapper.cs b/RazorEngineCore/AnonymousTypeWrapper.cs
@@ -32,7 +32,7 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)
                 return true;
             }
 
-            var type = result.GetType();
+            //var type = result.GetType();
 
             if (result.IsAnonymous())
             {
@@ -41,12 +41,7 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)
 
             if (result is IDictionary dictionary)
             {
-                List<object> keys = new List<object>();
-
-                foreach(object key in dictionary.Keys)
-                {
-                    keys.Add(key);
-                }
+                List<object> keys = dictionary.Keys.Cast<object>().ToList();
 
                 foreach(object key in keys)
                 {
@@ -56,22 +51,13 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)
                     }
                 }
             }
-            else if (result is IEnumerable enumerable && !(result is string))
+            else if (result is IEnumerable enumerable and not string)
             {
                 result = enumerable.Cast<object>()
-                        .Select(e =>
-                        {
-                            if (e.IsAnonymous())
-                            {
-                                return new AnonymousTypeWrapper(e);
-                            }
-
-                            return e;
-                        })
+                        .Select(e => e.IsAnonymous() ? new AnonymousTypeWrapper(e) : e)
                         .ToList();
             }
-
-
+            
             return true;
         }
     }
diff --git a/RazorEngineCore/ObjectExtenders.cs b/RazorEngineCore/ObjectExtenders.cs
@@ -4,6 +4,7 @@
 using System.IO;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 
 namespace RazorEngineCore
 {
@@ -32,18 +33,25 @@ public static bool IsAnonymous(this object obj)
                    && type.Attributes.HasFlag(TypeAttributes.NotPublic);
         }
 
-        public static long ReadLong(this Stream stream)
+        public static async Task<long> ReadLong(this Stream stream)
         {
             byte[] buffer = new byte[8];
-            stream.Read(buffer, 0, 8);
-
+#if NETSTANDARD2_0
+            _ = await stream.ReadAsync(buffer, 0, buffer.Length);
+#else
+            _ = await stream.ReadAsync(buffer.AsMemory(0, buffer.Length));
+#endif
             return BitConverter.ToInt64(buffer, 0);
         }
 
-        public static void WriteLong(this Stream stream, long value)
+        public static async Task WriteLong(this Stream stream, long value)
         {
             byte[] buffer = BitConverter.GetBytes(value);
-            stream.Write(buffer, 0, buffer.Length);
+#if NETSTANDARD2_0
+            await stream.WriteAsync(buffer, 0, buffer.Length);
+#else
+            await stream.WriteAsync(buffer);
+#endif
         }
     }
 }
diff --git a/RazorEngineCore/RazorEngine.cs b/RazorEngineCore/RazorEngine.cs
@@ -30,7 +30,7 @@ public IRazorEngineCompiledTemplate<T> Compile<T>(string content, Action<IRazorE
 
         public Task<IRazorEngineCompiledTemplate<T>> CompileAsync<T>(string content, Action<IRazorEngineCompilationOptionsBuilder> builderAction = null, CancellationToken cancellationToken = default) where T : IRazorEngineTemplate
         {
-            return Task.Factory.StartNew(() => this.Compile<T>(content: content, builderAction: builderAction, cancellationToken: cancellationToken));
+            return Task.Run(() => this.Compile<T>(content: content, builderAction: builderAction, cancellationToken: cancellationToken));
         }
 
         public IRazorEngineCompiledTemplate Compile(string content, Action<IRazorEngineCompilationOptionsBuilder> builderAction = null, CancellationToken cancellationToken = default)
@@ -46,7 +46,7 @@ public IRazorEngineCompiledTemplate Compile(string content, Action<IRazorEngineC
 
         public Task<IRazorEngineCompiledTemplate> CompileAsync(string content, Action<IRazorEngineCompilationOptionsBuilder> builderAction = null, CancellationToken cancellationToken = default)
         {
-            return Task.Factory.StartNew(() => this.Compile(
+            return Task.Run(() => this.Compile(
                 content, 
                 builderAction, 
                 cancellationToken));
@@ -105,7 +105,9 @@ protected virtual RazorEngineCompiledTemplateMeta CreateAndCompileToStream(strin
                    })
                     .Concat(options.MetadataReferences)
                     .ToList(),
-                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+                    .WithOptimizationLevel(OptimizationLevel.Release)
+                    .WithOverflowChecks(true));
 
 
             MemoryStream assemblyStream = new MemoryStream();
diff --git a/RazorEngineCore/RazorEngineCompilationOptionsBuilder.cs b/RazorEngineCore/RazorEngineCompilationOptionsBuilder.cs
@@ -63,9 +63,10 @@ private string RenderTypeName(Type type)
 
             string result = string.Join(".", elements.Where(e => !string.IsNullOrWhiteSpace(e)));
 
-            if (result.Contains('`'))
+            int tildeLocation = result.IndexOf('`');
+            if (tildeLocation > -1)
             {
-                result = result.Substring(0, result.IndexOf("`"));
+                result = result.Substring(0, tildeLocation);
             }
 
             if (type.GenericTypeArguments.Length == 0)
diff --git a/RazorEngineCore/RazorEngineCompiledTemplate.cs b/RazorEngineCore/RazorEngineCompiledTemplate.cs
@@ -22,13 +22,17 @@ public static RazorEngineCompiledTemplate LoadFromFile(string fileName)
 
         public static async Task<RazorEngineCompiledTemplate> LoadFromFileAsync(string fileName)
         {
+#if NETSTANDARD2_0
             using (FileStream fileStream = new FileStream(
-                path: fileName, 
-                mode: FileMode.Open, 
-                access: FileAccess.Read,
-                share: FileShare.None,
-                bufferSize: 4096, 
-                useAsync: true))
+#else
+            await using (FileStream fileStream = new FileStream(
+#endif
+                       path: fileName, 
+                       mode: FileMode.Open, 
+                       access: FileAccess.Read,
+                       share: FileShare.None,
+                       bufferSize: 4096, 
+                       useAsync: true))
             {
                 return await LoadFromStreamAsync(fileStream);
             }
diff --git a/RazorEngineCore/RazorEngineCompiledTemplateBase.cs b/RazorEngineCore/RazorEngineCompiledTemplateBase.cs
@@ -1,6 +1,5 @@
 ﻿using System.IO;
 using System;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace RazorEngineCore
@@ -19,7 +18,11 @@ public void SaveToFile(string fileName)
 
         public async Task SaveToFileAsync(string fileName)
         {
+#if NETSTANDARD2_0
             using (FileStream fileStream = new FileStream(
+#else
+            await using (FileStream fileStream = new FileStream(
+#endif
                        path: fileName,
                        mode: FileMode.OpenOrCreate,
                        access: FileAccess.Write,
@@ -36,9 +39,9 @@ public void SaveToStream(Stream stream)
             this.SaveToStreamAsync(stream).GetAwaiter().GetResult();
         }
 
-        public async Task SaveToStreamAsync(Stream stream)
+        public Task SaveToStreamAsync(Stream stream)
         {
-            await this.Meta.Write(stream);
+            return this.Meta.Write(stream);
         }
 
         public void EnableDebugging(string debuggingOutputDirectory = null)
diff --git a/RazorEngineCore/RazorEngineCompiledTemplateMeta.cs b/RazorEngineCore/RazorEngineCompiledTemplateMeta.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.IO;
+﻿using System.IO;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -16,7 +15,7 @@ public class RazorEngineCompiledTemplateMeta
 
         public async Task Write(Stream stream)
         {
-            stream.WriteLong(10001);
+            await stream.WriteLong(10001);
 
             await this.WriteBuffer(stream, this.AssemblyByteCode);
             await this.WriteBuffer(stream, this.PdbByteCode);
@@ -28,7 +27,7 @@ public async Task Write(Stream stream)
 
         public static async Task<RazorEngineCompiledTemplateMeta> Read(Stream stream)
         {
-            long version = stream.ReadLong();
+            long version = await stream.ReadLong();
 
             if (version == 10001)
             {
@@ -51,22 +50,26 @@ private static async Task<RazorEngineCompiledTemplateMeta> LoadVersion1(Stream s
             };
         }
 
-        private async Task WriteString(Stream stream, string value)
+        private Task WriteString(Stream stream, string value)
         {
             byte[] buffer = value == null ? null : Encoding.UTF8.GetBytes(value);
-            await this.WriteBuffer(stream, buffer);
+            return this.WriteBuffer(stream, buffer);
         }
 
         private async Task WriteBuffer(Stream stream, byte[] buffer)
         {
             if (buffer == null)
             {
-                stream.WriteLong(0);
+                await stream.WriteLong(0);
                 return;
             }
 
-            stream.WriteLong(buffer.Length);
+            await stream.WriteLong(buffer.Length);
+#if NETSTANDARD2_0
             await stream.WriteAsync(buffer, 0, buffer.Length);
+#else
+            await stream.WriteAsync(buffer);
+#endif
         }
 
         private static async Task<string> ReadString(Stream stream)
@@ -77,16 +80,19 @@ private static async Task<string> ReadString(Stream stream)
 
         private static async Task<byte[]> ReadBuffer(Stream stream)
         {
-            long length = stream.ReadLong();
+            long length = await stream.ReadLong();
 
             if (length == 0)
             {
                 return null;
             }
 
             byte[] buffer = new byte[length];
-            await stream.ReadAsync(buffer, 0, buffer.Length);
-
+#if NETSTANDARD2_0
+            _ = await stream.ReadAsync(buffer, 0, buffer.Length);
+#else
+            _ = await stream.ReadAsync(buffer);
+#endif
             return buffer;
         }
     }
diff --git a/RazorEngineCore/RazorEngineCompiledTemplateT.cs b/RazorEngineCore/RazorEngineCompiledTemplateT.cs
@@ -2,7 +2,6 @@
 using System.IO;
 using System.Reflection;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace RazorEngineCore
 {
@@ -24,13 +23,17 @@ public static RazorEngineCompiledTemplate<T> LoadFromFile(string fileName)
         
         public static async Task<RazorEngineCompiledTemplate<T>> LoadFromFileAsync(string fileName)
         {
+#if NETSTANDARD2_0
             using (FileStream fileStream = new FileStream(
-                       path: fileName,
-                       mode: FileMode.Open,
-                       access: FileAccess.Read,
-                       share: FileShare.None,
-                       bufferSize: 4096,
-                       useAsync: true))
+#else
+            await using (FileStream fileStream = new FileStream(
+#endif
+                             path: fileName,
+                             mode: FileMode.Open,
+                             access: FileAccess.Read,
+                             share: FileShare.None,
+                             bufferSize: 4096,
+                             useAsync: true))
             {
                 return await LoadFromStreamAsync(fileStream);
             }
@@ -53,7 +56,7 @@ public string Run(Action<T> initializer)
         
         public async Task<string> RunAsync(Action<T> initializer)
         {
-            T instance = (T) Activator.CreateInstance(this.TemplateType);
+            var instance = (T) Activator.CreateInstance(this.TemplateType);
             initializer(instance);
 
             if (this.IsDebuggerEnabled && instance is RazorEngineTemplateBase instance2)
diff --git a/RazorEngineCore/RazorEngineCore.csproj b/RazorEngineCore/RazorEngineCore.csproj
@@ -12,6 +12,7 @@
 		<Company>Alexander Selishchev</Company>
 		<SignAssembly>true</SignAssembly>
 		<AssemblyOriginatorKeyFile>key.snk</AssemblyOriginatorKeyFile>
+    <LangVersion>latest</LangVersion>
 	</PropertyGroup>
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
 		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>

Original file line number	Diff line number	Diff line change
`@@ -739,7 +739,7 @@ public void TestCompileCancellation_DynamicModel()`
`739`	`739`
`740`	`740`	`Assert.ThrowsException<OperationCanceledException>(() =>`
`741`	`741`	`{`
`742`		`- IRazorEngineCompiledTemplate template = razorEngine.Compile("Hello @Model.Name", cancellationToken: cancellationSource.Token);`
	`742`	`+ _ = razorEngine.Compile("Hello @Model.Name", cancellationToken: cancellationSource.Token);`
`743`	`743`	`});`
`744`	`744`	`}`
`745`	`745`	`}`
`@@ -754,7 +754,7 @@ public async Task TestCompileCancellation_DynamicModelAsync()`
`754`	`754`
`755`	`755`	`await Assert.ThrowsExceptionAsync<OperationCanceledException>(async () =>`
`756`	`756`	`{`
`757`		`- IRazorEngineCompiledTemplate template = await razorEngine.CompileAsync("Hello @Model.Name", cancellationToken: cancellationSource.Token);`
	`757`	`+ _ = await razorEngine.CompileAsync("Hello @Model.Name", cancellationToken: cancellationSource.Token);`
`758`	`758`	`});`
`759`	`759`	`}`
`760`	`760`	`}`
`@@ -769,7 +769,7 @@ public void TestCompileCancellation_TypedModel1()`
`769`	`769`
`770`	`770`	`Assert.ThrowsException<OperationCanceledException>(() =>`
`771`	`771`	`{`
`772`		`- IRazorEngineCompiledTemplate<TestTemplate1> template = razorEngine.Compile<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);`
	`772`	`+ _ = razorEngine.Compile<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);`
`773`	`773`	`});`
`774`	`774`	`}`
`775`	`775`	`}`
`@@ -784,7 +784,7 @@ public async Task TestCompileCancellation_TypedModel1Async()`
`784`	`784`
`785`	`785`	`await Assert.ThrowsExceptionAsync<OperationCanceledException>(async () =>`
`786`	`786`	`{`
`787`		`- IRazorEngineCompiledTemplate<TestTemplate1> template = await razorEngine.CompileAsync<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);`
	`787`	`+ _ = await razorEngine.CompileAsync<TestTemplate1>("Hello @A @B @(A + B) @C @Decorator(\"777\")", cancellationToken: cancellationSource.Token);`
`788`	`788`	`});`
`789`	`789`	`}`
`790`	`790`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)`
`32`	`32`	`return true;`
`33`	`33`	`}`
`34`	`34`
`35`		`- var type = result.GetType();`
	`35`	`+ //var type = result.GetType();`
`36`	`36`
`37`	`37`	`if (result.IsAnonymous())`
`38`	`38`	`{`
`@@ -41,12 +41,7 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)`
`41`	`41`
`42`	`42`	`if (result is IDictionary dictionary)`
`43`	`43`	`{`
`44`		`- List<object> keys = new List<object>();`
`45`		`-`
`46`		`- foreach(object key in dictionary.Keys)`
`47`		`- {`
`48`		`- keys.Add(key);`
`49`		`- }`
	`44`	`+ List<object> keys = dictionary.Keys.Cast<object>().ToList();`
`50`	`45`
`51`	`46`	`foreach(object key in keys)`
`52`	`47`	`{`
`@@ -56,22 +51,13 @@ public override bool TryGetMember(GetMemberBinder binder, out object result)`
`56`	`51`	`}`
`57`	`52`	`}`
`58`	`53`	`}`
`59`		`- else if (result is IEnumerable enumerable && !(result is string))`
	`54`	`+ else if (result is IEnumerable enumerable and not string)`
`60`	`55`	`{`
`61`	`56`	`result = enumerable.Cast<object>()`
`62`		`- .Select(e =>`
`63`		`- {`
`64`		`- if (e.IsAnonymous())`
`65`		`- {`
`66`		`- return new AnonymousTypeWrapper(e);`
`67`		`- }`
`68`		`-`
`69`		`- return e;`
`70`		`- })`
	`57`	`+ .Select(e => e.IsAnonymous() ? new AnonymousTypeWrapper(e) : e)`
`71`	`58`	`.ToList();`
`72`	`59`	`}`
`73`		`-`
`74`		`-`
	`60`	`+`
`75`	`61`	`return true;`
`76`	`62`	`}`
`77`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.IO;`
`5`	`5`	`using System.Reflection;`
`6`	`6`	`using System.Runtime.CompilerServices;`
	`7`	`+using System.Threading.Tasks;`
`7`	`8`
`8`	`9`	`namespace RazorEngineCore`
`9`	`10`	`{`
`@@ -32,18 +33,25 @@ public static bool IsAnonymous(this object obj)`
`32`	`33`	`&& type.Attributes.HasFlag(TypeAttributes.NotPublic);`
`33`	`34`	`}`
`34`	`35`
`35`		`- public static long ReadLong(this Stream stream)`
	`36`	`+ public static async Task<long> ReadLong(this Stream stream)`
`36`	`37`	`{`
`37`	`38`	`byte[] buffer = new byte[8];`
`38`		`- stream.Read(buffer, 0, 8);`
`39`		`-`
	`39`	`+#if NETSTANDARD2_0`
	`40`	`+ _ = await stream.ReadAsync(buffer, 0, buffer.Length);`
	`41`	`+#else`
	`42`	`+ _ = await stream.ReadAsync(buffer.AsMemory(0, buffer.Length));`
	`43`	`+#endif`
`40`	`44`	`return BitConverter.ToInt64(buffer, 0);`
`41`	`45`	`}`
`42`	`46`
`43`		`- public static void WriteLong(this Stream stream, long value)`
	`47`	`+ public static async Task WriteLong(this Stream stream, long value)`
`44`	`48`	`{`
`45`	`49`	`byte[] buffer = BitConverter.GetBytes(value);`
`46`		`- stream.Write(buffer, 0, buffer.Length);`
	`50`	`+#if NETSTANDARD2_0`
	`51`	`+ await stream.WriteAsync(buffer, 0, buffer.Length);`
	`52`	`+#else`
	`53`	`+ await stream.WriteAsync(buffer);`
	`54`	`+#endif`
`47`	`55`	`}`
`48`	`56`	`}`
`49`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,9 +63,10 @@ private string RenderTypeName(Type type)`
`63`	`63`
`64`	`64`	`string result = string.Join(".", elements.Where(e => !string.IsNullOrWhiteSpace(e)));`
`65`	`65`
`66`		- if (result.Contains('`'))
	`66`	+ int tildeLocation = result.IndexOf('`');
	`67`	`+ if (tildeLocation > -1)`
`67`	`68`	`{`
`68`		- result = result.Substring(0, result.IndexOf("`"));
	`69`	`+ result = result.Substring(0, tildeLocation);`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`if (type.GenericTypeArguments.Length == 0)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using System;`
`2`		`-using System.IO;`
	`1`	`+using System.IO;`
`3`	`2`	`using System.Text;`
`4`	`3`	`using System.Threading.Tasks;`
`5`	`4`
`@@ -16,7 +15,7 @@ public class RazorEngineCompiledTemplateMeta`
`16`	`15`
`17`	`16`	`public async Task Write(Stream stream)`
`18`	`17`	`{`
`19`		`- stream.WriteLong(10001);`
	`18`	`+ await stream.WriteLong(10001);`
`20`	`19`
`21`	`20`	`await this.WriteBuffer(stream, this.AssemblyByteCode);`
`22`	`21`	`await this.WriteBuffer(stream, this.PdbByteCode);`
`@@ -28,7 +27,7 @@ public async Task Write(Stream stream)`
`28`	`27`
`29`	`28`	`public static async Task<RazorEngineCompiledTemplateMeta> Read(Stream stream)`
`30`	`29`	`{`
`31`		`- long version = stream.ReadLong();`
	`30`	`+ long version = await stream.ReadLong();`
`32`	`31`
`33`	`32`	`if (version == 10001)`
`34`	`33`	`{`
`@@ -51,22 +50,26 @@ private static async Task<RazorEngineCompiledTemplateMeta> LoadVersion1(Stream s`
`51`	`50`	`};`
`52`	`51`	`}`
`53`	`52`
`54`		`- private async Task WriteString(Stream stream, string value)`
	`53`	`+ private Task WriteString(Stream stream, string value)`
`55`	`54`	`{`
`56`	`55`	`byte[] buffer = value == null ? null : Encoding.UTF8.GetBytes(value);`
`57`		`- await this.WriteBuffer(stream, buffer);`
	`56`	`+ return this.WriteBuffer(stream, buffer);`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`private async Task WriteBuffer(Stream stream, byte[] buffer)`
`61`	`60`	`{`
`62`	`61`	`if (buffer == null)`
`63`	`62`	`{`
`64`		`- stream.WriteLong(0);`
	`63`	`+ await stream.WriteLong(0);`
`65`	`64`	`return;`
`66`	`65`	`}`
`67`	`66`
`68`		`- stream.WriteLong(buffer.Length);`
	`67`	`+ await stream.WriteLong(buffer.Length);`
	`68`	`+#if NETSTANDARD2_0`
`69`	`69`	`await stream.WriteAsync(buffer, 0, buffer.Length);`
	`70`	`+#else`
	`71`	`+ await stream.WriteAsync(buffer);`
	`72`	`+#endif`
`70`	`73`	`}`
`71`	`74`
`72`	`75`	`private static async Task<string> ReadString(Stream stream)`
`@@ -77,16 +80,19 @@ private static async Task<string> ReadString(Stream stream)`
`77`	`80`
`78`	`81`	`private static async Task<byte[]> ReadBuffer(Stream stream)`
`79`	`82`	`{`
`80`		`- long length = stream.ReadLong();`
	`83`	`+ long length = await stream.ReadLong();`
`81`	`84`
`82`	`85`	`if (length == 0)`
`83`	`86`	`{`
`84`	`87`	`return null;`
`85`	`88`	`}`
`86`	`89`
`87`	`90`	`byte[] buffer = new byte[length];`
`88`		`- await stream.ReadAsync(buffer, 0, buffer.Length);`
`89`		`-`
	`91`	`+#if NETSTANDARD2_0`
	`92`	`+ _ = await stream.ReadAsync(buffer, 0, buffer.Length);`
	`93`	`+#else`
	`94`	`+ _ = await stream.ReadAsync(buffer);`
	`95`	`+#endif`
`90`	`96`	`return buffer;`
`91`	`97`	`}`
`92`	`98`	`}`