Changed version, pool size, removed async pool implementation and oth…

…er small things

src/StackExchange.Redis.Extensions.AspNetCore/StackExchange.Redis.Extensions.AspNetCore.csproj

@@ -5,7 +5,7 @@
 		<Title>StackExchange.Redis.Extensions.AspNetCore is a library that has a set of extensions method fpr ASP.NET Core.</Title>
 		<Summary>StackExchange.Redis.Extensions.AspNetCore is a library that has a set of extensions method fpr ASP.NET Core with the scope to simply the library configuration into the dependency injection</Summary>
 		<Description>StackExchange.Redis.Extensions.AspNetCore is a library that has a set of extensions method fpr ASP.NET Core</Description>
-		<VersionPrefix>5.1.1</VersionPrefix>
+		<VersionPrefix>5.1.2</VersionPrefix>
 		<!--<VersionSuffix>pre</VersionSuffix>-->
 		<Authors>Ugo Lattanzi</Authors>
 		<Copyright>Ugo Lattanzi</Copyright>

src/StackExchange.Redis.Extensions.Binary/BinarySerializer.cs

@@ -7,46 +7,32 @@ namespace StackExchange.Redis.Extensions.Binary
 {
     public class BinarySerializer : ISerializer
     {
-        private readonly BinaryFormatter _binaryFormatter = new BinaryFormatter();
+        private readonly BinaryFormatter binaryFormatter = new BinaryFormatter();
 
         public object Deserialize(byte[] serializedObject)
         {
             using (var ms = new MemoryStream(serializedObject))
             {
-                return _binaryFormatter.Deserialize(ms);
+                return binaryFormatter.Deserialize(ms);
             }
         }
 
         public T Deserialize<T>(byte[] serializedObject)
         {
             using (var ms = new MemoryStream(serializedObject))
             {
-                return (T)_binaryFormatter.Deserialize(ms);
+                return (T)binaryFormatter.Deserialize(ms);
             }
         }
 
-        public Task<object> DeserializeAsync(byte[] serializedObject)
-        {
-            return Task.Factory.StartNew(() => Deserialize(serializedObject));
-        }
-
-        public Task<T> DeserializeAsync<T>(byte[] serializedObject)
-        {
-            return Task.Factory.StartNew(() => Deserialize<T>(serializedObject));
-        }
 
         public byte[] Serialize(object item)
         {
             using (var ms = new MemoryStream())
             {
-                _binaryFormatter.Serialize(ms, item);
+                binaryFormatter.Serialize(ms, item);
                 return ms.ToArray();
             }
         }
-
-        public Task<byte[]> SerializeAsync(object item)
-        {
-            return Task.Factory.StartNew(() => Serialize(item));
-        }
     }
 }

src/StackExchange.Redis.Extensions.Binary/StackExchange.Redis.Extensions.Binary.csproj

@@ -8,7 +8,7 @@
 		<Description>StackExchange.Redis.Extensions is a library that extends StackExchange.Redis allowing you a set of functionality needed by common applications.
 
 This implementation is based on Microsoft's BinarySerializer</Description>
-		<VersionPrefix>5.1.1</VersionPrefix>
+    <VersionPrefix>5.1.2</VersionPrefix>
 		<!--<VersionSuffix>pre</VersionSuffix>-->
 		<Authors>Ugo Lattanzi</Authors>
 		<Copyright>Ugo Lattanzi</Copyright>

src/StackExchange.Redis.Extensions.Core/Configuration/RedisConfiguration.cs

@@ -17,7 +17,7 @@ public class RedisConfiguration
         private int database = 0;
         private RedisHost[] hosts;
         private ServerEnumerationStrategy serverEnumerationStrategy;
-        private int poolSize = 10;
+        private int poolSize = 5;
 	    private string[] excludeCommands;
 
         /// <summary>

src/StackExchange.Redis.Extensions.Core/ISerializer.cs

@@ -14,13 +14,6 @@ public interface ISerializer
 		/// <returns></returns>
 		byte[] Serialize(object item);
 
