reverse the lock work so we always add to the queue before writing

StackExchange.Redis.Tests/Scripting.cs

@@ -313,7 +313,7 @@ public void ScriptThrowsErrorInsideTransaction()
                     Assert.Equal(1L, a.Result);
                     Assert.Equal(2L, c.Result);
 
-                    Assert.True(b.IsFaulted);
+                    Assert.True(QuickWait(b).IsFaulted, "should be faulted");
                     Assert.Single(b.Exception.InnerExceptions);
                     var ex = b.Exception.InnerExceptions.Single();
                     Assert.IsType<RedisServerException>(ex);

StackExchange.Redis/PhysicalBridge.cs

@@ -706,8 +706,8 @@ private void SelectDatabaseInsideWriteLock(PhysicalConnection connection, Messag
                 var sel = connection.GetSelectDatabaseCommand(db, message);
                 if (sel != null)
                 {
-                    sel.WriteTo(connection);
                     connection.EnqueueInsideWriteLock(sel);
+                    sel.WriteTo(connection);
                     sel.SetRequestSent();
                     IncrementOpCount();
                 }
@@ -744,8 +744,8 @@ private WriteResult WriteMessageToServerInsideWriteLock(PhysicalConnection conne
                     var readmode = connection.GetReadModeCommand(isMasterOnly);
                     if (readmode != null)
                     {
-                        readmode.WriteTo(connection);
                         connection.EnqueueInsideWriteLock(readmode);
+                        readmode.WriteTo(connection);
                         readmode.SetRequestSent();
                         IncrementOpCount();
                     }
@@ -753,8 +753,8 @@ private WriteResult WriteMessageToServerInsideWriteLock(PhysicalConnection conne
                     if (message.IsAsking)
                     {
                         var asking = ReusableAskingCommand;
-                        asking.WriteTo(connection);
                         connection.EnqueueInsideWriteLock(asking);
+                        asking.WriteTo(connection);
                         asking.SetRequestSent();
                         IncrementOpCount();
                     }
@@ -772,9 +772,8 @@ private WriteResult WriteMessageToServerInsideWriteLock(PhysicalConnection conne
                         break;
                 }
 
-                //connection.EnqueueInsideWriteLock(message);
-                message.WriteTo(connection);
                 connection.EnqueueInsideWriteLock(message);
+                message.WriteTo(connection);
 
                 message.SetRequestSent();
                 IncrementOpCount();
@@ -798,21 +797,6 @@ private WriteResult WriteMessageToServerInsideWriteLock(PhysicalConnection conne
                 }
                 return WriteResult.Success;
             }
-            catch (RedisCommandException ex)
-            {
-                Trace("Write failed: " + ex.Message);
-                message.Fail(ConnectionFailureType.InternalFailure, ex, null);
-                this.CompleteSyncOrAsync(message);
-                // this failed without actually writing; we're OK with that... unless there's a transaction
-
-                if (connection?.TransactionActive == true)
-                {
-                    // we left it in a broken state; need to kill the connection
-                    connection.RecordConnectionFailed(ConnectionFailureType.ProtocolFailure, ex);
-                    return WriteResult.WriteFailure;
-                }
-                return WriteResult.Success;
-            }
             catch (Exception ex)
             {
                 Trace("Write failed: " + ex.Message);

StackExchange.Redis/PhysicalConnection.cs

@@ -457,7 +457,6 @@ internal void EnqueueInsideWriteLock(Message next)
             lock (_writtenAwaitingResponse)
             {
                 _writtenAwaitingResponse.Enqueue(next);
-                if (_writtenAwaitingResponse.Count == 1) Monitor.Pulse(_writtenAwaitingResponse);
             }
         }
 
@@ -1271,11 +1270,7 @@ private void MatchResult(RawResult result)
             lock (_writtenAwaitingResponse)
             {
                 if (_writtenAwaitingResponse.Count == 0)
-                {
-                    // we could be racing with the writer, but this *really* shouldn't
-                    // be even remotely close
-                    Monitor.Wait(_writtenAwaitingResponse, 500);
-                }
+                    throw new InvalidOperationException("Received response with no message waiting: " + result.ToString());
                 msg = _writtenAwaitingResponse.Dequeue();
             }