Unbreak mono build

StackExchange.Redis/StackExchange/Redis/ConnectionMultiplexer.cs

@@ -1764,11 +1764,15 @@ internal T ExecuteSyncImpl<T>(Message message, ResultProcessor<T> processor, Ser
                         else
                         {
                             int inst, qu, qs, qc, wr, wq, @in, ar;
+#if !__MonoCS__
                             var mgrState = socketManager.State;
+#endif
                             int queue = server.GetOutstandingCount(message.Command, out inst, out qu, out qs, out qc, out wr, out wq, out @in, out ar);
                             var sb = new StringBuilder("Timeout performing ").Append(message.CommandAndKey)
                                 .Append(", inst: ").Append(inst)
+#if !__MonoCS__
                                 .Append(", mgr: ").Append(mgrState)
+#endif
                                 .Append(", queue: ").Append(queue).Append(", qu=").Append(qu)
                                 .Append(", qs=").Append(qs).Append(", qc=").Append(qc)
                                 .Append(", wr=").Append(wr).Append("/").Append(wq)

StackExchange.Redis/StackExchange/Redis/IDatabase.cs

@@ -145,7 +145,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// </summary>
         /// <returns>yields all elements of the hash.</returns>
         /// <remarks>http://redis.io/commands/hscan</remarks>
-        IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None);
+        IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None);
 
         /// <summary>
         /// Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.
@@ -593,7 +593,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// </summary>
         /// <returns>yields all elements of the set.</returns>
         /// <remarks>http://redis.io/commands/sscan</remarks>
-        IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None);
+        IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None);
 
         /// <summary>
         /// Sorts a list, set or sorted set (numerically or alphabetically, ascending by default); By default, the elements themselves are compared, but the values can also be
@@ -786,7 +786,7 @@ public interface IDatabase : IRedis, IDatabaseAsync
         /// </summary>
         /// <returns>yields all elements of the sorted set.</returns>
         /// <remarks>http://redis.io/commands/zscan</remarks>
-        IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None);
+        IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None);
         /// <summary>
         /// Returns the score of member in the sorted set at key; If member does not exist in the sorted set, or key does not exist, nil is returned.
         /// </summary>

StackExchange.Redis/StackExchange/Redis/IServer.cs

@@ -237,7 +237,7 @@ public partial interface IServer : IRedis
         /// <remarks>Warning: consider KEYS as a command that should only be used in production environments with extreme care.</remarks>
         /// <remarks>http://redis.io/commands/keys</remarks>
         /// <remarks>http://redis.io/commands/scan</remarks>
-        IEnumerable<RedisKey> Keys(int database = 0, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None);
+        IEnumerable<RedisKey> Keys(int database = 0, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None);
 
         /// <summary>
         /// Return the time of the last DB save executed with success. A client may check if a BGSAVE command succeeded reading the LASTSAVE value, then issuing a BGSAVE command and checking at regular intervals every N seconds if LASTSAVE changed.

StackExchange.Redis/StackExchange/Redis/KeyspaceIsolation/DatabaseWrapper.cs

@@ -616,27 +616,27 @@ public TimeSpan Ping(CommandFlags flags = CommandFlags.None)
 
         IEnumerable<HashEntry> IDatabase.HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return HashScan(key, pattern, pageSize, RedisBase.CursorEnumerable.Origin, flags);
+            return HashScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, flags);
         }
-        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             return this.Inner.HashScan(this.ToInner(key), pattern, pageSize, flags);
         }
 
         IEnumerable<RedisValue> IDatabase.SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return SetScan(key, pattern, pageSize, RedisBase.CursorEnumerable.Origin, flags);
+            return SetScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, flags);
         }
-        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             return this.Inner.SetScan(this.ToInner(key), pattern, pageSize, cursor, flags);
         }
 
         IEnumerable<SortedSetEntry> IDatabase.SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return SortedSetScan(key, pattern, pageSize, RedisBase.CursorEnumerable.Origin, flags);