-		/// <summary>
-		/// Serializes the asynchronous.
-		/// </summary>
-		/// <param name="item">The item.</param>
-		/// <returns></returns>
-		Task<byte[]> SerializeAsync(object item);
-
 		/// <summary>
 		/// Deserializes the specified bytes.
 		/// </summary>
@@ -30,15 +23,6 @@ public interface ISerializer
 		/// </returns>
 		object Deserialize(byte[] serializedObject);
 
-		/// <summary>
-		/// Deserializes the specified bytes.
-		/// </summary>
-		/// <param name="serializedObject">The serialized object.</param>
-		/// <returns>
-		/// The instance of the specified Item
-		/// </returns>
-		Task<object> DeserializeAsync(byte[] serializedObject);
-
 		/// <summary>
 		/// Deserializes the specified bytes.
 		/// </summary>
@@ -48,15 +32,5 @@ public interface ISerializer
 		/// The instance of the specified Item
 		/// </returns>
 		T Deserialize<T>(byte[] serializedObject);
-
-		/// <summary>
-		/// Deserializes the specified bytes.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="serializedObject">The serialized object.</param>
-		/// <returns>
-		/// The instance of the specified Item
-		/// </returns>
-		Task<T> DeserializeAsync<T>(byte[] serializedObject);
 	}
 }

src/StackExchange.Redis.Extensions.Core/Implementations/RedisCacheConnectionPoolManager.cs

@@ -1,15 +1,14 @@
 using System;
 using System.Collections.Concurrent;
 using System.Linq;
-using System.Threading.Tasks;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using StackExchange.Redis.Extensions.Core.Configuration;
 
 namespace StackExchange.Redis.Extensions.Core.Implementations
 {
 	public class RedisCacheConnectionPoolManager : IRedisCacheConnectionPoolManager
 	{
-		private static ConcurrentBag<Lazy<Task<ConnectionMultiplexer>>> connections;
+		private static ConcurrentBag<Lazy<ConnectionMultiplexer>> connections;
 		private readonly RedisConfiguration redisConfiguration;
 
 		public RedisCacheConnectionPoolManager(RedisConfiguration redisConfiguration)
@@ -32,28 +31,27 @@ public void Dispose()
 
 		public IConnectionMultiplexer GetConnection()
         {
-            Lazy<Task<ConnectionMultiplexer>> response;
+            Lazy<ConnectionMultiplexer> response;
 	        var loadedLazys = connections.Where(lazy => lazy.IsValueCreated);
 
             if (loadedLazys.Count() == connections.Count) {
-		        response = connections.OrderBy(x=>x.Value.Result.GetCounters().TotalOutstanding).First();
+		        response = connections.OrderBy(x=>x.Value.GetCounters().TotalOutstanding).First();
 	        }
 	        else {
 		        response = connections.First(lazy => !lazy.IsValueCreated);
 	        }
 
-            return response.Value.Result;
+            return response.Value;
         }
 
 		private void Initialize()
 		{
-			connections = new ConcurrentBag<Lazy<Task<ConnectionMultiplexer>>>();
+			connections = new ConcurrentBag<Lazy<ConnectionMultiplexer>>();
 
 			for (int i = 0; i < redisConfiguration.PoolSize; i++)
 			{
-				connections.Add(new Lazy<Task<ConnectionMultiplexer>>(async () => await ConnectionMultiplexer.ConnectAsync(redisConfiguration.ConfigurationOptions)));
+				connections.Add(new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(redisConfiguration.ConfigurationOptions)));
 			}
 		}
-
 	}
 }

src/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.cs

@@ -35,7 +35,7 @@ public RedisDatabase(
 			}
 
 			keyprefix = keyPrefix;
-		}
+        }
 
 		public IDatabase Database { get; }
 
@@ -110,7 +110,7 @@ public async Task<T> GetAsync<T>(string key, CommandFlags flag = CommandFlags.No
 			if (!valueBytes.HasValue)
 				return default;
 
-            return await Serializer.DeserializeAsync<T>(valueBytes);
+            return Serializer.Deserialize<T>(valueBytes);
 		}
 
 		public async Task<T> GetAsync<T>(string key, DateTimeOffset expiresAt, CommandFlags flag = CommandFlags.None)
