Testing faster conversions

Author: LLT21

frameworks/CSharp/appmpower/src/appMpower.Orm/DotnetMethods.cs

@@ -21,6 +21,12 @@ public static class DotnetMethods
 
     public static byte[] Db()
     {
+        DbProviderFactory.SetConnectionString();
+        var byteArray = RawDb.LoadSingleQueryBytes().GetAwaiter().GetResult();
+
+        return byteArray;
+
+        /*
         var world = RawDb.LoadSingleQueryRow().GetAwaiter().GetResult();
 
         var memoryStream = new MemoryStream();
@@ -29,6 +35,7 @@ public static byte[] Db()
         _worldSerializer.Serialize(utf8JsonWriter, world);
 
         return memoryStream.ToArray();
+        */
     }
 
     public static byte[] Query(int queries)

frameworks/CSharp/appmpower/src/appMpower.Orm/NativeMethods.cs

@@ -45,6 +45,8 @@ public static void FreeHandlePointer(IntPtr handlePointer)
     [UnmanagedCallersOnly(EntryPoint = "Db")]
     public static unsafe IntPtr Db(int* length, IntPtr* handlePointer)
     {
+        //DbProviderFactory.SetConnectionString();
+        /*
         var world = RawDb.LoadSingleQueryRow().GetAwaiter().GetResult();
 
         var memoryStream = new MemoryStream();
@@ -54,6 +56,10 @@ public static unsafe IntPtr Db(int* length, IntPtr* handlePointer)
 
         *length = (int)utf8JsonWriter.BytesCommitted; 
         byte[] byteArray = memoryStream.ToArray();
+        */
+
+        var byteArray = RawDb.LoadSingleQueryBytes().GetAwaiter().GetResult();
+        *length = byteArray.Length; 
 
         GCHandle handle = GCHandle.Alloc(byteArray, GCHandleType.Pinned);
         // return the managed and byteArrayPointer pointer

frameworks/CSharp/appmpower/src/appMpower.Orm/RawDb.cs

@@ -28,6 +28,30 @@ public static async Task<World> LoadSingleQueryRow()
          }
       }
 
+      public static async Task<byte[]> LoadSingleQueryBytes()
+      {
+         using var pooledConnection = new DbConnection(DbProviderFactory.ConnectionString);
+         await pooledConnection.OpenAsync();
+
+         var (dbCommand, _) = CreateReadCommand(pooledConnection);
+
+         using (dbCommand)
+         {
+            var dataReader = await dbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow & CommandBehavior.SequentialAccess);
+
+            dataReader.Read();
+
+            byte[] buffer = new byte[4];
+
+            BitConverter.TryWriteBytes(buffer.AsSpan(0, 2), dataReader.GetInt16(0));
+            BitConverter.TryWriteBytes(buffer.AsSpan(2, 2), dataReader.GetInt16(1));
+
+            dataReader.Close();
+
+            return buffer;
+         }
+      }
+
       public static async Task<World> LoadSingleQueryRowById(int id)
       {
          using var pooledConnection = new DbConnection(DbProviderFactory.ConnectionString);

frameworks/CSharp/appmpower/src/appMpower/Middleware/SingleQueryMiddleware.cs

@@ -1,10 +1,14 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Text.Json;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
+using appMpower.Serializers;
+using System.Runtime.CompilerServices;
 
 namespace appMpower; 
 
@@ -15,6 +19,9 @@ public class SingleQueryMiddleware
     private readonly static KeyValuePair<string, StringValues> _headerContentType =
          new KeyValuePair<string, StringValues>("Content-Type", new StringValues("application/json"));
 
+    [ThreadStatic]
+    private static Utf8JsonWriter _utf8JsonWriter;
+
     private readonly RequestDelegate _nextStage;
 
     public SingleQueryMiddleware(RequestDelegate nextStage)
@@ -34,14 +41,42 @@ public unsafe Task Invoke(HttpContext httpContext)
             IntPtr handlePointer; 
 
             IntPtr bytePointer = NativeMethods.Db(out payloadLength, out handlePointer);
-            byte[] json = new byte[payloadLength];
-            Marshal.Copy(bytePointer, json, 0, payloadLength);
-            NativeMethods.FreeHandlePointer(handlePointer);
 
+            //byte[] byteArray = new byte[payloadLength];
+
+            /*
+            fixed (byte* destination = byteArray)
+            {
+                // Use Unsafe.CopyBlock to copy the memory from source to destination
+                Unsafe.CopyBlock(destination, (void*)bytePointer, (uint)payloadLength);
+            }
+            */
+
+            ReadOnlySpan<byte> sourceSpan = new ReadOnlySpan<byte>((void*)bytePointer, payloadLength);
+
+            // Create a managed array and copy the data
+            //sourceSpan.CopyTo(byteArray);
+
+            //Marshal.Copy(bytePointer, byteArray, 0, payloadLength);
+            //NativeMethods.FreeHandlePointer(handlePointer);
+
+            //byte[] byteArray = DotnetMethods.Db();
+
+            var pipeWriter = httpContext.Response.BodyWriter; 
+            Utf8JsonWriter utf8JsonWriter = _utf8JsonWriter ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true });
+            utf8JsonWriter.Reset(pipeWriter);
+
+            WorldSerializer.Serialize(utf8JsonWriter, 
+                                      BinaryPrimitives.ReadInt16LittleEndian(sourceSpan.Slice(0, 2)),
+                                      BinaryPrimitives.ReadInt16LittleEndian(sourceSpan.Slice(2, 2)));
+            utf8JsonWriter.Flush();
+            NativeMethods.FreeHandlePointer(handlePointer);
+            
             response.Headers.Add(
-                new KeyValuePair<string, StringValues>("Content-Length", payloadLength.ToString()));
+                new KeyValuePair<string, StringValues>("Content-Length", utf8JsonWriter.BytesCommitted.ToString()));
 
-            return response.Body.WriteAsync(json, 0, payloadLength);
+            //return response.Body.WriteAsync(Encoding.UTF8.GetBytes(json), 0, Encoding.UTF8.GetBytes(json).Length);
+            return Task.CompletedTask;
         }
 
         return _nextStage(httpContext);

frameworks/CSharp/appmpower/src/appMpower/Serializers/WorldSerializer.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Text.Json;
+
+namespace appMpower.Serializers
+{
+   public static class WorldSerializer
+   {
+      public static void Serialize(Utf8JsonWriter utf8JsonWriter, Int16 id, Int16 randomNumber)
+      {
+         utf8JsonWriter.WriteStartObject();
+         utf8JsonWriter.WriteNumber("id", id);
+         utf8JsonWriter.WriteNumber("randomNumber", randomNumber);
+         utf8JsonWriter.WriteEndObject();
+      }
+   }
+}