+            return SortedSetScan(key, pattern, pageSize, RedisBase.CursorUtils.Origin, flags);
         }
-        public IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorEnumerable.DefaultPageSize, long cursor = RedisBase.CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = RedisBase.CursorUtils.DefaultPageSize, long cursor = RedisBase.CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             return this.Inner.SortedSetScan(this.ToInner(key), pattern, pageSize, flags);
         }

StackExchange.Redis/StackExchange/Redis/RedisBase.cs

@@ -141,7 +141,7 @@ private ResultProcessor.TimingProcessor.TimerMessage GetTimerMessage(CommandFlag
         }
 
 
-        internal abstract class CursorEnumerable
+        internal static class CursorUtils
         {
             internal const int Origin = 0, DefaultPageSize = 10;
             internal static bool IsNil(RedisValue pattern)
@@ -152,7 +152,7 @@ internal static bool IsNil(RedisValue pattern)
                 return rawValue.Length == 1 && rawValue[0] == '*';
             }
         }
-        internal abstract class CursorEnumerable<T> : CursorEnumerable, IEnumerable<T>, IScanning
+        internal abstract class CursorEnumerable<T> : IEnumerable<T>, IScanning
         {
             private readonly RedisBase redis;
             private readonly ServerEndPoint server;

StackExchange.Redis/StackExchange/Redis/RedisDatabase.cs

@@ -195,10 +195,10 @@ public Task<long> HashLengthAsync(RedisKey key, CommandFlags flags = CommandFlag
 
         IEnumerable<HashEntry> IDatabase.HashScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return HashScan(key, pattern, pageSize, CursorEnumerable.Origin, flags);
+            return HashScan(key, pattern, pageSize, CursorUtils.Origin, flags);
         }
 
-        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorEnumerable.DefaultPageSize, long cursor = CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<HashEntry> HashScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorUtils.DefaultPageSize, long cursor = CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             var scan = TryScan<HashEntry>(key, pattern, pageSize, cursor, flags, RedisCommand.HSCAN, HashScanResultProcessor.Default);
             if (scan != null) return scan;
@@ -1041,10 +1041,10 @@ public Task<long> SetRemoveAsync(RedisKey key, RedisValue[] values, CommandFlags
 
         IEnumerable<RedisValue> IDatabase.SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return SetScan(key, pattern, pageSize, CursorEnumerable.Origin, flags);
+            return SetScan(key, pattern, pageSize, CursorUtils.Origin, flags);
         }
 
-        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorEnumerable.DefaultPageSize, long cursor = CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorUtils.DefaultPageSize, long cursor = CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             var scan = TryScan<RedisValue>(key, pattern, pageSize, cursor, flags, RedisCommand.SSCAN, SetScanResultProcessor.Default);
             if (scan != null) return scan;
@@ -1269,10 +1269,10 @@ public Task<long> SortedSetRemoveRangeByScoreAsync(RedisKey key, double start, d
 
         IEnumerable<SortedSetEntry> IDatabase.SortedSetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return SortedSetScan(key, pattern, pageSize, CursorEnumerable.Origin, flags);
+            return SortedSetScan(key, pattern, pageSize, CursorUtils.Origin, flags);
         }
 
-        public IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorEnumerable.DefaultPageSize, long cursor = CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<SortedSetEntry> SortedSetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = CursorUtils.DefaultPageSize, long cursor = CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             var scan = TryScan<SortedSetEntry>(key, pattern, pageSize, cursor, flags, RedisCommand.ZSCAN, SortedSetScanResultProcessor.Default);
             if (scan != null) return scan;
@@ -1998,7 +1998,7 @@ private IEnumerable<T> TryScan<T>(RedisKey key, RedisValue pattern, int pageSize
             var features = GetFeatures(Db, key, flags, out server);
             if (!features.Scan) return null;
 
-            if (CursorEnumerable.IsNil(pattern)) pattern = (byte[])null;
+            if (CursorUtils.IsNil(pattern)) pattern = (byte[])null;
             return new ScanIterator<T>(this, server, key, pattern, pageSize, cursor, flags, command, processor);
         }
 
@@ -2070,9 +2070,9 @@ protected override ResultProcessor<CursorEnumerable<T>.ScanResult> Processor
             }
             protected override Message CreateMessage(long cursor)
             {
-                if (IsNil(pattern))
+                if (CursorUtils.IsNil(pattern))
                 {
-                    if (pageSize == DefaultPageSize)
+                    if (pageSize == CursorUtils.DefaultPageSize)
                     {
                         return Message.Create(db, flags, command, key, cursor);
                     }
@@ -2083,7 +2083,7 @@ protected override Message CreateMessage(long cursor)
                 }
                 else
                 {
-                    if (pageSize == DefaultPageSize)
+                    if (pageSize == CursorUtils.DefaultPageSize)
                     {
                         return Message.Create(db, flags, command, key, cursor, RedisLiterals.MATCH, pattern);
                     }

StackExchange.Redis/StackExchange/Redis/RedisServer.cs

@@ -271,13 +271,13 @@ public Task<string> InfoRawAsync(RedisValue section = default(RedisValue), Comma
 
         IEnumerable<RedisKey> IServer.Keys(int database, RedisValue pattern, int pageSize, CommandFlags flags)
         {
-            return Keys(database, pattern, pageSize, CursorEnumerable.Origin, flags);
+            return Keys(database, pattern, pageSize, CursorUtils.Origin, flags);
         }
 
-        public IEnumerable<RedisKey> Keys(int database = 0, RedisValue pattern = default(RedisValue), int pageSize = CursorEnumerable.DefaultPageSize, long cursor = CursorEnumerable.Origin, CommandFlags flags = CommandFlags.None)
+        public IEnumerable<RedisKey> Keys(int database = 0, RedisValue pattern = default(RedisValue), int pageSize = CursorUtils.DefaultPageSize, long cursor = CursorUtils.Origin, CommandFlags flags = CommandFlags.None)
         {
             if (pageSize <= 0) throw new ArgumentOutOfRangeException("pageSize");
-            if (CursorEnumerable.IsNil(pattern)) pattern = RedisLiterals.Wildcard;
+            if (CursorUtils.IsNil(pattern)) pattern = RedisLiterals.Wildcard;
 
             if (multiplexer.CommandMap.IsAvailable(RedisCommand.SCAN))
             {
@@ -652,9 +652,9 @@ public KeysScanEnumerable(RedisServer server, int db, RedisValue pattern, int pa
 
             protected override Message CreateMessage(long cursor)
             {
-                if (IsNil(pattern))
+                if (CursorUtils.IsNil(pattern))
                 {
-                    if (pageSize == DefaultPageSize)
+                    if (pageSize == CursorUtils.DefaultPageSize)
                     {
                         return Message.Create(db, flags, RedisCommand.SCAN, cursor);
                     }
@@ -665,7 +665,7 @@ protected override Message CreateMessage(long cursor)
                 }
                 else
                 {
-                    if (pageSize == DefaultPageSize)
+                    if (pageSize == CursorUtils.DefaultPageSize)
                     {
                         return Message.Create(db, flags, RedisCommand.SCAN, cursor, RedisLiterals.MATCH, pattern);
                     }

StackExchange.Redis/StackExchange/Redis/TaskSource.cs

@@ -31,7 +31,7 @@ static TaskSource()
                 {
                     var method = new DynamicMethod("IsSyncSafe", typeof(bool), new[] { typeof(Task) }, typeof(Task), true);
                     var il = method.GetILGenerator();
-                    var hasContinuation = il.DefineLabel();
+                    //var hasContinuation = il.DefineLabel();
                     il.Emit(OpCodes.Ldarg_0);
                     il.Emit(OpCodes.Ldfld, continuationField);
                     Label nonNull = il.DefineLabel(), goodReturn = il.DefineLabel();