@@ -142,7 +142,7 @@ public bool Add<T>(string key, T value, When when = When.Always, CommandFlags fl
 
 		public async Task<bool> AddAsync<T>(string key, T value, When when = When.Always, CommandFlags flag = CommandFlags.None)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 
 			return await Database.StringSetAsync(key, entryBytes, null, when, flag);
 		}
@@ -167,7 +167,7 @@ public bool Add<T>(string key, T value, DateTimeOffset expiresAt, When when = Wh
 
 		public async Task<bool> AddAsync<T>(string key, T value, DateTimeOffset expiresAt, When when = When.Always, CommandFlags flag = CommandFlags.None)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 			var expiration = expiresAt.UtcDateTime.Subtract(DateTime.UtcNow);
 
 			return await Database.StringSetAsync(key, entryBytes, expiration, when, flag);
@@ -192,7 +192,7 @@ public bool Add<T>(string key, T value, TimeSpan expiresIn, When when = When.Alw
 
 		public async Task<bool> AddAsync<T>(string key, T value, TimeSpan expiresIn, When when = When.Always, CommandFlags flag = CommandFlags.None)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 
 			return await Database.StringSetAsync(key, entryBytes, expiresIn, when, flag);
 		}
@@ -355,7 +355,7 @@ public async Task<bool> SetAddAsync<T>(string key, T item, CommandFlags flag = C
 
 			if (item == null) throw new ArgumentNullException(nameof(item), "item cannot be null.");
 
-			var serializedObject = await Serializer.SerializeAsync(item);
+			var serializedObject = Serializer.Serialize(item);
 
 			return await Database.SetAddAsync(key, serializedObject, flag);
 		}
@@ -402,7 +402,7 @@ public async Task<bool> SetRemoveAsync<T>(string key, T item, CommandFlags flag
 
 			if (item == null) throw new ArgumentNullException(nameof(item), "item cannot be null.");
 
-			var serializedObject = await Serializer.SerializeAsync(item);
+			var serializedObject = Serializer.Serialize(item);
 
 			return await Database.SetRemoveAsync(key, serializedObject, flag);
 		}
@@ -554,7 +554,7 @@ public long Publish<T>(RedisChannel channel, T message, CommandFlags flags = Com
 		public async Task<long> PublishAsync<T>(RedisChannel channel, T message, CommandFlags flags = CommandFlags.None)
 		{
 			var sub = connectionMultiplexer.GetSubscriber();
-			return await sub.PublishAsync(channel, await Serializer.SerializeAsync(message), flags);
+			return await sub.PublishAsync(channel, Serializer.Serialize(message), flags);
 		}
 
 		public void Subscribe<T>(RedisChannel channel, Action<T> handler, CommandFlags flags = CommandFlags.None)
@@ -627,7 +627,7 @@ public async Task<long> ListAddToLeftAsync<T>(string key, T item, When when = Wh
 			if (item == null)
 				throw new ArgumentNullException(nameof(item), "item cannot be null.");
 
-			var serializedItem = await Serializer.SerializeAsync(item);
+			var serializedItem = Serializer.Serialize(item);
 
 			return await Database.ListLeftPushAsync(key, serializedItem, when, flags);
 		}
@@ -650,7 +650,7 @@ public async Task<T> ListGetFromRightAsync<T>(string key, CommandFlags flags = C
 
 			if (item == RedisValue.Null) return null;
 
-			return item == RedisValue.Null ? null : await Serializer.DeserializeAsync<T>(item);
+			return item == RedisValue.Null ? null : Serializer.Deserialize<T>(item);
 		}
 
 		public bool HashDelete(string hashKey, string key, CommandFlags commandFlags = CommandFlags.None)

src/StackExchange.Redis.Extensions.Core/StackExchange.Redis.Extensions.Core.csproj

@@ -13,7 +13,7 @@ To store complex data It requires one of the following implementations:
 - StackExchange.Redis.Extensions.Protobuf
 - StackExchange.Redis.Extensions.Utf8Json
 - StackExchange.Redis.Extensions.Binary</Description>
-		<VersionPrefix>5.1.1</VersionPrefix>
+    <VersionPrefix>5.1.2</VersionPrefix>
 		<!--<VersionSuffix>pre</VersionSuffix>-->
 		<IncludeSource>false</IncludeSource>
 		<IncludeSymbols>true</IncludeSymbols>

src/StackExchange.Redis.Extensions.Core/StackExchangeRedisCacheClient.cs

@@ -334,7 +334,7 @@ public async Task<T> GetAsync<T>(string key, CommandFlags flag = CommandFlags.No
 				return default(T);
 			}
 
-			return await Serializer.DeserializeAsync<T>(valueBytes);
+			return Serializer.Deserialize<T>(valueBytes);
 		}
 
 		/// <summary>
@@ -408,7 +408,7 @@ public bool Add<T>(string key, T value)
 		/// </returns>
 		public async Task<bool> AddAsync<T>(string key, T value)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 
 			return await Database.StringSetAsync(key, entryBytes);
 		}
