Fixed Interface usage IRemoveByPattern | Add documentation | Tiny perf on RemoveByPattern()

joelharkes · joelharkes · commit 49bad8a58b47 · 2017-03-23T16:39:44.000+01:00
diff --git a/src/ServiceStack.Redis/RedisClient.ICacheClient.cs b/src/ServiceStack.Redis/RedisClient.ICacheClient.cs
@@ -20,7 +20,7 @@
 namespace ServiceStack.Redis
 {
     public partial class RedisClient
-        : ICacheClient, IRemoveByPattern
+        : ICacheClient
     {
         public T Exec<T>(Func<RedisClient, T> action)
         {
diff --git a/src/ServiceStack.Redis/RedisClient.cs b/src/ServiceStack.Redis/RedisClient.cs
@@ -19,6 +19,7 @@
 using ServiceStack.Redis.Generic;
 using ServiceStack.Redis.Pipeline;
 using ServiceStack.Text;
+using ServiceStack.Caching;
 
 namespace ServiceStack.Redis
 {
@@ -30,7 +31,7 @@ namespace ServiceStack.Redis
     ///		 RedisClient.Sets => ICollection[string]
     /// </summary>
     public partial class RedisClient
-        : RedisNativeClient, IRedisClient
+        : RedisNativeClient, IRedisClient, IRemoveByPattern // IRemoveByPattern is implemented in this file.
     {
         public RedisClient()
         {
@@ -990,9 +991,9 @@ public string LoadLuaScript(string body)
 
         public void RemoveByPattern(string pattern)
         {
-            List<string> keys = Keys(pattern).ToStringList();
-            if (keys.Count > 0)
-                Del(keys.ToArray());
+            var keys = Keys(pattern).ToStringArray();
+            if (keys.Length > 0)
+                Del(keys);
         }
 
         public void RemoveByRegex(string pattern)
@@ -1118,6 +1119,7 @@ private static RedisServerRole ToServerRole(string roleName)
                     return RedisServerRole.Unknown;
             }
         }
+        
     }
 
 }
diff --git a/src/ServiceStack.Redis/RedisClientManagerCacheClient.cs b/src/ServiceStack.Redis/RedisClientManagerCacheClient.cs
@@ -181,19 +181,24 @@ public void RemoveByPattern(string pattern)
         {
             using (var client = GetClient())
             {
-                var redisClient = client as RedisClient;
+                var redisClient = client as IRemoveByPattern;
                 if (redisClient != null)
                 {
-                    List<string> keys = redisClient.Keys(pattern).ToStringList();
-                    if (keys.Count > 0)
-                        redisClient.Del(keys.ToArray());
+                    redisClient.RemoveByPattern(pattern);
                 }
             }
         }
 
         public void RemoveByRegex(string pattern)
         {
-            RemoveByPattern(pattern.Replace(".*", "*").Replace(".+", "?"));
+            using (var client = GetClient())
+            {
+                var redisClient = client as IRemoveByPattern;
+                if (redisClient != null)
+                {
+                    redisClient.RemoveByRegex(pattern);
+                }
+            }
         }
 
         public TimeSpan? GetTimeToLive(string key)
diff --git a/src/ServiceStack.Redis/RedisManagerPool.cs b/src/ServiceStack.Redis/RedisManagerPool.cs
@@ -11,20 +11,30 @@
 
 namespace ServiceStack.Redis
 {
+    ///<summary>
+    /// Configuration class for the RedisManagerPool
+    ///</summary>
     public class RedisPoolConfig
     {
+        /// <summary>
+        /// Default pool size used by every new instance of <see cref="RedisPoolConfig"/>. (default: 40)
+        /// </summary>
         public static int DefaultMaxPoolSize = 40;
 
         public RedisPoolConfig()
         {
+            // maybe a bit overkill? could be deprecated if you add max int on RedisManagerPool
             MaxPoolSize = RedisConfig.DefaultMaxPoolSize ?? DefaultMaxPoolSize;
         }
 
+        /// <summary>
+        /// Maximum ammount of <see cref="ICacheClient"/>s created by the <see cref="RedisManagerPool"/>.
+        /// </summary>
         public int MaxPoolSize { get; set; }
     }
 
     /// <summary>
-    /// Provides thread-safe pooling of redis client connections.
+    /// Provides thread-safe pooling of redis client connections. All connections are treaded as read and write hosts.
     /// </summary>
     public partial class RedisManagerPool
         : IRedisClientsManager, IRedisFailover, IHandleClientDispose, IHasRedisResolver
diff --git a/src/ServiceStack.Redis/RedisNativeClient.cs b/src/ServiceStack.Redis/RedisNativeClient.cs
@@ -28,7 +28,11 @@ namespace ServiceStack.Redis
     /// This class contains all the common operations for the RedisClient.
     /// The client contains a 1:1 mapping of c# methods to redis operations of the same name.
     ///
-    /// Not threadsafe use a pooled manager
+    /// Not threadsafe, use a pooled manager!
+    /// All redis calls on a single instances write to the same Socket.
+    /// If used in multiple threads (or async Tasks) at the same time you will find
+    /// that commands are not executed properly by redis and Servicestack wont be able to (json) serialize 
+    /// the data that comes back.
     /// </summary>
     public partial class RedisNativeClient
         : IRedisNativeClient

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`namespace ServiceStack.Redis`
`21`	`21`	`{`
`22`	`22`	`public partial class RedisClient`
`23`		`- : ICacheClient, IRemoveByPattern`
	`23`	`+ : ICacheClient`
`24`	`24`	`{`
`25`	`25`	`public T Exec<T>(Func<RedisClient, T> action)`
`26`	`26`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`using ServiceStack.Redis.Generic;`
`20`	`20`	`using ServiceStack.Redis.Pipeline;`
`21`	`21`	`using ServiceStack.Text;`
	`22`	`+using ServiceStack.Caching;`
`22`	`23`
`23`	`24`	`namespace ServiceStack.Redis`
`24`	`25`	`{`
`@@ -30,7 +31,7 @@ namespace ServiceStack.Redis`
`30`	`31`	`/// RedisClient.Sets => ICollection[string]`
`31`	`32`	`/// </summary>`
`32`	`33`	`public partial class RedisClient`
`33`		`- : RedisNativeClient, IRedisClient`
	`34`	`+ : RedisNativeClient, IRedisClient, IRemoveByPattern // IRemoveByPattern is implemented in this file.`
`34`	`35`	`{`
`35`	`36`	`public RedisClient()`
`36`	`37`	`{`
`@@ -990,9 +991,9 @@ public string LoadLuaScript(string body)`
`990`	`991`
`991`	`992`	`public void RemoveByPattern(string pattern)`
`992`	`993`	`{`
`993`		`- List<string> keys = Keys(pattern).ToStringList();`
`994`		`- if (keys.Count > 0)`
`995`		`- Del(keys.ToArray());`
	`994`	`+ var keys = Keys(pattern).ToStringArray();`
	`995`	`+ if (keys.Length > 0)`
	`996`	`+ Del(keys);`
`996`	`997`	`}`
`997`	`998`
`998`	`999`	`public void RemoveByRegex(string pattern)`
`@@ -1118,6 +1119,7 @@ private static RedisServerRole ToServerRole(string roleName)`
`1118`	`1119`	`return RedisServerRole.Unknown;`
`1119`	`1120`	`}`
`1120`	`1121`	`}`
	`1122`	`+`
`1121`	`1123`	`}`
`1122`	`1124`
`1123`	`1125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -181,19 +181,24 @@ public void RemoveByPattern(string pattern)`
`181`	`181`	`{`
`182`	`182`	`using (var client = GetClient())`
`183`	`183`	`{`
`184`		`- var redisClient = client as RedisClient;`
	`184`	`+ var redisClient = client as IRemoveByPattern;`
`185`	`185`	`if (redisClient != null)`
`186`	`186`	`{`
`187`		`- List<string> keys = redisClient.Keys(pattern).ToStringList();`
`188`		`- if (keys.Count > 0)`
`189`		`- redisClient.Del(keys.ToArray());`
	`187`	`+ redisClient.RemoveByPattern(pattern);`
`190`	`188`	`}`
`191`	`189`	`}`
`192`	`190`	`}`
`193`	`191`
`194`	`192`	`public void RemoveByRegex(string pattern)`
`195`	`193`	`{`
`196`		`- RemoveByPattern(pattern.Replace(".", "").Replace(".+", "?"));`
	`194`	`+ using (var client = GetClient())`
	`195`	`+ {`
	`196`	`+ var redisClient = client as IRemoveByPattern;`
	`197`	`+ if (redisClient != null)`
	`198`	`+ {`
	`199`	`+ redisClient.RemoveByRegex(pattern);`
	`200`	`+ }`
	`201`	`+ }`
`197`	`202`	`}`
`198`	`203`
`199`	`204`	`public TimeSpan? GetTimeToLive(string key)`
Original file line number	Diff line number	Diff line change
`@@ -11,20 +11,30 @@`
`11`	`11`
`12`	`12`	`namespace ServiceStack.Redis`
`13`	`13`	`{`
	`14`	`+ ///<summary>`
	`15`	`+ /// Configuration class for the RedisManagerPool`
	`16`	`+ ///</summary>`
`14`	`17`	`public class RedisPoolConfig`
`15`	`18`	`{`
	`19`	`+ /// <summary>`
	`20`	`+ /// Default pool size used by every new instance of <see cref="RedisPoolConfig"/>. (default: 40)`
	`21`	`+ /// </summary>`
`16`	`22`	`public static int DefaultMaxPoolSize = 40;`
`17`	`23`
`18`	`24`	`public RedisPoolConfig()`
`19`	`25`	`{`
	`26`	`+ // maybe a bit overkill? could be deprecated if you add max int on RedisManagerPool`
`20`	`27`	`MaxPoolSize = RedisConfig.DefaultMaxPoolSize ?? DefaultMaxPoolSize;`
`21`	`28`	`}`
`22`	`29`
	`30`	`+ /// <summary>`
	`31`	`+ /// Maximum ammount of <see cref="ICacheClient"/>s created by the <see cref="RedisManagerPool"/>.`
	`32`	`+ /// </summary>`
`23`	`33`	`public int MaxPoolSize { get; set; }`
`24`	`34`	`}`
`25`	`35`
`26`	`36`	`/// <summary>`
`27`		`- /// Provides thread-safe pooling of redis client connections.`
	`37`	`+ /// Provides thread-safe pooling of redis client connections. All connections are treaded as read and write hosts.`
`28`	`38`	`/// </summary>`
`29`	`39`	`public partial class RedisManagerPool`
`30`	`40`	`: IRedisClientsManager, IRedisFailover, IHandleClientDispose, IHasRedisResolver`