Cleanup memcached protocol

src/Bedrock.Framework.Experimental/Protocols/Memcached/MemcachedProtocol.cs

@@ -1,19 +1,22 @@
 using Bedrock.Framework.Experimental.Protocols.Memcached;
 using Bedrock.Framework.Protocols;
+
 using Microsoft.AspNetCore.Connections;
+
 using System;
 using System.Buffers;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+
 using static Bedrock.Framework.Experimental.Protocols.Memcached.Enums;
 
 namespace Bedrock.Framework.Experimental.Protocols.Memcached
 {
     public class MemcachedProtocol
-    {        
+    {
         private readonly ConnectionContext _connection;
         private readonly MemcachedMessageWriter _memcachedMessageWriter;
         private readonly MemcachedMessageReader _memcachedMessageReader;
@@ -40,6 +43,8 @@ public MemcachedProtocol(ConnectionContext connection)
 
         private async Task<byte[]> CommandWithResult(MemcachedRequest request)
         {
+            await _semaphore.WaitAsync();
+
             try
             {
                 var result = await ExecuteCommand(request);
@@ -53,13 +58,15 @@ private async Task<byte[]> CommandWithResult(MemcachedRequest request)
                 }
             }
             finally
-            {                
+            {
                 _semaphore.Release();
             }
         }
 
         private async Task CommandWithNoResult(MemcachedRequest request)
         {
+            await _semaphore.WaitAsync();
+
             try
             {
                 var result = await ExecuteCommand(request);
@@ -73,59 +80,44 @@ private async Task CommandWithNoResult(MemcachedRequest request)
                 _semaphore.Release();
             }
         }
-       
-        public async Task<byte[]> Get(string key)
+
+        public Task<byte[]> Get(string key)
         {
-            await _semaphore.WaitAsync();
-
-            var keyBytes = Encoding.UTF8.GetBytes(key);
-            var request = new MemcachedRequest(Enums.Opcode.Get, keyBytes, NextOpaque);
+            var request = new MemcachedRequest(Enums.Opcode.Get, key, NextOpaque);
 
-            return await CommandWithResult(request);                   
+            return CommandWithResult(request);
         }
 
-        public async Task Delete(string key)
+        public Task Delete(string key)
         {
-            await _semaphore.WaitAsync();
-
-            var keyBytes = Encoding.UTF8.GetBytes(key);
-            var request = new MemcachedRequest(Enums.Opcode.Delete, keyBytes, NextOpaque);
+            var request = new MemcachedRequest(Enums.Opcode.Delete, key, NextOpaque);
 
-            await CommandWithNoResult(request);
+            return CommandWithNoResult(request);
         }
 
-        public async Task Set(string key, byte[] value, TimeSpan? expireIn)
+        public Task Set(string key, byte[] value, TimeSpan? expireIn)
         {
-            await _semaphore.WaitAsync();
+            var request = new MemcachedRequest(Enums.Opcode.Set, key, NextOpaque, value, TypeCode.Object, expireIn);
 
-            var keyBytes = Encoding.UTF8.GetBytes(key);            
-            var request = new MemcachedRequest(Enums.Opcode.Set, keyBytes, NextOpaque, value, TypeCode.Object, expireIn);
-
-            await CommandWithNoResult(request);          
+            return CommandWithNoResult(request);
         }
 
-        public async Task Add(string key, byte[] value, TimeSpan? expireIn)
+        public Task Add(string key, byte[] value, TimeSpan? expireIn)
         {
-            await _semaphore.WaitAsync();
+            var request = new MemcachedRequest(Enums.Opcode.Add, key, NextOpaque, value, TypeCode.Object, expireIn);
 
-            var keyBytes = Encoding.UTF8.GetBytes(key);
-            var request = new MemcachedRequest(Enums.Opcode.Add, keyBytes, NextOpaque, value, TypeCode.Object, expireIn);
-
-            await CommandWithNoResult(request);
+            return CommandWithNoResult(request);
         }
 
-        public async Task Replace(string key, byte[] value, TimeSpan? expireIn)
+        public Task Replace(string key, byte[] value, TimeSpan? expireIn)
         {
-            await _semaphore.WaitAsync();
+            var request = new MemcachedRequest(Enums.Opcode.Replace, key, NextOpaque, value, TypeCode.Object, expireIn);
 
-            var keyBytes = Encoding.UTF8.GetBytes(key);
-            var request = new MemcachedRequest(Enums.Opcode.Replace, keyBytes, NextOpaque, value, TypeCode.Object, expireIn);
-
-            await CommandWithNoResult(request);
+            return CommandWithNoResult(request);
         }
 
         private async Task<MemcachedResponse> ExecuteCommand(MemcachedRequest request)
-        {           
+        {
             await _protocolWriter.WriteAsync(_memcachedMessageWriter, request);
             var result = await _protocolReader.ReadAsync(_memcachedMessageReader);
             _protocolReader.Advance();

src/Bedrock.Framework.Experimental/Protocols/Memcached/MemcachedRequest.cs

@@ -14,21 +14,38 @@ public class MemcachedRequest
         public TypeCode Flags { get; }
         public TimeSpan? ExpireIn { get; }
 
-        public MemcachedRequest(Opcode opcode, byte[] key, uint opaque,byte[] value, TypeCode flags, TimeSpan ? expireIn=null)
+        public MemcachedRequest(Opcode opcode, string key, uint opaque, byte[] value, TypeCode flags, TimeSpan? expireIn = null)
         {
-            Opcode = opcode;
-            Key = key;
-            Opaque = opaque;
-            Value = value;
-            Flags = flags;
-            ExpireIn = expireIn;            
+            Opcode   = opcode;
+            Key      = Encoding.UTF8.GetBytes(key);
+            Opaque   = opaque;
+            Value    = value;
+            Flags    = flags;
+            ExpireIn = expireIn;
+        }
+
+        public MemcachedRequest(Opcode opcode, byte[] key, uint opaque, byte[] value, TypeCode flags, TimeSpan? expireIn = null)
+        {
+            Opcode   = opcode;
+            Key      = key;
+            Opaque   = opaque;
+            Value    = value;
+            Flags    = flags;
+            ExpireIn = expireIn;
         }
 
         public MemcachedRequest(Opcode opcode, byte[] key, uint opaque)
         {
             Opcode = opcode;
-            Key = key;
+            Key    = key;
             Opaque = opaque;   
         }
+
+        public MemcachedRequest(Opcode opcode, string key, uint opaque)
+        {
+            Opcode = opcode;
+            Key    = Encoding.UTF8.GetBytes(key);
+            Opaque = opaque;
+        }
     }
 }