@@ -471,7 +471,7 @@ public bool Add<T>(string key, T value, DateTimeOffset expiresAt)
 		/// </returns>
 		public async Task<bool> AddAsync<T>(string key, T value, DateTimeOffset expiresAt)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 			var expiration = expiresAt.Subtract(DateTimeOffset.Now);
 
 			return await Database.StringSetAsync(key, entryBytes, expiration);
@@ -536,7 +536,7 @@ public bool Add<T>(string key, T value, TimeSpan expiresIn)
 		/// </returns>
 		public async Task<bool> AddAsync<T>(string key, T value, TimeSpan expiresIn)
 		{
-			var entryBytes = await Serializer.SerializeAsync(value);
+			var entryBytes = Serializer.Serialize(value);
 
 			return await Database.StringSetAsync(key, entryBytes, expiresIn);
 		}
@@ -841,7 +841,7 @@ public async Task<bool> SetAddAsync<T>(string key, T item) where T : class
 				throw new ArgumentNullException(nameof(item), "item cannot be null.");
 			}
 
-			var serializedObject = await Serializer.SerializeAsync(item);
+			var serializedObject = Serializer.Serialize(item);
 
 			return await Database.SetAddAsync(key, serializedObject);
 		}
@@ -939,7 +939,7 @@ public async Task<bool> SetRemoveAsync<T>(string key, T item) where T : class
 				throw new ArgumentNullException(nameof(item), "item cannot be null.");
 			}
 
-			var serializedObject = await Serializer.SerializeAsync(item);
+			var serializedObject = Serializer.Serialize(item);
 
 			return await Database.SetRemoveAsync(key, serializedObject);
 		}
@@ -1221,7 +1221,7 @@ public long Publish<T>(RedisChannel channel, T message, CommandFlags flags = Com
 		public async Task<long> PublishAsync<T>(RedisChannel channel, T message, CommandFlags flags = CommandFlags.None)
 		{
 			var sub = connectionMultiplexer.GetSubscriber();
-			return await sub.PublishAsync(channel, await Serializer.SerializeAsync(message), flags);
+			return await sub.PublishAsync(channel, Serializer.Serialize(message), flags);
 		}
 
 		/// <summary>
@@ -1371,7 +1371,7 @@ public async Task<long> ListAddToLeftAsync<T>(string key, T item) where T : clas
 				throw new ArgumentNullException(nameof(item), "item cannot be null.");
 			}
 
-			var serializedItem = await Serializer.SerializeAsync(item);
+			var serializedItem = Serializer.Serialize(item);
 
 			return await Database.ListLeftPushAsync(key, serializedItem);
 		}
@@ -1419,7 +1419,7 @@ public async Task<T> ListGetFromRightAsync<T>(string key) where T : class
 
 			if (item == RedisValue.Null) return null;
 
-			return item == RedisValue.Null ? null : await Serializer.DeserializeAsync<T>(item);
+			return item == RedisValue.Null ? null : Serializer.Deserialize<T>(item);
 		}
 
 		private Dictionary<string, string> ParseInfo(string info)