remove redundant casts via AsInstanceOf (#6744)

SimonCropp · Aaronontheweb · web-flow · commit 4f27bac819bb · 2023-05-09T20:15:37.000-05:00
Co-authored-by: Aaron Stannard &lt;aaron@petabridge.com&gt;
diff --git a/src/core/Akka.Persistence/Fsm/PersistentFSMBase.cs b/src/core/Akka.Persistence/Fsm/PersistentFSMBase.cs
@@ -633,9 +633,9 @@ protected virtual void LogTermination(FSMBase.Reason reason)
         {
             if (reason is FSMBase.Failure failure)
             {
-                if (failure.Cause is Exception)
+                if (failure.Cause is Exception exception)
                 {
-                    _log.Error(failure.Cause.AsInstanceOf<Exception>(), "terminating due to Failure");
+                    _log.Error(exception, "terminating due to Failure");
                 }
                 else
                 {
diff --git a/src/core/Akka.Remote/Endpoint.cs b/src/core/Akka.Remote/Endpoint.cs
@@ -1438,8 +1438,8 @@ private void EnqueueInBuffer(object message)
             var send = message as EndpointManager.Send;
             if (send != null && send.Message is IPriorityMessage)
                 _prioBuffer.AddLast(send);
-            else if (send != null && send.Message is ActorSelectionMessage &&
-                     send.Message.AsInstanceOf<ActorSelectionMessage>().Message is IPriorityMessage)
+            else if (send != null && send.Message is ActorSelectionMessage actorSelectionMessage &&
+                     actorSelectionMessage.Message is IPriorityMessage)
             {
                 _prioBuffer.AddLast(send);
             }
diff --git a/src/core/Akka.Remote/EndpointManager.cs b/src/core/Akka.Remote/EndpointManager.cs
@@ -755,7 +755,7 @@ protected void Accepting()
                         //the quarantine uid has lost the race with some failure, do nothing
                     }
                 }
-                else if (policy.Item1 is Quarantined && policy.Item2 != null && policy.Item1.AsInstanceOf<Quarantined>().Uid == policy.Item2.Value)
+                else if (policy.Item1 is Quarantined quarantined && policy.Item2 != null && quarantined.Uid == policy.Item2.Value)
                 {
                     // the UID to be quarantined already exists, do nothing
                 }
diff --git a/src/core/Akka.Remote/RemoteActorRefProvider.cs b/src/core/Akka.Remote/RemoteActorRefProvider.cs
@@ -378,9 +378,9 @@ public IInternalActorRef ActorOf(ActorSystemImpl system, Props props, IInternalA
                 .Aggregate(Deploy.None, (deploy1, deploy2) => deploy2.WithFallback(deploy1));
 
             //match for remote scope
-            if (propsDeploy.Scope is RemoteScope)
+            if (propsDeploy.Scope is RemoteScope remoteScope)
             {
-                var addr = propsDeploy.Scope.AsInstanceOf<RemoteScope>().Address;
+                var addr = remoteScope.Address;
 
                 //Even if this actor is in RemoteScope, it might still be a local address
                 if (HasAddress(addr))
diff --git a/src/core/Akka.Remote/RemoteDeployer.cs b/src/core/Akka.Remote/RemoteDeployer.cs
@@ -64,9 +64,9 @@ private static Deploy CheckRemoteRouterConfig(Deploy deploy)
             var nodes = deploy.Config.GetStringList("target.nodes", new string[] { }).Select(Address.Parse).ToList();
             if (nodes.Any() && deploy.RouterConfig != null)
             {
-                if (deploy.RouterConfig is Pool)
+                if (deploy.RouterConfig is Pool pool)
                     return
-                        deploy.WithRouterConfig(new RemoteRouterConfig(deploy.RouterConfig.AsInstanceOf<Pool>(), nodes));
+                        deploy.WithRouterConfig(new RemoteRouterConfig(pool, nodes));
                 return deploy.WithScope(scope: Deploy.NoScopeGiven);
             }
             else
diff --git a/src/core/Akka.Remote/Transport/AkkaProtocolTransport.cs b/src/core/Akka.Remote/Transport/AkkaProtocolTransport.cs
@@ -1120,11 +1120,10 @@ AssociationHandle GetHandle(ProtocolStateData data)
                         // Invalidate exposed but still unfinished promise. The underlying association disappeared, so after
                         // registration immediately signal a disassociate
                         Disassociated disassociateNotification;
-                        if (@event.Reason is Failure && @event.Reason.AsInstanceOf<Failure>().Cause is DisassociateInfo)
+                        if (@event.Reason is Failure { Cause: DisassociateInfo disassociateInfo })
                         {
                             disassociateNotification =
-                                new Disassociated(@event.Reason.AsInstanceOf<Failure>().Cause
-                                    .AsInstanceOf<DisassociateInfo>());
+                                new Disassociated(disassociateInfo);
                         }
                         else
                         {
@@ -1140,10 +1139,10 @@ AssociationHandle GetHandle(ProtocolStateData data)
                     case ListenerReady lr:
                     {
                         Disassociated disassociateNotification;
-                        if (@event.Reason is Failure failure && failure.Cause is DisassociateInfo)
+                        if (@event.Reason is Failure { Cause: DisassociateInfo disassociateInfo })
                         {
                             disassociateNotification =
-                                new Disassociated(failure.Cause.AsInstanceOf<DisassociateInfo>());
+                                new Disassociated(disassociateInfo);
                         }
                         else
                         {
diff --git a/src/core/Akka.Remote/Transport/FailureInjectorTransportAdapter.cs b/src/core/Akka.Remote/Transport/FailureInjectorTransportAdapter.cs
@@ -304,7 +304,7 @@ protected override void InterceptAssociate(Address remoteAddress, TaskCompletion
         /// <param name="ev">TBD</param>
         public void Notify(IAssociationEvent ev)
         {
-            if (ev is InboundAssociation && ShouldDropInbound(ev.AsInstanceOf<InboundAssociation>().Association.RemoteAddress, ev, "notify"))
+            if (ev is InboundAssociation inboundAssociation && ShouldDropInbound(inboundAssociation.Association.RemoteAddress, ev, "notify"))
             {
                 //ignore
             }
@@ -374,7 +374,10 @@ public bool ShouldDropOutbound(Address remoteAddress, object instance, string de
 
         private IAssociationEvent InterceptInboundAssociation(IAssociationEvent ev)
         {
-            if (ev is InboundAssociation) return new InboundAssociation(new FailureInjectorHandle(ev.AsInstanceOf<InboundAssociation>().Association, this));
+            if (ev is InboundAssociation inboundAssociation)
+            {
+                return new InboundAssociation(new FailureInjectorHandle(inboundAssociation.Association, this));
+            }
             return ev;
         }
 
diff --git a/src/core/Akka.Remote/Transport/ThrottleTransportAdapter.cs b/src/core/Akka.Remote/Transport/ThrottleTransportAdapter.cs
@@ -1115,29 +1115,28 @@ private void InitializeFSM()
         {
             When(ThrottlerState.WaitExposedHandle, @event =>
             {
-                if (@event.FsmEvent is ThrottlerManager.Handle && @event.StateData is Uninitialized)
+                if (@event is { FsmEvent: ThrottlerManager.Handle handle, StateData: Uninitialized })
                 {
                     // register to downstream layer and wait for origin
                     OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
                     return
                         GoTo(ThrottlerState.WaitOrigin)
                             .Using(
-                                new ExposedHandle(
-                                    @event.FsmEvent.AsInstanceOf<ThrottlerManager.Handle>().ThrottlerHandle));
+                                new ExposedHandle(handle.ThrottlerHandle));
                 }
                 return null;
             });
 
             When(ThrottlerState.WaitOrigin, @event =>
             {
-                if (@event.FsmEvent is InboundPayload && @event.StateData is ExposedHandle)
+                if (@event is { FsmEvent: InboundPayload payload, StateData: ExposedHandle handle })
                 {
-                    var b = @event.FsmEvent.AsInstanceOf<InboundPayload>().Payload;
+                    var b = payload.Payload;
                     ThrottledMessages.Enqueue(b);
                     var origin = PeekOrigin(b);
                     if (origin != null)
                     {
-                        Manager.Tell(new ThrottlerManager.Checkin(origin, @event.StateData.AsInstanceOf<ExposedHandle>().Handle));
+                        Manager.Tell(new ThrottlerManager.Checkin(origin, handle.Handle));
                         return GoTo(ThrottlerState.WaitMode);
                     }
                     return Stay();
@@ -1147,17 +1146,16 @@ private void InitializeFSM()
 
             When(ThrottlerState.WaitMode, @event =>
             {
-                if (@event.FsmEvent is InboundPayload)
+                if (@event.FsmEvent is InboundPayload payload)
                 {
-                    var b = @event.FsmEvent.AsInstanceOf<InboundPayload>().Payload;
+                    var b = payload.Payload;
                     ThrottledMessages.Enqueue(b);
                     return Stay();
                 }
 
-                if (@event.FsmEvent is ThrottleMode && @event.StateData is ExposedHandle)
+                if (@event is { FsmEvent: ThrottleMode mode, StateData: ExposedHandle handle })
                 {
-                    var mode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();
-                    var exposedHandle = @event.StateData.AsInstanceOf<ExposedHandle>().Handle;
+                    var exposedHandle = handle.Handle;
                     InboundThrottleMode = mode;
                     try
                     {
@@ -1191,16 +1189,15 @@ private void InitializeFSM()
 
             When(ThrottlerState.WaitUpstreamListener, @event =>
             {
-                if (@event.FsmEvent is InboundPayload)
+                if (@event.FsmEvent is InboundPayload payload)
                 {
-                    var b = @event.FsmEvent.AsInstanceOf<InboundPayload>();
-                    ThrottledMessages.Enqueue(b.Payload);
+                    ThrottledMessages.Enqueue(payload.Payload);
                     return Stay();
                 }
 
-                if (@event.FsmEvent is ThrottlerManager.Listener)
+                if (@event.FsmEvent is ThrottlerManager.Listener listener)
                 {
-                    UpstreamListener = @event.FsmEvent.AsInstanceOf<ThrottlerManager.Listener>().HandleEventListener;
+                    UpstreamListener = listener.HandleEventListener;
                     Self.Tell(new Dequeue());
                     return GoTo(ThrottlerState.Throttling);
                 }
@@ -1210,19 +1207,17 @@ private void InitializeFSM()
 
             When(ThrottlerState.WaitModeAndUpstreamListener, @event =>
             {
-                if (@event.FsmEvent is ThrottlerManager.ListenerAndMode)
+                if (@event.FsmEvent is ThrottlerManager.ListenerAndMode listenerAndMode)
                 {
-                    var listenerAndMode = @event.FsmEvent.AsInstanceOf<ThrottlerManager.ListenerAndMode>();
                     UpstreamListener = listenerAndMode.HandleEventListener;
                     InboundThrottleMode = listenerAndMode.Mode;
                     Self.Tell(new Dequeue());
                     return GoTo(ThrottlerState.Throttling);
                 }
 
-                if (@event.FsmEvent is InboundPayload)
+                if (@event.FsmEvent is InboundPayload inboundPayload)
                 {
-                    var b = @event.FsmEvent.AsInstanceOf<InboundPayload>();
-                    ThrottledMessages.Enqueue(b.Payload);
+                    ThrottledMessages.Enqueue(inboundPayload.Payload);
                     return Stay();
                 }
 
@@ -1231,9 +1226,8 @@ private void InitializeFSM()
 
             When(ThrottlerState.Throttling, @event =>
             {
-                if (@event.FsmEvent is ThrottleMode)
+                if (@event.FsmEvent is ThrottleMode mode)
                 {
-                    var mode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();
                     InboundThrottleMode = mode;
                     if (mode is Blackhole) ThrottledMessages = new Queue<ByteString>();
                     CancelTimer(DequeueTimerName);
@@ -1243,9 +1237,9 @@ private void InitializeFSM()
                     return Stay();
                 }
 
-                if (@event.FsmEvent is InboundPayload)
+                if (@event.FsmEvent is InboundPayload inboundPayload)
                 {
-                    ForwardOrDelay(@event.FsmEvent.AsInstanceOf<InboundPayload>().Payload);
+                    ForwardOrDelay(inboundPayload.Payload);
                     return Stay();
                 }
 
@@ -1269,9 +1263,9 @@ private void InitializeFSM()
             WhenUnhandled(@event =>
             {
                 // we should always set the throttling mode
-                if (@event.FsmEvent is ThrottleMode)
+                if (@event.FsmEvent is ThrottleMode mode)
                 {
-                    InboundThrottleMode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();
+                    InboundThrottleMode = mode;
                     Sender.Tell(SetThrottleAck.Instance);
                     return Stay();
                 }
@@ -1281,9 +1275,9 @@ private void InitializeFSM()
                     return Stop(); // not notifying the upstream handler is intentional: we are relying on heartbeating
                 }
 
-                if (@event.FsmEvent is FailWith)
+                if (@event.FsmEvent is FailWith failWith)
                 {
-                    var reason = @event.FsmEvent.AsInstanceOf<FailWith>().FailReason;
+                    var reason = failWith.FailReason;
                     if (UpstreamListener != null) UpstreamListener.Notify(new Disassociated(reason));
                     return Stop();
                 }
@@ -1310,9 +1304,9 @@ private Address PeekOrigin(ByteString b)
             try
             {
                 var pdu = _codec.DecodePdu(b);
-                if (pdu is Associate)
+                if (pdu is Associate associate)
                 {
-                    return pdu.AsInstanceOf<Associate>().Info.Origin;
+                    return associate.Info.Origin;
                 }
                 return null;
             }
diff --git a/src/core/Akka.Tests/Routing/RoutingSpec.cs b/src/core/Akka.Tests/Routing/RoutingSpec.cs
@@ -184,8 +184,8 @@ await AwaitConditionAsync(async () =>
 
                 var res = await ReceiveWhileAsync(100.Milliseconds(), x =>
                 {
-                    if (x is IActorRef)
-                        return x.AsInstanceOf<IActorRef>();
+                    if (x is IActorRef actorRef)
+                        return actorRef;
 
                     return null;
                 }, msgs: 2).ToListAsync();
diff --git a/src/core/Akka/Actor/FSM.cs b/src/core/Akka/Actor/FSM.cs
@@ -1332,9 +1332,9 @@ protected virtual void LogTermination(Reason reason)
         {
             if (reason is Failure failure)
             {
-                if (failure.Cause is Exception)
+                if (failure.Cause is Exception exception)
                 {
-                    _log.Error(failure.Cause.AsInstanceOf<Exception>(), "terminating due to Failure");
+                    _log.Error(exception, "terminating due to Failure");
                 }
                 else
                 {
diff --git a/src/core/Akka/Serialization/Serialization.cs b/src/core/Akka/Serialization/Serialization.cs
@@ -561,9 +561,9 @@ public static string SerializedActorPath(IActorRef actorRef)
 
             var path = actorRef.Path;
             ExtendedActorSystem originalSystem = null;
-            if (actorRef is ActorRefWithCell)
+            if (actorRef is ActorRefWithCell actorRefWithCell)
             {
-                originalSystem = actorRef.AsInstanceOf<ActorRefWithCell>().Underlying.System.AsInstanceOf<ExtendedActorSystem>();
+                originalSystem = actorRefWithCell.Underlying.System.AsInstanceOf<ExtendedActorSystem>();
             }
 
             if (CurrentTransportInformation == null)

Original file line number	Diff line number	Diff line change
`@@ -633,9 +633,9 @@ protected virtual void LogTermination(FSMBase.Reason reason)`
`633`	`633`	`{`
`634`	`634`	`if (reason is FSMBase.Failure failure)`
`635`	`635`	`{`
`636`		`- if (failure.Cause is Exception)`
	`636`	`+ if (failure.Cause is Exception exception)`
`637`	`637`	`{`
`638`		`- _log.Error(failure.Cause.AsInstanceOf<Exception>(), "terminating due to Failure");`
	`638`	`+ _log.Error(exception, "terminating due to Failure");`
`639`	`639`	`}`
`640`	`640`	`else`
`641`	`641`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1438,8 +1438,8 @@ private void EnqueueInBuffer(object message)`
`1438`	`1438`	`var send = message as EndpointManager.Send;`
`1439`	`1439`	`if (send != null && send.Message is IPriorityMessage)`
`1440`	`1440`	`_prioBuffer.AddLast(send);`
`1441`		`- else if (send != null && send.Message is ActorSelectionMessage &&`
`1442`		`- send.Message.AsInstanceOf<ActorSelectionMessage>().Message is IPriorityMessage)`
	`1441`	`+ else if (send != null && send.Message is ActorSelectionMessage actorSelectionMessage &&`
	`1442`	`+ actorSelectionMessage.Message is IPriorityMessage)`
`1443`	`1443`	`{`
`1444`	`1444`	`_prioBuffer.AddLast(send);`
`1445`	`1445`	`}`
Original file line number	Diff line number	Diff line change
`@@ -755,7 +755,7 @@ protected void Accepting()`
`755`	`755`	`//the quarantine uid has lost the race with some failure, do nothing`
`756`	`756`	`}`
`757`	`757`	`}`
`758`		`- else if (policy.Item1 is Quarantined && policy.Item2 != null && policy.Item1.AsInstanceOf<Quarantined>().Uid == policy.Item2.Value)`
	`758`	`+ else if (policy.Item1 is Quarantined quarantined && policy.Item2 != null && quarantined.Uid == policy.Item2.Value)`
`759`	`759`	`{`
`760`	`760`	`// the UID to be quarantined already exists, do nothing`
`761`	`761`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,9 +64,9 @@ private static Deploy CheckRemoteRouterConfig(Deploy deploy)`
`64`	`64`	`var nodes = deploy.Config.GetStringList("target.nodes", new string[] { }).Select(Address.Parse).ToList();`
`65`	`65`	`if (nodes.Any() && deploy.RouterConfig != null)`
`66`	`66`	`{`
`67`		`- if (deploy.RouterConfig is Pool)`
	`67`	`+ if (deploy.RouterConfig is Pool pool)`
`68`	`68`	`return`
`69`		`- deploy.WithRouterConfig(new RemoteRouterConfig(deploy.RouterConfig.AsInstanceOf<Pool>(), nodes));`
	`69`	`+ deploy.WithRouterConfig(new RemoteRouterConfig(pool, nodes));`
`70`	`70`	`return deploy.WithScope(scope: Deploy.NoScopeGiven);`
`71`	`71`	`}`
`72`	`72`	`else`
Original file line number	Diff line number	Diff line change
`@@ -1120,11 +1120,10 @@ AssociationHandle GetHandle(ProtocolStateData data)`
`1120`	`1120`	`// Invalidate exposed but still unfinished promise. The underlying association disappeared, so after`
`1121`	`1121`	`// registration immediately signal a disassociate`
`1122`	`1122`	`Disassociated disassociateNotification;`
`1123`		`- if (@event.Reason is Failure && @event.Reason.AsInstanceOf<Failure>().Cause is DisassociateInfo)`
	`1123`	`+ if (@event.Reason is Failure { Cause: DisassociateInfo disassociateInfo })`
`1124`	`1124`	`{`
`1125`	`1125`	`disassociateNotification =`
`1126`		`- new Disassociated(@event.Reason.AsInstanceOf<Failure>().Cause`
`1127`		`- .AsInstanceOf<DisassociateInfo>());`
	`1126`	`+ new Disassociated(disassociateInfo);`
`1128`	`1127`	`}`
`1129`	`1128`	`else`
`1130`	`1129`	`{`
`@@ -1140,10 +1139,10 @@ AssociationHandle GetHandle(ProtocolStateData data)`
`1140`	`1139`	`case ListenerReady lr:`
`1141`	`1140`	`{`
`1142`	`1141`	`Disassociated disassociateNotification;`
`1143`		`- if (@event.Reason is Failure failure && failure.Cause is DisassociateInfo)`
	`1142`	`+ if (@event.Reason is Failure { Cause: DisassociateInfo disassociateInfo })`
`1144`	`1143`	`{`
`1145`	`1144`	`disassociateNotification =`
`1146`		`- new Disassociated(failure.Cause.AsInstanceOf<DisassociateInfo>());`
	`1145`	`+ new Disassociated(disassociateInfo);`
`1147`	`1146`	`}`
`1148`	`1147`	`else`
`1149`	`1148`	`{`
Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ protected override void InterceptAssociate(Address remoteAddress, TaskCompletion`
`304`	`304`	`/// <param name="ev">TBD</param>`
`305`	`305`	`public void Notify(IAssociationEvent ev)`
`306`	`306`	`{`
`307`		`- if (ev is InboundAssociation && ShouldDropInbound(ev.AsInstanceOf<InboundAssociation>().Association.RemoteAddress, ev, "notify"))`
	`307`	`+ if (ev is InboundAssociation inboundAssociation && ShouldDropInbound(inboundAssociation.Association.RemoteAddress, ev, "notify"))`
`308`	`308`	`{`
`309`	`309`	`//ignore`
`310`	`310`	`}`
`@@ -374,7 +374,10 @@ public bool ShouldDropOutbound(Address remoteAddress, object instance, string de`
`374`	`374`
`375`	`375`	`private IAssociationEvent InterceptInboundAssociation(IAssociationEvent ev)`
`376`	`376`	`{`
`377`		`- if (ev is InboundAssociation) return new InboundAssociation(new FailureInjectorHandle(ev.AsInstanceOf<InboundAssociation>().Association, this));`
	`377`	`+ if (ev is InboundAssociation inboundAssociation)`
	`378`	`+ {`
	`379`	`+ return new InboundAssociation(new FailureInjectorHandle(inboundAssociation.Association, this));`
	`380`	`+ }`
`378`	`381`	`return ev;`
`379`	`382`	`}`
`380`	`383`
Original file line number	Diff line number	Diff line change
`@@ -1115,29 +1115,28 @@ private void InitializeFSM()`
`1115`	`1115`	`{`
`1116`	`1116`	`When(ThrottlerState.WaitExposedHandle, @event =>`
`1117`	`1117`	`{`
`1118`		`- if (@event.FsmEvent is ThrottlerManager.Handle && @event.StateData is Uninitialized)`
	`1118`	`+ if (@event is { FsmEvent: ThrottlerManager.Handle handle, StateData: Uninitialized })`
`1119`	`1119`	`{`
`1120`	`1120`	`// register to downstream layer and wait for origin`
`1121`	`1121`	`OriginalHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));`
`1122`	`1122`	`return`
`1123`	`1123`	`GoTo(ThrottlerState.WaitOrigin)`
`1124`	`1124`	`.Using(`
`1125`		`- new ExposedHandle(`
`1126`		`- @event.FsmEvent.AsInstanceOf<ThrottlerManager.Handle>().ThrottlerHandle));`
	`1125`	`+ new ExposedHandle(handle.ThrottlerHandle));`
`1127`	`1126`	`}`
`1128`	`1127`	`return null;`
`1129`	`1128`	`});`
`1130`	`1129`
`1131`	`1130`	`When(ThrottlerState.WaitOrigin, @event =>`
`1132`	`1131`	`{`
`1133`		`- if (@event.FsmEvent is InboundPayload && @event.StateData is ExposedHandle)`
	`1132`	`+ if (@event is { FsmEvent: InboundPayload payload, StateData: ExposedHandle handle })`
`1134`	`1133`	`{`
`1135`		`- var b = @event.FsmEvent.AsInstanceOf<InboundPayload>().Payload;`
	`1134`	`+ var b = payload.Payload;`
`1136`	`1135`	`ThrottledMessages.Enqueue(b);`
`1137`	`1136`	`var origin = PeekOrigin(b);`
`1138`	`1137`	`if (origin != null)`
`1139`	`1138`	`{`
`1140`		`- Manager.Tell(new ThrottlerManager.Checkin(origin, @event.StateData.AsInstanceOf<ExposedHandle>().Handle));`
	`1139`	`+ Manager.Tell(new ThrottlerManager.Checkin(origin, handle.Handle));`
`1141`	`1140`	`return GoTo(ThrottlerState.WaitMode);`
`1142`	`1141`	`}`
`1143`	`1142`	`return Stay();`
`@@ -1147,17 +1146,16 @@ private void InitializeFSM()`
`1147`	`1146`
`1148`	`1147`	`When(ThrottlerState.WaitMode, @event =>`
`1149`	`1148`	`{`
`1150`		`- if (@event.FsmEvent is InboundPayload)`
	`1149`	`+ if (@event.FsmEvent is InboundPayload payload)`
`1151`	`1150`	`{`
`1152`		`- var b = @event.FsmEvent.AsInstanceOf<InboundPayload>().Payload;`
	`1151`	`+ var b = payload.Payload;`
`1153`	`1152`	`ThrottledMessages.Enqueue(b);`
`1154`	`1153`	`return Stay();`
`1155`	`1154`	`}`
`1156`	`1155`
`1157`		`- if (@event.FsmEvent is ThrottleMode && @event.StateData is ExposedHandle)`
	`1156`	`+ if (@event is { FsmEvent: ThrottleMode mode, StateData: ExposedHandle handle })`
`1158`	`1157`	`{`
`1159`		`- var mode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();`
`1160`		`- var exposedHandle = @event.StateData.AsInstanceOf<ExposedHandle>().Handle;`
	`1158`	`+ var exposedHandle = handle.Handle;`
`1161`	`1159`	`InboundThrottleMode = mode;`
`1162`	`1160`	`try`
`1163`	`1161`	`{`
`@@ -1191,16 +1189,15 @@ private void InitializeFSM()`
`1191`	`1189`
`1192`	`1190`	`When(ThrottlerState.WaitUpstreamListener, @event =>`
`1193`	`1191`	`{`
`1194`		`- if (@event.FsmEvent is InboundPayload)`
	`1192`	`+ if (@event.FsmEvent is InboundPayload payload)`
`1195`	`1193`	`{`
`1196`		`- var b = @event.FsmEvent.AsInstanceOf<InboundPayload>();`
`1197`		`- ThrottledMessages.Enqueue(b.Payload);`
	`1194`	`+ ThrottledMessages.Enqueue(payload.Payload);`
`1198`	`1195`	`return Stay();`
`1199`	`1196`	`}`
`1200`	`1197`
`1201`		`- if (@event.FsmEvent is ThrottlerManager.Listener)`
	`1198`	`+ if (@event.FsmEvent is ThrottlerManager.Listener listener)`
`1202`	`1199`	`{`
`1203`		`- UpstreamListener = @event.FsmEvent.AsInstanceOf<ThrottlerManager.Listener>().HandleEventListener;`
	`1200`	`+ UpstreamListener = listener.HandleEventListener;`
`1204`	`1201`	`Self.Tell(new Dequeue());`
`1205`	`1202`	`return GoTo(ThrottlerState.Throttling);`
`1206`	`1203`	`}`
`@@ -1210,19 +1207,17 @@ private void InitializeFSM()`
`1210`	`1207`
`1211`	`1208`	`When(ThrottlerState.WaitModeAndUpstreamListener, @event =>`
`1212`	`1209`	`{`
`1213`		`- if (@event.FsmEvent is ThrottlerManager.ListenerAndMode)`
	`1210`	`+ if (@event.FsmEvent is ThrottlerManager.ListenerAndMode listenerAndMode)`
`1214`	`1211`	`{`
`1215`		`- var listenerAndMode = @event.FsmEvent.AsInstanceOf<ThrottlerManager.ListenerAndMode>();`
`1216`	`1212`	`UpstreamListener = listenerAndMode.HandleEventListener;`
`1217`	`1213`	`InboundThrottleMode = listenerAndMode.Mode;`
`1218`	`1214`	`Self.Tell(new Dequeue());`
`1219`	`1215`	`return GoTo(ThrottlerState.Throttling);`
`1220`	`1216`	`}`
`1221`	`1217`
`1222`		`- if (@event.FsmEvent is InboundPayload)`
	`1218`	`+ if (@event.FsmEvent is InboundPayload inboundPayload)`
`1223`	`1219`	`{`
`1224`		`- var b = @event.FsmEvent.AsInstanceOf<InboundPayload>();`
`1225`		`- ThrottledMessages.Enqueue(b.Payload);`
	`1220`	`+ ThrottledMessages.Enqueue(inboundPayload.Payload);`
`1226`	`1221`	`return Stay();`
`1227`	`1222`	`}`
`1228`	`1223`
`@@ -1231,9 +1226,8 @@ private void InitializeFSM()`
`1231`	`1226`
`1232`	`1227`	`When(ThrottlerState.Throttling, @event =>`
`1233`	`1228`	`{`
`1234`		`- if (@event.FsmEvent is ThrottleMode)`
	`1229`	`+ if (@event.FsmEvent is ThrottleMode mode)`
`1235`	`1230`	`{`
`1236`		`- var mode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();`
`1237`	`1231`	`InboundThrottleMode = mode;`
`1238`	`1232`	`if (mode is Blackhole) ThrottledMessages = new Queue<ByteString>();`
`1239`	`1233`	`CancelTimer(DequeueTimerName);`
`@@ -1243,9 +1237,9 @@ private void InitializeFSM()`
`1243`	`1237`	`return Stay();`
`1244`	`1238`	`}`
`1245`	`1239`
`1246`		`- if (@event.FsmEvent is InboundPayload)`
	`1240`	`+ if (@event.FsmEvent is InboundPayload inboundPayload)`
`1247`	`1241`	`{`
`1248`		`- ForwardOrDelay(@event.FsmEvent.AsInstanceOf<InboundPayload>().Payload);`
	`1242`	`+ ForwardOrDelay(inboundPayload.Payload);`
`1249`	`1243`	`return Stay();`
`1250`	`1244`	`}`
`1251`	`1245`
`@@ -1269,9 +1263,9 @@ private void InitializeFSM()`
`1269`	`1263`	`WhenUnhandled(@event =>`
`1270`	`1264`	`{`
`1271`	`1265`	`// we should always set the throttling mode`
`1272`		`- if (@event.FsmEvent is ThrottleMode)`
	`1266`	`+ if (@event.FsmEvent is ThrottleMode mode)`
`1273`	`1267`	`{`
`1274`		`- InboundThrottleMode = @event.FsmEvent.AsInstanceOf<ThrottleMode>();`
	`1268`	`+ InboundThrottleMode = mode;`
`1275`	`1269`	`Sender.Tell(SetThrottleAck.Instance);`
`1276`	`1270`	`return Stay();`
`1277`	`1271`	`}`
`@@ -1281,9 +1275,9 @@ private void InitializeFSM()`
`1281`	`1275`	`return Stop(); // not notifying the upstream handler is intentional: we are relying on heartbeating`
`1282`	`1276`	`}`
`1283`	`1277`
`1284`		`- if (@event.FsmEvent is FailWith)`
	`1278`	`+ if (@event.FsmEvent is FailWith failWith)`
`1285`	`1279`	`{`
`1286`		`- var reason = @event.FsmEvent.AsInstanceOf<FailWith>().FailReason;`
	`1280`	`+ var reason = failWith.FailReason;`
`1287`	`1281`	`if (UpstreamListener != null) UpstreamListener.Notify(new Disassociated(reason));`
`1288`	`1282`	`return Stop();`
`1289`	`1283`	`}`
`@@ -1310,9 +1304,9 @@ private Address PeekOrigin(ByteString b)`
`1310`	`1304`	`try`
`1311`	`1305`	`{`
`1312`	`1306`	`var pdu = _codec.DecodePdu(b);`
`1313`		`- if (pdu is Associate)`
	`1307`	`+ if (pdu is Associate associate)`
`1314`	`1308`	`{`
`1315`		`- return pdu.AsInstanceOf<Associate>().Info.Origin;`
	`1309`	`+ return associate.Info.Origin;`
`1316`	`1310`	`}`
`1317`	`1311`	`return null;`
`1318`	`1312`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,8 +184,8 @@ await AwaitConditionAsync(async () =>`
`184`	`184`
`185`	`185`	`var res = await ReceiveWhileAsync(100.Milliseconds(), x =>`
`186`	`186`	`{`
`187`		`- if (x is IActorRef)`
`188`		`- return x.AsInstanceOf<IActorRef>();`
	`187`	`+ if (x is IActorRef actorRef)`
	`188`	`+ return actorRef;`
`189`	`189`
`190`	`190`	`return null;`
`191`	`191`	`}, msgs: 2).ToListAsync();`
Original file line number	Diff line number	Diff line change
`@@ -1332,9 +1332,9 @@ protected virtual void LogTermination(Reason reason)`
`1332`	`1332`	`{`
`1333`	`1333`	`if (reason is Failure failure)`
`1334`	`1334`	`{`
`1335`		`- if (failure.Cause is Exception)`
	`1335`	`+ if (failure.Cause is Exception exception)`
`1336`	`1336`	`{`
`1337`		`- _log.Error(failure.Cause.AsInstanceOf<Exception>(), "terminating due to Failure");`
	`1337`	`+ _log.Error(exception, "terminating due to Failure");`
`1338`	`1338`	`}`
`1339`	`1339`	`else`
`1340`	`1340`	`{`
Original file line number	Diff line number	Diff line change
`@@ -561,9 +561,9 @@ public static string SerializedActorPath(IActorRef actorRef)`
`561`	`561`
`562`	`562`	`var path = actorRef.Path;`
`563`	`563`	`ExtendedActorSystem originalSystem = null;`
`564`		`- if (actorRef is ActorRefWithCell)`
	`564`	`+ if (actorRef is ActorRefWithCell actorRefWithCell)`
`565`	`565`	`{`
`566`		`- originalSystem = actorRef.AsInstanceOf<ActorRefWithCell>().Underlying.System.AsInstanceOf<ExtendedActorSystem>();`
	`566`	`+ originalSystem = actorRefWithCell.Underlying.System.AsInstanceOf<ExtendedActorSystem>();`
`567`	`567`	`}`
`568`	`568`
`569`	`569`	`if (CurrentTransportInformation == null)`