com.unity.netcode.gameobjects@1.5.1

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.5.1] - 2023-06-07

### Added

- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
- The location of the automatically-created default network prefab list can now be configured (#2544)
- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)

### Fixed

- Fixed: Fixed a null reference in codegen in some projects (#2581)
- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)

## Changed

- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)

CHANGELOG.md

@@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
+## [1.5.1] - 2023-06-07
+
+### Added
+
+- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
+- The location of the automatically-created default network prefab list can now be configured (#2544)
+- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
+- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)
+
+### Fixed
+
+- Fixed: Fixed a null reference in codegen in some projects (#2581)
+- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
+- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
+- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
+- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
+- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
+- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
+- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
+- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
+- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
+- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
+- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
+- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
+- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
+- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
+- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
+- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)
+
+## Changed
+
+- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
+- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
+- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
+
 ## [1.4.0] - 2023-04-10
 
 ### Added

Components/NetworkTransform.cs

@@ -2392,16 +2392,6 @@ namespace Unity.Netcode.Components
             m_CachedNetworkManager = NetworkManager;
 
             Initialize();
-            // This assures the initial spawning of the object synchronizes all connected clients
-            // with the current transform values. This should not be placed within Initialize since
-            // that can be invoked when ownership changes.
-            if (CanCommitToTransform)
-            {
-                var currentPosition = GetSpaceRelativePosition();
-                var currentRotation = GetSpaceRelativeRotation();
-                // Teleport to current position
-                SetStateInternal(currentPosition, currentRotation, transform.localScale, true);
-            }
         }
 
         /// <inheritdoc/>
@@ -2472,6 +2462,7 @@ namespace Unity.Netcode.Components
             CanCommitToTransform = IsServerAuthoritative() ? IsServer : IsOwner;
             var replicatedState = ReplicatedNetworkState;
             var currentPosition = GetSpaceRelativePosition();
+            var currentRotation = GetSpaceRelativeRotation();
 
             if (CanCommitToTransform)
             {
@@ -2483,6 +2474,9 @@ namespace Unity.Netcode.Components
                 // Authority only updates once per network tick
                 NetworkManager.NetworkTickSystem.Tick -= NetworkTickSystem_Tick;
                 NetworkManager.NetworkTickSystem.Tick += NetworkTickSystem_Tick;
+
+                // Teleport to current position
+                SetStateInternal(currentPosition, currentRotation, transform.localScale, true);
             }
             else
             {
@@ -2494,15 +2488,42 @@ namespace Unity.Netcode.Components
                 NetworkManager.NetworkTickSystem.Tick -= NetworkTickSystem_Tick;
 
                 ResetInterpolatedStateToCurrentAuthoritativeState();
-                m_CurrentPosition = GetSpaceRelativePosition();
+                m_CurrentPosition = currentPosition;
                 m_CurrentScale = transform.localScale;
-                m_CurrentRotation = GetSpaceRelativeRotation();
+                m_CurrentRotation = currentRotation;
 
             }
 
             OnInitialize(ref replicatedState);
         }
 
+        /// <inheritdoc/>
+        /// <remarks>
+        /// When a parent changes, non-authoritative instances should:
+        /// - Apply the resultant position, rotation, and scale from the parenting action.
+        /// - Clear interpolators (even if not enabled on this frame)
+        /// - Reset the interpolators to the position, rotation, and scale resultant values.
+        /// This prevents interpolation visual anomalies and issues during initial synchronization
+        /// </remarks>
+        public override void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
+        {
+            // Only if we are not authority
+            if (!CanCommitToTransform)
+            {
+                m_CurrentPosition = GetSpaceRelativePosition();
+                m_CurrentRotation = GetSpaceRelativeRotation();
+                m_CurrentScale = GetScale();
+                m_ScaleInterpolator.Clear();
+                m_PositionInterpolator.Clear();
+                m_RotationInterpolator.Clear();
+                var tempTime = new NetworkTime(NetworkManager.NetworkConfig.TickRate, NetworkManager.ServerTime.Tick).Time;
+                UpdatePositionInterpolator(m_CurrentPosition, tempTime, true);
+                m_ScaleInterpolator.ResetTo(m_CurrentScale, tempTime);
+                m_RotationInterpolator.ResetTo(m_CurrentRotation, tempTime);
+            }
+            base.OnNetworkObjectParentChanged(parentNetworkObject);
+        }
+
         /// <summary>
         /// Directly sets a state on the authoritative transform.
         /// Owner clients can directly set the state on a server authoritative transform
@@ -2656,6 +2677,12 @@ namespace Unity.Netcode.Components
                 }
             }
 
+            // If we have not received any additional state updates since the very
+            // initial synchronization, then exit early.
+            if (m_LocalAuthoritativeNetworkState.IsSynchronizing)
+            {
+                return;
+            }
             // Apply the current authoritative state
             ApplyAuthoritativeState();
         }

Documentation~/index.md

@@ -7,8 +7,8 @@ Netcode for GameObjects is a Unity package that provides networking capabilities
 See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
 
 - [Documentation](https://docs-multiplayer.unity3d.com/netcode/current/about)
-- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/migration/install)
-- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/helloworld/helloworldintro)
+- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/installation)
+- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/get-started-ngo)
 - [API Reference](https://docs-multiplayer.unity3d.com/netcode/current/api/introduction)
 
 # Technical details
@@ -32,4 +32,4 @@ On the following runtime platforms:
 |June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
 |August 5, 2021|Update product/package name|
 |September 9,2021|Updated the links and name of the file.|
-|April 20, 2022|Updated links|
+|April 20, 2022|Updated links|

Editor/CodeGen/CodeGenHelpers.cs

@@ -10,6 +10,7 @@ using Unity.Collections;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
+using Object = System.Object;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
@@ -112,6 +113,60 @@ namespace Unity.Netcode.Editor.CodeGen
 
             return name;
         }
+        public static TypeReference MakeGenericType(this TypeReference self, params TypeReference[] arguments)
+        {
+            if (self.GenericParameters.Count != arguments.Length)
+            {
+                throw new ArgumentException();
+            }
+
+            var instance = new GenericInstanceType(self);
+            foreach (var argument in arguments)
+            {
+                instance.GenericArguments.Add(argument);
+            }
+
+            return instance;
+        }
+
+        public static MethodReference MakeGeneric(this MethodReference self, params TypeReference[] arguments)
+        {
+            var reference = new MethodReference(self.Name, self.ReturnType)
+            {
+                DeclaringType = self.DeclaringType.MakeGenericType(arguments),
+                HasThis = self.HasThis,
+                ExplicitThis = self.ExplicitThis,
+                CallingConvention = self.CallingConvention,
+            };
+
+            foreach (var parameter in self.Parameters)
+            {
+                reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
+            }
+
+            foreach (var generic_parameter in self.GenericParameters)
+            {
+                reference.GenericParameters.Add(new GenericParameter(generic_parameter.Name, reference));
+            }
+
+            return reference;
+        }
+
+        public static bool IsSubclassOf(this TypeReference typeReference, TypeReference baseClass)
+        {
+            var type = typeReference.Resolve();
+            if (type?.BaseType == null || type.BaseType.Name == nameof(Object))
+            {
+                return false;
+            }
+
+            if (type.BaseType.Resolve() == baseClass.Resolve())
+            {
+                return true;
+            }
+
+            return type.BaseType.IsSubclassOf(baseClass);
+        }
 
         public static bool HasInterface(this TypeReference typeReference, string interfaceTypeFullName)
         {

Editor/CodeGen/INetworkMessageILPP.cs

@@ -101,31 +101,28 @@ namespace Unity.Netcode.Editor.CodeGen
         private ModuleDefinition m_NetcodeModule;
         private PostProcessorAssemblyResolver m_AssemblyResolver;
 
-        private MethodReference m_MessagingSystem_ReceiveMessage_MethodRef;
-        private MethodReference m_MessagingSystem_CreateMessageAndGetVersion_MethodRef;
-        private TypeReference m_MessagingSystem_MessageWithHandler_TypeRef;
-        private MethodReference m_MessagingSystem_MessageHandler_Constructor_TypeRef;
-        private MethodReference m_MessagingSystem_VersionGetter_Constructor_TypeRef;
+        private MethodReference m_MessageManager_ReceiveMessage_MethodRef;
+        private MethodReference m_MessageManager_CreateMessageAndGetVersion_MethodRef;
+        private TypeReference m_MessageManager_MessageWithHandler_TypeRef;
+        private MethodReference m_MessageManager_MessageHandler_Constructor_TypeRef;
+        private MethodReference m_MessageManager_VersionGetter_Constructor_TypeRef;
         private FieldReference m_ILPPMessageProvider___network_message_types_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_MessageType_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_Handler_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_MessageType_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_Handler_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_GetVersion_FieldRef;
         private MethodReference m_Type_GetTypeFromHandle_MethodRef;
         private MethodReference m_List_Add_MethodRef;
 
-        private const string k_ReceiveMessageName = nameof(MessagingSystem.ReceiveMessage);
-        private const string k_CreateMessageAndGetVersionName = nameof(MessagingSystem.CreateMessageAndGetVersion);
+        private const string k_ReceiveMessageName = nameof(NetworkMessageManager.ReceiveMessage);
+        private const string k_CreateMessageAndGetVersionName = nameof(NetworkMessageManager.CreateMessageAndGetVersion);
 
         private bool ImportReferences(ModuleDefinition moduleDefinition)
         {
             // Different environments seem to have different situations...
-            // Some have these definitions in netstandard.dll...
-            // some seem to have them elsewhere...
-            // Since they're standard .net classes they're not going to cause
-            // the same issues as referencing other assemblies, in theory, since
-            // the definitions should be standard and consistent across platforms
-            // (i.e., there's no #if UNITY_EDITOR in them that could create
-            // invalid IL code)
+            // Some have these definitions in netstandard.dll, some seem to have them elsewhere...
+            // Since they're standard .net classes they're not going to cause the same issues as referencing other assemblies,
+            // in theory, since the definitions should be standard and consistent across platforms
+            // (i.e., there's no #if UNITY_EDITOR in them that could create invalid IL code)
             TypeDefinition typeTypeDef = moduleDefinition.ImportReference(typeof(Type)).Resolve();
             TypeDefinition listTypeDef = moduleDefinition.ImportReference(typeof(List<>)).Resolve();
 
@@ -133,22 +130,22 @@ namespace Unity.Netcode.Editor.CodeGen
             TypeDefinition versionGetterTypeDef = null;
             TypeDefinition messageWithHandlerTypeDef = null;
             TypeDefinition ilppMessageProviderTypeDef = null;
-            TypeDefinition messagingSystemTypeDef = null;
+            TypeDefinition messageManagerSystemTypeDef = null;
             foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
             {
-                if (messageHandlerTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.MessageHandler))
+                if (messageHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageHandler))
                 {
                     messageHandlerTypeDef = netcodeTypeDef;
                     continue;
                 }
 
-                if (versionGetterTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.VersionGetter))
+                if (versionGetterTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.VersionGetter))
                 {
                     versionGetterTypeDef = netcodeTypeDef;
                     continue;
                 }
 
-                if (messageWithHandlerTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem.MessageWithHandler))
+                if (messageWithHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageWithHandler))
                 {
                     messageWithHandlerTypeDef = netcodeTypeDef;
                     continue;
@@ -160,29 +157,29 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
-                if (messagingSystemTypeDef == null && netcodeTypeDef.Name == nameof(MessagingSystem))
+                if (messageManagerSystemTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager))
                 {
-                    messagingSystemTypeDef = netcodeTypeDef;
+                    messageManagerSystemTypeDef = netcodeTypeDef;
                     continue;
                 }
             }
 
-            m_MessagingSystem_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(messageHandlerTypeDef.GetConstructors().First());
-            m_MessagingSystem_VersionGetter_Constructor_TypeRef = moduleDefinition.ImportReference(versionGetterTypeDef.GetConstructors().First());
+            m_MessageManager_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(messageHandlerTypeDef.GetConstructors().First());
+            m_MessageManager_VersionGetter_Constructor_TypeRef = moduleDefinition.ImportReference(versionGetterTypeDef.GetConstructors().First());
 
-            m_MessagingSystem_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerTypeDef);
+            m_MessageManager_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerTypeDef);
             foreach (var fieldDef in messageWithHandlerTypeDef.Fields)
             {
                 switch (fieldDef.Name)
                 {
-                    case nameof(MessagingSystem.MessageWithHandler.MessageType):
-                        m_MessagingSystem_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.MessageType):
+                        m_MessageManager_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
-                    case nameof(MessagingSystem.MessageWithHandler.Handler):
-                        m_MessagingSystem_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.Handler):
+                        m_MessageManager_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
-                    case nameof(MessagingSystem.MessageWithHandler.GetVersion):
-                        m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                    case nameof(NetworkMessageManager.MessageWithHandler.GetVersion):
+                        m_MessageManager_MessageWithHandler_GetVersion_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
                 }
             }
@@ -219,15 +216,15 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
             }
 
-            foreach (var methodDef in messagingSystemTypeDef.Methods)
+            foreach (var methodDef in messageManagerSystemTypeDef.Methods)
             {
                 switch (methodDef.Name)
                 {
                     case k_ReceiveMessageName:
-                        m_MessagingSystem_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        m_MessageManager_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
                     case k_CreateMessageAndGetVersionName:
-                        m_MessagingSystem_CreateMessageAndGetVersion_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        m_MessageManager_CreateMessageAndGetVersion_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
                 }
             }
@@ -256,27 +253,27 @@ namespace Unity.Netcode.Editor.CodeGen
 
         private void CreateInstructionsToRegisterType(ILProcessor processor, List<Instruction> instructions, TypeReference type, MethodReference receiveMethod, MethodReference versionMethod)
         {
-            // MessagingSystem.__network_message_types.Add(new MessagingSystem.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
-            processor.Body.Variables.Add(new VariableDefinition(m_MessagingSystem_MessageWithHandler_TypeRef));
+            // NetworkMessageManager.__network_message_types.Add(new NetworkMessageManager.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
+            processor.Body.Variables.Add(new VariableDefinition(m_MessageManager_MessageWithHandler_TypeRef));
             int messageWithHandlerLocIdx = processor.Body.Variables.Count - 1;
 
             instructions.Add(processor.Create(OpCodes.Ldsfld, m_ILPPMessageProvider___network_message_types_FieldRef));
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
-            instructions.Add(processor.Create(OpCodes.Initobj, m_MessagingSystem_MessageWithHandler_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Initobj, m_MessageManager_MessageWithHandler_TypeRef));
 
             // tmp.MessageType = typeof(type);
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldtoken, type));
             instructions.Add(processor.Create(OpCodes.Call, m_Type_GetTypeFromHandle_MethodRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_MessageType_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_MessageType_FieldRef));
 
             // tmp.Handler = MessageHandler.ReceveMessage<type>
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldnull));
 
             instructions.Add(processor.Create(OpCodes.Ldftn, receiveMethod));
-            instructions.Add(processor.Create(OpCodes.Newobj, m_MessagingSystem_MessageHandler_Constructor_TypeRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_Handler_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_MessageHandler_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_Handler_FieldRef));
 
 
             // tmp.GetVersion = MessageHandler.CreateMessageAndGetVersion<type>
@@ -284,15 +281,15 @@ namespace Unity.Netcode.Editor.CodeGen
             instructions.Add(processor.Create(OpCodes.Ldnull));
 
             instructions.Add(processor.Create(OpCodes.Ldftn, versionMethod));
-            instructions.Add(processor.Create(OpCodes.Newobj, m_MessagingSystem_VersionGetter_Constructor_TypeRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_GetVersion_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_VersionGetter_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_GetVersion_FieldRef));
 
             // ILPPMessageProvider.__network_message_types.Add(tmp);
             instructions.Add(processor.Create(OpCodes.Ldloc, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Callvirt, m_List_Add_MethodRef));
         }
 
-        // Creates a static module constructor (which is executed when the module is loaded) that registers all the message types in the assembly with MessagingSystem.
+        // Creates a static module constructor (which is executed when the module is loaded) that registers all the message types in the assembly with NetworkMessageManager.
         // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized C# (that attribute doesn't exist in Unity, but the static module constructor still works).
         // https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0
         // https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
@@ -310,9 +307,9 @@ namespace Unity.Netcode.Editor.CodeGen
 
                     foreach (var type in networkMessageTypes)
                     {
-                        var receiveMethod = new GenericInstanceMethod(m_MessagingSystem_ReceiveMessage_MethodRef);
+                        var receiveMethod = new GenericInstanceMethod(m_MessageManager_ReceiveMessage_MethodRef);
                         receiveMethod.GenericArguments.Add(type);
-                        var versionMethod = new GenericInstanceMethod(m_MessagingSystem_CreateMessageAndGetVersion_MethodRef);
+                        var versionMethod = new GenericInstanceMethod(m_MessageManager_CreateMessageAndGetVersion_MethodRef);
                         versionMethod.GenericArguments.Add(type);
                         CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
                     }

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -18,6 +18,8 @@ namespace Unity.Netcode.Editor.CodeGen
     internal sealed class NetworkBehaviourILPP : ILPPInterface
     {
         private const string k_ReadValueMethodName = nameof(FastBufferReader.ReadValueSafe);
+        private const string k_ReadValueInPlaceMethodName = nameof(FastBufferReader.ReadValueSafeInPlace);
+        private const string k_ReadValueTempMethodName = nameof(FastBufferReader.ReadValueSafeTemp);
         private const string k_WriteValueMethodName = nameof(FastBufferWriter.WriteValueSafe);
 
         public override ILPPInterface GetInstance() => this;
@@ -166,6 +168,11 @@ namespace Unity.Netcode.Editor.CodeGen
 
                     foreach (var type in m_WrappedNetworkVariableTypes)
                     {
+                        if (type.Resolve() == null)
+                        {
+                            continue;
+                        }
+
                         if (IsSpecialCaseType(type))
                         {
                             continue;
@@ -177,7 +184,72 @@ namespace Unity.Netcode.Editor.CodeGen
                         GenericInstanceMethod serializeMethod = null;
                         GenericInstanceMethod equalityMethod;
 
-                        if (type.IsValueType)
+
+                        if (type.Resolve().FullName == "Unity.Collections.NativeArray`1")
+                        {
+                            var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
+                            if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef);
+                            }
+                            else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef);
+                            }
+                            else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef);
+                            }
+
+                            if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
+                            {
+                                equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef);
+                            }
+                            else
+                            {
+                                equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef);
+                            }
+
+                            if (serializeMethod != null)
+                            {
+                                serializeMethod.GenericArguments.Add(wrappedType);
+                            }
+                            equalityMethod.GenericArguments.Add(wrappedType);
+                        }
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                        else if (type.Resolve().FullName == "Unity.Collections.NativeList`1")
+                        {
+                            var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
+                            if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef);
+                            }
+                            else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef);
+                            }
+                            else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
+                            {
+                                serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef);
+                            }
+
+                            if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
+                            {
+                                equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef);
+                            }
+                            else
+                            {
+                                equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef);
+                            }
+
+                            if (serializeMethod != null)
+                            {
+                                serializeMethod.GenericArguments.Add(wrappedType);
+                            }
+                            equalityMethod.GenericArguments.Add(wrappedType);
+                        }
+#endif
+                        else if (type.IsValueType)
                         {
                             if (type.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || type.Resolve().IsEnum || IsMemcpyableType(type))
                             {
@@ -200,11 +272,32 @@ namespace Unity.Netcode.Editor.CodeGen
                             {
                                 equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef);
                             }
+
+                            if (serializeMethod != null)
+                            {
+                                serializeMethod.GenericArguments.Add(type);
+                            }
+                            equalityMethod.GenericArguments.Add(type);
                         }
                         else
                         {
                             if (type.HasInterface(typeof(INetworkSerializable).FullName))
                             {
+                                var constructors = type.Resolve().GetConstructors();
+                                var hasEmptyConstructor = false;
+                                foreach (var constructor in constructors)
+                                {
+                                    if (constructor.Parameters.Count == 0)
+                                    {
+                                        hasEmptyConstructor = true;
+                                    }
+                                }
+
+                                if (!hasEmptyConstructor)
+                                {
+                                    m_Diagnostics.AddError($"{type} cannot be used in a network variable - Managed {nameof(INetworkSerializable)} instances must meet the `new()` (default empty constructor) constraint.");
+                                    continue;
+                                }
                                 serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef);
                             }
 
@@ -216,14 +309,18 @@ namespace Unity.Netcode.Editor.CodeGen
                             {
                                 equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
                             }
+
+                            if (serializeMethod != null)
+                            {
+                                serializeMethod.GenericArguments.Add(type);
+                            }
+                            equalityMethod.GenericArguments.Add(type);
                         }
 
                         if (serializeMethod != null)
                         {
-                            serializeMethod.GenericArguments.Add(type);
                             instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(serializeMethod)));
                         }
-                        equalityMethod.GenericArguments.Add(type);
                         instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(equalityMethod)));
                     }
 
@@ -251,11 +348,15 @@ namespace Unity.Netcode.Editor.CodeGen
         private FieldReference m_NetworkManager_rpc_name_table_FieldRef;
         private MethodReference m_NetworkManager_rpc_name_table_Add_MethodRef;
         private TypeReference m_NetworkBehaviour_TypeRef;
+        private TypeReference m_NetworkVariableBase_TypeRef;
+        private MethodReference m_NetworkVariableBase_Initialize_MethodRef;
+        private MethodReference m_NetworkBehaviour___nameNetworkVariable_MethodRef;
         private MethodReference m_NetworkBehaviour_beginSendServerRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_endSendServerRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_beginSendClientRpc_MethodRef;
         private MethodReference m_NetworkBehaviour_endSendClientRpc_MethodRef;
         private FieldReference m_NetworkBehaviour_rpc_exec_stage_FieldRef;
+        private FieldReference m_NetworkBehaviour_NetworkVariableFields_FieldRef;
         private MethodReference m_NetworkBehaviour_getNetworkManager_MethodRef;
         private MethodReference m_NetworkBehaviour_getOwnerClientId_MethodRef;
         private MethodReference m_NetworkHandlerDelegateCtor_MethodRef;
@@ -267,14 +368,37 @@ namespace Unity.Netcode.Editor.CodeGen
         private FieldReference m_ServerRpcParams_Receive_SenderClientId_FieldRef;
         private TypeReference m_ClientRpcParams_TypeRef;
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef;
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef;
+#endif
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef;
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef;
+#endif
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef;
         private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef;
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef;
+#endif
         private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef;
         private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef;
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef;
+#endif
         private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef;
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef;
+#endif
         private MethodReference m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef;
 
+        private MethodReference m_ExceptionCtorMethodReference;
+        private MethodReference m_List_NetworkVariableBase_Add;
+
         private MethodReference m_BytePacker_WriteValueBitPacked_Short_MethodRef;
         private MethodReference m_BytePacker_WriteValueBitPacked_UShort_MethodRef;
         private MethodReference m_BytePacker_WriteValueBitPacked_Int_MethodRef;
@@ -289,6 +413,8 @@ namespace Unity.Netcode.Editor.CodeGen
         private MethodReference m_ByteUnpacker_ReadValueBitPacked_Long_MethodRef;
         private MethodReference m_ByteUnpacker_ReadValueBitPacked_ULong_MethodRef;
 
+        private MethodReference m_NetworkBehaviour_createNativeList_MethodRef;
+
         private TypeReference m_FastBufferWriter_TypeRef;
         private readonly Dictionary<string, MethodReference> m_FastBufferWriter_WriteValue_MethodRefs = new Dictionary<string, MethodReference>();
         private readonly List<MethodReference> m_FastBufferWriter_ExtensionMethodRefs = new List<MethodReference>();
@@ -348,12 +474,18 @@ namespace Unity.Netcode.Editor.CodeGen
         private const string k_NetworkManager_rpc_name_table = nameof(NetworkManager.__rpc_name_table);
 
         private const string k_NetworkBehaviour_rpc_exec_stage = nameof(NetworkBehaviour.__rpc_exec_stage);
+        private const string k_NetworkBehaviour_NetworkVariableFields = nameof(NetworkBehaviour.NetworkVariableFields);
         private const string k_NetworkBehaviour_beginSendServerRpc = nameof(NetworkBehaviour.__beginSendServerRpc);
         private const string k_NetworkBehaviour_endSendServerRpc = nameof(NetworkBehaviour.__endSendServerRpc);
         private const string k_NetworkBehaviour_beginSendClientRpc = nameof(NetworkBehaviour.__beginSendClientRpc);
         private const string k_NetworkBehaviour_endSendClientRpc = nameof(NetworkBehaviour.__endSendClientRpc);
+        private const string k_NetworkBehaviour___initializeVariables = nameof(NetworkBehaviour.__initializeVariables);
+        private const string k_NetworkBehaviour_createNativeList = nameof(NetworkBehaviour.__createNativeList);
         private const string k_NetworkBehaviour_NetworkManager = nameof(NetworkBehaviour.NetworkManager);
         private const string k_NetworkBehaviour_OwnerClientId = nameof(NetworkBehaviour.OwnerClientId);
+        private const string k_NetworkBehaviour___nameNetworkVariable = nameof(NetworkBehaviour.__nameNetworkVariable);
+
+        private const string k_NetworkVariableBase_Initialize = nameof(NetworkVariableBase.Initialize);
 
         private const string k_RpcAttribute_Delivery = nameof(RpcAttribute.Delivery);
         private const string k_ServerRpcAttribute_RequireOwnership = nameof(ServerRpcAttribute.RequireOwnership);
@@ -379,6 +511,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
             TypeDefinition networkManagerTypeDef = null;
             TypeDefinition networkBehaviourTypeDef = null;
+            TypeDefinition networkVariableBaseTypeDef = null;
             TypeDefinition networkHandlerDelegateTypeDef = null;
             TypeDefinition rpcParamsTypeDef = null;
             TypeDefinition serverRpcParamsTypeDef = null;
@@ -402,6 +535,12 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
+                if (networkVariableBaseTypeDef == null && netcodeTypeDef.Name == nameof(NetworkVariableBase))
+                {
+                    networkVariableBaseTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
                 if (networkHandlerDelegateTypeDef == null && netcodeTypeDef.Name == nameof(NetworkManager.RpcReceiveHandler))
                 {
                     networkHandlerDelegateTypeDef = netcodeTypeDef;
@@ -548,6 +687,12 @@ namespace Unity.Netcode.Editor.CodeGen
                     case k_NetworkBehaviour_endSendClientRpc:
                         m_NetworkBehaviour_endSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
+                    case k_NetworkBehaviour_createNativeList:
+                        m_NetworkBehaviour_createNativeList_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
+                    case k_NetworkBehaviour___nameNetworkVariable:
+                        m_NetworkBehaviour___nameNetworkVariable_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
                 }
             }
 
@@ -558,6 +703,21 @@ namespace Unity.Netcode.Editor.CodeGen
                     case k_NetworkBehaviour_rpc_exec_stage:
                         m_NetworkBehaviour_rpc_exec_stage_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
+                    case k_NetworkBehaviour_NetworkVariableFields:
+                        m_NetworkBehaviour_NetworkVariableFields_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                        break;
+                }
+            }
+
+
+            m_NetworkVariableBase_TypeRef = moduleDefinition.ImportReference(networkVariableBaseTypeDef);
+            foreach (var methodDef in networkVariableBaseTypeDef.Methods)
+            {
+                switch (methodDef.Name)
+                {
+                    case k_NetworkVariableBase_Initialize:
+                        m_NetworkVariableBase_Initialize_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
                 }
             }
 
@@ -685,24 +845,69 @@ namespace Unity.Netcode.Editor.CodeGen
                     case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef = method;
                         break;
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyArray):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef = method;
+                        break;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyList):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef = method;
+                        break;
+#endif
                     case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef = method;
                         break;
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableArray):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef = method;
+                        break;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method;
+                        break;
+#endif
                     case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method;
                         break;
                     case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedString):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef = method;
                         break;
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringArray):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef = method;
+                        break;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringList):
+                        m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef = method;
+                        break;
+#endif
+
                     case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef = method;
                         break;
                     case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef = method;
                         break;
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableArray):
+                        m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef = method;
+                        break;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList):
+                        m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method;
+                        break;
+#endif
                     case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method;
                         break;
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsArray):
+                        m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef = method;
+                        break;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsList):
+                        m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef = method;
+                        break;
+#endif
                     case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedClassEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef = method;
                         break;
@@ -785,6 +990,16 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
             }
 
+            // Standard types are really hard to reliably find using the Mono Cecil way, they resolve differently in Mono vs .NET Core
+            // Importing with typeof() is less dangerous for standard framework types though, so we can just do it
+            var exceptionType = typeof(Exception);
+            var exceptionCtor = exceptionType.GetConstructor(new[] { typeof(string) });
+            m_ExceptionCtorMethodReference = m_MainModule.ImportReference(exceptionCtor);
+
+            var listType = typeof(List<NetworkVariableBase>);
+            var addMethod = listType.GetMethod(nameof(List<NetworkVariableBase>.Add), new[] { typeof(NetworkVariableBase) });
+            m_List_NetworkVariableBase_Add = moduleDefinition.ImportReference(addMethod);
+
             return true;
         }
 
@@ -931,6 +1146,8 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
             }
 
+            GenerateVariableInitialization(typeDefinition);
+
             if (!typeDefinition.HasGenericParameters && !typeDefinition.IsGenericInstance)
             {
                 var fieldTypes = new List<TypeReference>();
@@ -1147,28 +1364,48 @@ namespace Unity.Netcode.Editor.CodeGen
                         continue;
                     }
 
-                    var checkType = paramType.Resolve();
+                    var checkType = paramType;
                     if (paramType.IsArray)
                     {
                         checkType = ((ArrayType)paramType).ElementType.Resolve();
                     }
 
-                    if ((parameters[0].ParameterType.Resolve() == checkType ||
-                         (parameters[0].ParameterType.Resolve() == checkType.MakeByReferenceType().Resolve() && parameters[0].IsIn)))
+                    if (!method.HasGenericParameters)
                     {
-                        return method;
-                    }
+                        if (!paramType.IsGenericInstance && (parameters[0].ParameterType.Resolve() == checkType ||
+                                (parameters[0].ParameterType.Resolve() == checkType.MakeByReferenceType().Resolve() && parameters[0].IsIn)))
+                        {
+                            return method;
+                        }
 
-                    if (parameters[0].ParameterType == paramType ||
-                        (parameters[0].ParameterType == paramType.MakeByReferenceType() && parameters[0].IsIn))
-                    {
-                        return method;
+                        if (parameters[0].ParameterType == paramType || parameters[0].ParameterType.FullName == paramType.FullName ||
+                            (parameters[0].ParameterType == paramType.MakeByReferenceType() && parameters[0].IsIn))
+                        {
+                            return method;
+                        }
                     }
-
-                    if (method.HasGenericParameters && method.GenericParameters.Count == 1)
+                    else if (method.GenericParameters.Count == 1)
                     {
+                        var resolved = method.Parameters[0].ParameterType.Resolve();
+                        if (resolved != null && resolved != paramType.Resolve())
+                        {
+                            continue;
+                        }
                         if (method.GenericParameters[0].HasConstraints)
                         {
+                            if (paramType.IsGenericInstance && (
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                                    paramType.Resolve().FullName == "Unity.Collections.NativeList`1" ||
+#endif
+                                    paramType.Resolve().FullName == "Unity.Collections.NativeArray`1"))
+                            {
+                                if (method.Parameters[0].ParameterType.Resolve() != paramType.Resolve())
+                                {
+                                    continue;
+                                }
+                                var instanceType = (GenericInstanceType)paramType;
+                                checkType = instanceType.GenericArguments[0];
+                            }
                             var meetsConstraints = true;
                             foreach (var constraint in method.GenericParameters[0].Constraints)
                             {
@@ -1201,7 +1438,17 @@ namespace Unity.Netcode.Editor.CodeGen
                             if (meetsConstraints)
                             {
                                 var instanceMethod = new GenericInstanceMethod(method);
-                                if (paramType.IsArray)
+
+                                if (paramType.IsGenericInstance && (
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                                        paramType.Resolve().FullName == "Unity.Collections.NativeList`1" ||
+#endif
+                                        paramType.Resolve().FullName == "Unity.Collections.NativeArray`1"))
+                                {
+                                    var wrappedType = ((GenericInstanceType)paramType).GenericArguments[0];
+                                    instanceMethod.GenericArguments.Add(wrappedType);
+                                }
+                                else if (paramType.IsArray)
                                 {
                                     instanceMethod.GenericArguments.Add(((ArrayType)paramType).ElementType);
                                 }
@@ -1310,9 +1557,9 @@ namespace Unity.Netcode.Editor.CodeGen
                         continue;
                     }
 
-                    if (!parameters[0].IsOut)
+                    if (!parameters[0].IsOut && !parameters[0].ParameterType.IsByReference)
                     {
-                        return null;
+                        continue;
                     }
 
                     var methodParam = ((ByReferenceType)parameters[0].ParameterType).ElementType;
@@ -1322,24 +1569,56 @@ namespace Unity.Netcode.Editor.CodeGen
                         continue;
                     }
 
-                    var checkType = paramType.Resolve();
+                    var checkType = (TypeReference)paramType.Resolve();
                     if (paramType.IsArray)
                     {
                         checkType = ((ArrayType)paramType).ElementType.Resolve();
                     }
 
-                    if (methodParam.Resolve() == checkType.Resolve() || methodParam.Resolve() == checkType.MakeByReferenceType().Resolve())
+                    if (!method.HasGenericParameters)
                     {
-                        return method;
-                    }
+                        if (!paramType.IsGenericInstance && (methodParam.Resolve() == checkType.Resolve() || methodParam.Resolve() == checkType.MakeByReferenceType().Resolve()))
+                        {
+                            return method;
+                        }
 
-                    if (methodParam.Resolve() == paramType || methodParam.Resolve() == paramType.MakeByReferenceType().Resolve())
-                    {
-                        return method;
+                        if (methodParam.Resolve() == paramType || methodParam.FullName == paramType.FullName)
+                        {
+                            return method;
+                        }
                     }
-
-                    if (method.HasGenericParameters && method.GenericParameters.Count == 1)
+                    else if (method.GenericParameters.Count == 1)
                     {
+                        var resolved = method.Parameters[0].ParameterType.Resolve();
+                        if (resolved != null && resolved != paramType.Resolve())
+                        {
+                            continue;
+                        }
+                        if (paramType.IsGenericInstance && (
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                                paramType.Resolve().FullName == "Unity.Collections.NativeList`1" ||
+#endif
+                                paramType.Resolve().FullName == "Unity.Collections.NativeArray`1"))
+                        {
+                            if (method.Name == "OnSendGlobalCounterClientRpc")
+                            {
+                                m_Diagnostics.AddWarning(
+                                    $"{method}: {method.Parameters[0].ParameterType} | {paramType}"
+                                    );
+                            }
+                            if (method.Parameters[0].ParameterType.Resolve() != paramType.Resolve())
+                            {
+                                if (method.Name == "OnSendGlobalCounterClientRpc")
+                                {
+                                    m_Diagnostics.AddWarning(
+                                        $"{method}: Not suitable"
+                                    );
+                                }
+                                continue;
+                            }
+                            var instanceType = (GenericInstanceType)paramType;
+                            checkType = instanceType.GenericArguments[0];
+                        }
                         if (method.GenericParameters[0].HasConstraints)
                         {
                             var meetsConstraints = true;
@@ -1376,7 +1655,16 @@ namespace Unity.Netcode.Editor.CodeGen
                             if (meetsConstraints)
                             {
                                 var instanceMethod = new GenericInstanceMethod(method);
-                                if (paramType.IsArray)
+                                if (paramType.IsGenericInstance && (
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                                        paramType.Resolve().FullName == "Unity.Collections.NativeList`1" ||
+#endif
+                                        paramType.Resolve().FullName == "Unity.Collections.NativeArray`1"))
+                                {
+                                    var wrappedType = ((GenericInstanceType)paramType).GenericArguments[0];
+                                    instanceMethod.GenericArguments.Add(wrappedType);
+                                }
+                                else if (paramType.IsArray)
                                 {
                                     instanceMethod.GenericArguments.Add(((ArrayType)paramType).ElementType);
                                 }
@@ -1384,7 +1672,6 @@ namespace Unity.Netcode.Editor.CodeGen
                                 {
                                     instanceMethod.GenericArguments.Add(paramType);
                                 }
-
                                 return instanceMethod;
                             }
                         }
@@ -1446,7 +1733,22 @@ namespace Unity.Netcode.Editor.CodeGen
                     }
                 }
 
-                var typeMethod = GetFastBufferReaderReadMethod(k_ReadValueMethodName, paramType);
+                MethodReference typeMethod;
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                if (paramType.Resolve().FullName == "Unity.Collections.NativeList`1")
+                {
+                    typeMethod = GetFastBufferReaderReadMethod(k_ReadValueInPlaceMethodName, paramType);
+                }
+                else
+#endif
+                if (paramType.Resolve().FullName == "Unity.Collections.NativeArray`1")
+                {
+                    typeMethod = GetFastBufferReaderReadMethod(k_ReadValueTempMethodName, paramType);
+                }
+                else
+                {
+                    typeMethod = GetFastBufferReaderReadMethod(k_ReadValueMethodName, paramType);
+                }
                 if (typeMethod != null)
                 {
                     methodRef = m_MainModule.ImportReference(typeMethod);
@@ -1786,7 +2088,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     }
                     else
                     {
-                        m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to serialize {paramType.Name}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
+                        m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to serialize {paramType}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
                         continue;
                     }
 
@@ -1889,6 +2191,132 @@ namespace Unity.Netcode.Editor.CodeGen
             instructions.ForEach(instruction => processor.Body.Instructions.Insert(0, instruction));
         }
 
+        private void GenerateVariableInitialization(TypeDefinition type)
+        {
+            foreach (var methodDefinition in type.Methods)
+            {
+                if (methodDefinition.Name == k_NetworkBehaviour___initializeVariables)
+                {
+                    // If this hits, we've already generated the method for this class because a child class got processed first.
+                    return;
+                }
+            }
+
+            var method = new MethodDefinition(
+                k_NetworkBehaviour___initializeVariables,
+                MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.HideBySig,
+                m_MainModule.TypeSystem.Void);
+
+            var processor = method.Body.GetILProcessor();
+
+            method.Body.Variables.Add(new VariableDefinition(m_MainModule.TypeSystem.Boolean));
+
+            processor.Emit(OpCodes.Nop);
+
+            foreach (var fieldDefinition in type.Fields)
+            {
+                FieldReference field = fieldDefinition;
+                if (type.HasGenericParameters)
+                {
+                    var genericType = new GenericInstanceType(fieldDefinition.DeclaringType);
+                    foreach (var parameter in fieldDefinition.DeclaringType.GenericParameters)
+                    {
+                        genericType.GenericArguments.Add(parameter);
+                    }
+                    field = new FieldReference(fieldDefinition.Name, fieldDefinition.FieldType, genericType);
+                }
+                if (!field.FieldType.IsArray && !field.FieldType.Resolve().IsArray && field.FieldType.IsSubclassOf(m_NetworkVariableBase_TypeRef))
+                {
+                    // if({variable} == null) {
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldfld, field);
+                    processor.Emit(OpCodes.Ldnull);
+                    processor.Emit(OpCodes.Ceq);
+                    processor.Emit(OpCodes.Stloc_0);
+                    processor.Emit(OpCodes.Ldloc_0);
+
+                    var afterThrowInstruction = processor.Create(OpCodes.Nop);
+
+                    processor.Emit(OpCodes.Brfalse, afterThrowInstruction);
+
+                    // throw new Exception("...");
+                    processor.Emit(OpCodes.Nop);
+                    processor.Emit(OpCodes.Ldstr, $"{type.Name}.{field.Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
+                    processor.Emit(OpCodes.Newobj, m_ExceptionCtorMethodReference);
+                    processor.Emit(OpCodes.Throw);
+
+                    // }
+                    processor.Append(afterThrowInstruction);
+
+                    // {variable}.Initialize(this);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldfld, field);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Callvirt, m_NetworkVariableBase_Initialize_MethodRef);
+
+                    // __nameNetworkVariable({variable}, "{variable}");
+                    processor.Emit(OpCodes.Nop);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldfld, field);
+                    processor.Emit(OpCodes.Ldstr, field.Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty));
+                    processor.Emit(OpCodes.Call, m_NetworkBehaviour___nameNetworkVariable_MethodRef);
+
+                    // NetworkVariableFields.Add({variable});
+                    processor.Emit(OpCodes.Nop);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldfld, m_NetworkBehaviour_NetworkVariableFields_FieldRef);
+                    processor.Emit(OpCodes.Ldarg_0);
+                    processor.Emit(OpCodes.Ldfld, field);
+                    processor.Emit(OpCodes.Callvirt, m_List_NetworkVariableBase_Add);
+                }
+            }
+
+            // Find the base method...
+            MethodReference initializeVariablesBaseReference = null;
+            foreach (var methodDefinition in type.BaseType.Resolve().Methods)
+            {
+                if (methodDefinition.Name == k_NetworkBehaviour___initializeVariables)
+                {
+                    initializeVariablesBaseReference = m_MainModule.ImportReference(methodDefinition);
+                    break;
+                }
+            }
+
+            if (initializeVariablesBaseReference == null)
+            {
+                // If we couldn't find it, we have to go ahead and add it.
+                // The base class could be in another assembly... that's ok, this won't
+                // actually save but it'll generate the same method the same way later,
+                // so this at least allows us to reference it.
+                GenerateVariableInitialization(type.BaseType.Resolve());
+                foreach (var methodDefinition in type.BaseType.Resolve().Methods)
+                {
+                    if (methodDefinition.Name == k_NetworkBehaviour___initializeVariables)
+                    {
+                        initializeVariablesBaseReference = m_MainModule.ImportReference(methodDefinition);
+                        break;
+                    }
+                }
+            }
+
+            if (type.BaseType.Resolve().HasGenericParameters)
+            {
+                var baseTypeInstance = (GenericInstanceType)type.BaseType;
+                initializeVariablesBaseReference = initializeVariablesBaseReference.MakeGeneric(baseTypeInstance.GenericArguments.ToArray());
+            }
+
+            // base.__initializeVariables();
+            processor.Emit(OpCodes.Nop);
+            processor.Emit(OpCodes.Ldarg_0);
+            processor.Emit(OpCodes.Call, initializeVariablesBaseReference);
+            processor.Emit(OpCodes.Nop);
+
+            processor.Emit(OpCodes.Ret);
+
+            type.Methods.Add(method);
+        }
+
         private MethodDefinition GenerateStaticHandler(MethodDefinition methodDefinition, CustomAttribute rpcAttribute, uint rpcMethodId)
         {
             var typeSystem = methodDefinition.Module.TypeSystem;
@@ -2048,6 +2476,28 @@ namespace Unity.Netcode.Editor.CodeGen
                     processor.Emit(OpCodes.Brfalse, jumpInstruction);
                 }
 
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+                if (paramType.IsGenericInstance && paramType.Resolve().FullName == "Unity.Collections.NativeList`1")
+                {
+                    // var list = NetworkBehaviour.__createNativeList<T>();
+
+                    // This simplifies things - easier to call __createNativeList() and have the implementation in C#
+                    // than to try to actually construct a NativeList in IL. This is also more future-proof.
+
+                    // Unlike other types, NativeList<> calls ReadValueSafeInPlace instead of ReadValueSafe.
+                    // FastBufferReader doesn't support a non-in-place deserializer for NativeList in order to
+                    // avoid users using it without realizing the allocation overhead that would cost. In-place
+                    // is more efficient when an existing value exists, and when it doesn't, it's easy to create one,
+                    // which is what we do here.
+
+                    var method = new GenericInstanceMethod(m_NetworkBehaviour_createNativeList_MethodRef);
+                    var genericParam = (GenericInstanceType)paramType;
+                    method.GenericArguments.Add(genericParam.GenericArguments[0]);
+                    processor.Emit(OpCodes.Call, method);
+                    processor.Emit(OpCodes.Stloc, localIndex);
+                }
+#endif
+
                 var foundMethodRef = GetReadMethodForParameter(paramType, out var methodRef);
                 if (foundMethodRef)
                 {
@@ -2100,7 +2550,7 @@ namespace Unity.Netcode.Editor.CodeGen
                 }
                 else
                 {
-                    m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to serialize {paramType.Name}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
+                    m_Diagnostics.AddError(methodDefinition, $"{methodDefinition.Name} - Don't know how to deserialize {paramType}. RPC parameter types must either implement {nameof(INetworkSerializeByMemcpy)} or {nameof(INetworkSerializable)}. If this type is external and you are sure its memory layout makes it serializable by memcpy, you can replace {paramType} with {typeof(ForceNetworkSerializeByMemcpy<>).Name}<{paramType}>, or you can create extension methods for {nameof(FastBufferReader)}.{nameof(FastBufferReader.ReadValueSafe)}(this {nameof(FastBufferReader)}, out {paramType}) and {nameof(FastBufferWriter)}.{nameof(FastBufferWriter.WriteValueSafe)}(this {nameof(FastBufferWriter)}, in {paramType}) to define serialization for this type.");
                     continue;
                 }
 

Editor/CodeGen/RuntimeAccessModifiersILPP.cs

@@ -112,7 +112,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
             foreach (var fieldDefinition in typeDefinition.Fields)
             {
-                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage))
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage) || fieldDefinition.Name == nameof(NetworkBehaviour.NetworkVariableFields))
                 {
                     fieldDefinition.IsFamily = true;
                 }
@@ -123,7 +123,10 @@ namespace Unity.Netcode.Editor.CodeGen
                 if (methodDefinition.Name == nameof(NetworkBehaviour.__beginSendServerRpc) ||
                     methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
                     methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
-                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc))
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__initializeVariables) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__nameNetworkVariable) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__createNativeList))
                 {
                     methodDefinition.IsFamily = true;
                 }

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -0,0 +1,30 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    [FilePath("ProjectSettings/NetcodeForGameObjects.asset", FilePathAttribute.Location.ProjectFolder)]
+    public class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
+    {
+        internal static readonly string DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        [SerializeField] public string NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+        public string TempNetworkPrefabsPath;
+
+        private void OnEnable()
+        {
+            if (NetworkPrefabsPath == "")
+            {
+                NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+            }
+            TempNetworkPrefabsPath = NetworkPrefabsPath;
+        }
+
+        [SerializeField]
+        public bool GenerateDefaultNetworkPrefabs;
+
+        internal void SaveSettings()
+        {
+            Save(true);
+        }
+    }
+}

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2727d53a542a4c1aa312905c3a02d807
+timeCreated: 1685564945

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -1,6 +1,4 @@
 using UnityEditor;
-using UnityEngine;
-
 
 namespace Unity.Netcode.Editor.Configuration
 {
@@ -39,15 +37,4 @@ namespace Unity.Netcode.Editor.Configuration
             EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
         }
     }
-
-    [FilePath("ProjectSettings/NetcodeForGameObjects.settings", FilePathAttribute.Location.ProjectFolder)]
-    internal class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
-    {
-        [SerializeField] public bool GenerateDefaultNetworkPrefabs = true;
-
-        internal void SaveSettings()
-        {
-            Save(true);
-        }
-    }
 }

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -1,5 +1,9 @@
+using System.Collections.Generic;
+using System.IO;
 using UnityEditor;
 using UnityEngine;
+using Directory = UnityEngine.Windows.Directory;
+using File = UnityEngine.Windows.File;
 
 namespace Unity.Netcode.Editor.Configuration
 {
@@ -20,11 +24,60 @@ namespace Unity.Netcode.Editor.Configuration
                 label = "Netcode for GameObjects",
                 keywords = new[] { "netcode", "editor" },
                 guiHandler = OnGuiHandler,
+                deactivateHandler = OnDeactivate
             };
 
             return provider;
         }
 
+        private static void OnDeactivate()
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (settings.TempNetworkPrefabsPath != settings.NetworkPrefabsPath)
+            {
+                var newPath = settings.TempNetworkPrefabsPath;
+                if (newPath == "")
+                {
+                    newPath = NetcodeForGameObjectsProjectSettings.DefaultNetworkPrefabsPath;
+                    settings.TempNetworkPrefabsPath = newPath;
+                }
+                var oldPath = settings.NetworkPrefabsPath;
+                settings.NetworkPrefabsPath = settings.TempNetworkPrefabsPath;
+                var dirName = Path.GetDirectoryName(newPath);
+                if (!Directory.Exists(dirName))
+                {
+                    var dirs = dirName.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
+                    var dirsQueue = new Queue<string>(dirs);
+                    var parent = dirsQueue.Dequeue();
+                    while (dirsQueue.Count != 0)
+                    {
+                        var child = dirsQueue.Dequeue();
+                        var together = Path.Combine(parent, child);
+                        if (!Directory.Exists(together))
+                        {
+                            AssetDatabase.CreateFolder(parent, child);
+                        }
+
+                        parent = together;
+                    }
+                }
+
+                if (Directory.Exists(dirName))
+                {
+                    if (File.Exists(oldPath))
+                    {
+                        AssetDatabase.MoveAsset(oldPath, newPath);
+                        if (File.Exists(oldPath))
+                        {
+                            File.Delete(oldPath);
+                        }
+                        AssetDatabase.Refresh();
+                    }
+                }
+                settings.SaveSettings();
+            }
+        }
+
 
         internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
         internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
@@ -70,6 +123,7 @@ namespace Unity.Netcode.Editor.Configuration
             var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
             var settings = NetcodeForGameObjectsProjectSettings.instance;
             var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
+            var networkPrefabsPath = settings.TempNetworkPrefabsPath;
 
             EditorGUI.BeginChangeCheck();
 
@@ -97,6 +151,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 GUILayout.BeginVertical("Box");
                 const string generateNetworkPrefabsString = "Generate Default Network Prefabs List";
+                const string networkPrefabsLocationString = "Default Network Prefabs List path";
 
                 if (s_MaxLabelWidth == 0)
                 {
@@ -114,6 +169,14 @@ namespace Unity.Netcode.Editor.Configuration
                         "to date with all NetworkObject prefabs."),
                     generateDefaultPrefabs,
                     GUILayout.Width(s_MaxLabelWidth + 20));
+
+                GUI.SetNextControlName("Location");
+                networkPrefabsPath = EditorGUILayout.TextField(
+                    new GUIContent(
+                        networkPrefabsLocationString,
+                        "The path to the asset the default NetworkPrefabList object should be stored in."),
+                    networkPrefabsPath,
+                    GUILayout.Width(s_MaxLabelWidth + 270));
                 GUILayout.EndVertical();
             }
             EditorGUILayout.EndFoldoutHeaderGroup();
@@ -123,6 +186,7 @@ namespace Unity.Netcode.Editor.Configuration
                 NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
                 NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
                 settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
+                settings.TempNetworkPrefabsPath = networkPrefabsPath;
                 settings.SaveSettings();
             }
         }

Editor/Configuration/NetworkPrefabProcessor.cs

@@ -9,16 +9,15 @@ namespace Unity.Netcode.Editor.Configuration
     /// </summary>
     public class NetworkPrefabProcessor : AssetPostprocessor
     {
-        private static string s_DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
         public static string DefaultNetworkPrefabsPath
         {
             get
             {
-                return s_DefaultNetworkPrefabsPath;
+                return NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath;
             }
             internal set
             {
-                s_DefaultNetworkPrefabsPath = value;
+                NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath = value;
                 // Force a recache of the prefab list
                 s_PrefabsList = null;
             }

Editor/NetworkBehaviourEditor.cs

@@ -41,13 +41,11 @@ namespace Unity.Netcode.Editor
                 {
                     m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                     m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
-                    Debug.Log($"Adding NetworkVariable {fields[i].Name}");
                 }
                 if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
                 {
                     m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                     m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
-                    Debug.Log($"Adding NetworkList {fields[i].Name}");
                 }
             }
         }
@@ -81,7 +79,25 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.BeginHorizontal();
             if (genericType.IsValueType)
             {
-                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkContainerValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                var isEquatable = false;
+                foreach (var iface in genericType.GetInterfaces())
+                {
+                    if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEquatable<>))
+                    {
+                        isEquatable = true;
+                    }
+                }
+
+                MethodInfo method;
+                if (isEquatable)
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueTypeIEquatable), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+                else
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueType), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+
                 var genericMethod = method.MakeGenericMethod(genericType);
                 genericMethod.Invoke(this, new[] { (object)index });
             }
@@ -94,7 +110,23 @@ namespace Unity.Netcode.Editor
             }
         }
 
-        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged, IEquatable<T>
+        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception e)
+            {
+                Debug.Log(e);
+                throw;
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private void RenderNetworkContainerValueTypeIEquatable<T>(int index) where T : unmanaged, IEquatable<T>
         {
             try
             {
@@ -240,7 +272,7 @@ namespace Unity.Netcode.Editor
             bool expanded = true;
             while (property.NextVisible(expanded))
             {
-                if (m_NetworkVariableNames.Contains(property.name))
+                if (m_NetworkVariableNames.Contains(ObjectNames.NicifyVariableName(property.name)))
                 {
                     // Skip rendering of NetworkVars, they have special rendering
                     continue;

Editor/NetworkManagerEditor.cs

@@ -339,7 +339,7 @@ namespace Unity.Netcode.Editor
             const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
             const string openDocsButtonText = "Open Docs";
             const string dismissButtonText = "Dismiss";
-            const string targetUrl = "https://docs-multiplayer.unity3d.com/netcode/current/tools/install-tools";
+            const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
             const string infoIconName = "console.infoicon";
 
             if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)

Runtime/Configuration/NetworkConfig.cs

@@ -156,7 +156,7 @@ namespace Unity.Netcode
         public string ToBase64()
         {
             NetworkConfig config = this;
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+            var writer = new FastBufferWriter(1024, Allocator.Temp);
             using (writer)
             {
                 writer.WriteValueSafe(config.ProtocolVersion);
@@ -228,7 +228,7 @@ namespace Unity.Netcode
                 return m_ConfigHash.Value;
             }
 
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, int.MaxValue);
+            var writer = new FastBufferWriter(1024, Allocator.Temp, int.MaxValue);
             using (writer)
             {
                 writer.WriteValueSafe(ProtocolVersion);

Runtime/Configuration/NetworkPrefab.cs

@@ -12,10 +12,12 @@ namespace Unity.Netcode
         /// No oeverride is present
         /// </summary>
         None,
+
         /// <summary>
         /// Override the prefab when the given SourcePrefabToOverride is requested
         /// </summary>
         Prefab,
+
         /// <summary>
         /// Override the prefab when the given SourceHashToOverride is requested
         /// Used in situations where the server assets do not exist in client builds
@@ -71,19 +73,23 @@ namespace Unity.Netcode
                 switch (Override)
                 {
                     case NetworkPrefabOverride.None:
-                        if (Prefab != null && Prefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (Prefab != null && Prefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Prefab:
-                        if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Source Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Source Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     case NetworkPrefabOverride.Hash:
                         return SourceHashToOverride;
                     default:
@@ -102,12 +108,14 @@ namespace Unity.Netcode
                         return 0;
                     case NetworkPrefabOverride.Prefab:
                     case NetworkPrefabOverride.Hash:
-                        if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject no))
                         {
-                            return no.GlobalObjectIdHash;
-                        }
+                            if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
 
-                        throw new InvalidOperationException("Target Prefab field isn't set or isn't a Network Object");
+                            throw new InvalidOperationException($"Target Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
                     default:
                         throw new ArgumentOutOfRangeException();
                 }
@@ -130,9 +138,9 @@ namespace Unity.Netcode
                 {
                     if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                     {
-                        NetworkLog.LogWarning($"{NetworkManager.PrefabDebugHelper(this)} is missing " +
-                                              $"a {nameof(NetworkObject)} component (entry will be ignored).");
+                        NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                     }
+
                     return false;
                 }
 
@@ -148,9 +156,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero " +
-                                    "(entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -178,9 +186,9 @@ namespace Unity.Netcode
                         {
                             if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
                             {
-                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) " +
-                                    $"is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) is missing a {nameof(NetworkObject)} component (entry will be ignored).");
                             }
+
                             return false;
                         }
 
@@ -195,6 +203,7 @@ namespace Unity.Netcode
                 {
                     NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!");
                 }
+
                 switch (Override)
                 {
                     case NetworkPrefabOverride.Hash:
@@ -208,8 +217,10 @@ namespace Unity.Netcode
                             break;
                         }
                 }
+
                 return false;
             }
+
             return true;
         }
 

Runtime/Configuration/NetworkPrefabs.cs

@@ -38,10 +38,15 @@ namespace Unity.Netcode
         [NonSerialized]
         private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
 
+        [NonSerialized]
+        private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
+
         private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
         {
             if (AddPrefabRegistration(networkPrefab))
             {
+                // Don't add this to m_RuntimeAddedPrefabs
+                // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
                 m_Prefabs.Add(networkPrefab);
             }
         }
@@ -67,8 +72,6 @@ namespace Unity.Netcode
                 list.OnAdd -= AddTriggeredByNetworkPrefabList;
                 list.OnRemove -= RemoveTriggeredByNetworkPrefabList;
             }
-
-            NetworkPrefabsLists.Clear();
         }
 
         /// <summary>
@@ -77,13 +80,7 @@ namespace Unity.Netcode
         /// </summary>
         public void Initialize(bool warnInvalid = true)
         {
-            if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0)
-            {
-                NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " +
-                    "Prefab registrations made before initialization will be replaced by NetworkPrefabsList.");
-                m_Prefabs.Clear();
-            }
-
+            m_Prefabs.Clear();
             foreach (var list in NetworkPrefabsLists)
             {
                 list.OnAdd += AddTriggeredByNetworkPrefabList;
@@ -93,7 +90,7 @@ namespace Unity.Netcode
             NetworkPrefabOverrideLinks.Clear();
             OverrideToNetworkPrefab.Clear();
 
-            var prefabs = NetworkPrefabsLists.Count != 0 ? new List<NetworkPrefab>() : m_Prefabs;
+            var prefabs = new List<NetworkPrefab>();
 
             if (NetworkPrefabsLists.Count != 0)
             {
@@ -126,6 +123,18 @@ namespace Unity.Netcode
                 }
             }
 
+            foreach (var networkPrefab in m_RuntimeAddedPrefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
             // Clear out anything that is invalid or not used
             if (removeList?.Count > 0)
             {
@@ -152,6 +161,7 @@ namespace Unity.Netcode
             if (AddPrefabRegistration(networkPrefab))
             {
                 m_Prefabs.Add(networkPrefab);
+                m_RuntimeAddedPrefabs.Add(networkPrefab);
                 return true;
             }
 
@@ -175,6 +185,7 @@ namespace Unity.Netcode
             }
 
             m_Prefabs.Remove(prefab);
+            m_RuntimeAddedPrefabs.Remove(prefab);
             OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
             NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
         }
@@ -203,6 +214,15 @@ namespace Unity.Netcode
                     return;
                 }
             }
+
+            for (int i = 0; i < m_RuntimeAddedPrefabs.Count; i++)
+            {
+                if (m_RuntimeAddedPrefabs[i].Prefab == prefab)
+                {
+                    Remove(m_RuntimeAddedPrefabs[i]);
+                    return;
+                }
+            }
         }
 
         /// <summary>

Runtime/Connection/NetworkClient.cs

@@ -7,30 +7,74 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkClient
     {
+        /// <summary>
+        /// Returns true if the session instance is considered a server
+        /// </summary>
+        internal bool IsServer { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a client
+        /// </summary>
+        internal bool IsClient { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a host
+        /// </summary>
+        internal bool IsHost => IsClient && IsServer;
+
+        /// <summary>
+        /// When true, the client is connected, approved, and synchronized with
+        /// the server.
+        /// </summary>
+        internal bool IsConnected { get; set; }
+
+        /// <summary>
+        /// Is true when the client has been approved.
+        /// </summary>
+        internal bool IsApproved { get; set; }
+
         /// <summary>
         /// The ClientId of the NetworkClient
         /// </summary>
+        // TODO-2023-Q2: Determine if we want to make this property a public get and internal/private set
+        // There is no reason for a user to want to set this, but this will fail the package-validation-suite
         public ulong ClientId;
 
         /// <summary>
         /// The PlayerObject of the Client
         /// </summary>
+        // TODO-2023-Q2: Determine if we want to make this property a public get and internal/private set
+        // There is no reason for a user to want to set this, but this will fail the package-validation-suite
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this Client
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public List<NetworkObject> OwnedObjects
-        {
-            get
-            {
-                if (PlayerObject != null && PlayerObject.NetworkManager != null && PlayerObject.NetworkManager.IsListening)
-                {
-                    return PlayerObject.NetworkManager.SpawnManager.GetClientOwnedObjects(ClientId);
-                }
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
 
-                return new List<NetworkObject>();
+        internal NetworkSpawnManager SpawnManager { get; private set; }
+
+        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        {
+            IsServer = isServer;
+            IsClient = isClient;
+            if (!IsServer && !isClient)
+            {
+                PlayerObject = null;
+                ClientId = 0;
+                IsConnected = false;
+                IsApproved = false;
             }
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
+            }
+        }
+
+        internal void AssignPlayerObject(ref NetworkObject networkObject)
+        {
+            PlayerObject = networkObject;
         }
     }
 }

Runtime/Connection/NetworkConnectionManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d98eff74d73bc2a42bd5624c47ce8fe1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Connection/PendingClient.cs

@@ -1,10 +1,15 @@
+using UnityEngine;
+
 namespace Unity.Netcode
 {
     /// <summary>
+    /// Server-Side Only:
     /// A class representing a client that is currently in the process of connecting
     /// </summary>
     public class PendingClient
     {
+        internal Coroutine ApprovalCoroutine = null;
+
         /// <summary>
         /// The ClientId of the client
         /// </summary>

Runtime/Core/ComponentFactory.cs

@@ -51,7 +51,7 @@ namespace Unity.Netcode
         /// </summary>
         public static void SetDefaults()
         {
-            SetDefault<IDeferredMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+            SetDefault<IDeferredNetworkMessageManager>(networkManager => new DeferredMessageManager(networkManager));
 
             SetDefault<IRealTimeProvider>(networkManager => new RealTimeProvider());
         }

Runtime/Core/NetworkBehaviour.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using Unity.Collections;
 using UnityEngine;
 
@@ -65,7 +63,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -86,7 +84,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -96,7 +94,7 @@ namespace Unity.Netcode
             }
             else
             {
-                rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
             }
 
             bufferWriter.Dispose();
@@ -146,7 +144,7 @@ namespace Unity.Netcode
                     networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
                     break;
                 case RpcDelivery.Unreliable:
-                    if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
+                    if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
                     {
                         throw new OverflowException("RPC parameters are too large for unreliable delivery.");
                     }
@@ -176,7 +174,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
             }
             else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
             {
@@ -195,7 +193,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
+                rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
             }
             else
             {
@@ -208,7 +206,7 @@ namespace Unity.Netcode
                         shouldSendToHost = true;
                         continue;
                     }
-                    rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
+                    rpcWriteSize = NetworkManager.ConnectionManager.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
                 }
             }
 
@@ -223,7 +221,7 @@ namespace Unity.Netcode
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
-                    Header = new MessageHeader(),
+                    Header = new NetworkMessageHeader(),
                     SerializedHeaderSize = 0,
                     MessageSize = 0
                 };
@@ -277,6 +275,14 @@ namespace Unity.Netcode
 #endif
         }
 
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal static NativeList<T> __createNativeList<T>() where T : unmanaged
+#pragma warning restore IDE1006 // restore naming rule violation check
+        {
+            return new NativeList<T>(Allocator.Temp);
+        }
+
         internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
         {
             var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
@@ -551,35 +557,25 @@ namespace Unity.Netcode
 
         private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
         private readonly List<NetworkDelivery> m_DeliveryTypesForNetworkVariableGroups = new List<NetworkDelivery>();
+
+        // RuntimeAccessModifiersILPP will make this `protected`
         internal readonly List<NetworkVariableBase> NetworkVariableFields = new List<NetworkVariableBase>();
 
-        private static Dictionary<Type, FieldInfo[]> s_FieldTypes = new Dictionary<Type, FieldInfo[]>();
-
-        private static FieldInfo[] GetFieldInfoForType(Type type)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        internal virtual void __initializeVariables()
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (!s_FieldTypes.ContainsKey(type))
-            {
-                s_FieldTypes.Add(type, GetFieldInfoForTypeRecursive(type));
-            }
-
-            return s_FieldTypes[type];
+            // ILPP generates code for all NetworkBehaviour subtypes to initialize each type's network variables.
         }
 
-        private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List<FieldInfo> list = null)
+#pragma warning disable IDE1006 // disable naming rule violation check
+        // RuntimeAccessModifiersILPP will make this `protected`
+        // Using this method here because ILPP doesn't seem to let us do visibility modification on properties.
+        internal void __nameNetworkVariable(NetworkVariableBase variable, string varName)
+#pragma warning restore IDE1006 // restore naming rule violation check
         {
-            if (list == null)
-            {
-                list = new List<FieldInfo>();
-            }
-
-            list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
-
-            if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
-            {
-                return GetFieldInfoForTypeRecursive(type.BaseType, list);
-            }
-
-            return list.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();
+            variable.Name = varName;
         }
 
         internal void InitializeVariables()
@@ -591,22 +587,7 @@ namespace Unity.Netcode
 
             m_VarInit = true;
 
-            var sortedFields = GetFieldInfoForType(GetType());
-            for (int i = 0; i < sortedFields.Length; i++)
-            {
-                var fieldType = sortedFields[i].FieldType;
-                if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
-                {
-                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this) ?? throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-                    instance.Initialize(this);
-
-                    var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
-                    var sanitizedVariableName = sortedFields[i].Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
-                    instanceNameProperty?.SetValue(instance, sanitizedVariableName);
-
-                    NetworkVariableFields.Add(instance);
-                }
-            }
+            __initializeVariables();
 
             {
                 // Create index map for delivery types
@@ -718,7 +699,7 @@ namespace Unity.Netcode
                     // so we don't have to do this serialization work if we're not going to use the result.
                     if (IsServer && targetClientId == NetworkManager.ServerClientId)
                     {
-                        var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tmpWriter = new FastBufferWriter(NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkManager.MessageManager.FragmentedMessageMaxSize);
                         using (tmpWriter)
                         {
                             message.Serialize(tmpWriter, message.Version);
@@ -726,7 +707,7 @@ namespace Unity.Netcode
                     }
                     else
                     {
-                        NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
+                        NetworkManager.ConnectionManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
                     }
                 }
             }

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -8,6 +8,8 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkBehaviourUpdater
     {
+        private NetworkManager m_NetworkManager;
+        private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -19,7 +21,7 @@ namespace Unity.Netcode
             m_DirtyNetworkObjects.Add(networkObject);
         }
 
-        internal void NetworkBehaviourUpdate(NetworkManager networkManager)
+        internal void NetworkBehaviourUpdate()
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             m_NetworkBehaviourUpdate.Begin();
@@ -30,7 +32,7 @@ namespace Unity.Netcode
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
 
-                if (networkManager.IsServer)
+                if (m_ConnectionManager.LocalClient.IsServer)
                 {
                     foreach (var dirtyObj in m_DirtyNetworkObjects)
                     {
@@ -39,9 +41,9 @@ namespace Unity.Netcode
                             dirtyObj.ChildNetworkBehaviours[k].PreVariableUpdate();
                         }
 
-                        for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
+                        for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
                         {
-                            var client = networkManager.ConnectedClientsList[i];
+                            var client = m_ConnectionManager.ConnectedClientsList[i];
 
                             if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
@@ -104,5 +106,26 @@ namespace Unity.Netcode
             }
         }
 
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+        }
+
+        internal void Shutdown()
+        {
+            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+        }
+
+        // TODO 2023-Q2: Order of operations requires NetworkVariable updates first then showing NetworkObjects
+        private void NetworkBehaviourUpdater_Tick()
+        {
+            // First update NetworkVariables
+            NetworkBehaviourUpdate();
+
+            // Then show any NetworkObjects queued to be made visible/shown
+            m_NetworkManager.SpawnManager.HandleNetworkObjectShow();
+        }
     }
 }

Runtime/Core/NetworkObject.cs

@@ -188,6 +188,12 @@ namespace Unity.Netcode
         /// </remarks>
         public Action OnMigratedToNewScene;
 
+        /// <summary>
+        /// When set to false, the NetworkObject will be spawned with no observers initially (other than the server)
+        /// </summary>
+        [Tooltip("When false, the NetworkObject will spawn with no observers initially. (default is true)")]
+        public bool SpawnWithObservers = true;
+
         /// <summary>
         /// Delegate type for checking visibility
         /// </summary>
@@ -361,8 +367,7 @@ namespace Unity.Netcode
                 }
                 return;
             }
-
-            NetworkManager.MarkObjectForShowingTo(this, clientId);
+            NetworkManager.SpawnManager.MarkObjectForShowingTo(this, clientId);
             Observers.Add(clientId);
         }
 
@@ -452,7 +457,7 @@ namespace Unity.Netcode
                 throw new VisibilityChangeException("Cannot hide an object from the server");
             }
 
-            if (!NetworkManager.RemoveObjectFromShowingTo(this, clientId))
+            if (!NetworkManager.SpawnManager.RemoveObjectFromShowingTo(this, clientId))
             {
                 if (!Observers.Contains(clientId))
                 {
@@ -466,7 +471,7 @@ namespace Unity.Netcode
                     DestroyGameObject = !IsSceneObject.Value
                 };
                 // Send destroy call
-                var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
                 NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
             }
         }
@@ -532,14 +537,30 @@ namespace Unity.Netcode
 
         private void OnDestroy()
         {
-            if (NetworkManager != null && NetworkManager.IsListening && NetworkManager.IsServer == false && IsSpawned &&
-                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            // If no NetworkManager is assigned, then just exit early
+            if (!NetworkManager)
             {
-                throw new NotServerException($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                return;
             }
 
-            if (NetworkManager != null && NetworkManager.SpawnManager != null &&
-                NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
+            if (NetworkManager.IsListening && !NetworkManager.IsServer && IsSpawned &&
+                (IsSceneObject == null || (IsSceneObject.Value != true)))
+            {
+                // Clients should not despawn NetworkObjects while connected to a session, but we don't want to destroy the current call stack
+                // if this happens. Instead, we should just generate a network log error and exit early (as long as we are not shutting down).
+                if (!NetworkManager.ShutdownInProgress)
+                {
+                    // Since we still have a session connection, log locally and on the server to inform user of this issue.
+                    if (NetworkManager.LogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogErrorServer($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
+                    }
+                    return;
+                }
+                // Otherwise, clients can despawn NetworkObjects while shutting down and should not generate any messages when this happens
+            }
+
+            if (NetworkManager.SpawnManager != null && NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
                 if (this == networkObject)
                 {
@@ -898,7 +919,7 @@ namespace Unity.Netcode
                     }
                 }
 
-                NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
+                NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientIds, idx);
             }
         }
 

Runtime/Logging/NetworkLog.cs

@@ -51,35 +51,58 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogErrorServer(string message) => LogServer(message, LogType.Error);
 
+        internal static NetworkManager NetworkManagerOverride;
+
         private static void LogServer(string message, LogType logType)
         {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
-            ulong localId = NetworkManager.Singleton != null ? NetworkManager.Singleton.LocalClientId : 0;
-
+            ulong localId = networkManager?.LocalClientId ?? 0;
+            bool isServer = networkManager?.IsServer ?? true;
             switch (logType)
             {
                 case LogType.Info:
-                    LogInfoServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogInfoServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogInfo(message);
+                    }
                     break;
                 case LogType.Warning:
-                    LogWarningServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogWarningServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogWarning(message);
+                    }
                     break;
                 case LogType.Error:
-                    LogErrorServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogErrorServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogError(message);
+                    }
                     break;
             }
 
-            if (NetworkManager.Singleton != null && !NetworkManager.Singleton.IsServer && NetworkManager.Singleton.NetworkConfig.EnableNetworkLogs)
+            if (!isServer && networkManager.NetworkConfig.EnableNetworkLogs)
             {
-
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
                     Message = message
                 };
-                var size = NetworkManager.Singleton.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
+                var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
+                networkManager.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
             }
         }
 

Runtime/Messaging/CustomMessageManager.cs

@@ -90,7 +90,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -123,7 +123,7 @@ namespace Unity.Netcode
             {
                 SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
             {
@@ -275,7 +275,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream,
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -333,7 +333,7 @@ namespace Unity.Netcode
                 Hash = hash,
                 SendData = messageStream
             };
-            var size = m_NetworkManager.SendMessage(ref message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)

Runtime/Messaging/DefaultMessageSender.cs

@@ -0,0 +1,26 @@
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Default NetworkTransport Message Sender
+    /// <see cref="NetworkMessageManager"/>
+    /// </summary>
+    internal class DefaultMessageSender : INetworkMessageSender
+    {
+        private NetworkTransport m_NetworkTransport;
+        private NetworkConnectionManager m_ConnectionManager;
+
+        public DefaultMessageSender(NetworkManager manager)
+        {
+            m_NetworkTransport = manager.NetworkConfig.NetworkTransport;
+            m_ConnectionManager = manager.ConnectionManager;
+        }
+
+        public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+        {
+            var sendBuffer = batchData.ToTempByteArray();
+
+            m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);
+        }
+    }
+}

Runtime/Messaging/DefaultMessageSender.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ea6bdd38832d9947bb21c4b35bf61d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/DeferredMessageManager.cs

@@ -3,12 +3,12 @@ using Unity.Collections;
 
 namespace Unity.Netcode
 {
-    internal class DeferredMessageManager : IDeferredMessageManager
+    internal class DeferredMessageManager : IDeferredNetworkMessageManager
     {
         protected struct TriggerData
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int SerializedHeaderSize;
@@ -19,7 +19,7 @@ namespace Unity.Netcode
             public NativeList<TriggerData> TriggerData;
         }
 
-        protected readonly Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+        protected readonly Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
 
         private readonly NetworkManager m_NetworkManager;
 
@@ -36,7 +36,7 @@ namespace Unity.Netcode
         /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
         /// without the requested object ID being spawned, the triggers for it are automatically deleted.
         /// </summary>
-        public virtual unsafe void DeferMessage(IDeferredMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
         {
             if (!m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -90,7 +90,7 @@ namespace Unity.Netcode
             }
         }
 
-        protected virtual void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
         {
             if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
             {
@@ -105,7 +105,7 @@ namespace Unity.Netcode
             triggerInfo.TriggerData.Dispose();
         }
 
-        public virtual void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public virtual void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             if (m_Triggers.TryGetValue(trigger, out var triggers))
             {
@@ -116,7 +116,7 @@ namespace Unity.Netcode
                     foreach (var deferredMessage in triggerInfo.TriggerData)
                     {
                         // Reader will be disposed within HandleMessage
-                        m_NetworkManager.MessagingSystem.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
+                        m_NetworkManager.ConnectionManager.MessageManager.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
                     }
 
                     triggerInfo.TriggerData.Dispose();

Runtime/Messaging/DisconnectReasonMessage.cs

@@ -10,11 +10,9 @@ namespace Unity.Netcode
         {
             string reasonSent = Reason ?? string.Empty;
 
-            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion
-            // on this side of things - we just have to make sure the receiving side knows what version we sent it,
-            // since whoever has the higher version number is responsible for versioning and they may be the one
-            // with the higher version number.
+            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion on this side of things.
+            // We just have to make sure the receiving side knows what version we sent it, since whoever has the higher version number is responsible for versioning and they may be the one with the higher version number.
             BytePacker.WriteValueBitPacked(writer, Version);
 
             if (writer.TryBeginWrite(FastBufferWriter.GetWriteSize(reasonSent)))
@@ -24,15 +22,14 @@ namespace Unity.Netcode
             else
             {
                 writer.WriteValueSafe(string.Empty);
-                NetworkLog.LogWarning(
-                    "Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
+                NetworkLog.LogWarning("Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
             }
         }
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message
-            // itself. This will override what we got from MessagingSystem... which will always be 0 here.
+            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // This will override what we got from MessageManager... which will always be 0 here.
             ByteUnpacker.ReadValueBitPacked(reader, out receivedMessageVersion);
             reader.ReadValueSafe(out Reason);
             return true;
@@ -40,7 +37,7 @@ namespace Unity.Netcode
 
         public void Handle(ref NetworkContext context)
         {
-            ((NetworkManager)context.SystemOwner).DisconnectReason = Reason;
+            ((NetworkManager)context.SystemOwner).ConnectionManager.DisconnectReason = Reason;
         }
     };
 }

Runtime/Messaging/IDeferredNetworkMessageManager.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal interface IDeferredMessageManager
+    internal interface IDeferredNetworkMessageManager
     {
         internal enum TriggerType
         {

Runtime/Messaging/ILPPMessageProvider.cs

@@ -2,14 +2,14 @@ using System.Collections.Generic;
 
 namespace Unity.Netcode
 {
-    internal struct ILPPMessageProvider : IMessageProvider
+    internal struct ILPPMessageProvider : INetworkMessageProvider
     {
 #pragma warning disable IDE1006 // disable naming rule violation check
         // This is NOT modified by RuntimeAccessModifiersILPP right now, but is populated by ILPP.
-        internal static readonly List<MessagingSystem.MessageWithHandler> __network_message_types = new List<MessagingSystem.MessageWithHandler>();
+        internal static readonly List<NetworkMessageManager.MessageWithHandler> __network_message_types = new List<NetworkMessageManager.MessageWithHandler>();
 #pragma warning restore IDE1006 // restore naming rule violation check
 
-        public List<MessagingSystem.MessageWithHandler> GetMessages()
+        public List<NetworkMessageManager.MessageWithHandler> GetMessages()
         {
             return __network_message_types;
         }

Runtime/Messaging/IMessageProvider.cs

@@ -1,9 +0,0 @@
-using System.Collections.Generic;
-
-namespace Unity.Netcode
-{
-    internal interface IMessageProvider
-    {
-        List<MessagingSystem.MessageWithHandler> GetMessages();
-    }
-}

Runtime/Messaging/INetworkMessage.cs

@@ -1,4 +1,3 @@
-using Unity.Collections;
 
 namespace Unity.Netcode
 {

Runtime/Messaging/INetworkMessageProvider.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    internal interface INetworkMessageProvider
+    {
+        List<NetworkMessageManager.MessageWithHandler> GetMessages();
+    }
+}

Runtime/Messaging/INetworkMessageSender.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode
 {
-    internal interface IMessageSender
+    internal interface INetworkMessageSender
     {
         void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData);
     }

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -24,7 +24,7 @@ namespace Unity.Netcode
             ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
 

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -84,18 +84,18 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
                 messageHashesInOrder[i] = messageVersion.Hash;
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionApprovedMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
                 }
             }
-            networkManager.MessagingSystem.SetServerMessageOrder(messageHashesInOrder);
+            networkManager.ConnectionManager.MessageManager.SetServerMessageOrder(messageHashesInOrder);
             messageHashesInOrder.Dispose();
             // ============================================================
             // END FORBIDDEN SEGMENT
@@ -117,8 +117,11 @@ namespace Unity.Netcode
             networkManager.NetworkTimeSystem.Reset(time.Time, 0.15f); // Start with a constant RTT of 150 until we receive values from the transport.
             networkManager.NetworkTickSystem.Reset(networkManager.NetworkTimeSystem.LocalTime, networkManager.NetworkTimeSystem.ServerTime);
 
-            networkManager.LocalClient = new NetworkClient() { ClientId = networkManager.LocalClientId };
-            networkManager.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.SetRole(false, true, networkManager);
+            networkManager.ConnectionManager.LocalClient.IsApproved = true;
+            networkManager.ConnectionManager.LocalClient.ClientId = OwnerClientId;
+            // Stop the client-side approval timeout coroutine since we are approved.
+            networkManager.ConnectionManager.StopClientApprovalCoroutine();
 
             // Only if scene management is disabled do we handle NetworkObject synchronization at this point
             if (!networkManager.NetworkConfig.EnableSceneManagement)
@@ -138,7 +141,7 @@ namespace Unity.Netcode
                 // Mark the client being connected
                 networkManager.IsConnectedClient = true;
                 // When scene management is disabled we notify after everything is synchronized
-                networkManager.InvokeOnClientConnectedCallback(context.SenderId);
+                networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
             }
         }
     }

Runtime/Messaging/Messages/ConnectionRequestMessage.cs

@@ -59,11 +59,11 @@ namespace Unity.Netcode
             {
                 var messageVersion = new MessageVersionData();
                 messageVersion.Deserialize(reader);
-                networkManager.MessagingSystem.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
+                networkManager.ConnectionManager.MessageManager.SetVersion(context.SenderId, messageVersion.Hash, messageVersion.Version);
 
                 // Update the received version since this message will always be passed version 0, due to the map not
                 // being initialized until just now.
-                var messageType = networkManager.MessagingSystem.GetMessageForHash(messageVersion.Hash);
+                var messageType = networkManager.ConnectionManager.MessageManager.GetMessageForHash(messageVersion.Hash);
                 if (messageType == typeof(ConnectionRequestMessage))
                 {
                     receivedMessageVersion = messageVersion.Version;
@@ -135,7 +135,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             var senderId = context.SenderId;
 
-            if (networkManager.PendingClients.TryGetValue(senderId, out PendingClient client))
+            if (networkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client))
             {
                 // Set to pending approval to prevent future connection requests from being approved
                 client.ConnectionState = PendingClient.State.PendingApproval;
@@ -143,17 +143,8 @@ namespace Unity.Netcode
 
             if (networkManager.NetworkConfig.ConnectionApproval)
             {
-                // Note: Delegate creation allocates.
-                // Note: ToArray() also allocates. :(
-                var response = new NetworkManager.ConnectionApprovalResponse();
-                networkManager.ClientsToApprove[senderId] = response;
-
-                networkManager.ConnectionApprovalCallback(
-                    new NetworkManager.ConnectionApprovalRequest
-                    {
-                        Payload = ConnectionData,
-                        ClientNetworkId = senderId
-                    }, response);
+                var messageRequest = this;
+                networkManager.ConnectionManager.ApproveConnection(ref messageRequest, ref context);
             }
             else
             {
@@ -162,7 +153,7 @@ namespace Unity.Netcode
                     Approved = true,
                     CreatePlayerObject = networkManager.NetworkConfig.PlayerPrefab != null
                 };
-                networkManager.HandleConnectionApproval(senderId, response);
+                networkManager.ConnectionManager.HandleConnectionApproval(senderId, response);
             }
         }
     }

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -23,7 +23,7 @@ namespace Unity.Netcode
             ObjectInfo.Deserialize(reader);
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -26,7 +26,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(NetworkObjectId, out var networkObject))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -67,8 +67,8 @@ namespace Unity.Netcode
                 // The object containing the behaviour we're about to process is about to be shown to this client
                 // As a result, the client will get the fully serialized NetworkVariable and would be confused by
                 // an extraneous delta
-                if (NetworkBehaviour.NetworkManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
-                    NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId]
+                if (NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    NetworkBehaviour.NetworkManager.SpawnManager.ObjectsToShowToClient[TargetClientId]
                     .Contains(NetworkBehaviour.NetworkObject))
                 {
                     shouldWrite = false;
@@ -90,7 +90,7 @@ namespace Unity.Netcode
                 {
                     if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                     {
-                        var tempWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
+                        var tempWriter = new FastBufferWriter(NetworkBehaviour.NetworkManager.MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp, NetworkBehaviour.NetworkManager.MessageManager.FragmentedMessageMaxSize);
                         NetworkBehaviour.NetworkVariableFields[i].WriteDelta(tempWriter);
                         BytePacker.WriteValueBitPacked(writer, tempWriter.Length);
 
@@ -234,7 +234,7 @@ namespace Unity.Netcode
             }
             else
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -85,7 +85,7 @@ namespace Unity.Netcode
 
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -23,7 +23,7 @@ namespace Unity.Netcode
             var networkManager = (NetworkManager)context.SystemOwner;
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(metadata.NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, metadata.NetworkObjectId, reader, ref context);
                 return false;
             }
 

Runtime/Messaging/NetworkBatchHeader.cs

@@ -3,7 +3,7 @@ namespace Unity.Netcode
     /// <summary>
     /// Header placed at the start of each message batch
     /// </summary>
-    internal struct BatchHeader : INetworkSerializeByMemcpy
+    internal struct NetworkBatchHeader : INetworkSerializeByMemcpy
     {
         internal const ushort MagicValue = 0x1160;
         /// <summary>

Runtime/Messaging/NetworkContext.cs

@@ -6,7 +6,7 @@ namespace Unity.Netcode
     internal ref struct NetworkContext
     {
         /// <summary>
-        /// An opaque object used to represent the owner of the MessagingSystem that's receiving the message.
+        /// An opaque object used to represent the owner of the NetworkMessageManager that's receiving the message.
         /// Outside of testing environments, the type of this variable will be <see cref="NetworkManager"/>
         /// </summary>
         public object SystemOwner;
@@ -24,7 +24,7 @@ namespace Unity.Netcode
         /// <summary>
         /// The header data that was sent with the message
         /// </summary>
-        public MessageHeader Header;
+        public NetworkMessageHeader Header;
 
         /// <summary>
         /// The actual serialized size of the header when packed into the buffer

Runtime/Messaging/NetworkManagerHooks.cs

@@ -0,0 +1,119 @@
+using System;
+
+namespace Unity.Netcode
+{
+    internal class NetworkManagerHooks : INetworkHooks
+    {
+        private NetworkManager m_NetworkManager;
+
+        internal NetworkManagerHooks(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery, int messageSizeBytes) where T : INetworkMessage
+        {
+        }
+
+        public void OnBeforeReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnAfterReceiveMessage(ulong senderId, Type messageType, int messageSizeBytes)
+        {
+        }
+
+        public void OnBeforeSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnAfterSendBatch(ulong clientId, int messageCount, int batchSizeInBytes, NetworkDelivery delivery)
+        {
+        }
+
+        public void OnBeforeReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public void OnAfterReceiveBatch(ulong senderId, int messageCount, int batchSizeInBytes)
+        {
+        }
+
+        public bool OnVerifyCanSend(ulong destinationId, Type messageType, NetworkDelivery delivery)
+        {
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
+        {
+            if (m_NetworkManager.IsServer)
+            {
+                if (messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectionManager.PendingClients.TryGetValue(senderId, out PendingClient client) && (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+            }
+            else
+            {
+                if (messageType == typeof(ConnectionRequestMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+
+                if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage))
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                    }
+
+                    return false;
+                }
+            }
+
+            return !m_NetworkManager.MessageManager.StopProcessing;
+        }
+
+        public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+
+        public void OnAfterHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
+        {
+        }
+    }
+}

Runtime/Messaging/NetworkManagerHooks.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c2be7fa492911d549bfca52be96c0906
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/NetworkMessageHeader.cs

@@ -3,13 +3,11 @@ namespace Unity.Netcode
     /// <summary>
     /// This is the header data that's serialized to the network when sending an <see cref="INetworkMessage"/>
     /// </summary>
-    internal struct MessageHeader : INetworkSerializeByMemcpy
+    internal struct NetworkMessageHeader : INetworkSerializeByMemcpy
     {
         /// <summary>
-        /// The byte representation of the message type. This is automatically assigned to each message
-        /// by the MessagingSystem. This value is deterministic only so long as the list of messages remains
-        /// unchanged - if new messages are added or messages are removed, MessageType assignments may be
-        /// calculated differently.
+        /// The byte representation of the message type. This is automatically assigned to each message by the NetworkMessageManager.
+        /// This value is deterministic only so long as the list of messages remains unchanged - if new messages are added or messages are removed, MessageType assignments may be calculated differently.
         /// </summary>
         public uint MessageType;
 

Runtime/Messaging/NetworkMessageManager.cs

@@ -11,22 +11,34 @@ namespace Unity.Netcode
 {
     internal class HandlerNotRegisteredException : SystemException
     {
-        public HandlerNotRegisteredException() { }
-        public HandlerNotRegisteredException(string issue) : base(issue) { }
+        public HandlerNotRegisteredException()
+        {
+        }
+
+        public HandlerNotRegisteredException(string issue) : base(issue)
+        {
+        }
     }
 
     internal class InvalidMessageStructureException : SystemException
     {
-        public InvalidMessageStructureException() { }
-        public InvalidMessageStructureException(string issue) : base(issue) { }
+        public InvalidMessageStructureException()
+        {
+        }
+
+        public InvalidMessageStructureException(string issue) : base(issue)
+        {
+        }
     }
 
-    internal class MessagingSystem : IDisposable
+    internal class NetworkMessageManager : IDisposable
     {
+        public bool StopProcessing = false;
+
         private struct ReceiveQueueItem
         {
             public FastBufferReader Reader;
-            public MessageHeader Header;
+            public NetworkMessageHeader Header;
             public ulong SenderId;
             public float Timestamp;
             public int MessageHeaderSerializedSize;
@@ -34,7 +46,7 @@ namespace Unity.Netcode
 
         private struct SendQueueItem
         {
-            public BatchHeader BatchHeader;
+            public NetworkBatchHeader BatchHeader;
             public FastBufferWriter Writer;
             public readonly NetworkDelivery NetworkDelivery;
 
@@ -42,11 +54,12 @@ namespace Unity.Netcode
             {
                 Writer = new FastBufferWriter(writerSize, writerAllocator, maxWriterSize);
                 NetworkDelivery = delivery;
-                BatchHeader = new BatchHeader { Magic = BatchHeader.MagicValue };
+                BatchHeader = new NetworkBatchHeader { Magic = NetworkBatchHeader.MagicValue };
             }
         }
 
-        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, MessagingSystem system);
+        internal delegate void MessageHandler(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager);
+
         internal delegate int VersionGetter();
 
         private NativeList<ReceiveQueueItem> m_IncomingMessageQueue = new NativeList<ReceiveQueueItem>(16, Allocator.Persistent);
@@ -58,6 +71,8 @@ namespace Unity.Netcode
         private Dictionary<Type, uint> m_MessageTypes = new Dictionary<Type, uint>();
         private Dictionary<ulong, NativeList<SendQueueItem>> m_SendQueues = new Dictionary<ulong, NativeList<SendQueueItem>>();
 
+        private HashSet<ulong> m_DisconnectedClients = new HashSet<ulong>();
+
         // This is m_PerClientMessageVersion[clientId][messageType] = version
         private Dictionary<ulong, Dictionary<Type, int>> m_PerClientMessageVersions = new Dictionary<ulong, Dictionary<Type, int>>();
         private Dictionary<uint, Type> m_MessagesByHash = new Dictionary<uint, Type>();
@@ -67,7 +82,7 @@ namespace Unity.Netcode
 
         private uint m_HighMessageType;
         private object m_Owner;
-        private IMessageSender m_MessageSender;
+        private INetworkMessageSender m_Sender;
         private bool m_Disposed;
 
         internal Type[] MessageTypes => m_ReverseTypeMap;
@@ -80,8 +95,9 @@ namespace Unity.Netcode
             return m_MessageTypes[t];
         }
 
-        public const int NON_FRAGMENTED_MESSAGE_MAX_SIZE = 1300;
-        public const int FRAGMENTED_MESSAGE_MAX_SIZE = int.MaxValue;
+        public const int DefaultNonFragmentedMessageMaxSize = 1300;
+        public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
+        public int FragmentedMessageMaxSize = int.MaxValue;
 
         internal struct MessageWithHandler
         {
@@ -94,7 +110,7 @@ namespace Unity.Netcode
         {
             var prioritizedTypes = new List<MessageWithHandler>();
 
-            // first pass puts the priority message in the first indices
+            // First pass puts the priority message in the first indices
             // Those are the messages that must be delivered in order to allow re-ordering the others later
             foreach (var t in allowedTypes)
             {
@@ -117,17 +133,18 @@ namespace Unity.Netcode
             return prioritizedTypes;
         }
 
-        public MessagingSystem(IMessageSender messageSender, object owner, IMessageProvider provider = null)
+        public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
-                m_MessageSender = messageSender;
+                m_Sender = sender;
                 m_Owner = owner;
 
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
+
                 var allowedTypes = provider.GetMessages();
 
                 allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
@@ -144,20 +161,21 @@ namespace Unity.Netcode
             }
         }
 
-        public unsafe void Dispose()
+        public void Dispose()
         {
             if (m_Disposed)
             {
                 return;
             }
 
-            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes
-            // from the queue.
+            // Can't just iterate SendQueues or SendQueues.Keys because ClientDisconnected removes from the queue.
             foreach (var kvp in m_SendQueues)
             {
-                CleanupDisconnectedClient(kvp.Key);
+                ClientDisconnected(kvp.Key);
             }
 
+            CleanupDisconnectedClients();
+
             for (var queueIndex = 0; queueIndex < m_IncomingMessageQueue.Length; ++queueIndex)
             {
                 // Avoid copies...
@@ -169,7 +187,7 @@ namespace Unity.Netcode
             m_Disposed = true;
         }
 
-        ~MessagingSystem()
+        ~NetworkMessageManager()
         {
             Dispose();
         }
@@ -186,7 +204,7 @@ namespace Unity.Netcode
 
         private void RegisterMessageType(MessageWithHandler messageWithHandler)
         {
-            // if we are out of space, perform amortized linear growth
+            // If we are out of space, perform amortized linear growth
             if (m_HighMessageType == m_MessageHandlers.Length)
             {
                 Array.Resize(ref m_MessageHandlers, 2 * m_MessageHandlers.Length);
@@ -220,19 +238,18 @@ namespace Unity.Netcode
         {
             unsafe
             {
-                fixed (byte* nativeData = data.Array)
+                fixed (byte* dataPtr = data.Array)
                 {
-                    var batchReader =
-                        new FastBufferReader(nativeData + data.Offset, Allocator.None, data.Count);
-                    if (!batchReader.TryBeginRead(sizeof(BatchHeader)))
+                    var batchReader = new FastBufferReader(dataPtr + data.Offset, Allocator.None, data.Count);
+                    if (!batchReader.TryBeginRead(sizeof(NetworkBatchHeader)))
                     {
                         NetworkLog.LogError("Received a packet too small to contain a BatchHeader. Ignoring it.");
                         return;
                     }
 
-                    batchReader.ReadValue(out BatchHeader batchHeader);
+                    batchReader.ReadValue(out NetworkBatchHeader batchHeader);
 
-                    if (batchHeader.Magic != BatchHeader.MagicValue)
+                    if (batchHeader.Magic != NetworkBatchHeader.MagicValue)
                     {
                         NetworkLog.LogError($"Received a packet with an invalid Magic Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
                         return;
@@ -259,8 +276,7 @@ namespace Unity.Netcode
 
                     for (var messageIdx = 0; messageIdx < batchHeader.BatchCount; ++messageIdx)
                     {
-
-                        var messageHeader = new MessageHeader();
+                        var messageHeader = new NetworkMessageHeader();
                         var position = batchReader.Position;
                         try
                         {
@@ -280,19 +296,20 @@ namespace Unity.Netcode
                             NetworkLog.LogError("Received a message that claimed a size larger than the packet, ending early!");
                             return;
                         }
+
                         m_IncomingMessageQueue.Add(new ReceiveQueueItem
                         {
                             Header = messageHeader,
                             SenderId = clientId,
                             Timestamp = receiveTime,
                             // Copy the data for this message into a new FastBufferReader that owns that memory.
-                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it,
-                            // so we must move it to memory we do own.
+                            // We can't guarantee the memory in the ArraySegment stays valid because we don't own it, so we must move it to memory we do own.
                             Reader = new FastBufferReader(batchReader.GetUnsafePtrAtCurrentPosition(), Allocator.TempJob, (int)messageHeader.MessageSize),
                             MessageHeaderSerializedSize = receivedHeaderSize,
                         });
                         batchReader.Seek(batchReader.Position + (int)messageHeader.MessageSize);
                     }
+
                     for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                     {
                         m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length);
@@ -320,6 +337,7 @@ namespace Unity.Netcode
             {
                 return null;
             }
+
             return m_MessagesByHash[messageHash];
         }
 
@@ -329,6 +347,7 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             var messageType = m_MessagesByHash[messageHash];
 
             if (!m_PerClientMessageVersions.ContainsKey(clientId))
@@ -353,6 +372,7 @@ namespace Unity.Netcode
                 {
                     continue;
                 }
+
                 var messageType = m_MessagesByHash[messagesInIdOrder[i]];
                 var oldId = oldTypes[messageType];
                 var handler = oldHandlers[oldId];
@@ -363,7 +383,7 @@ namespace Unity.Netcode
             }
         }
 
-        public void HandleMessage(in MessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
+        public void HandleMessage(in NetworkMessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
         {
             using (reader)
             {
@@ -372,6 +392,7 @@ namespace Unity.Netcode
                     Debug.LogWarning($"Received a message with invalid message type value {header.MessageType}");
                     return;
                 }
+
                 var context = new NetworkContext
                 {
                     SystemOwner = m_Owner,
@@ -391,13 +412,12 @@ namespace Unity.Netcode
                 var handler = m_MessageHandlers[header.MessageType];
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
 
-                // This will also log an exception is if the server knows about a message type the client doesn't know
-                // about. In this case the handler will be null. It is still an issue the user must deal with: If the
-                // two connecting builds know about different messages, the server should not send a message to a client
-                // that doesn't know about it
+                // This will also log an exception is if the server knows about a message type the client doesn't know about.
+                // In this case the handler will be null. It is still an issue the user must deal with:
+                // If the two connecting builds know about different messages, the server should not send a message to a client that doesn't know about it
                 if (handler == null)
                 {
                     Debug.LogException(new HandlerNotRegisteredException(header.MessageType.ToString()));
@@ -406,9 +426,7 @@ namespace Unity.Netcode
                 {
                     // No user-land message handler exceptions should escape the receive loop.
                     // If an exception is throw, the message is ignored.
-                    // Example use case: A bad message is received that can't be deserialized and throws
-                    // an OverflowException because it specifies a length greater than the number of bytes in it
-                    // for some dynamic-length value.
+                    // Example use case: A bad message is received that can't be deserialized and throws an OverflowException because it specifies a length greater than the number of bytes in it for some dynamic-length value.
                     try
                     {
                         handler.Invoke(reader, ref context, this);
@@ -418,15 +436,21 @@ namespace Unity.Netcode
                         Debug.LogException(e);
                     }
                 }
+
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
-                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
                 }
             }
         }
 
-        internal unsafe void ProcessIncomingMessageQueue()
+        internal void ProcessIncomingMessageQueue()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             for (var index = 0; index < m_IncomingMessageQueue.Length; ++index)
             {
                 // Avoid copies...
@@ -447,21 +471,22 @@ namespace Unity.Netcode
             {
                 return;
             }
+
             m_SendQueues[clientId] = new NativeList<SendQueueItem>(16, Allocator.Persistent);
         }
 
         internal void ClientDisconnected(ulong clientId)
         {
-            if (!m_SendQueues.ContainsKey(clientId))
-            {
-                return;
-            }
-            CleanupDisconnectedClient(clientId);
-            m_SendQueues.Remove(clientId);
+            m_DisconnectedClients.Add(clientId);
         }
 
         private void CleanupDisconnectedClient(ulong clientId)
         {
+            if (!m_SendQueues.ContainsKey(clientId))
+            {
+                return;
+            }
+
             var queue = m_SendQueues[clientId];
             for (var i = 0; i < queue.Length; ++i)
             {
@@ -469,23 +494,19 @@ namespace Unity.Netcode
             }
 
             queue.Dispose();
+            m_SendQueues.Remove(clientId);
+
+            m_PerClientMessageVersions.Remove(clientId);
         }
 
         internal void CleanupDisconnectedClients()
         {
-            var removeList = new NativeList<ulong>(Allocator.Temp);
-            foreach (var clientId in m_PerClientMessageVersions.Keys)
+            foreach (var clientId in m_DisconnectedClients)
             {
-                if (!m_SendQueues.ContainsKey(clientId))
-                {
-                    removeList.Add(clientId);
-                }
+                CleanupDisconnectedClient(clientId);
             }
 
-            foreach (var clientId in removeList)
-            {
-                m_PerClientMessageVersions.Remove(clientId);
-            }
+            m_DisconnectedClients.Clear();
         }
 
         public static int CreateMessageAndGetVersion<T>() where T : INetworkMessage, new()
@@ -500,14 +521,15 @@ namespace Unity.Netcode
                 if (forReceive)
                 {
                     Debug.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
-
                 }
                 else
                 {
                     Debug.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
                 }
+
                 return -1;
             }
+
             if (!versionMap.TryGetValue(type, out var messageVersion))
             {
                 return -1;
@@ -516,7 +538,7 @@ namespace Unity.Netcode
             return messageVersion;
         }
 
-        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, MessagingSystem system) where T : INetworkMessage, new()
+        public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
         {
             var message = new T();
             var messageVersion = 0;
@@ -525,24 +547,25 @@ namespace Unity.Netcode
             // and can't change.
             if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage))
             {
-                messageVersion = system.GetMessageVersion(typeof(T), context.SenderId, true);
+                messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
                 if (messageVersion < 0)
                 {
                     return;
                 }
             }
+
             if (message.Deserialize(reader, ref context, messageVersion))
             {
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnBeforeHandleMessage(ref message, ref context);
                 }
 
                 message.Handle(ref context);
 
-                for (var hookIdx = 0; hookIdx < system.m_Hooks.Count; ++hookIdx)
+                for (var hookIdx = 0; hookIdx < manager.m_Hooks.Count; ++hookIdx)
                 {
-                    system.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
+                    manager.m_Hooks[hookIdx].OnAfterHandleMessage(ref message, ref context);
                 }
             }
         }
@@ -574,9 +597,8 @@ namespace Unity.Netcode
             for (var i = 0; i < clientIds.Count; ++i)
             {
                 var messageVersion = 0;
-                // Special case because this is the message that carries the version info - thus the version info isn't
-                // populated yet when we get this. The first part of this message always has to be the version data
-                // and can't change.
+                // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
+                // The first part of this message always has to be the version data and can't change.
                 if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
                     messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
@@ -594,9 +616,9 @@ namespace Unity.Netcode
 
                 sentMessageVersions.Add(messageVersion);
 
-                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FRAGMENTED_MESSAGE_MAX_SIZE : NON_FRAGMENTED_MESSAGE_MAX_SIZE;
+                var maxSize = delivery == NetworkDelivery.ReliableFragmentedSequenced ? FragmentedMessageMaxSize : NonFragmentedMessageMaxSize;
 
-                using var tmpSerializer = new FastBufferWriter(NON_FRAGMENTED_MESSAGE_MAX_SIZE - FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<MessageHeader>());
+                using var tmpSerializer = new FastBufferWriter(NonFragmentedMessageMaxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp, maxSize - FastBufferWriter.GetWriteSize<NetworkMessageHeader>());
 
                 message.Serialize(tmpSerializer, messageVersion);
 
@@ -612,9 +634,9 @@ namespace Unity.Netcode
         internal unsafe int SendPreSerializedMessage<TMessageType>(in FastBufferWriter tmpSerializer, int maxSize, ref TMessageType message, NetworkDelivery delivery, in IReadOnlyList<ulong> clientIds, int messageVersionFilter)
             where TMessageType : INetworkMessage
         {
-            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<MessageHeader>(), Allocator.Temp);
+            using var headerSerializer = new FastBufferWriter(FastBufferWriter.GetWriteSize<NetworkMessageHeader>(), Allocator.Temp);
 
-            var header = new MessageHeader
+            var header = new NetworkMessageHeader
             {
                 MessageSize = (uint)tmpSerializer.Length,
                 MessageType = m_MessageTypes[typeof(TMessageType)],
@@ -624,13 +646,16 @@ namespace Unity.Netcode
 
             for (var i = 0; i < clientIds.Count; ++i)
             {
-                var messageVersion = 0;
-                // Special case because this is the message that carries the version info - thus the version info isn't
-                // populated yet when we get this. The first part of this message always has to be the version data
-                // and can't change.
+                if (m_DisconnectedClients.Contains(clientIds[i]))
+                {
+                    continue;
+                }
+
+                // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
+                // The first part of this message always has to be the version data and can't change.
                 if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
                 {
-                    messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
+                    var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
                     {
                         // Client doesn't know this message exists, don't send it at all.
@@ -658,20 +683,16 @@ namespace Unity.Netcode
                 var sendQueueItem = m_SendQueues[clientId];
                 if (sendQueueItem.Length == 0)
                 {
-                    sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                        maxSize));
-                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(BatchHeader));
+                    sendQueueItem.Add(new SendQueueItem(delivery, NonFragmentedMessageMaxSize, Allocator.TempJob, maxSize));
+                    sendQueueItem.ElementAt(0).Writer.Seek(sizeof(NetworkBatchHeader));
                 }
                 else
                 {
                     ref var lastQueueItem = ref sendQueueItem.ElementAt(sendQueueItem.Length - 1);
-                    if (lastQueueItem.NetworkDelivery != delivery ||
-                        lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position
-                        < tmpSerializer.Length + headerSerializer.Length)
+                    if (lastQueueItem.NetworkDelivery != delivery || lastQueueItem.Writer.MaxCapacity - lastQueueItem.Writer.Position < tmpSerializer.Length + headerSerializer.Length)
                     {
-                        sendQueueItem.Add(new SendQueueItem(delivery, NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.TempJob,
-                            maxSize));
-                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(BatchHeader));
+                        sendQueueItem.Add(new SendQueueItem(delivery, NonFragmentedMessageMaxSize, Allocator.TempJob, maxSize));
+                        sendQueueItem.ElementAt(sendQueueItem.Length - 1).Writer.Seek(sizeof(NetworkBatchHeader));
                     }
                 }
 
@@ -768,6 +789,11 @@ namespace Unity.Netcode
 
         internal unsafe void ProcessSendQueues()
         {
+            if (StopProcessing)
+            {
+                return;
+            }
+
             foreach (var kvp in m_SendQueues)
             {
                 var clientId = kvp.Key;
@@ -775,6 +801,15 @@ namespace Unity.Netcode
                 for (var i = 0; i < sendQueueItem.Length; ++i)
                 {
                     ref var queueItem = ref sendQueueItem.ElementAt(i);
+                    // This is checked at every iteration because
+                    // 1) each writer needs to be disposed, so we have to do the full loop regardless, and
+                    // 2) the call to m_MessageSender.Send() may result in calling ClientDisconnected(), so the result of this check may change partway through iteration
+                    if (m_DisconnectedClients.Contains(clientId))
+                    {
+                        queueItem.Writer.Dispose();
+                        continue;
+                    }
+
                     if (queueItem.BatchHeader.BatchCount == 0)
                     {
                         queueItem.Writer.Dispose();
@@ -789,9 +824,9 @@ namespace Unity.Netcode
                     queueItem.Writer.Seek(0);
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
                     // Skipping the Verify and sneaking the write mark in because we know it's fine.
-                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(BatchHeader);
+                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(NetworkBatchHeader);
 #endif
-                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(BatchHeader), queueItem.Writer.Length - sizeof(BatchHeader));
+                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), queueItem.Writer.Length - sizeof(NetworkBatchHeader));
 
                     queueItem.BatchHeader.BatchSize = queueItem.Writer.Length;
 
@@ -800,7 +835,7 @@ namespace Unity.Netcode
 
                     try
                     {
-                        m_MessageSender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
+                        m_Sender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
 
                         for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                         {
@@ -812,6 +847,7 @@ namespace Unity.Netcode
                         queueItem.Writer.Dispose();
                     }
                 }
+
                 sendQueueItem.Clear();
             }
         }

Runtime/Metrics/NetworkMetricsManager.cs

@@ -0,0 +1,44 @@
+#if MULTIPLAYER_TOOLS
+using Unity.Multiplayer.Tools;
+#endif
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This probably needs to all be migrated into <see cref="NetworkConnectionManager"/>, but
+    /// keeping it separated for the time being
+    /// </summary>
+    internal class NetworkMetricsManager
+    {
+        internal INetworkMetrics NetworkMetrics { get; private set; }
+
+        private NetworkManager m_NetworkManager;
+
+        public void UpdateMetrics()
+        {
+            NetworkMetrics.UpdateNetworkObjectsCount(m_NetworkManager.SpawnManager.SpawnedObjects.Count);
+            NetworkMetrics.UpdateConnectionsCount((m_NetworkManager.IsServer) ? m_NetworkManager.ConnectionManager.ConnectedClients.Count : 1);
+            NetworkMetrics.DispatchFrame();
+        }
+
+        public void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            if (NetworkMetrics == null)
+            {
+#if MULTIPLAYER_TOOLS
+                NetworkMetrics = new NetworkMetrics();
+#else
+                NetworkMetrics = new NullNetworkMetrics();
+#endif
+            }
+
+#if MULTIPLAYER_TOOLS
+            NetworkSolutionInterface.SetInterface(new NetworkSolutionInterfaceParameters
+            {
+                NetworkObjectProvider = new NetworkObjectProvider(networkManager),
+            });
+#endif
+        }
+    }
+}

Runtime/Metrics/NetworkMetricsManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b20a0fe127a24d48867c2ee448bdb1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/NetworkVariable/Collections/NetworkList.cs

@@ -75,7 +75,7 @@ namespace Unity.Netcode
                 return;
             }
 
-            m_NetworkBehaviour.NetworkManager.MarkNetworkObjectDirty(m_NetworkBehaviour.NetworkObject);
+            m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 
         /// <inheritdoc />
@@ -490,12 +490,14 @@ namespace Unity.Netcode
                 throw new InvalidOperationException("Client is not allowed to write to this NetworkList");
             }
 
+            var value = m_List[index];
             m_List.RemoveAt(index);
 
             var listEvent = new NetworkListEvent<T>()
             {
                 Type = NetworkListEvent<T>.EventType.RemoveAt,
-                Index = index
+                Index = index,
+                Value = value
             };
 
             HandleAddListEvent(listEvent);

Runtime/NetworkVariable/NetworkVariable.cs

@@ -33,6 +33,13 @@ namespace Unity.Netcode
             : base(readPerm, writePerm)
         {
             m_InternalValue = value;
+            // Since we start with IsDirty = true, this doesn't need to be duplicated
+            // right away. It won't get read until after ResetDirty() is called, and
+            // the duplicate will be made there. Avoiding calling
+            // NetworkVariableSerialization<T>.Duplicate() is important because calling
+            // it in the constructor might not give users enough time to set the
+            // DuplicateValue callback if they're using UserNetworkVariableSerialization
+            m_PreviousValue = default;
         }
 
         /// <summary>
@@ -41,6 +48,11 @@ namespace Unity.Netcode
         [SerializeField]
         private protected T m_InternalValue;
 
+        private protected T m_PreviousValue;
+
+        private bool m_HasPreviousValue;
+        private bool m_IsDisposed;
+
         /// <summary>
         /// The value of the NetworkVariable container
         /// </summary>
@@ -61,9 +73,83 @@ namespace Unity.Netcode
                 }
 
                 Set(value);
+                m_IsDisposed = false;
             }
         }
 
+        internal ref T RefValue()
+        {
+            return ref m_InternalValue;
+        }
+
+        public override void Dispose()
+        {
+            if (m_IsDisposed)
+            {
+                return;
+            }
+
+            m_IsDisposed = true;
+            if (m_InternalValue is IDisposable internalValueDisposable)
+            {
+                internalValueDisposable.Dispose();
+            }
+
+            m_InternalValue = default;
+            if (m_HasPreviousValue && m_PreviousValue is IDisposable previousValueDisposable)
+            {
+                m_HasPreviousValue = false;
+                previousValueDisposable.Dispose();
+            }
+
+            m_PreviousValue = default;
+        }
+
+        ~NetworkVariable()
+        {
+            Dispose();
+        }
+
+        /// <summary>
+        /// Gets Whether or not the container is dirty
+        /// </summary>
+        /// <returns>Whether or not the container is dirty</returns>
+        public override bool IsDirty()
+        {
+            // For most cases we can use the dirty flag.
+            // This doesn't work for cases where we're wrapping more complex types
+            // like INetworkSerializable, NativeList, NativeArray, etc.
+            // Changes to the values in those types don't call the Value.set method,
+            // so we can't catch those changes and need to compare the current value
+            // against the previous one.
+            if (base.IsDirty())
+            {
+                return true;
+            }
+
+            // Cache the dirty value so we don't perform this again if we already know we're dirty
+            // Unfortunately we can't cache the NOT dirty state, because that might change
+            // in between to checks... but the DIRTY state won't change until ResetDirty()
+            // is called.
+            var dirty = !NetworkVariableSerialization<T>.AreEqual(ref m_PreviousValue, ref m_InternalValue);
+            SetDirty(dirty);
+            return dirty;
+        }
+
+        /// <summary>
+        /// Resets the dirty state and marks the variable as synced / clean
+        /// </summary>
+        public override void ResetDirty()
+        {
+            base.ResetDirty();
+            // Resetting the dirty value declares that the current value is not dirty
+            // Therefore, we set the m_PreviousValue field to a duplicate of the current
+            // field, so that our next dirty check is made against the current "not dirty"
+            // value.
+            m_HasPreviousValue = true;
+            NetworkVariableSerialization<T>.Serializer.Duplicate(m_InternalValue, ref m_PreviousValue);
+        }
+
         /// <summary>
         /// Sets the <see cref="Value"/>, marks the <see cref="NetworkVariable{T}"/> dirty, and invokes the <see cref="OnValueChanged"/> callback
         /// if there are subscribers to that event.

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -94,7 +94,8 @@ namespace Unity.Netcode
                                      "Are you modifying a NetworkVariable before the NetworkObject is spawned?");
                     return;
                 }
-                m_NetworkBehaviour.NetworkManager.MarkNetworkObjectDirty(m_NetworkBehaviour.NetworkObject);
+
+                m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
             }
         }
 

Runtime/NetworkVariable/NetworkVariableSerialization.cs

@@ -20,6 +20,8 @@ namespace Unity.Netcode
         // of it to pass it as a ref parameter.
         public void Write(FastBufferWriter writer, ref T value);
         public void Read(FastBufferReader reader, ref T value);
+        internal void ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator);
+        public void Duplicate(in T value, ref T duplicatedValue);
     }
 
     /// <summary>
@@ -35,6 +37,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<short>.ReadWithAllocator(FastBufferReader reader, out short value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in short value, ref short duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -50,6 +62,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<ushort>.ReadWithAllocator(FastBufferReader reader, out ushort value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in ushort value, ref ushort duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -65,6 +87,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<int>.ReadWithAllocator(FastBufferReader reader, out int value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in int value, ref int duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -80,6 +112,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<uint>.ReadWithAllocator(FastBufferReader reader, out uint value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in uint value, ref uint duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -95,6 +137,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<long>.ReadWithAllocator(FastBufferReader reader, out long value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in long value, ref long duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -110,6 +162,16 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValueBitPacked(reader, out value);
         }
+
+        void INetworkVariableSerializer<ulong>.ReadWithAllocator(FastBufferReader reader, out ulong value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in ulong value, ref ulong duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
     /// <summary>
@@ -130,8 +192,84 @@ namespace Unity.Netcode
         {
             reader.ReadUnmanagedSafe(out value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
+    internal class UnmanagedArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteUnmanagedSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadUnmanagedSafe(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadUnmanagedSafe(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    internal class UnmanagedListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteUnmanagedSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadUnmanagedSafeInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for FixedStrings
     /// </summary>
@@ -146,8 +284,92 @@ namespace Unity.Netcode
         {
             reader.ReadValueSafeInPlace(ref value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
+        }
     }
 
+    /// <summary>
+    /// Serializer for FixedStrings
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FixedStringArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteValueSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadValueSafe(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadValueSafe(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    /// <summary>
+    /// Serializer for FixedStrings
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FixedStringListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INativeList<byte>, IUTF8Bytes
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteValueSafe(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadValueSafeInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for unmanaged INetworkSerializable types
     /// </summary>
@@ -163,10 +385,93 @@ namespace Unity.Netcode
         {
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
             value.NetworkSerialize(bufferSerializer);
+        }
 
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            duplicatedValue = value;
         }
     }
 
+    /// <summary>
+    /// Serializer for unmanaged INetworkSerializable types
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class UnmanagedNetworkSerializableArraySerializer<T> : INetworkVariableSerializer<NativeArray<T>> where T : unmanaged, INetworkSerializable
+    {
+        public void Write(FastBufferWriter writer, ref NativeArray<T> value)
+        {
+            writer.WriteNetworkSerializable(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeArray<T> value)
+        {
+            value.Dispose();
+            reader.ReadNetworkSerializable(out value, Allocator.Persistent);
+        }
+
+        void INetworkVariableSerializer<NativeArray<T>>.ReadWithAllocator(FastBufferReader reader, out NativeArray<T> value, Allocator allocator)
+        {
+            reader.ReadNetworkSerializable(out value, allocator);
+        }
+
+        public void Duplicate(in NativeArray<T> value, ref NativeArray<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated || duplicatedValue.Length != value.Length)
+            {
+                if (duplicatedValue.IsCreated)
+                {
+                    duplicatedValue.Dispose();
+                }
+
+                duplicatedValue = new NativeArray<T>(value.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+    /// <summary>
+    /// Serializer for unmanaged INetworkSerializable types
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class UnmanagedNetworkSerializableListSerializer<T> : INetworkVariableSerializer<NativeList<T>> where T : unmanaged, INetworkSerializable
+    {
+        public void Write(FastBufferWriter writer, ref NativeList<T> value)
+        {
+            writer.WriteNetworkSerializable(value);
+        }
+        public void Read(FastBufferReader reader, ref NativeList<T> value)
+        {
+            reader.ReadNetworkSerializableInPlace(ref value);
+        }
+
+        void INetworkVariableSerializer<NativeList<T>>.ReadWithAllocator(FastBufferReader reader, out NativeList<T> value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in NativeList<T> value, ref NativeList<T> duplicatedValue)
+        {
+            if (!duplicatedValue.IsCreated)
+            {
+                duplicatedValue = new NativeList<T>(value.Length, Allocator.Persistent);
+            }
+            else if (value.Length != duplicatedValue.Length)
+            {
+                duplicatedValue.ResizeUninitialized(value.Length);
+            }
+
+            duplicatedValue.CopyFrom(value);
+        }
+    }
+#endif
+
     /// <summary>
     /// Serializer for managed INetworkSerializable types, which differs from the unmanaged implementation in that it
     /// has to be null-aware
@@ -201,6 +506,21 @@ namespace Unity.Netcode
                 value.NetworkSerialize(bufferSerializer);
             }
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            using var writer = new FastBufferWriter(256, Allocator.Temp);
+            var refValue = value;
+            Write(writer, ref refValue);
+
+            using var reader = new FastBufferReader(writer, Allocator.None);
+            Read(reader, ref duplicatedValue);
+        }
     }
 
     /// <summary>
@@ -227,14 +547,26 @@ namespace Unity.Netcode
         public delegate void ReadValueDelegate(FastBufferReader reader, out T value);
 
         /// <summary>
-        /// The <see cref="WriteValueDelegate"/> delegate handler declaration
+        /// The read value delegate handler definition
+        /// </summary>
+        /// <param name="reader">The <see cref="FastBufferReader"/> to read the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be read</param>
+        public delegate void DuplicateValueDelegate(in T value, ref T duplicatedValue);
+
+        /// <summary>
+        /// Callback to write a value
         /// </summary>
         public static WriteValueDelegate WriteValue;
 
         /// <summary>
-        /// The <see cref="ReadValueDelegate"/> delegate handler declaration
+        /// Callback to read a value
         /// </summary>
         public static ReadValueDelegate ReadValue;
+
+        /// <summary>
+        /// Callback to create a duplicate of a value, used to check for dirty status.
+        /// </summary>
+        public static DuplicateValueDelegate DuplicateValue;
     }
 
     /// <summary>
@@ -250,20 +582,34 @@ namespace Unity.Netcode
     {
         public void Write(FastBufferWriter writer, ref T value)
         {
-            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null)
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
             {
-                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)} and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
             }
             UserNetworkVariableSerialization<T>.WriteValue(writer, value);
         }
         public void Read(FastBufferReader reader, ref T value)
         {
-            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null)
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
             {
-                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)} and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
             }
             UserNetworkVariableSerialization<T>.ReadValue(reader, out value);
         }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                throw new ArgumentException($"Type {typeof(T).FullName} is not supported by {typeof(NetworkVariable<>).Name}. If this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+            }
+            UserNetworkVariableSerialization<T>.DuplicateValue(value, ref duplicatedValue);
+        }
     }
 
     /// <summary>
@@ -309,6 +655,26 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new UnmanagedTypeSerializer<T>();
         }
 
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
         /// NetworkSerialize
@@ -319,6 +685,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new UnmanagedNetworkSerializableSerializer<T>();
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableArray<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedNetworkSerializableArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableList<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedNetworkSerializableListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that implements INetworkSerializable and will be serialized through a call to
         /// NetworkSerialize
@@ -339,6 +727,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.Serializer = new FixedStringSerializer<T>();
         }
 
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringArray<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new FixedStringArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringList<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new FixedStringListSerializer<T>();
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that will be checked for equality using T.Equals()
         /// </summary>
@@ -357,6 +767,26 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.AreEqual = NetworkVariableSerialization<T>.EqualityEquals;
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableArray<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableSerialization<T>.EqualityEqualsArray;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableList<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableSerialization<T>.EqualityEqualsList;
+        }
+#endif
+
         /// <summary>
         /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
         /// equal if they are bitwise equivalent in memory
@@ -367,6 +797,28 @@ namespace Unity.Netcode
             NetworkVariableSerialization<T>.AreEqual = NetworkVariableSerialization<T>.ValueEquals;
         }
 
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableSerialization<T>.ValueEqualsArray;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableSerialization<T>.ValueEqualsList;
+        }
+#endif
+
         /// <summary>
         /// Registers a managed type that will be checked for equality using the == operator
         /// </summary>
@@ -405,6 +857,58 @@ namespace Unity.Netcode
             return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType)) == 0;
         }
 
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+#endif
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+
         internal static bool EqualityEqualsObject<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class, IEquatable<TValueType>
         {
             if (a == null)
@@ -425,6 +929,74 @@ namespace Unity.Netcode
             return a.Equals(b);
         }
 
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+#endif
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         internal static bool ClassEquals<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class
         {
             return a == b;

Runtime/Profiling/ProfilingHooks.cs

@@ -8,8 +8,8 @@ namespace Unity.Netcode
     {
         private Dictionary<Type, ProfilerMarker> m_HandlerProfilerMarkers = new Dictionary<Type, ProfilerMarker>();
         private Dictionary<Type, ProfilerMarker> m_SenderProfilerMarkers = new Dictionary<Type, ProfilerMarker>();
-        private readonly ProfilerMarker m_SendBatch = new ProfilerMarker($"{nameof(MessagingSystem)}.SendBatch");
-        private readonly ProfilerMarker m_ReceiveBatch = new ProfilerMarker($"{nameof(MessagingSystem)}.ReceiveBatchBatch");
+        private readonly ProfilerMarker m_SendBatch = new ProfilerMarker($"{nameof(NetworkMessageManager)}.SendBatch");
+        private readonly ProfilerMarker m_ReceiveBatch = new ProfilerMarker($"{nameof(NetworkMessageManager)}.ReceiveBatchBatch");
 
         private ProfilerMarker GetHandlerProfilerMarker(Type type)
         {
@@ -19,7 +19,7 @@ namespace Unity.Netcode
                 return marker;
             }
 
-            marker = new ProfilerMarker($"{nameof(MessagingSystem)}.DeserializeAndHandle.{type.Name}");
+            marker = new ProfilerMarker($"{nameof(NetworkMessageManager)}.DeserializeAndHandle.{type.Name}");
             m_HandlerProfilerMarkers[type] = marker;
             return marker;
         }
@@ -32,7 +32,7 @@ namespace Unity.Netcode
                 return marker;
             }
 
-            marker = new ProfilerMarker($"{nameof(MessagingSystem)}.SerializeAndEnqueue.{type.Name}");
+            marker = new ProfilerMarker($"{nameof(NetworkMessageManager)}.SerializeAndEnqueue.{type.Name}");
             m_SenderProfilerMarkers[type] = marker;
             return marker;
         }

Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -337,7 +337,7 @@ namespace Unity.Netcode
                 return;
             }
             else // Warn users if they are changing this after there are clients already connected and synchronized
-            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsServer ? 0 : 1) && sceneManager.ClientSynchronizationMode != mode)
+            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                 {

Runtime/SceneManagement/NetworkSceneManager.cs

@@ -524,7 +524,7 @@ namespace Unity.Netcode
         /// </summary>
         internal Dictionary<uint, SceneEventData> SceneEventDataStore;
 
-        private NetworkManager m_NetworkManager { get; }
+        internal readonly NetworkManager NetworkManager;
 
         // Keep track of this scene until the NetworkSceneManager is destroyed.
         internal Scene DontDestroyOnLoadScene;
@@ -575,7 +575,7 @@ namespace Unity.Netcode
         /// <returns>SceneEventData instance</returns>
         internal SceneEventData BeginSceneEvent()
         {
-            var sceneEventData = new SceneEventData(m_NetworkManager);
+            var sceneEventData = new SceneEventData(NetworkManager);
             SceneEventDataStore.Add(sceneEventData.SceneEventId, sceneEventData);
             return sceneEventData;
         }
@@ -720,18 +720,18 @@ namespace Unity.Netcode
         /// <param name="mode"><see cref="LoadSceneMode"/> for initial client synchronization</param>
         public void SetClientSynchronizationMode(LoadSceneMode mode)
         {
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.SetClientSynchronizationMode(ref networkManager, mode);
         }
 
         /// <summary>
         /// Constructor
         /// </summary>
-        /// <param name="networkManager">one <see cref="NetworkManager"/> instance per <see cref="NetworkSceneManager"/> instance</param>
+        /// <param name="networkManager">one <see cref="Netcode.NetworkManager"/> instance per <see cref="NetworkSceneManager"/> instance</param>
         /// <param name="sceneEventDataPoolSize">maximum <see cref="SceneEventData"/> pool size</param>
         internal NetworkSceneManager(NetworkManager networkManager)
         {
-            m_NetworkManager = networkManager;
+            NetworkManager = networkManager;
             SceneEventDataStore = new Dictionary<uint, SceneEventData>();
 
             // Generates the scene name to hash value
@@ -750,7 +750,7 @@ namespace Unity.Netcode
         private void SceneManager_ActiveSceneChanged(Scene current, Scene next)
         {
             // If no clients are connected, then don't worry about notifications
-            if (!(m_NetworkManager.ConnectedClientsIds.Count > (m_NetworkManager.IsHost ? 1 : 0)))
+            if (!(NetworkManager.ConnectedClientsIds.Count > (NetworkManager.IsHost ? 1 : 0)))
             {
                 return;
             }
@@ -771,7 +771,7 @@ namespace Unity.Netcode
                 var sceneEvent = BeginSceneEvent();
                 sceneEvent.SceneEventType = SceneEventType.ActiveSceneChanged;
                 sceneEvent.ActiveSceneHash = BuildIndexToHash[next.buildIndex];
-                SendSceneEventData(sceneEvent.SceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+                SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
                 EndSceneEvent(sceneEvent.SceneEventId);
             }
         }
@@ -786,9 +786,18 @@ namespace Unity.Netcode
         /// <returns>true (Valid) or false (Invalid)</returns>
         internal bool ValidateSceneBeforeLoading(uint sceneHash, LoadSceneMode loadSceneMode)
         {
-            var validated = true;
             var sceneName = SceneNameFromHash(sceneHash);
             var sceneIndex = SceneUtility.GetBuildIndexByScenePath(sceneName);
+            return ValidateSceneBeforeLoading(sceneIndex, sceneName, loadSceneMode);
+        }
+
+        /// <summary>
+        /// Overloaded version that is invoked by <see cref="ValidateSceneBeforeLoading"/> and <see cref="SynchronizeNetworkObjects"/>.
+        /// This specifically is to allow runtime generated scenes to be excluded by the server during synchronization.
+        /// </summary>
+        internal bool ValidateSceneBeforeLoading(int sceneIndex, string sceneName, LoadSceneMode loadSceneMode)
+        {
+            var validated = true;
             if (VerifySceneBeforeLoading != null)
             {
                 validated = VerifySceneBeforeLoading.Invoke(sceneIndex, sceneName, loadSceneMode);
@@ -796,9 +805,9 @@ namespace Unity.Netcode
             if (!validated && !m_DisableValidationWarningMessages)
             {
                 var serverHostorClient = "Client";
-                if (m_NetworkManager.IsServer)
+                if (NetworkManager.IsServer)
                 {
-                    serverHostorClient = m_NetworkManager.IsHost ? "Host" : "Server";
+                    serverHostorClient = NetworkManager.IsHost ? "Host" : "Server";
                 }
 
                 Debug.LogWarning($"Scene {sceneName} of Scenes in Build Index {sceneIndex} being loaded in {loadSceneMode} mode failed validation on the {serverHostorClient}!");
@@ -837,7 +846,7 @@ namespace Unity.Netcode
                         if (!ScenesLoaded.ContainsKey(sceneLoaded.handle))
                         {
                             ScenesLoaded.Add(sceneLoaded.handle, sceneLoaded);
-                            SceneManagerHandler.StartTrackingScene(sceneLoaded, true, m_NetworkManager);
+                            SceneManagerHandler.StartTrackingScene(sceneLoaded, true, NetworkManager);
                             return sceneLoaded;
                         }
                     }
@@ -886,7 +895,7 @@ namespace Unity.Netcode
                 // Most common scenario for DontDestroyOnLoad is when NetworkManager is set to not be destroyed
                 if (serverSceneHandle == DontDestroyOnLoadScene.handle)
                 {
-                    SceneBeingSynchronized = m_NetworkManager.gameObject.scene;
+                    SceneBeingSynchronized = NetworkManager.gameObject.scene;
                     return;
                 }
                 else
@@ -940,9 +949,9 @@ namespace Unity.Netcode
             {
                 EventData = SceneEventDataStore[sceneEventId]
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, targetClientIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, targetClientIds);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(targetClientIds, (uint)SceneEventDataStore[sceneEventId].SceneEventType, SceneNameFromHash(SceneEventDataStore[sceneEventId].SceneHash), size);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(targetClientIds, (uint)SceneEventDataStore[sceneEventId].SceneEventType, SceneNameFromHash(SceneEventDataStore[sceneEventId].SceneHash), size);
         }
 
         /// <summary>
@@ -952,16 +961,16 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventUnloading(Scene scene)
         {
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 throw new NotServerException("Only server can start a scene event!");
             }
 
-            if (!m_NetworkManager.NetworkConfig.EnableSceneManagement)
+            if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
                 //Log message about enabling SceneManagement
                 throw new Exception(
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(NetworkManager)}'s {nameof(NetworkConfig)}. " +
+                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
                     $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
             }
 
@@ -981,15 +990,15 @@ namespace Unity.Netcode
         /// <returns></returns>
         private SceneEventProgress ValidateSceneEventLoading(string sceneName)
         {
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 throw new NotServerException("Only server can start a scene event!");
             }
-            if (!m_NetworkManager.NetworkConfig.EnableSceneManagement)
+            if (!NetworkManager.NetworkConfig.EnableSceneManagement)
             {
                 //Log message about enabling SceneManagement
                 throw new Exception(
-                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(NetworkManager)}'s {nameof(NetworkConfig)}. " +
+                    $"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
                     $"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
             }
 
@@ -1017,7 +1026,7 @@ namespace Unity.Netcode
                 return new SceneEventProgress(null, SceneEventProgressStatus.InvalidSceneName);
             }
 
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneHash = SceneHashFromNameOrPath(sceneName)
             };
@@ -1052,10 +1061,10 @@ namespace Unity.Netcode
             {
                 EventData = sceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, m_NetworkManager.ConnectedClientsIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ConnectedClientsIds);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(
-                m_NetworkManager.ConnectedClientsIds,
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(
+                NetworkManager.ConnectedClientsIds,
                 (uint)sceneEventProgress.SceneEventType,
                 SceneNameFromHash(sceneEventProgress.SceneHash),
                 size);
@@ -1116,7 +1125,7 @@ namespace Unity.Netcode
             // Any NetworkObjects marked to not be destroyed with a scene and reside within the scene about to be unloaded
             // should be migrated temporarily into the DDOL, once the scene is unloaded they will be migrated into the
             // currently active scene.
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.MoveObjectsFromSceneToDontDestroyOnLoad(ref networkManager, scene);
 
             var sceneEventData = BeginSceneEvent();
@@ -1179,18 +1188,18 @@ namespace Unity.Netcode
             // Any NetworkObjects marked to not be destroyed with a scene and reside within the scene about to be unloaded
             // should be migrated temporarily into the DDOL, once the scene is unloaded they will be migrated into the
             // currently active scene.
-            var networkManager = m_NetworkManager;
+            var networkManager = NetworkManager;
             SceneManagerHandler.MoveObjectsFromSceneToDontDestroyOnLoad(ref networkManager, scene);
 
             m_IsSceneEventActive = true;
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneEventId = sceneEventData.SceneEventId,
                 OnSceneEventCompleted = OnSceneUnloaded
             };
             var sceneUnload = SceneManagerHandler.UnloadSceneAsync(scene, sceneEventProgress);
 
-            SceneManagerHandler.StopTrackingScene(sceneHandle, sceneName, m_NetworkManager);
+            SceneManagerHandler.StopTrackingScene(sceneHandle, sceneName, NetworkManager);
 
             // Remove our server to scene handle lookup
             if (!RemoveServerClientSceneHandle(sceneEventData.SceneHandle, sceneHandle))
@@ -1206,10 +1215,10 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = LoadSceneMode.Additive,     // The only scenes unloaded are scenes that were additively loaded
                 SceneName = sceneName,
-                ClientId = m_NetworkManager.LocalClientId   // Server sent this message to the client, but client is executing it
+                ClientId = NetworkManager.LocalClientId   // Server sent this message to the client, but client is executing it
             });
 
-            OnUnload?.Invoke(m_NetworkManager.LocalClientId, sceneName, sceneUnload);
+            OnUnload?.Invoke(NetworkManager.LocalClientId, sceneName, sceneUnload);
         }
 
         /// <summary>
@@ -1219,7 +1228,7 @@ namespace Unity.Netcode
         private void OnSceneUnloaded(uint sceneEventId)
         {
             // If we are shutdown or about to shutdown, then ignore this event
-            if (!m_NetworkManager.IsListening || m_NetworkManager.ShutdownInProgress)
+            if (!NetworkManager.IsListening || NetworkManager.ShutdownInProgress)
             {
                 return;
             }
@@ -1229,15 +1238,15 @@ namespace Unity.Netcode
 
             var sceneEventData = SceneEventDataStore[sceneEventId];
             // First thing we do, if we are a server, is to send the unload scene event.
-            if (m_NetworkManager.IsServer)
+            if (NetworkManager.IsServer)
             {
                 // Server sends the unload scene notification after unloading because it will despawn all scene relative in-scene NetworkObjects
                 // If we send this event to all clients before the server is finished unloading they will get warning about an object being
                 // despawned that no longer exists
-                SendSceneEventData(sceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+                SendSceneEventData(sceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
 
                 //Only if we are a host do we want register having loaded for the associated SceneEventProgress
-                if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && m_NetworkManager.IsHost)
+                if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && NetworkManager.IsHost)
                 {
                     SceneEventProgressTracking[sceneEventData.SceneEventProgressId].ClientFinishedSceneEvent(NetworkManager.ServerClientId);
                 }
@@ -1252,13 +1261,13 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = SceneNameFromHash(sceneEventData.SceneHash),
-                ClientId = m_NetworkManager.IsServer ? NetworkManager.ServerClientId : m_NetworkManager.LocalClientId
+                ClientId = NetworkManager.IsServer ? NetworkManager.ServerClientId : NetworkManager.LocalClientId
             });
 
-            OnUnloadComplete?.Invoke(m_NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash));
+            OnUnloadComplete?.Invoke(NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash));
 
             // Clients send a notification back to the server they have completed the unload scene event
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
                 SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
             }
@@ -1288,7 +1297,7 @@ namespace Unity.Netcode
                 // Validate the scene as well as ignore the DDOL (which will have a negative buildIndex)
                 if (currentActiveScene.name != keyHandleEntry.Value.name && keyHandleEntry.Value.buildIndex >= 0)
                 {
-                    var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+                    var sceneEventProgress = new SceneEventProgress(NetworkManager)
                     {
                         SceneEventId = sceneEventId,
                         OnSceneEventCompleted = EmptySceneUnloadedOperation
@@ -1299,7 +1308,7 @@ namespace Unity.Netcode
             }
             // clear out our scenes loaded list
             ScenesLoaded.Clear();
-            SceneManagerHandler.ClearSceneTracking(m_NetworkManager);
+            SceneManagerHandler.ClearSceneTracking(NetworkManager);
         }
 
         /// <summary>
@@ -1348,7 +1357,7 @@ namespace Unity.Netcode
                 IsSpawnedObjectsPendingInDontDestroyOnLoad = true;
 
                 // Destroy current scene objects before switching.
-                m_NetworkManager.SpawnManager.ServerDestroySpawnedSceneObjects();
+                NetworkManager.SpawnManager.ServerDestroySpawnedSceneObjects();
 
                 // Preserve the objects that should not be destroyed during the scene event
                 MoveObjectsToDontDestroyOnLoad();
@@ -1390,7 +1399,7 @@ namespace Unity.Netcode
 
             internal static void RegisterScene(NetworkSceneManager networkSceneManager, Scene scene, LoadSceneMode loadSceneMode, AsyncOperation asyncOperation = null)
             {
-                var networkManager = networkSceneManager.m_NetworkManager;
+                var networkManager = networkSceneManager.NetworkManager;
                 if (!s_Instances.ContainsKey(networkManager))
                 {
                     s_Instances.Add(networkManager, new List<SceneUnloadEventHandler>());
@@ -1401,11 +1410,11 @@ namespace Unity.Netcode
 
             private static void SceneUnloadComplete(SceneUnloadEventHandler sceneUnloadEventHandler)
             {
-                if (sceneUnloadEventHandler == null || sceneUnloadEventHandler.m_NetworkSceneManager == null || sceneUnloadEventHandler.m_NetworkSceneManager.m_NetworkManager == null)
+                if (sceneUnloadEventHandler == null || sceneUnloadEventHandler.m_NetworkSceneManager == null || sceneUnloadEventHandler.m_NetworkSceneManager.NetworkManager == null)
                 {
                     return;
                 }
-                var networkManager = sceneUnloadEventHandler.m_NetworkSceneManager.m_NetworkManager;
+                var networkManager = sceneUnloadEventHandler.m_NetworkSceneManager.NetworkManager;
                 if (s_Instances.ContainsKey(networkManager))
                 {
                     s_Instances[networkManager].Remove(sceneUnloadEventHandler);
@@ -1449,7 +1458,7 @@ namespace Unity.Netcode
             {
                 if (m_Scene.handle == scene.handle && !m_ShuttingDown)
                 {
-                    if (m_NetworkSceneManager != null && m_NetworkSceneManager.m_NetworkManager != null)
+                    if (m_NetworkSceneManager != null && m_NetworkSceneManager.NetworkManager != null)
                     {
                         m_NetworkSceneManager.OnSceneEvent?.Invoke(new SceneEvent()
                         {
@@ -1484,7 +1493,7 @@ namespace Unity.Netcode
                     ClientId = clientId
                 });
 
-                m_NetworkSceneManager.OnUnload?.Invoke(networkSceneManager.m_NetworkManager.LocalClientId, m_Scene.name, null);
+                m_NetworkSceneManager.OnUnload?.Invoke(networkSceneManager.NetworkManager.LocalClientId, m_Scene.name, null);
             }
         }
 
@@ -1527,7 +1536,7 @@ namespace Unity.Netcode
                 SceneUnloadEventHandler.RegisterScene(this, SceneManager.GetActiveScene(), LoadSceneMode.Single);
 
             }
-            var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+            var sceneEventProgress = new SceneEventProgress(NetworkManager)
             {
                 SceneEventId = sceneEventId,
                 OnSceneEventCompleted = OnSceneLoaded
@@ -1540,10 +1549,10 @@ namespace Unity.Netcode
                 SceneEventType = sceneEventData.SceneEventType,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = sceneName,
-                ClientId = m_NetworkManager.LocalClientId
+                ClientId = NetworkManager.LocalClientId
             });
 
-            OnLoad?.Invoke(m_NetworkManager.LocalClientId, sceneName, sceneEventData.LoadSceneMode, sceneLoad);
+            OnLoad?.Invoke(NetworkManager.LocalClientId, sceneName, sceneEventData.LoadSceneMode, sceneLoad);
         }
 
         /// <summary>
@@ -1553,7 +1562,7 @@ namespace Unity.Netcode
         private void OnSceneLoaded(uint sceneEventId)
         {
             // If we are shutdown or about to shutdown, then ignore this event
-            if (!m_NetworkManager.IsListening || m_NetworkManager.ShutdownInProgress)
+            if (!NetworkManager.IsListening || NetworkManager.ShutdownInProgress)
             {
                 return;
             }
@@ -1586,7 +1595,7 @@ namespace Unity.Netcode
             // not destroy temporary scene are moved into the active scene
             IsSpawnedObjectsPendingInDontDestroyOnLoad = false;
 
-            if (m_NetworkManager.IsServer)
+            if (NetworkManager.IsServer)
             {
                 OnServerLoadedScene(sceneEventId, nextScene);
             }
@@ -1618,8 +1627,8 @@ namespace Unity.Netcode
                     if (!keyValuePairBySceneHandle.Value.IsPlayerObject)
                     {
                         // All in-scene placed NetworkObjects default to being owned by the server
-                        m_NetworkManager.SpawnManager.SpawnNetworkObjectLocally(keyValuePairBySceneHandle.Value,
-                            m_NetworkManager.SpawnManager.GetNetworkObjectId(), true, false, NetworkManager.ServerClientId, true);
+                        NetworkManager.SpawnManager.SpawnNetworkObjectLocally(keyValuePairBySceneHandle.Value,
+                            NetworkManager.SpawnManager.GetNetworkObjectId(), true, false, NetworkManager.ServerClientId, true);
                     }
                 }
             }
@@ -1631,9 +1640,9 @@ namespace Unity.Netcode
             sceneEventData.SceneHandle = scene.handle;
 
             // Send all clients the scene load event
-            for (int j = 0; j < m_NetworkManager.ConnectedClientsList.Count; j++)
+            for (int j = 0; j < NetworkManager.ConnectedClientsList.Count; j++)
             {
-                var clientId = m_NetworkManager.ConnectedClientsList[j].ClientId;
+                var clientId = NetworkManager.ConnectedClientsList[j].ClientId;
                 if (clientId != NetworkManager.ServerClientId)
                 {
                     sceneEventData.TargetClientId = clientId;
@@ -1641,8 +1650,8 @@ namespace Unity.Netcode
                     {
                         EventData = sceneEventData
                     };
-                    var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, clientId);
-                    m_NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, scene.name, size);
+                    var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, clientId);
+                    NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, scene.name, size);
                 }
             }
 
@@ -1660,7 +1669,7 @@ namespace Unity.Netcode
             OnLoadComplete?.Invoke(NetworkManager.ServerClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
 
             //Second, only if we are a host do we want register having loaded for the associated SceneEventProgress
-            if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && m_NetworkManager.IsHost)
+            if (SceneEventProgressTracking.ContainsKey(sceneEventData.SceneEventProgressId) && NetworkManager.IsHost)
             {
                 SceneEventProgressTracking[sceneEventData.SceneEventProgressId].ClientFinishedSceneEvent(NetworkManager.ServerClientId);
             }
@@ -1686,11 +1695,11 @@ namespace Unity.Netcode
                 SceneEventType = SceneEventType.LoadComplete,
                 LoadSceneMode = sceneEventData.LoadSceneMode,
                 SceneName = SceneNameFromHash(sceneEventData.SceneHash),
-                ClientId = m_NetworkManager.LocalClientId,
+                ClientId = NetworkManager.LocalClientId,
                 Scene = scene,
             });
 
-            OnLoadComplete?.Invoke(m_NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
+            OnLoadComplete?.Invoke(NetworkManager.LocalClientId, SceneNameFromHash(sceneEventData.SceneHash), sceneEventData.LoadSceneMode);
 
             EndSceneEvent(sceneEventId);
         }
@@ -1713,7 +1722,7 @@ namespace Unity.Netcode
         internal void SynchronizeNetworkObjects(ulong clientId)
         {
             // Update the clients
-            m_NetworkManager.SpawnManager.UpdateObservedNetworkObjects(clientId);
+            NetworkManager.SpawnManager.UpdateObservedNetworkObjects(clientId);
 
             var sceneEventData = BeginSceneEvent();
             sceneEventData.ClientSynchronizationMode = ClientSynchronizationMode;
@@ -1744,24 +1753,22 @@ namespace Unity.Netcode
                     continue;
                 }
 
-                var sceneHash = SceneHashFromNameOrPath(scene.path);
-
                 // This would depend upon whether we are additive or not
                 // If we are the base scene, then we set the root scene index;
                 if (activeScene == scene)
                 {
-                    if (!ValidateSceneBeforeLoading(sceneHash, sceneEventData.LoadSceneMode))
+                    if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, sceneEventData.LoadSceneMode))
                     {
                         continue;
                     }
-                    sceneEventData.SceneHash = sceneHash;
+                    sceneEventData.SceneHash = SceneHashFromNameOrPath(scene.path);
                     sceneEventData.SceneHandle = scene.handle;
                 }
-                else if (!ValidateSceneBeforeLoading(sceneHash, LoadSceneMode.Additive))
+                else if (!ValidateSceneBeforeLoading(scene.buildIndex, scene.name, LoadSceneMode.Additive))
                 {
                     continue;
                 }
-                sceneEventData.AddSceneToSynchronize(sceneHash, scene.handle);
+                sceneEventData.AddSceneToSynchronize(SceneHashFromNameOrPath(scene.path), scene.handle);
             }
 
             sceneEventData.AddSpawnedNetworkObjects();
@@ -1771,8 +1778,8 @@ namespace Unity.Netcode
             {
                 EventData = sceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, clientId);
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, "", size);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, clientId);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(clientId, (uint)sceneEventData.SceneEventType, "", size);
 
             // Notify the local server that the client has been sent the synchronize event
             OnSceneEvent?.Invoke(new SceneEvent()
@@ -1811,17 +1818,17 @@ namespace Unity.Netcode
                 OnSceneEvent?.Invoke(new SceneEvent()
                 {
                     SceneEventType = SceneEventType.Synchronize,
-                    ClientId = m_NetworkManager.LocalClientId,
+                    ClientId = NetworkManager.LocalClientId,
                 });
 
-                OnSynchronize?.Invoke(m_NetworkManager.LocalClientId);
+                OnSynchronize?.Invoke(NetworkManager.LocalClientId);
             }
 
             // Always check to see if the scene needs to be validated
             if (!ValidateSceneBeforeLoading(sceneHash, loadSceneMode))
             {
                 HandleClientSceneEvent(sceneEventId);
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogInfo($"Client declined to load the scene {sceneName}, continuing with synchronization.");
                 }
@@ -1835,12 +1842,12 @@ namespace Unity.Netcode
             // it should pass through to post load processing (ClientLoadedSynchronization).
             // For ClientSynchronizationMode LoadSceneMode.Additive, if the scene is already loaded or the active scene is the scene to be loaded (does not require it to
             // be the initial primary scene) then go ahead and pass through to post load processing (ClientLoadedSynchronization).
-            var shouldPassThrough = SceneManagerHandler.ClientShouldPassThrough(sceneName, sceneHash == sceneEventData.SceneHash, ClientSynchronizationMode, m_NetworkManager);
+            var shouldPassThrough = SceneManagerHandler.ClientShouldPassThrough(sceneName, sceneHash == sceneEventData.SceneHash, ClientSynchronizationMode, NetworkManager);
 
             if (!shouldPassThrough)
             {
                 // If not, then load the scene
-                var sceneEventProgress = new SceneEventProgress(m_NetworkManager)
+                var sceneEventProgress = new SceneEventProgress(NetworkManager)
                 {
                     SceneEventId = sceneEventId,
                     OnSceneEventCompleted = ClientLoadedSynchronization
@@ -1854,10 +1861,10 @@ namespace Unity.Netcode
                     SceneEventType = SceneEventType.Load,
                     LoadSceneMode = loadSceneMode,
                     SceneName = sceneName,
-                    ClientId = m_NetworkManager.LocalClientId,
+                    ClientId = NetworkManager.LocalClientId,
                 });
 
-                OnLoad?.Invoke(m_NetworkManager.LocalClientId, sceneName, loadSceneMode, sceneLoad);
+                OnLoad?.Invoke(NetworkManager.LocalClientId, sceneName, loadSceneMode, sceneLoad);
             }
             else
             {
@@ -1875,7 +1882,7 @@ namespace Unity.Netcode
         {
             var sceneEventData = SceneEventDataStore[sceneEventId];
             var sceneName = SceneNameFromHash(sceneEventData.ClientSceneHash);
-            var nextScene = SceneManagerHandler.GetSceneFromLoadedScenes(sceneName, m_NetworkManager);
+            var nextScene = SceneManagerHandler.GetSceneFromLoadedScenes(sceneName, NetworkManager);
             if (!nextScene.IsValid())
             {
                 nextScene = GetAndAddNewlyLoadedSceneByName(sceneName);
@@ -1915,9 +1922,9 @@ namespace Unity.Netcode
             {
                 EventData = responseSceneEventData
             };
-            var size = m_NetworkManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ServerClientId);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ServerClientId);
 
-            m_NetworkManager.NetworkMetrics.TrackSceneEventSent(NetworkManager.ServerClientId, (uint)responseSceneEventData.SceneEventType, sceneName, size);
+            NetworkManager.NetworkMetrics.TrackSceneEventSent(NetworkManager.ServerClientId, (uint)responseSceneEventData.SceneEventType, sceneName, size);
 
             EndSceneEvent(responseSceneEventData.SceneEventId);
 
@@ -1928,10 +1935,10 @@ namespace Unity.Netcode
                 LoadSceneMode = loadSceneMode,
                 SceneName = sceneName,
                 Scene = nextScene,
-                ClientId = m_NetworkManager.LocalClientId,
+                ClientId = NetworkManager.LocalClientId,
             });
 
-            OnLoadComplete?.Invoke(m_NetworkManager.LocalClientId, sceneName, loadSceneMode);
+            OnLoadComplete?.Invoke(NetworkManager.LocalClientId, sceneName, loadSceneMode);
 
             // Check to see if we still have scenes to load and synchronize with
             HandleClientSceneEvent(sceneEventId);
@@ -1944,7 +1951,7 @@ namespace Unity.Netcode
         /// </summary>
         private void SynchronizeNetworkObjectScene()
         {
-            foreach (var networkObject in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
             {
                 // This is only done for dynamically spawned NetworkObjects
                 // Theoretically, a server could have NetworkObjects in a server-side only scene, if the client doesn't have that scene loaded
@@ -1969,9 +1976,9 @@ namespace Unity.Netcode
 
                             SceneManager.MoveGameObjectToScene(networkObject.gameObject, scene);
                         }
-                        else if (m_NetworkManager.LogLevel <= LogLevel.Normal)
+                        else if (NetworkManager.LogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogWarningServer($"[Client-{m_NetworkManager.LocalClientId}][{networkObject.gameObject.name}] Server - " +
+                            NetworkLog.LogWarningServer($"[Client-{NetworkManager.LocalClientId}][{networkObject.gameObject.name}] Server - " +
                                 $"client scene mismatch detected! Client-side has no scene loaded with handle ({networkObject.SceneOriginHandle})!");
                         }
                     }
@@ -2026,8 +2033,6 @@ namespace Unity.Netcode
                         {
                             // Include anything in the DDOL scene
                             PopulateScenePlacedObjects(DontDestroyOnLoadScene, false);
-                            // Synchronize the NetworkObjects for this scene
-                            sceneEventData.SynchronizeSceneNetworkObjects(m_NetworkManager);
 
                             // If needed, set the currently active scene
                             if (HashToBuildIndex.ContainsKey(sceneEventData.ActiveSceneHash))
@@ -2039,23 +2044,26 @@ namespace Unity.Netcode
                                 }
                             }
 
-                            // If needed, migrate dynamically spawned NetworkObjects to the same scene as on the server side
+                            // Spawn and Synchronize all NetworkObjects
+                            sceneEventData.SynchronizeSceneNetworkObjects(NetworkManager);
+
+                            // If needed, migrate dynamically spawned NetworkObjects to the same scene as they are on the server
                             SynchronizeNetworkObjectScene();
 
                             sceneEventData.SceneEventType = SceneEventType.SynchronizeComplete;
                             SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
 
                             // All scenes are synchronized, let the server know we are done synchronizing
-                            m_NetworkManager.IsConnectedClient = true;
+                            NetworkManager.IsConnectedClient = true;
 
                             // Client is now synchronized and fully "connected".  This also means the client can send "RPCs" at this time
-                            m_NetworkManager.InvokeOnClientConnectedCallback(m_NetworkManager.LocalClientId);
+                            NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(NetworkManager.LocalClientId);
 
                             // Notify the client that they have finished synchronizing
                             OnSceneEvent?.Invoke(new SceneEvent()
                             {
                                 SceneEventType = sceneEventData.SceneEventType,
-                                ClientId = m_NetworkManager.LocalClientId, // Client sent this to the server
+                                ClientId = NetworkManager.LocalClientId, // Client sent this to the server
                             });
 
                             // Process any SceneEventType.ObjectSceneChanged messages that
@@ -2068,10 +2076,10 @@ namespace Unity.Netcode
                             // scene not synchronized by the server will remain loaded)
                             if (PostSynchronizationSceneUnloading && ClientSynchronizationMode == LoadSceneMode.Additive)
                             {
-                                SceneManagerHandler.UnloadUnassignedScenes(m_NetworkManager);
+                                SceneManagerHandler.UnloadUnassignedScenes(NetworkManager);
                             }
 
-                            OnSynchronizeComplete?.Invoke(m_NetworkManager.LocalClientId);
+                            OnSynchronizeComplete?.Invoke(NetworkManager.LocalClientId);
 
                             EndSceneEvent(sceneEventId);
                         }
@@ -2191,11 +2199,11 @@ namespace Unity.Netcode
                         // TODO 2023: We should have a better name for this or have multiple states the
                         // client progresses through (the name and associated legacy behavior/expected state
                         // of the client was persisted since MLAPI)
-                        m_NetworkManager.InvokeOnClientConnectedCallback(clientId);
+                        NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
 
                         // Check to see if the client needs to resynchronize and before sending the message make sure the client is still connected to avoid
                         // a potential crash within the MessageSystem (i.e. sending to a client that no longer exists)
-                        if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && m_NetworkManager.ConnectedClients.ContainsKey(clientId))
+                        if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && NetworkManager.ConnectedClients.ContainsKey(clientId))
                         {
                             sceneEventData.SceneEventType = SceneEventType.ReSynchronize;
                             SendSceneEventData(sceneEventId, new ulong[] { clientId });
@@ -2225,13 +2233,13 @@ namespace Unity.Netcode
         /// <param name="reader">data associated with the scene event</param>
         internal void HandleSceneEvent(ulong clientId, FastBufferReader reader)
         {
-            if (m_NetworkManager != null)
+            if (NetworkManager != null)
             {
                 var sceneEventData = BeginSceneEvent();
 
                 sceneEventData.Deserialize(reader);
 
-                m_NetworkManager.NetworkMetrics.TrackSceneEventReceived(
+                NetworkManager.NetworkMetrics.TrackSceneEventReceived(
                    clientId, (uint)sceneEventData.SceneEventType, SceneNameFromHash(sceneEventData.SceneHash), reader.Length);
 
                 if (sceneEventData.IsSceneEventClientSide())
@@ -2250,7 +2258,7 @@ namespace Unity.Netcode
                             // used if the server is synchronizing the same scenes (i.e. if a matching scene is already loaded on the
                             // client side, then that scene will be used as opposed to loading another scene). This allows for clients
                             // to reconnect to a network session without having to unload all of the scenes and reload all of the scenes.
-                            SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, m_NetworkManager);
+                            SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
                         }
                     }
                     HandleClientSceneEvent(sceneEventData.SceneEventId);
@@ -2262,7 +2270,7 @@ namespace Unity.Netcode
             }
             else
             {
-                Debug.LogError($"{nameof(HandleSceneEvent)} was invoked but {nameof(NetworkManager)} reference was null!");
+                Debug.LogError($"{nameof(HandleSceneEvent)} was invoked but {nameof(Netcode.NetworkManager)} reference was null!");
             }
         }
 
@@ -2274,7 +2282,7 @@ namespace Unity.Netcode
         {
             // Create a local copy of the spawned objects list since the spawn manager will adjust the list as objects
             // are despawned.
-            var localSpawnedObjectsHashSet = new HashSet<NetworkObject>(m_NetworkManager.SpawnManager.SpawnedObjectsList);
+            var localSpawnedObjectsHashSet = new HashSet<NetworkObject>(NetworkManager.SpawnManager.SpawnedObjectsList);
             foreach (var networkObject in localSpawnedObjectsHashSet)
             {
                 if (networkObject == null || (networkObject != null && networkObject.gameObject.scene == DontDestroyOnLoadScene))
@@ -2291,7 +2299,7 @@ namespace Unity.Netcode
                         UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
                     }
                 }
-                else if (m_NetworkManager.IsServer)
+                else if (NetworkManager.IsServer)
                 {
                     networkObject.Despawn();
                 }
@@ -2330,7 +2338,7 @@ namespace Unity.Netcode
                 var globalObjectIdHash = networkObjectInstance.GlobalObjectIdHash;
                 var sceneHandle = networkObjectInstance.gameObject.scene.handle;
                 // We check to make sure the NetworkManager instance is the same one to be "NetcodeIntegrationTestHelpers" compatible and filter the list on a per scene basis (for additive scenes)
-                if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == m_NetworkManager ||
+                if (networkObjectInstance.IsSceneObject != false && (networkObjectInstance.NetworkManager == NetworkManager ||
                     networkObjectInstance.NetworkManagerOwner == null) && sceneHandle == sceneToFilterBy.handle)
                 {
                     if (!ScenePlacedObjects.ContainsKey(globalObjectIdHash))
@@ -2358,7 +2366,7 @@ namespace Unity.Netcode
         /// <param name="scene">scene to move the NetworkObjects to</param>
         internal void MoveObjectsFromDontDestroyOnLoadToScene(Scene scene)
         {
-            foreach (var networkObject in m_NetworkManager.SpawnManager.SpawnedObjectsList)
+            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
             {
                 if (networkObject == null)
                 {
@@ -2389,9 +2397,9 @@ namespace Unity.Netcode
         internal void NotifyNetworkObjectSceneChanged(NetworkObject networkObject)
         {
             // Really, this should never happen but in case it does
-            if (!m_NetworkManager.IsServer)
+            if (!NetworkManager.IsServer)
             {
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogErrorServer("[Please Report This Error][NotifyNetworkObjectSceneChanged] A client is trying to notify of an object's scene change!");
                 }
@@ -2402,7 +2410,7 @@ namespace Unity.Netcode
             if (networkObject.IsSceneObject != false)
             {
                 // Really, this should ever happen but in case it does
-                if (m_NetworkManager.LogLevel == LogLevel.Developer)
+                if (NetworkManager.LogLevel == LogLevel.Developer)
                 {
                     NetworkLog.LogErrorServer("[Please Report This Error][NotifyNetworkObjectSceneChanged] Trying to notify in-scene placed object scene change!");
                 }
@@ -2468,20 +2476,57 @@ namespace Unity.Netcode
             ObjectsMigratedIntoNewScene.Clear();
         }
 
+
+        private List<int> m_ScenesToRemoveFromObjectMigration = new List<int>();
+
         /// <summary>
-        /// Should be invoked during PostLateUpdate just prior to the
-        /// MessagingSystem processes its outbound message queue.
+        /// Should be invoked during PostLateUpdate just prior to the NetworkMessageManager processes its outbound message queue.
         /// </summary>
         internal void CheckForAndSendNetworkObjectSceneChanged()
         {
             // Early exit if not the server or there is nothing pending
-            if (!m_NetworkManager.IsServer || ObjectsMigratedIntoNewScene.Count == 0)
+            if (!NetworkManager.IsServer || ObjectsMigratedIntoNewScene.Count == 0)
             {
                 return;
             }
+
+            // Double check that the NetworkObjects to migrate still exist
+            m_ScenesToRemoveFromObjectMigration.Clear();
+            foreach (var sceneEntry in ObjectsMigratedIntoNewScene)
+            {
+                for (int i = sceneEntry.Value.Count - 1; i >= 0; i--)
+                {
+                    // Remove NetworkObjects that are no longer spawned
+                    if (!sceneEntry.Value[i].IsSpawned)
+                    {
+                        sceneEntry.Value.RemoveAt(i);
+                    }
+                }
+                // If the scene entry no longer has any NetworkObjects to migrate
+                // then add it to the list of scenes to be removed from the table
+                // of scenes containing NetworkObjects to migrate.
+                if (sceneEntry.Value.Count == 0)
+                {
+                    m_ScenesToRemoveFromObjectMigration.Add(sceneEntry.Key);
+                }
+            }
+
+            // Remove sceneHandle entries that no longer have any NetworkObjects remaining
+            foreach (var sceneHandle in m_ScenesToRemoveFromObjectMigration)
+            {
+                ObjectsMigratedIntoNewScene.Remove(sceneHandle);
+            }
+
+            // If there is nothing to send a migration notification for then exit
+            if (ObjectsMigratedIntoNewScene.Count == 0)
+            {
+                return;
+            }
+
+            // Some NetworkObjects still exist, send the message
             var sceneEvent = BeginSceneEvent();
             sceneEvent.SceneEventType = SceneEventType.ObjectSceneChanged;
-            SendSceneEventData(sceneEvent.SceneEventId, m_NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
+            SendSceneEventData(sceneEvent.SceneEventId, NetworkManager.ConnectedClientsIds.Where(c => c != NetworkManager.ServerClientId).ToArray());
             EndSceneEvent(sceneEvent.SceneEventId);
         }
 

Runtime/Serialization/BufferSerializer.cs

@@ -124,6 +124,25 @@ namespace Unity.Netcode
         /// <typeparam name="T">The type being serialized</typeparam>
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValue(ref value);
 
+        /// <summary>
+        /// Read or write a NativeArray of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValue(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValue(ref value);
+#endif
+
         /// <summary>
         /// Read or write a struct or class value implementing INetworkSerializable
         /// </summary>
@@ -266,6 +285,7 @@ namespace Unity.Netcode
         // Those two are necessary to serialize FixedStrings efficiently
         // - otherwise we'd just be memcpy'ing the whole thing even if
         // most of it isn't used.
+
         /// <summary>
         /// Read or write a FixedString value
         /// </summary>
@@ -275,6 +295,27 @@ namespace Unity.Netcode
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value);
 
+        /// <summary>
+        /// Read or write a NativeArray of FixedString values
+        /// </summary>
+        /// <typeparam name="T">The network serializable type</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of FixedStrings</param>
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of FixedString values
+        /// </summary>
+        /// <typeparam name="T">The network serializable type</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of FixedStrings</param>
+        public void SerializeValue<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Implementation.SerializeValue(ref value);
+#endif
+
         /// <summary>
         /// Read or write a NetworkSerializable value.
         /// SerializeValue() is the preferred method to do this - this is provided for backward compatibility only.
@@ -381,6 +422,31 @@ namespace Unity.Netcode
         /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Implementation.SerializeValuePreChecked(ref value);
 
+        /// <summary>
+        /// Serialize a NativeArray of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The network serializable types in an array</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValuePreChecked(ref value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Serialize a NativeList of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The network serializable types in an array</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution of structs</param>
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Implementation.SerializeValuePreChecked(ref value);
+#endif
+
         /// <summary>
         /// Serialize a Vector2, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
@@ -463,7 +529,7 @@ namespace Unity.Netcode
         public void SerializeValuePreChecked(ref Vector4 value) => m_Implementation.SerializeValuePreChecked(ref value);
 
         /// <summary>
-        /// Serialize a Vector4Array, "pre-checked", which skips buffer checks.
+        /// Serialize a Vector4 array, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
         /// calling this. In release builds, calling this without calling "PreCheck" may read or write
         /// past the end of the buffer, which will cause memory corruption and undefined behavior.

Runtime/Serialization/BufferSerializerReader.cs

@@ -30,34 +30,56 @@ namespace Unity.Netcode
         public void SerializeValue(ref byte value) => m_Reader.ReadByteSafe(out value);
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValueSafe(out value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValueSafe(out value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueSafe(out value, allocator);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueSafeInPlace(ref value);
+#endif
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Reader.ReadNetworkSerializableInPlace(ref value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Reader.ReadValue(out value);
 
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafe(out value);
 
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafe(out value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValueSafeInPlace(ref value);
+#endif
+
         public void SerializeValue(ref Vector2 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector2[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector3 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector3[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector2Int value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector2Int[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector3Int value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector3Int[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Vector4 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Vector4[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Quaternion value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Quaternion[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Color value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Color[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Color32 value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Color32[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Ray value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Ray[] value) => m_Reader.ReadValueSafe(out value);
+
         public void SerializeValue(ref Ray2D value) => m_Reader.ReadValueSafe(out value);
         public void SerializeValue(ref Ray2D[] value) => m_Reader.ReadValueSafe(out value);
 
@@ -72,30 +94,48 @@ namespace Unity.Netcode
         public void SerializeValuePreChecked(ref byte value) => m_Reader.ReadByte(out value);
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Reader.ReadValue(out value);
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValue(out value, allocator);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Reader.ReadValueInPlace(ref value);
+#endif
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector2 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector2[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector3 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector3[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector2Int value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector2Int[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector3Int value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector3Int[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Vector4 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Vector4[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Quaternion value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Quaternion[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Color value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Color[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Color32 value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Color32[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Ray value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Ray[] value) => m_Reader.ReadValue(out value);
+
         public void SerializeValuePreChecked(ref Ray2D value) => m_Reader.ReadValue(out value);
         public void SerializeValuePreChecked(ref Ray2D[] value) => m_Reader.ReadValue(out value);
     }

Runtime/Serialization/BufferSerializerWriter.cs

@@ -30,33 +30,55 @@ namespace Unity.Netcode
         public void SerializeValue(ref byte value) => m_Writer.WriteByteSafe(value);
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValueSafe(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValueSafe(value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValueSafe(value);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValueSafe(value);
+#endif
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Writer.WriteValue(value);
         public void SerializeValue<T>(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => m_Writer.WriteValue(value);
+
         public void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+        public void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValue<T>(ref NativeList<T> value) where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValueSafe(value);
+#endif
 
         public void SerializeValue(ref Vector2 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector2[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector3 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector3[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector2Int value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector2Int[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector3Int value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector3Int[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Vector4 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Vector4[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Quaternion value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Quaternion[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Color value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Color[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Color32 value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Color32[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Ray value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Ray[] value) => m_Writer.WriteValueSafe(value);
+
         public void SerializeValue(ref Ray2D value) => m_Writer.WriteValueSafe(value);
         public void SerializeValue(ref Ray2D[] value) => m_Writer.WriteValueSafe(value);
 
@@ -77,29 +99,44 @@ namespace Unity.Netcode
 
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => m_Writer.WriteValue(value);
+        public void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValue(value);
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged => m_Writer.WriteValue(value);
+#endif
+
         public void SerializeValuePreChecked<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes => m_Writer.WriteValue(value);
 
         public void SerializeValuePreChecked(ref Vector2 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector2[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector3 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector3[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector2Int value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector2Int[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector3Int value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector3Int[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Vector4 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Vector4[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Quaternion value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Quaternion[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Color value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Color[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Color32 value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Color32[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Ray value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Ray[] value) => m_Writer.WriteValue(value);
+
         public void SerializeValuePreChecked(ref Ray2D value) => m_Writer.WriteValue(value);
         public void SerializeValuePreChecked(ref Ray2D[] value) => m_Writer.WriteValue(value);
     }

Runtime/Serialization/FastBufferReader.cs

@@ -62,7 +62,7 @@ namespace Unity.Netcode
 
         private static unsafe ReaderHandle* CreateHandle(byte* buffer, int length, int offset, Allocator copyAllocator, Allocator internalAllocator)
         {
-            ReaderHandle* readerHandle = null;
+            ReaderHandle* readerHandle;
             if (copyAllocator == Allocator.None)
             {
                 readerHandle = (ReaderHandle*)UnsafeUtility.Malloc(sizeof(ReaderHandle), UnsafeUtility.AlignOf<byte>(), internalAllocator);
@@ -461,6 +461,42 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Read a NativeArray of INetworkSerializables
+        /// </summary>
+        /// <param name="value">INetworkSerializable instance</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <typeparam name="T">the array to read the values of type `T` into</typeparam>
+        /// <exception cref="NotImplementedException"></exception>
+        public void ReadNetworkSerializable<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged, INetworkSerializable
+        {
+            ReadValueSafe(out int size);
+            value = new NativeArray<T>(size, allocator);
+            for (var i = 0; i < size; ++i)
+            {
+                ReadNetworkSerializable(out T item);
+                value[i] = item;
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a NativeList of INetworkSerializables
+        /// </summary>
+        /// <param name="value">INetworkSerializable instance</param>
+        /// <typeparam name="T">the array to read the values of type `T` into</typeparam>
+        /// <exception cref="NotImplementedException"></exception>
+        public void ReadNetworkSerializableInPlace<T>(ref NativeList<T> value) where T : unmanaged, INetworkSerializable
+        {
+            ReadValueSafe(out int size);
+            value.Resize(size, NativeArrayOptions.UninitializedMemory);
+            for (var i = 0; i < size; ++i)
+            {
+                ReadNetworkSerializable(out value.ElementAt(i));
+            }
+        }
+#endif
+
         /// <summary>
         /// Read an INetworkSerializable in-place, without constructing a new one
         /// Note that this will NOT check for null before calling NetworkSerialize
@@ -757,6 +793,44 @@ namespace Unity.Netcode
                 ReadBytesSafe(bytes, sizeInBytes);
             }
         }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanaged<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
+        {
+            ReadUnmanaged(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new NativeArray<T>(sizeInTs, allocator);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytes(bytes, sizeInBytes);
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedSafe<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
+        {
+            ReadUnmanagedSafe(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value = new NativeArray<T>(sizeInTs, allocator);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytesSafe(bytes, sizeInBytes);
+        }
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedInPlace<T>(ref NativeList<T> value) where T : unmanaged
+        {
+            ReadUnmanaged(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytes(bytes, sizeInBytes);
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void ReadUnmanagedSafeInPlace<T>(ref NativeList<T> value) where T : unmanaged
+        {
+            ReadUnmanagedSafe(out int sizeInTs);
+            int sizeInBytes = sizeInTs * sizeof(T);
+            value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
+            byte* bytes = (byte*)value.GetUnsafePtr();
+            ReadBytesSafe(bytes, sizeInBytes);
+        }
+#endif
 
         /// <summary>
         /// Read a NetworkSerializable value
@@ -800,6 +874,19 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default) where T : INetworkSerializable, new() => ReadNetworkSerializable(out value);
 
+        /// <summary>
+        /// Read a NetworkSerializable NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForNetworkSerializable unused = default) where T : unmanaged, INetworkSerializable => ReadNetworkSerializable(out value, allocator);
+
 
         /// <summary>
         /// Read a struct
@@ -819,6 +906,72 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValue<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanaged(out value);
 
+        /// <summary>
+        /// Read a struct NativeArray
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValue<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, allocator);
+            }
+            else
+            {
+                ReadUnmanaged(out value, allocator);
+            }
+        }
+
+        /// <summary>
+        /// Read a struct NativeArray using a Temp allocator. Equivalent to ReadValue(out value, Allocator.Temp)
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueTemp<T>(out NativeArray<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, Allocator.Temp);
+            }
+            else
+            {
+                ReadUnmanaged(out value, Allocator.Temp);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a struct NativeList
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueInPlace<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Read(this, ref value);
+            }
+            else
+            {
+                ReadUnmanagedInPlace(ref value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Read a struct
         ///
@@ -843,6 +996,81 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => ReadUnmanagedSafe(out value);
 
+        /// <summary>
+        /// Read a struct NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, allocator);
+            }
+            else
+            {
+                ReadUnmanagedSafe(out value, allocator);
+            }
+        }
+
+        /// <summary>
+        /// Read a struct NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeTemp<T>(out NativeArray<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.ReadWithAllocator(this, out value, Allocator.Temp);
+            }
+            else
+            {
+                ReadUnmanagedSafe(out value, Allocator.Temp);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a struct NativeList
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeInPlace<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Read(this, ref value);
+            }
+            else
+            {
+                ReadUnmanagedSafeInPlace(ref value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Read a primitive value (int, bool, etc)
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
@@ -880,7 +1108,7 @@ namespace Unity.Netcode
         public void ReadValueSafe<T>(out T value, FastBufferWriter.ForPrimitives unused = default) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> => ReadUnmanagedSafe(out value);
 
         /// <summary>
-        /// Read a primitive value (int, bool, etc)
+        /// Read a primitive value (int, bool, etc) array
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
         /// on values that are not primitives.
         ///
@@ -936,6 +1164,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForEnums unused = default) where T : unmanaged, Enum => ReadUnmanagedSafe(out value);
 
+
         /// <summary>
         /// Read a Vector2
         /// </summary>
@@ -1346,5 +1575,94 @@ namespace Unity.Netcode
             value.Length = length;
             ReadBytesSafe(value.GetUnsafePtr(), length);
         }
+
+        /// <summary>
+        /// Read a FixedString NativeArray.
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new NativeArray<T>(length, allocator);
+            var ptr = (T*)value.GetUnsafePtr();
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref ptr[i]);
+            }
+        }
+
+        /// <summary>
+        /// Read a FixedString NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ReadValueSafeTemp<T>(out NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new NativeArray<T>(length, Allocator.Temp);
+            var ptr = (T*)value.GetUnsafePtr();
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref ptr[i]);
+            }
+        }
+
+        /// <summary>
+        /// Read a FixedString NativeArray using a Temp allocator. Equivalent to ReadValueSafe(out value, Allocator.Temp)
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value = new T[length];
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref value[i]);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read a FixedString NativeList.
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple reads at once by calling TryBeginRead.
+        /// </summary>
+        /// <param name="value">the value to read</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadValueSafeInPlace<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            ReadUnmanagedSafe(out int length);
+            value.Resize(length, NativeArrayOptions.UninitializedMemory);
+            for (var i = 0; i < length; ++i)
+            {
+                ReadValueSafeInPlace(ref value.ElementAt(i));
+            }
+        }
+#endif
     }
 }

Runtime/Serialization/FastBufferWriter.cs

@@ -452,6 +452,42 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write a NativeArray of INetworkSerializables
+        /// </summary>
+        /// <param name="array">The value to write</param>
+        /// <param name="count"></param>
+        /// <param name="offset"></param>
+        /// <typeparam name="T"></typeparam>
+        public void WriteNetworkSerializable<T>(NativeArray<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            WriteValueSafe(sizeInTs);
+            foreach (var item in array)
+            {
+                WriteNetworkSerializable(item);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of INetworkSerializables
+        /// </summary>
+        /// <param name="array">The value to write</param>
+        /// <param name="count"></param>
+        /// <param name="offset"></param>
+        /// <typeparam name="T"></typeparam>
+        public void WriteNetworkSerializable<T>(NativeList<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            WriteValueSafe(sizeInTs);
+            foreach (var item in array)
+            {
+                WriteNetworkSerializable(item);
+            }
+        }
+#endif
+
         /// <summary>
         /// Writes a string
         /// </summary>
@@ -536,6 +572,40 @@ namespace Unity.Netcode
             return sizeof(int) + sizeInBytes;
         }
 
+        /// <summary>
+        /// Get the required size to write a NativeArray
+        /// </summary>
+        /// <param name="array">The array to write</param>
+        /// <param name="count">The amount of elements to write</param>
+        /// <param name="offset">Where in the array to start</param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int GetWriteSize<T>(NativeArray<T> array, int count = -1, int offset = 0) where T : unmanaged
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            int sizeInBytes = sizeInTs * sizeof(T);
+            return sizeof(int) + sizeInBytes;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Get the required size to write a NativeList
+        /// </summary>
+        /// <param name="array">The array to write</param>
+        /// <param name="count">The amount of elements to write</param>
+        /// <param name="offset">Where in the array to start</param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int GetWriteSize<T>(NativeList<T> array, int count = -1, int offset = 0) where T : unmanaged
+        {
+            int sizeInTs = count != -1 ? count : array.Length - offset;
+            int sizeInBytes = sizeInTs * sizeof(T);
+            return sizeof(int) + sizeInBytes;
+        }
+#endif
+
         /// <summary>
         /// Write a partial value. The specified number of bytes is written from the value and the rest is ignored.
         /// </summary>
@@ -680,6 +750,32 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytes(NativeArray<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytes(ptr, size == -1 ? value.Length : size, offset);
+        }
+
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytes(NativeList<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytes(ptr, size == -1 ? value.Length : size, offset);
+        }
+
         /// <summary>
         /// Write multiple bytes to the stream
         ///
@@ -698,6 +794,32 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytesSafe(NativeArray<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
+        }
+
+        /// <summary>
+        /// Write multiple bytes to the stream
+        /// </summary>
+        /// <param name="value">Value to write</param>
+        /// <param name="size">Number of bytes to write</param>
+        /// <param name="offset">Offset into the buffer to begin writing</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void WriteBytesSafe(NativeList<byte> value, int size = -1, int offset = 0)
+        {
+            byte* ptr = (byte*)value.GetUnsafePtr();
+            WriteBytesSafe(ptr, size == -1 ? value.Length : size, offset);
+        }
+
         /// <summary>
         /// Copy the contents of this writer into another writer.
         /// The contents will be copied from the beginning of this writer to its current position.
@@ -749,6 +871,44 @@ namespace Unity.Netcode
             return value.Length + sizeof(int);
         }
 
+        /// <summary>
+        /// Get the write size for an array of FixedStrings
+        /// </summary>
+        /// <param name="value"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static int GetWriteSize<T>(in NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            var size = sizeof(int);
+            foreach (var item in value)
+            {
+                size += sizeof(int) + item.Length;
+            }
+
+            return size;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Get the write size for an array of FixedStrings
+        /// </summary>
+        /// <param name="value"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static int GetWriteSize<T>(in NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            var size = sizeof(int);
+            foreach (var item in value)
+            {
+                size += sizeof(int) + item.Length;
+            }
+
+            return size;
+        }
+#endif
+
         /// <summary>
         /// Get the size required to write an unmanaged value of type T
         /// </summary>
@@ -799,6 +959,50 @@ namespace Unity.Netcode
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanaged<T>(NativeArray<T> value) where T : unmanaged
+        {
+            WriteUnmanaged(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T) * value.Length);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanagedSafe<T>(NativeArray<T> value) where T : unmanaged
+        {
+            WriteUnmanagedSafe(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T) * value.Length);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged
+        {
+            WriteUnmanaged(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytes(bytes, sizeof(T) * value.Length);
+            }
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged
+        {
+            WriteUnmanagedSafe(value.Length);
+            var ptr = (T*)value.GetUnsafePtr();
+            {
+                byte* bytes = (byte*)ptr;
+                WriteBytesSafe(bytes, sizeof(T) * value.Length);
+            }
+        }
+#endif
+
         /// <summary>
         /// This empty struct exists to allow overloading WriteValue based on generic constraints.
         /// At the bytecode level, constraints aren't included in the method signature, so if multiple
@@ -869,6 +1073,20 @@ namespace Unity.Netcode
 
         }
 
+        /// <summary>
+        /// This empty struct exists to allow overloading WriteValue based on generic constraints.
+        /// At the bytecode level, constraints aren't included in the method signature, so if multiple
+        /// methods exist with the same signature, it causes a compile error because they would end up
+        /// being emitted as the same method, even if the constraints are different.
+        /// Adding an empty struct with a default value gives them different signatures in the bytecode,
+        /// which then allows the compiler to do overload resolution based on the generic constraints
+        /// without the user having to pass the struct in themselves.
+        /// </summary>
+        public struct ForGeneric
+        {
+
+        }
+
         /// <summary>
         /// Write a NetworkSerializable value
         /// </summary>
@@ -929,6 +1147,50 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValue<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanaged(value);
 
+        /// <summary>
+        /// Write a struct NativeArray
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(NativeArray<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanaged(value);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a struct NativeList
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(NativeList<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanaged(value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Write a struct
         ///
@@ -953,6 +1215,56 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValueSafe<T>(T[] value, ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy => WriteUnmanagedSafe(value);
 
+        /// <summary>
+        /// Write a struct NativeArray
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(NativeArray<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeArray<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanagedSafe(value);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a struct NativeList
+        ///
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">The values to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(NativeList<T> value, ForGeneric unused = default) where T : unmanaged
+        {
+            if (typeof(INetworkSerializable).IsAssignableFrom(typeof(T)))
+            {
+                // This calls WriteNetworkSerializable in a way that doesn't require
+                // any boxing.
+                NetworkVariableSerialization<NativeList<T>>.Serializer.Write(this, ref value);
+            }
+            else
+            {
+                WriteUnmanagedSafe(value);
+            }
+        }
+#endif
+
         /// <summary>
         /// Write a primitive value (int, bool, etc)
         /// Accepts any value that implements the given interfaces, but is not guaranteed to work correctly
@@ -1185,7 +1497,6 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteValue(Ray2D[] value) => WriteUnmanaged(value);
 
-
         /// <summary>
         /// Write a Vector2
         ///
@@ -1415,6 +1726,65 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Write an array of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(T[] value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in NativeArray<T> value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of FixedString values. Writes only the part of each string that's actually used.
+        /// When calling TryBeginWrite, ensure you calculate the write size correctly (preferably by calling
+        /// FastBufferWriter.GetWriteSize())
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValue<T>(in NativeList<T> value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+#endif
+
 
         /// <summary>
         /// Write a FixedString value. Writes only the part of the string that's actually used.
@@ -1435,5 +1805,76 @@ namespace Unity.Netcode
             }
             WriteValue(value);
         }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(T[] value, ForFixedStrings unused = default)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+        /// <summary>
+        /// Write a NativeArray of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in NativeArray<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Write a NativeList of FixedString values. Writes only the part of each string that's actually used.
+        /// "Safe" version - automatically performs bounds checking. Less efficient than bounds checking
+        /// for multiple writes at once by calling TryBeginWrite.
+        /// </summary>
+        /// <param name="value">the value to write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteValueSafe<T>(in NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            if (!TryBeginWriteInternal(GetWriteSize(value)))
+            {
+                throw new OverflowException("Writing past the end of the buffer");
+            }
+            WriteUnmanaged(value.Length);
+            foreach (var str in value)
+            {
+                WriteValue(str);
+            }
+        }
+#endif
     }
 }

Runtime/Serialization/IReaderWriter.cs

@@ -96,6 +96,25 @@ namespace Unity.Netcode
         /// <typeparam name="T">The type being serialized</typeparam>
         void SerializeValue<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
 
+        /// <summary>
+        /// Read or write a NativeArray of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of struct values implementing ISerializeByMemcpy
+        /// </summary>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+#endif
+
         /// <summary>
         /// Read or write a struct or class value implementing INetworkSerializable
         /// </summary>
@@ -121,6 +140,27 @@ namespace Unity.Netcode
         void SerializeValue<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes;
 
+        /// <summary>
+        /// Read or write NativeArray of FixedString values
+        /// </summary>
+        /// <param name="value">The value to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeArray<T> value, Allocator allocator)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Read or write a NativeList of FixedString values
+        /// </summary>
+        /// <param name="value">The value to read/write</param>
+        /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        void SerializeValue<T>(ref NativeList<T> value)
+            where T : unmanaged, INativeList<byte>, IUTF8Bytes;
+#endif
+
         /// <summary>
         /// Read or write a Vector2 value
         /// </summary>
@@ -344,6 +384,31 @@ namespace Unity.Netcode
         /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
         void SerializeValuePreChecked<T>(ref T[] value, FastBufferWriter.ForStructs unused = default) where T : unmanaged, INetworkSerializeByMemcpy;
 
+        /// <summary>
+        /// Serialize a NativeArray of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="allocator">The allocator to use to construct the resulting NativeArray when reading</param>
+        /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
+        void SerializeValuePreChecked<T>(ref NativeArray<T> value, Allocator allocator, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Serialize a NativeList of structs, "pre-checked", which skips buffer checks.
+        /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
+        /// calling this. In release builds, calling this without calling "PreCheck" may read or write
+        /// past the end of the buffer, which will cause memory corruption and undefined behavior.
+        /// </summary>
+        /// <typeparam name="T">The type being serialized</typeparam>
+        /// <param name="value">The values to read/write</param>
+        /// <param name="unused">An unused parameter that can be used for enabling overload resolution based on generic constraints</param>
+        void SerializeValuePreChecked<T>(ref NativeList<T> value, FastBufferWriter.ForGeneric unused = default) where T : unmanaged;
+#endif
+
         /// <summary>
         /// Serialize a FixedString, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
@@ -438,7 +503,7 @@ namespace Unity.Netcode
         void SerializeValuePreChecked(ref Vector4 value);
 
         /// <summary>
-        /// Serialize a Vector4Array, "pre-checked", which skips buffer checks.
+        /// Serialize a Vector4 array, "pre-checked", which skips buffer checks.
         /// In debug and editor builds, a check is made to ensure you've called "PreCheck" before
         /// calling this. In release builds, calling this without calling "PreCheck" may read or write
         /// past the end of the buffer, which will cause memory corruption and undefined behavior.

Runtime/Spawning/NetworkPrefabHandler.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
@@ -49,6 +50,8 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkPrefabHandler
     {
+        private NetworkManager m_NetworkManager;
+
         /// <summary>
         /// Links a network prefab asset to a class with the INetworkPrefabInstanceHandler interface
         /// </summary>
@@ -60,6 +63,8 @@ namespace Unity.Netcode
         /// </summary>
         private readonly Dictionary<uint, uint> m_PrefabInstanceToPrefabAsset = new Dictionary<uint, uint>();
 
+        internal static string PrefabDebugHelper(NetworkPrefab networkPrefab) => $"{nameof(NetworkPrefab)} \"{networkPrefab.Prefab.name}\"";
+
         /// <summary>
         /// Use a <see cref="GameObject"/> to register a class that implements the <see cref="INetworkPrefabInstanceHandler"/> interface with the <see cref="NetworkPrefabHandler"/>
         /// </summary>
@@ -132,23 +137,23 @@ namespace Unity.Netcode
                             }
                             else
                             {
-                                throw new System.Exception($"{targetNetworkObject.name} does not have a {nameof(NetworkObject)} component!");
+                                throw new Exception($"{targetNetworkObject.name} does not have a {nameof(NetworkObject)} component!");
                             }
                         }
                     }
                     else
                     {
-                        throw new System.Exception($"{sourceNetworkPrefab.name} does not have a {nameof(NetworkObject)} component!");
+                        throw new Exception($"{sourceNetworkPrefab.name} does not have a {nameof(NetworkObject)} component!");
                     }
                 }
                 else
                 {
-                    throw new System.Exception($"You should only call {nameof(RegisterHostGlobalObjectIdHashValues)} as a Host!");
+                    throw new Exception($"You should only call {nameof(RegisterHostGlobalObjectIdHashValues)} as a Host!");
                 }
             }
             else
             {
-                throw new System.Exception($"You can only call {nameof(RegisterHostGlobalObjectIdHashValues)} once NetworkManager is listening!");
+                throw new Exception($"You can only call {nameof(RegisterHostGlobalObjectIdHashValues)} once NetworkManager is listening!");
             }
         }
 
@@ -190,6 +195,7 @@ namespace Unity.Netcode
                         break;
                     }
                 }
+
                 m_PrefabInstanceToPrefabAsset.Remove(networkPrefabHashKey);
             }
 
@@ -201,30 +207,21 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="networkPrefab"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(GameObject networkPrefab)
-        {
-            return ContainsHandler(networkPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
-        }
+        internal bool ContainsHandler(GameObject networkPrefab) => ContainsHandler(networkPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash);
 
         /// <summary>
         /// Check to see if a <see cref="NetworkObject"/> is registered to an <see cref="INetworkPrefabInstanceHandler"/> implementation
         /// </summary>
         /// <param name="networkObject"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(NetworkObject networkObject)
-        {
-            return ContainsHandler(networkObject.GlobalObjectIdHash);
-        }
+        internal bool ContainsHandler(NetworkObject networkObject) => ContainsHandler(networkObject.GlobalObjectIdHash);
 
         /// <summary>
         /// Check to see if a <see cref="NetworkObject.GlobalObjectIdHash"/> is registered to an <see cref="INetworkPrefabInstanceHandler"/> implementation
         /// </summary>
         /// <param name="networkPrefabHash"></param>
         /// <returns>true or false</returns>
-        internal bool ContainsHandler(uint networkPrefabHash)
-        {
-            return m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
-        }
+        internal bool ContainsHandler(uint networkPrefabHash) => m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabHash) || m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash);
 
         /// <summary>
         /// Returns the source NetworkPrefab's <see cref="NetworkObject.GlobalObjectIdHash"/>
@@ -237,9 +234,10 @@ namespace Unity.Netcode
             {
                 return networkPrefabHash;
             }
-            else if (m_PrefabInstanceToPrefabAsset.ContainsKey(networkPrefabHash))
+
+            if (m_PrefabInstanceToPrefabAsset.TryGetValue(networkPrefabHash, out var hash))
             {
-                return m_PrefabInstanceToPrefabAsset[networkPrefabHash];
+                return hash;
             }
 
             return 0;
@@ -256,9 +254,9 @@ namespace Unity.Netcode
         /// <returns></returns>
         internal NetworkObject HandleNetworkPrefabSpawn(uint networkPrefabAssetHash, ulong ownerClientId, Vector3 position, Quaternion rotation)
         {
-            if (m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabAssetHash))
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
             {
-                var networkObjectInstance = m_PrefabAssetToPrefabHandler[networkPrefabAssetHash].Instantiate(ownerClientId, position, rotation);
+                var networkObjectInstance = prefabInstanceHandler.Instantiate(ownerClientId, position, rotation);
 
                 //Now we must make sure this alternate PrefabAsset spawned in place of the prefab asset with the networkPrefabAssetHash (GlobalObjectIdHash)
                 //is registered and linked to the networkPrefabAssetHash so during the HandleNetworkPrefabDestroy process we can identify the alternate prefab asset.
@@ -282,19 +280,146 @@ namespace Unity.Netcode
             var networkObjectInstanceHash = networkObjectInstance.GlobalObjectIdHash;
 
             // Do we have custom overrides registered?
-            if (m_PrefabInstanceToPrefabAsset.ContainsKey(networkObjectInstanceHash))
+            if (m_PrefabInstanceToPrefabAsset.TryGetValue(networkObjectInstanceHash, out var networkPrefabAssetHash))
             {
-                var networkPrefabAssetHash = m_PrefabInstanceToPrefabAsset[networkObjectInstanceHash];
-                if (m_PrefabAssetToPrefabHandler.ContainsKey(networkPrefabAssetHash))
+                if (m_PrefabAssetToPrefabHandler.TryGetValue(networkPrefabAssetHash, out var prefabInstanceHandler))
                 {
-                    m_PrefabAssetToPrefabHandler[networkPrefabAssetHash].Destroy(networkObjectInstance);
+                    prefabInstanceHandler.Destroy(networkObjectInstance);
                 }
             }
             else // Otherwise the NetworkObject is the source NetworkPrefab
-            if (m_PrefabAssetToPrefabHandler.ContainsKey(networkObjectInstanceHash))
+            if (m_PrefabAssetToPrefabHandler.TryGetValue(networkObjectInstanceHash, out var prefabInstanceHandler))
             {
-                m_PrefabAssetToPrefabHandler[networkObjectInstanceHash].Destroy(networkObjectInstance);
+                prefabInstanceHandler.Destroy(networkObjectInstance);
             }
         }
+
+        /// <summary>
+        /// Returns the <see cref="GameObject"/> to use as the override as could be defined within the NetworkPrefab list
+        /// Note: This should be used to create <see cref="GameObject"/> pools (with <see cref="NetworkObject"/> components)
+        /// under the scenario where you are using the Host model as it spawns everything locally. As such, the override
+        /// will not be applied when spawning locally on a Host.
+        /// Related Classes and Interfaces:
+        /// <see cref="INetworkPrefabInstanceHandler"/>
+        /// </summary>
+        /// <param name="gameObject">the <see cref="GameObject"/> to be checked for a <see cref="NetworkManager"/> defined NetworkPrefab override</param>
+        /// <returns>a <see cref="GameObject"/> that is either the override or if no overrides exist it returns the same as the one passed in as a parameter</returns>
+        public GameObject GetNetworkPrefabOverride(GameObject gameObject)
+        {
+            if (gameObject.TryGetComponent<NetworkObject>(out var networkObject))
+            {
+                if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash))
+                {
+                    switch (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override)
+                    {
+                        case NetworkPrefabOverride.Hash:
+                        case NetworkPrefabOverride.Prefab:
+                            {
+                                return m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab;
+                            }
+                    }
+                }
+            }
+
+            return gameObject;
+        }
+
+        /// <summary>
+        /// Adds a new prefab to the network prefab list.
+        /// This can be any GameObject with a NetworkObject component, from any source (addressables, asset
+        /// bundles, Resource.Load, dynamically created, etc)
+        ///
+        /// There are three limitations to this method:
+        /// - If you have NetworkConfig.ForceSamePrefabs enabled, you can only do this before starting
+        /// networking, and the server and all connected clients must all have the same exact set of prefabs
+        /// added via this method before connecting
+        /// - Adding a prefab on the server does not automatically add it on the client - it's up to you
+        /// to make sure the client and server are synchronized via whatever method makes sense for your game
+        /// (RPCs, configurations, deterministic loading, etc)
+        /// - If the server sends a Spawn message to a client that has not yet added a prefab for, the spawn message
+        /// and any other relevant messages will be held for a configurable time (default 1 second, configured via
+        /// NetworkConfig.SpawnTimeout) before an error is logged. This is intended to enable the SDK to gracefully
+        /// handle unexpected conditions (slow disks, slow network, etc) that slow down asset loading. This timeout
+        /// should not be relied on and code shouldn't be written around it - your code should be written so that
+        /// the asset is expected to be loaded before it's needed.
+        /// </summary>
+        /// <param name="prefab"></param>
+        /// <exception cref="Exception"></exception>
+        public void AddNetworkPrefab(GameObject prefab)
+        {
+            if (m_NetworkManager.IsListening && m_NetworkManager.NetworkConfig.ForceSamePrefabs)
+            {
+                throw new Exception($"All prefabs must be registered before starting {nameof(NetworkManager)} when {nameof(NetworkConfig.ForceSamePrefabs)} is enabled.");
+            }
+
+            var networkObject = prefab.GetComponent<NetworkObject>();
+            if (!networkObject)
+            {
+                throw new Exception($"All {nameof(NetworkPrefab)}s must contain a {nameof(NetworkObject)} component.");
+            }
+
+            var networkPrefab = new NetworkPrefab { Prefab = prefab };
+            bool added = m_NetworkManager.NetworkConfig.Prefabs.Add(networkPrefab);
+            if (m_NetworkManager.IsListening && added)
+            {
+                m_NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, networkObject.GlobalObjectIdHash);
+            }
+        }
+
+        /// <summary>
+        /// Remove a prefab from the prefab list.
+        /// As with AddNetworkPrefab, this is specific to the client it's called on -
+        /// calling it on the server does not automatically remove anything on any of the
+        /// client processes.
+        ///
+        /// Like AddNetworkPrefab, when NetworkConfig.ForceSamePrefabs is enabled,
+        /// this cannot be called after connecting.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void RemoveNetworkPrefab(GameObject prefab)
+        {
+            if (m_NetworkManager.IsListening && m_NetworkManager.NetworkConfig.ForceSamePrefabs)
+            {
+                throw new Exception($"Prefabs cannot be removed after starting {nameof(NetworkManager)} when {nameof(NetworkConfig.ForceSamePrefabs)} is enabled.");
+            }
+
+            var globalObjectIdHash = prefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
+            m_NetworkManager.NetworkConfig.Prefabs.Remove(prefab);
+            if (ContainsHandler(globalObjectIdHash))
+            {
+                RemoveHandler(globalObjectIdHash);
+            }
+        }
+
+        /// <summary>
+        /// If one exists, registers the player prefab
+        /// </summary>
+        internal void RegisterPlayerPrefab()
+        {
+            var networkConfig = m_NetworkManager.NetworkConfig;
+            // If we have a player prefab, then we need to verify it is in the list of NetworkPrefabOverrideLinks for client side spawning.
+            if (networkConfig.PlayerPrefab != null)
+            {
+                if (networkConfig.PlayerPrefab.TryGetComponent<NetworkObject>(out var playerPrefabNetworkObject))
+                {
+                    //In the event there is no NetworkPrefab entry (i.e. no override for default player prefab)
+                    if (!networkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject.GlobalObjectIdHash))
+                    {
+                        //Then add a new entry for the player prefab
+                        AddNetworkPrefab(networkConfig.PlayerPrefab);
+                    }
+                }
+                else
+                {
+                    // Provide the name of the prefab with issues so the user can more easily find the prefab and fix it
+                    Debug.LogError($"{nameof(NetworkConfig.PlayerPrefab)} (\"{networkConfig.PlayerPrefab.name}\") has no NetworkObject assigned to it!.");
+                }
+            }
+        }
+
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+        }
     }
 }

Runtime/Spawning/NetworkSpawnManager.cs

@@ -10,6 +10,9 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkSpawnManager
     {
+        // Stores the objects that need to be shown at end-of-frame
+        internal Dictionary<ulong, List<NetworkObject>> ObjectsToShowToClient = new Dictionary<ulong, List<NetworkObject>>();
+
         /// <summary>
         /// The currently spawned objects
         /// </summary>
@@ -37,6 +40,41 @@ namespace Unity.Netcode
         /// </summary>
         private Dictionary<ulong, ulong> m_ObjectToOwnershipTable = new Dictionary<ulong, ulong>();
 
+        internal void MarkObjectForShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                ObjectsToShowToClient.Add(clientId, new List<NetworkObject>());
+            }
+            ObjectsToShowToClient[clientId].Add(networkObject);
+        }
+
+        // returns whether any matching objects would have become visible and were returned to hidden state
+        internal bool RemoveObjectFromShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            var ret = false;
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                return false;
+            }
+
+            // probably overkill, but deals with multiple entries
+            while (ObjectsToShowToClient[clientId].Contains(networkObject))
+            {
+                Debug.LogWarning(
+                    "Object was shown and hidden from the same client in the same Network frame. As a result, the client will _not_ receive a NetworkSpawn");
+                ObjectsToShowToClient[clientId].Remove(networkObject);
+                ret = true;
+            }
+
+            if (ret)
+            {
+                networkObject.Observers.Remove(clientId);
+            }
+
+            return ret;
+        }
+
         /// <summary>
         /// Used to update a NetworkObject's ownership
         /// </summary>
@@ -141,11 +179,6 @@ namespace Unity.Netcode
         /// </summary>
         public NetworkManager NetworkManager { get; }
 
-        internal NetworkSpawnManager(NetworkManager networkManager)
-        {
-            NetworkManager = networkManager;
-        }
-
         internal readonly Queue<ReleasedNetworkId> ReleasedNetworkObjectIds = new Queue<ReleasedNetworkId>();
         private ulong m_NetworkObjectIdCounter;
 
@@ -223,7 +256,7 @@ namespace Unity.Netcode
                 NetworkObjectId = networkObject.NetworkObjectId,
                 OwnerClientId = networkObject.OwnerClientId
             };
-            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.ConnectedClientsIds);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, NetworkManager.ConnectedClientsIds);
 
             foreach (var client in NetworkManager.ConnectedClients)
             {
@@ -286,7 +319,7 @@ namespace Unity.Netcode
             {
                 if (networkObject.IsNetworkVisibleTo(client.Value.ClientId))
                 {
-                    var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
+                    var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, client.Value.ClientId);
                     NetworkManager.NetworkMetrics.TrackOwnershipChangeSent(client.Key, networkObject, size);
                 }
             }
@@ -584,8 +617,10 @@ namespace Unity.Netcode
                 }
             }
 
-            if (NetworkManager.IsServer)
+            // If we are the server and should spawn with observers
+            if (NetworkManager.IsServer && networkObject.SpawnWithObservers)
             {
+                // Add client observers
                 for (int i = 0; i < NetworkManager.ConnectedClientsList.Count; i++)
                 {
                     if (networkObject.CheckObjectVisibility == null || networkObject.CheckObjectVisibility(NetworkManager.ConnectedClientsList[i].ClientId))
@@ -600,7 +635,7 @@ namespace Unity.Netcode
 
             networkObject.InvokeBehaviourNetworkSpawn();
 
-            NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredMessageManager.TriggerType.OnSpawn, networkId);
+            NetworkManager.DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnSpawn, networkId);
 
             // propagate the IsSceneObject setting to child NetworkObjects
             var children = networkObject.GetComponentsInChildren<NetworkObject>();
@@ -633,7 +668,7 @@ namespace Unity.Netcode
             {
                 ObjectInfo = networkObject.GetMessageSceneObject(clientId)
             };
-            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, clientId);
+            var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, clientId);
             NetworkManager.NetworkMetrics.TrackObjectSpawnSent(clientId, networkObject, size);
         }
 
@@ -883,7 +918,7 @@ namespace Unity.Netcode
                             NetworkObjectId = networkObject.NetworkObjectId,
                             DestroyGameObject = networkObject.IsSceneObject != false ? destroyGameObject : true
                         };
-                        var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, m_TargetClientIds);
+                        var size = NetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, m_TargetClientIds);
                         foreach (var targetClientId in m_TargetClientIds)
                         {
                             NetworkManager.NetworkMetrics.TrackObjectDestroySent(targetClientId, networkObject, size);
@@ -944,5 +979,27 @@ namespace Unity.Netcode
                 }
             }
         }
+
+        /// <summary>
+        /// See <see cref="NetworkBehaviourUpdater.NetworkBehaviourUpdater_Tick"/>
+        /// </summary>
+        internal void HandleNetworkObjectShow()
+        {
+            // Handle NetworkObjects to show
+            foreach (var client in ObjectsToShowToClient)
+            {
+                ulong clientId = client.Key;
+                foreach (var networkObject in client.Value)
+                {
+                    SendSpawnCallForObject(clientId, networkObject);
+                }
+            }
+            ObjectsToShowToClient.Clear();
+        }
+
+        internal NetworkSpawnManager(NetworkManager networkManager)
+        {
+            NetworkManager = networkManager;
+        }
     }
 }

Runtime/Timing/NetworkTickSystem.cs

@@ -50,7 +50,7 @@ namespace Unity.Netcode
         {
             if (tickRate == 0)
             {
-                throw new ArgumentException("Tickrate must be a positive value.", nameof(tickRate));
+                throw new ArgumentException("Tick rate must be a positive value.", nameof(tickRate));
             }
 
             TickRate = tickRate;

Runtime/Timing/NetworkTimeSystem.cs

@@ -1,4 +1,5 @@
 using System;
+using Unity.Profiling;
 
 namespace Unity.Netcode
 {
@@ -8,6 +9,34 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkTimeSystem
     {
+        /// <summary>
+        /// TODO 2023-Q2: Not sure if this just needs to go away, but there is nothing that ever replaces this
+        /// </summary>
+        /// <remarks>
+        /// This was the original comment when it lived in NetworkManager:
+        /// todo talk with UX/Product, find good default value for this
+        /// </remarks>
+        private const float k_DefaultBufferSizeSec = 0.05f;
+
+        /// <summary>
+        /// Time synchronization frequency defaults to 1 synchronization message per second
+        /// </summary>
+        private const double k_TimeSyncFrequency = 1.0d;
+
+        /// <summary>
+        /// The threshold, in seconds, used to force a hard catchup of network time
+        /// </summary>
+        private const double k_HardResetThresholdSeconds = 0.2d;
+
+        /// <summary>
+        /// Default adjustment ratio
+        /// </summary>
+        private const double k_DefaultAdjustmentRatio = 0.01d;
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+        private static ProfilerMarker s_SyncTime = new ProfilerMarker($"{nameof(NetworkManager)}.SyncTime");
+#endif
+
         private double m_TimeSec;
         private double m_CurrentLocalTimeOffset;
         private double m_DesiredLocalTimeOffset;
@@ -50,6 +79,16 @@ namespace Unity.Netcode
         internal double LastSyncedServerTimeSec { get; private set; }
         internal double LastSyncedRttSec { get; private set; }
 
+        private NetworkConnectionManager m_ConnectionManager;
+        private NetworkTransport m_NetworkTransport;
+        private NetworkTickSystem m_NetworkTickSystem;
+        private NetworkManager m_NetworkManager;
+
+        /// <summary>
+        /// <see cref="k_TimeSyncFrequency"/>
+        /// </summary>
+        private int m_TimeSyncFrequencyTicks;
+
         /// <summary>
         /// The constructor class for <see cref="NetworkTickSystem"/>
         /// </summary>
@@ -57,7 +96,7 @@ namespace Unity.Netcode
         /// <param name="serverBufferSec">The amount of the time in seconds the client should buffer incoming messages from the server.</param>
         /// <param name="hardResetThresholdSec">The threshold, in seconds, used to force a hard catchup of network time.</param>
         /// <param name="adjustmentRatio">The ratio at which the NetworkTimeSystem speeds up or slows down time.</param>
-        public NetworkTimeSystem(double localBufferSec, double serverBufferSec, double hardResetThresholdSec, double adjustmentRatio = 0.01d)
+        public NetworkTimeSystem(double localBufferSec, double serverBufferSec = k_DefaultBufferSizeSec, double hardResetThresholdSec = k_HardResetThresholdSeconds, double adjustmentRatio = k_DefaultAdjustmentRatio)
         {
             LocalBufferSec = localBufferSec;
             ServerBufferSec = serverBufferSec;
@@ -65,6 +104,89 @@ namespace Unity.Netcode
             AdjustmentRatio = adjustmentRatio;
         }
 
+        /// <summary>
+        /// The primary time system is initialized when a server-host or client is started
+        /// </summary>
+        internal NetworkTickSystem Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkTransport = networkManager.NetworkConfig.NetworkTransport;
+            m_TimeSyncFrequencyTicks = (int)(k_TimeSyncFrequency * networkManager.NetworkConfig.TickRate);
+            m_NetworkTickSystem = new NetworkTickSystem(networkManager.NetworkConfig.TickRate, 0, 0);
+            // Only the server side needs to register for tick based time synchronization
+            if (m_ConnectionManager.LocalClient.IsServer)
+            {
+                m_NetworkTickSystem.Tick += OnTickSyncTime;
+            }
+
+            return m_NetworkTickSystem;
+        }
+
+        internal void UpdateTime()
+        {
+            // As a client wait to run the time system until we are connected.
+            // As a client or server don't worry about the time system if we are no longer processing messages
+            if (!m_ConnectionManager.LocalClient.IsServer && !m_ConnectionManager.LocalClient.IsConnected)
+            {
+                return;
+            }
+
+            // Only update RTT here, server time is updated by time sync messages
+            var reset = Advance(m_NetworkManager.RealTimeProvider.UnscaledDeltaTime);
+            if (reset)
+            {
+                m_NetworkTickSystem.Reset(LocalTime, ServerTime);
+            }
+
+            m_NetworkTickSystem.UpdateTick(LocalTime, ServerTime);
+
+            if (!m_ConnectionManager.LocalClient.IsServer)
+            {
+                Sync(LastSyncedServerTimeSec + m_NetworkManager.RealTimeProvider.UnscaledDeltaTime, m_NetworkTransport.GetCurrentRtt(NetworkManager.ServerClientId) / 1000d);
+            }
+        }
+
+        /// <summary>
+        /// Server-Side:
+        /// Synchronizes time with clients based on the given <see cref="m_TimeSyncFrequencyTicks"/>.
+        /// Also: <see cref="k_TimeSyncFrequency"/>
+        /// </summary>
+        /// <remarks>
+        /// The default is to send 1 time synchronization message per second
+        /// </remarks>
+        private void OnTickSyncTime()
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            s_SyncTime.Begin();
+#endif
+
+            // Check if we need to send a time synchronization message, and if so send it
+            if (m_ConnectionManager.LocalClient.IsServer && m_NetworkTickSystem.ServerTime.Tick % m_TimeSyncFrequencyTicks == 0)
+            {
+                var message = new TimeSyncMessage
+                {
+                    Tick = m_NetworkTickSystem.ServerTime.Tick
+                };
+                m_ConnectionManager.SendMessage(ref message, NetworkDelivery.Unreliable, m_ConnectionManager.ConnectedClientIds);
+            }
+
+#if DEVELOPMENT_BUILD || UNITY_EDITOR
+            s_SyncTime.End();
+#endif
+        }
+
+        /// <summary>
+        /// Invoke when shutting down the NetworkManager
+        /// </summary>
+        internal void Shutdown()
+        {
+            if (m_ConnectionManager.LocalClient.IsServer)
+            {
+                m_NetworkTickSystem.Tick -= OnTickSyncTime;
+            }
+        }
+
         /// <summary>
         /// Creates a new instance of the <see cref="NetworkTimeSystem"/> class for a server instance.
         /// The server will not apply any buffer values which ensures that local time equals server time.

Runtime/Transports/UTP/UnityTransport.cs

@@ -524,7 +524,7 @@ namespace Unity.Netcode.Transports.UTP
                 //reflection, but this does not live in the context of a performance-critical loop, it runs once at initial connection time.
                 if (m_RelayServerData.Equals(default(RelayServerData)))
                 {
-                    Debug.LogError("You must call SetRelayServerData() at least once before calling StartRelayServer.");
+                    Debug.LogError("You must call SetRelayServerData() at least once before calling StartClient.");
                     return false;
                 }
 
@@ -536,6 +536,13 @@ namespace Unity.Netcode.Transports.UTP
                 serverEndpoint = ConnectionData.ServerEndPoint;
             }
 
+            // Verify the endpoint is valid before proceeding
+            if (serverEndpoint.Family == NetworkFamily.Invalid)
+            {
+                Debug.LogError($"Target server network address ({ConnectionData.Address}) is {nameof(NetworkFamily.Invalid)}!");
+                return false;
+            }
+
             InitDriver();
 
             var bindEndpoint = serverEndpoint.Family == NetworkFamily.Ipv6 ? NetworkEndpoint.AnyIpv6 : NetworkEndpoint.AnyIpv4;
@@ -554,6 +561,13 @@ namespace Unity.Netcode.Transports.UTP
 
         private bool ServerBindAndListen(NetworkEndpoint endPoint)
         {
+            // Verify the endpoint is valid before proceeding
+            if (endPoint.Family == NetworkFamily.Invalid)
+            {
+                Debug.LogError($"Network listen address ({ConnectionData.Address}) is {nameof(NetworkFamily.Invalid)}!");
+                return false;
+            }
+
             InitDriver();
 
             int result = m_Driver.Bind(endPoint);
@@ -696,7 +710,7 @@ namespace Unity.Netcode.Transports.UTP
             //reflection, but this does not live in the context of a performance-critical loop, it runs once at initial connection time.
             if (m_RelayServerData.Equals(default(RelayServerData)))
             {
-                Debug.LogError("You must call SetRelayServerData() at least once before calling StartRelayServer.");
+                Debug.LogError("You must call SetRelayServerData() at least once before calling StartServer.");
                 return false;
             }
             else
@@ -939,7 +953,7 @@ namespace Unity.Netcode.Transports.UTP
                     {
                         continue;
                     }
-                    var transportClientId = NetworkManager.ClientIdToTransportId(ngoConnectionId);
+                    var transportClientId = NetworkManager.ConnectionManager.ClientIdToTransportId(ngoConnectionId);
                     ExtractNetworkMetricsForClient(transportClientId);
                 }
             }
@@ -1163,7 +1177,7 @@ namespace Unity.Netcode.Transports.UTP
 
             if (NetworkManager != null)
             {
-                var transportId = NetworkManager.ClientIdToTransportId(clientId);
+                var transportId = NetworkManager.ConnectionManager.ClientIdToTransportId(clientId);
 
                 var rtt = ExtractRtt(ParseClientId(transportId));
                 if (rtt > 0)
@@ -1268,7 +1282,7 @@ namespace Unity.Netcode.Transports.UTP
                     // provide any reliability guarantees anymore. Disconnect the client since at
                     // this point they're bound to become desynchronized.
 
-                    var ngoClientId = NetworkManager?.TransportIdToClientId(clientId) ?? clientId;
+                    var ngoClientId = NetworkManager?.ConnectionManager.TransportIdToClientId(clientId) ?? clientId;
                     Debug.LogError($"Couldn't add payload of size {payload.Count} to reliable send queue. " +
                         $"Closing connection {ngoClientId} as reliability guarantees can't be maintained.");
 
@@ -1368,24 +1382,22 @@ namespace Unity.Netcode.Transports.UTP
         /// </summary>
         public override void Shutdown()
         {
-            if (!m_Driver.IsCreated)
+            if (m_Driver.IsCreated)
             {
-                return;
-            }
+                // Flush all send queues to the network. NGO can be configured to flush its message
+                // queue on shutdown. But this only calls the Send() method, which doesn't actually
+                // get anything to the network.
+                foreach (var kvp in m_SendQueue)
+                {
+                    SendBatchedMessages(kvp.Key, kvp.Value);
+                }
 
-            // Flush all send queues to the network. NGO can be configured to flush its message
-            // queue on shutdown. But this only calls the Send() method, which doesn't actually
-            // get anything to the network.
-            foreach (var kvp in m_SendQueue)
-            {
-                SendBatchedMessages(kvp.Key, kvp.Value);
+                // The above flush only puts the message in UTP internal buffers, need an update to
+                // actually get the messages on the wire. (Normally a flush send would be sufficient,
+                // but there might be disconnect messages and those require an update call.)
+                m_Driver.ScheduleUpdate().Complete();
             }
 
-            // The above flush only puts the message in UTP internal buffers, need an update to
-            // actually get the messages on the wire. (Normally a flush send would be sufficient,
-            // but there might be disconnect messages and those require an update call.)
-            m_Driver.ScheduleUpdate().Complete();
-
             DisposeInternals();
 
             m_ReliableReceiveQueues.Clear();

TestHelpers/Runtime/MessageHooksConditional.cs

@@ -95,8 +95,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 Assert.IsNotNull(m_MessageReceiptCheck, $"{nameof(m_MessageReceiptCheck)} is null, did you forget to initialize?");
                 MessageHooks.ReceiptCheck = m_MessageReceiptCheck;
             }
-            Assert.IsNotNull(m_NetworkManager.MessagingSystem, $"{nameof(NetworkManager.MessagingSystem)} is null! Did you forget to start first?");
-            m_NetworkManager.MessagingSystem.Hook(MessageHooks);
+            Assert.IsNotNull(m_NetworkManager.ConnectionManager.MessageManager, $"{nameof(NetworkMessageManager)} is null! Did you forget to start first?");
+            m_NetworkManager.ConnectionManager.MessageManager.Hook(MessageHooks);
         }
 
         internal void AssignMessageType<T>() where T : INetworkMessage
@@ -115,7 +115,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
         internal void RemoveHook()
         {
-            m_NetworkManager.MessagingSystem.Unhook(MessageHooks);
+            m_NetworkManager.ConnectionManager.MessageManager.Unhook(MessageHooks);
         }
 
         internal void AssignMessageType(Type type)

TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -431,6 +431,18 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
         }
 
+        /// <summary>
+        /// CreateAndStartNewClient Only
+        /// Override this method to bypass the waiting for a client to connect.
+        /// </summary>
+        /// <remarks>
+        /// Use this for testing connection and disconnection scenarios
+        /// </remarks>
+        protected virtual bool ShouldWaitForNewClientToConnect(NetworkManager networkManager)
+        {
+            return true;
+        }
+
         /// <summary>
         /// This will create, start, and connect a new client while in the middle of an
         /// integration test.
@@ -448,26 +460,29 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             if (LogAllMessages)
             {
-                networkManager.MessagingSystem.Hook(new DebugNetworkHooks());
+                networkManager.ConnectionManager.MessageManager.Hook(new DebugNetworkHooks());
             }
 
             AddRemoveNetworkManager(networkManager, true);
 
             OnNewClientStarted(networkManager);
 
-            // Wait for the new client to connect
-            yield return WaitForClientsConnectedOrTimeOut();
-
-            OnNewClientStartedAndConnected(networkManager);
-            if (s_GlobalTimeoutHelper.TimedOut)
+            if (ShouldWaitForNewClientToConnect(networkManager))
             {
-                AddRemoveNetworkManager(networkManager, false);
-                Object.DestroyImmediate(networkManager.gameObject);
-            }
+                // Wait for the new client to connect
+                yield return WaitForClientsConnectedOrTimeOut();
 
-            AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
-            ClientNetworkManagerPostStart(networkManager);
-            VerboseDebug($"[{networkManager.name}] Created and connected!");
+                OnNewClientStartedAndConnected(networkManager);
+                if (s_GlobalTimeoutHelper.TimedOut)
+                {
+                    AddRemoveNetworkManager(networkManager, false);
+                    Object.DestroyImmediate(networkManager.gameObject);
+                }
+
+                AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
+                ClientNetworkManagerPostStart(networkManager);
+                VerboseDebug($"[{networkManager.name}] Created and connected!");
+            }
         }
 
         /// <summary>
@@ -487,7 +502,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             if (LogAllMessages)
             {
-                networkManager.MessagingSystem.Hook(new DebugNetworkHooks());
+                networkManager.ConnectionManager.MessageManager.Hook(new DebugNetworkHooks());
             }
 
             AddRemoveNetworkManager(networkManager, true);
@@ -1056,10 +1071,10 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         protected void EnableMessageLogging()
         {
-            m_ServerNetworkManager.MessagingSystem.Hook(new DebugNetworkHooks());
+            m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new DebugNetworkHooks());
             foreach (var client in m_ClientNetworkManagers)
             {
-                client.MessagingSystem.Hook(new DebugNetworkHooks());
+                client.ConnectionManager.MessageManager.Hook(new DebugNetworkHooks());
             }
         }
 
@@ -1578,12 +1593,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())
 #endif
                     {
-                        var method = behaviour.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
-                        if (method == null)
-                        {
-                            method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
-                        }
-
+                        var method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                         method?.Invoke(behaviour, new object[] { });
                     }
                 }

TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs

@@ -303,7 +303,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
             clientToStart.StartClient();
             s_Hooks[clientToStart] = new MultiInstanceHooks();
-            clientToStart.MessagingSystem.Hook(s_Hooks[clientToStart]);
+            clientToStart.ConnectionManager.MessageManager.Hook(s_Hooks[clientToStart]);
             if (!NetworkManagerInstances.Contains(clientToStart))
             {
                 NetworkManagerInstances.Add(clientToStart);
@@ -440,7 +440,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
 
             var hooks = new MultiInstanceHooks();
-            server.MessagingSystem.Hook(hooks);
+            server.ConnectionManager.MessageManager.Hook(hooks);
             s_Hooks[server] = hooks;
 
             // if set, then invoke this for the server
@@ -452,7 +452,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 clients[i].StartClient();
                 hooks = new MultiInstanceHooks();
-                clients[i].MessagingSystem.Hook(hooks);
+                clients[i].ConnectionManager.MessageManager.Hook(hooks);
                 s_Hooks[clients[i]] = hooks;
 
                 // if set, then invoke this for the client

TestHelpers/Runtime/NetcodeLogAssert.cs

@@ -3,10 +3,11 @@ using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using NUnit.Framework;
 using UnityEngine;
+using UnityEngine.TestTools;
 
 namespace Unity.Netcode.RuntimeTests
 {
-    public class NetcodeLogAssert
+    public class NetcodeLogAssert : IDisposable
     {
         private struct LogData
         {
@@ -20,8 +21,11 @@ namespace Unity.Netcode.RuntimeTests
 
         private List<LogData> AllLogs { get; }
 
-        public NetcodeLogAssert()
+        private bool m_ResetIgnoreFailingMessagesOnTearDown;
+        public NetcodeLogAssert(bool ignorFailingMessages = false, bool resetOnTearDown = true)
         {
+            LogAssert.ignoreFailingMessages = ignorFailingMessages;
+            m_ResetIgnoreFailingMessagesOnTearDown = resetOnTearDown;
             AllLogs = new List<LogData>();
             Activate();
         }
@@ -51,6 +55,16 @@ namespace Unity.Netcode.RuntimeTests
             }
         }
 
+        [UnityTearDown]
+        public void OnTearDown()
+        {
+            // Defaults to true and will reset LogAssert.ignoreFailingMessages during tear down
+            if (m_ResetIgnoreFailingMessagesOnTearDown)
+            {
+                LogAssert.ignoreFailingMessages = false;
+            }
+        }
+
         public void Dispose()
         {
             Dispose(true);
@@ -59,6 +73,8 @@ namespace Unity.Netcode.RuntimeTests
 
         private void Dispose(bool disposing)
         {
+            // Always reset when disposing
+            LogAssert.ignoreFailingMessages = false;
             if (m_Disposed)
             {
                 return;
@@ -131,6 +147,7 @@ namespace Unity.Netcode.RuntimeTests
                     if (logEvent.LogType == type && messageRegex.IsMatch(logEvent.Message))
                     {
                         found = true;
+                        break;
                     }
                 }
 
@@ -141,6 +158,23 @@ namespace Unity.Netcode.RuntimeTests
             }
         }
 
+        public bool HasLogBeenReceived(LogType type, string message)
+        {
+            var found = false;
+            lock (m_Lock)
+            {
+                foreach (var logEvent in AllLogs)
+                {
+                    if (logEvent.LogType == type && message.Equals(logEvent.Message))
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            return found;
+        }
+
         public void Reset()
         {
             lock (m_Lock)

Tests/Editor/Messaging/DisconnectOnSendTests.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace Unity.Netcode.EditorTests
+{
+    public class DisconnectOnSendTests
+    {
+        private struct TestMessage : INetworkMessage, INetworkSerializeByMemcpy
+        {
+            public void Serialize(FastBufferWriter writer, int targetVersion)
+            {
+            }
+
+            public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+            {
+                return true;
+            }
+
+            public void Handle(ref NetworkContext context)
+            {
+            }
+
+            public int Version => 0;
+        }
+
+        private class DisconnectOnSendMessageSender : INetworkMessageSender
+        {
+            public NetworkMessageManager MessageManager;
+
+            public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+            {
+                MessageManager.ClientDisconnected(clientId);
+            }
+        }
+
+        private class TestMessageProvider : INetworkMessageProvider
+        {
+            // Keep track of what we sent
+            private List<NetworkMessageManager.MessageWithHandler> m_MessageList = new List<NetworkMessageManager.MessageWithHandler>
+            {
+                new NetworkMessageManager.MessageWithHandler
+                {
+                    MessageType = typeof(TestMessage),
+                    Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
+                    GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
+                }
+            };
+
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
+            {
+                return m_MessageList;
+            }
+        }
+
+        private TestMessageProvider m_TestMessageProvider;
+        private DisconnectOnSendMessageSender m_MessageSender;
+        private NetworkMessageManager m_MessageManager;
+        private ulong[] m_Clients = { 0 };
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_MessageSender = new DisconnectOnSendMessageSender();
+            m_TestMessageProvider = new TestMessageProvider();
+            m_MessageManager = new NetworkMessageManager(m_MessageSender, this, m_TestMessageProvider);
+            m_MessageSender.MessageManager = m_MessageManager;
+            m_MessageManager.ClientConnected(0);
+            m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_MessageManager.Dispose();
+        }
+
+        private TestMessage GetMessage()
+        {
+            return new TestMessage();
+        }
+
+        [Test]
+        public void WhenDisconnectIsCalledDuringSend_NoErrorsOccur()
+        {
+            var message = GetMessage();
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+
+            // This is where an exception would be thrown and logged.
+            m_MessageManager.ProcessSendQueues();
+        }
+    }
+}

Tests/Editor/Messaging/DisconnectOnSendTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7984df99de5c4b85a1b8567582d00c64
+timeCreated: 1680888331

Tests/Editor/Messaging/MessageCorruptionTests.cs

@@ -39,17 +39,17 @@ namespace Unity.Netcode.EditorTests
             public int Version => 0;
         }
 
-        private class TestMessageProvider : IMessageProvider
+        private class TestMessageProvider : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessage),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessage>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
                     }
                 };
             }
@@ -64,7 +64,7 @@ namespace Unity.Netcode.EditorTests
             AdditionalGarbageData,
         }
 
-        private class TestMessageSender : IMessageSender
+        private class TestMessageSender : INetworkMessageSender
         {
 
             public TypeOfCorruption Corruption;
@@ -108,7 +108,7 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
-        private MessagingSystem m_MessagingSystem;
+        private NetworkMessageManager m_MessageManager;
         private TestMessageSender m_MessageSender;
 
         [SetUp]
@@ -118,16 +118,16 @@ namespace Unity.Netcode.EditorTests
             TestMessage.Deserialized = false;
             m_MessageSender = new TestMessageSender();
 
-            m_MessagingSystem = new MessagingSystem(m_MessageSender, this, new TestMessageProvider());
+            m_MessageManager = new NetworkMessageManager(m_MessageSender, this, new TestMessageProvider());
 
-            m_MessagingSystem.ClientConnected(0);
-            m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
+            m_MessageManager.ClientConnected(0);
+            m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
         }
 
         [TearDown]
         public void TearDown()
         {
-            m_MessagingSystem.Dispose();
+            m_MessageManager.Dispose();
         }
 
         private TestMessage GetMessage()
@@ -159,14 +159,14 @@ namespace Unity.Netcode.EditorTests
             }
 
             // Dummy batch header
-            var batchHeader = new BatchHeader
+            var batchHeader = new NetworkBatchHeader
             {
                 BatchCount = 1
             };
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
             var message = GetMessage();
 
@@ -182,11 +182,11 @@ namespace Unity.Netcode.EditorTests
 
                 // Fill out the rest of the batch header
                 writer.Seek(0);
-                batchHeader = new BatchHeader
+                batchHeader = new NetworkBatchHeader
                 {
-                    Magic = BatchHeader.MagicValue,
+                    Magic = NetworkBatchHeader.MagicValue,
                     BatchSize = writer.Length,
-                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
                     BatchCount = 1
                 };
                 writer.WriteValue(batchHeader);
@@ -194,7 +194,7 @@ namespace Unity.Netcode.EditorTests
 
                 var receivedMessage = m_MessageSender.MessageQueue[0];
                 m_MessageSender.MessageQueue.Clear();
-                m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
+                m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
                 Assert.IsFalse(TestMessage.Deserialized);
                 Assert.IsFalse(TestMessage.Handled);
             }

Tests/Editor/Messaging/MessageReceivingTests.cs

@@ -39,23 +39,23 @@ namespace Unity.Netcode.EditorTests
             public int Version => 0;
         }
 
-        private class TestMessageProvider : IMessageProvider
+        private class TestMessageProvider : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessage),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessage>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
                     }
                 };
             }
         }
 
-        private MessagingSystem m_MessagingSystem;
+        private NetworkMessageManager m_MessageManager;
 
         [SetUp]
         public void SetUp()
@@ -64,14 +64,14 @@ namespace Unity.Netcode.EditorTests
             TestMessage.Handled = false;
             TestMessage.DeserializedValues.Clear();
 
-            m_MessagingSystem = new MessagingSystem(new NopMessageSender(), this, new TestMessageProvider());
-            m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
+            m_MessageManager = new NetworkMessageManager(new NopMessageSender(), this, new TestMessageProvider());
+            m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
         }
 
         [TearDown]
         public void TearDown()
         {
-            m_MessagingSystem.Dispose();
+            m_MessageManager.Dispose();
         }
 
         private TestMessage GetMessage()
@@ -88,10 +88,10 @@ namespace Unity.Netcode.EditorTests
         [Test]
         public void WhenHandlingAMessage_ReceiveMethodIsCalled()
         {
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
             var message = GetMessage();
 
@@ -104,7 +104,7 @@ namespace Unity.Netcode.EditorTests
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
-                    m_MessagingSystem.HandleMessage(messageHeader, reader, 0, 0, 0);
+                    m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
                     Assert.IsTrue(TestMessage.Deserialized);
                     Assert.IsTrue(TestMessage.Handled);
                     Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
@@ -116,14 +116,14 @@ namespace Unity.Netcode.EditorTests
         [Test]
         public unsafe void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
         {
-            var batchHeader = new BatchHeader
+            var batchHeader = new NetworkBatchHeader
             {
                 BatchCount = 1
             };
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
             var message = GetMessage();
 
@@ -139,11 +139,11 @@ namespace Unity.Netcode.EditorTests
 
                 // Fill out the rest of the batch header
                 writer.Seek(0);
-                batchHeader = new BatchHeader
+                batchHeader = new NetworkBatchHeader
                 {
-                    Magic = BatchHeader.MagicValue,
+                    Magic = NetworkBatchHeader.MagicValue,
                     BatchSize = writer.Length,
-                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
                     BatchCount = 1
                 };
                 writer.WriteValue(batchHeader);
@@ -151,7 +151,7 @@ namespace Unity.Netcode.EditorTests
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
-                    m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
+                    m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
                     Assert.IsFalse(TestMessage.Deserialized);
                     Assert.IsFalse(TestMessage.Handled);
                     Assert.IsEmpty(TestMessage.DeserializedValues);
@@ -162,14 +162,14 @@ namespace Unity.Netcode.EditorTests
         [Test]
         public unsafe void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
         {
-            var batchHeader = new BatchHeader
+            var batchHeader = new NetworkBatchHeader
             {
                 BatchCount = 1
             };
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (uint)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
             var message = GetMessage();
 
@@ -183,11 +183,11 @@ namespace Unity.Netcode.EditorTests
 
                 // Fill out the rest of the batch header
                 writer.Seek(0);
-                batchHeader = new BatchHeader
+                batchHeader = new NetworkBatchHeader
                 {
-                    Magic = BatchHeader.MagicValue,
+                    Magic = NetworkBatchHeader.MagicValue,
                     BatchSize = writer.Length,
-                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
                     BatchCount = 1
                 };
                 writer.WriteValue(batchHeader);
@@ -195,8 +195,8 @@ namespace Unity.Netcode.EditorTests
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
-                    m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
-                    m_MessagingSystem.ProcessIncomingMessageQueue();
+                    m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
+                    m_MessageManager.ProcessIncomingMessageQueue();
                     Assert.IsTrue(TestMessage.Deserialized);
                     Assert.IsTrue(TestMessage.Handled);
                     Assert.AreEqual(1, TestMessage.DeserializedValues.Count);
@@ -208,14 +208,14 @@ namespace Unity.Netcode.EditorTests
         [Test]
         public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
         {
-            var batchHeader = new BatchHeader
+            var batchHeader = new NetworkBatchHeader
             {
                 BatchCount = 2
             };
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
             var message = GetMessage();
             var message2 = GetMessage();
@@ -233,11 +233,11 @@ namespace Unity.Netcode.EditorTests
 
                 // Fill out the rest of the batch header
                 writer.Seek(0);
-                batchHeader = new BatchHeader
+                batchHeader = new NetworkBatchHeader
                 {
-                    Magic = BatchHeader.MagicValue,
+                    Magic = NetworkBatchHeader.MagicValue,
                     BatchSize = writer.Length,
-                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), writer.Length - sizeof(NetworkBatchHeader)),
                     BatchCount = 2
                 };
                 writer.WriteValue(batchHeader);
@@ -245,12 +245,12 @@ namespace Unity.Netcode.EditorTests
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
-                    m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
+                    m_MessageManager.HandleIncomingData(0, new ArraySegment<byte>(writer.ToArray()), 0);
                     Assert.IsFalse(TestMessage.Deserialized);
                     Assert.IsFalse(TestMessage.Handled);
                     Assert.IsEmpty(TestMessage.DeserializedValues);
 
-                    m_MessagingSystem.ProcessIncomingMessageQueue();
+                    m_MessageManager.ProcessIncomingMessageQueue();
                     Assert.IsTrue(TestMessage.Deserialized);
                     Assert.IsTrue(TestMessage.Handled);
                     Assert.AreEqual(2, TestMessage.DeserializedValues.Count);

Tests/Editor/Messaging/MessageRegistrationTests.cs

@@ -48,23 +48,23 @@ namespace Unity.Netcode.EditorTests
 
             public int Version => 0;
         }
-        private class TestMessageProviderOne : IMessageProvider
+        private class TestMessageProviderOne : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessageOne),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessageOne>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageOne>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessageOne>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageOne>
                     },
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessageTwo),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessageTwo>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageTwo>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessageTwo>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageTwo>
                     }
                 };
             }
@@ -91,17 +91,17 @@ namespace Unity.Netcode.EditorTests
 
             public int Version => 0;
         }
-        private class TestMessageProviderTwo : IMessageProvider
+        private class TestMessageProviderTwo : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessageThree),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessageThree>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageThree>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessageThree>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageThree>
                     }
                 };
             }
@@ -127,17 +127,17 @@ namespace Unity.Netcode.EditorTests
 
             public int Version => 0;
         }
-        private class TestMessageProviderThree : IMessageProvider
+        private class TestMessageProviderThree : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessageFour),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessageFour>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessageFour>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessageFour>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessageFour>
                     }
                 };
             }
@@ -148,9 +148,9 @@ namespace Unity.Netcode.EditorTests
         {
             var sender = new NopMessageSender();
 
-            using var systemOne = new MessagingSystem(sender, null, new TestMessageProviderOne());
-            using var systemTwo = new MessagingSystem(sender, null, new TestMessageProviderTwo());
-            using var systemThree = new MessagingSystem(sender, null, new TestMessageProviderThree());
+            using var systemOne = new NetworkMessageManager(sender, null, new TestMessageProviderOne());
+            using var systemTwo = new NetworkMessageManager(sender, null, new TestMessageProviderTwo());
+            using var systemThree = new NetworkMessageManager(sender, null, new TestMessageProviderThree());
 
             using (systemOne)
             using (systemTwo)
@@ -172,18 +172,18 @@ namespace Unity.Netcode.EditorTests
         {
             var sender = new NopMessageSender();
 
-            using var systemOne = new MessagingSystem(sender, null, new TestMessageProviderOne());
-            using var systemTwo = new MessagingSystem(sender, null, new TestMessageProviderTwo());
-            using var systemThree = new MessagingSystem(sender, null, new TestMessageProviderThree());
+            using var systemOne = new NetworkMessageManager(sender, null, new TestMessageProviderOne());
+            using var systemTwo = new NetworkMessageManager(sender, null, new TestMessageProviderTwo());
+            using var systemThree = new NetworkMessageManager(sender, null, new TestMessageProviderThree());
 
             using (systemOne)
             using (systemTwo)
             using (systemThree)
             {
-                MessagingSystem.MessageHandler handlerOne = MessagingSystem.ReceiveMessage<TestMessageOne>;
-                MessagingSystem.MessageHandler handlerTwo = MessagingSystem.ReceiveMessage<TestMessageTwo>;
-                MessagingSystem.MessageHandler handlerThree = MessagingSystem.ReceiveMessage<TestMessageThree>;
-                MessagingSystem.MessageHandler handlerFour = MessagingSystem.ReceiveMessage<TestMessageFour>;
+                NetworkMessageManager.MessageHandler handlerOne = NetworkMessageManager.ReceiveMessage<TestMessageOne>;
+                NetworkMessageManager.MessageHandler handlerTwo = NetworkMessageManager.ReceiveMessage<TestMessageTwo>;
+                NetworkMessageManager.MessageHandler handlerThree = NetworkMessageManager.ReceiveMessage<TestMessageThree>;
+                NetworkMessageManager.MessageHandler handlerFour = NetworkMessageManager.ReceiveMessage<TestMessageFour>;
 
                 Assert.AreEqual(handlerOne, systemOne.MessageHandlers[systemOne.GetMessageType(typeof(TestMessageOne))]);
                 Assert.AreEqual(handlerTwo, systemOne.MessageHandlers[systemOne.GetMessageType(typeof(TestMessageTwo))]);
@@ -216,29 +216,29 @@ namespace Unity.Netcode.EditorTests
         }
 #pragma warning restore IDE1006
 
-        internal class OrderingMessageProvider : IMessageProvider
+        internal class OrderingMessageProvider : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                var listMessages = new List<MessagingSystem.MessageWithHandler>();
+                var listMessages = new List<NetworkMessageManager.MessageWithHandler>();
 
-                var messageWithHandler = new MessagingSystem.MessageWithHandler
+                var messageWithHandler = new NetworkMessageManager.MessageWithHandler
                 {
                     MessageType = typeof(zzzLateLexicographicNetworkMessage),
-                    GetVersion = MessagingSystem.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>
+                    GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>
                 };
                 listMessages.Add(messageWithHandler);
 
                 messageWithHandler.MessageType = typeof(ConnectionRequestMessage);
-                messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionRequestMessage>;
+                messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<ConnectionRequestMessage>;
                 listMessages.Add(messageWithHandler);
 
                 messageWithHandler.MessageType = typeof(ConnectionApprovedMessage);
-                messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<ConnectionApprovedMessage>;
+                messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<ConnectionApprovedMessage>;
                 listMessages.Add(messageWithHandler);
 
                 messageWithHandler.MessageType = typeof(AAAEarlyLexicographicNetworkMessage);
-                messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<AAAEarlyLexicographicNetworkMessage>;
+                messageWithHandler.GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<AAAEarlyLexicographicNetworkMessage>;
                 listMessages.Add(messageWithHandler);
 
                 return listMessages;
@@ -250,18 +250,18 @@ namespace Unity.Netcode.EditorTests
         {
             var sender = new NopMessageSender();
             var provider = new OrderingMessageProvider();
-            using var messagingSystem = new MessagingSystem(sender, null, provider);
+            using var messageManager = new NetworkMessageManager(sender, null, provider);
 
             // the 2 priority messages should appear first, in lexicographic order
-            Assert.AreEqual(messagingSystem.MessageTypes[0], typeof(ConnectionApprovedMessage));
-            Assert.AreEqual(messagingSystem.MessageTypes[1], typeof(ConnectionRequestMessage));
+            Assert.AreEqual(messageManager.MessageTypes[0], typeof(ConnectionApprovedMessage));
+            Assert.AreEqual(messageManager.MessageTypes[1], typeof(ConnectionRequestMessage));
 
             // the other should follow after
-            Assert.AreEqual(messagingSystem.MessageTypes[2], typeof(AAAEarlyLexicographicNetworkMessage));
-            Assert.AreEqual(messagingSystem.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
+            Assert.AreEqual(messageManager.MessageTypes[2], typeof(AAAEarlyLexicographicNetworkMessage));
+            Assert.AreEqual(messageManager.MessageTypes[3], typeof(zzzLateLexicographicNetworkMessage));
 
             // there should not be any extras
-            Assert.AreEqual(messagingSystem.MessageHandlerCount, 4);
+            Assert.AreEqual(messageManager.MessageHandlerCount, 4);
         }
     }
 }

Tests/Editor/Messaging/MessageSendingTests.cs

@@ -18,6 +18,7 @@ namespace Unity.Netcode.EditorTests
             public int B;
             public int C;
             public static bool Serialized;
+
             public void Serialize(FastBufferWriter writer, int targetVersion)
             {
                 Serialized = true;
@@ -36,7 +37,7 @@ namespace Unity.Netcode.EditorTests
             public int Version => 0;
         }
 
-        private class TestMessageSender : IMessageSender
+        private class TestMessageSender : INetworkMessageSender
         {
             public List<byte[]> MessageQueue = new List<byte[]>();
 
@@ -46,30 +47,31 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
-        private class TestMessageProvider : IMessageProvider, IDisposable
+        private class TestMessageProvider : INetworkMessageProvider, IDisposable
         {
             // Keep track of what we sent
-            private List<List<MessagingSystem.MessageWithHandler>> m_CachedMessages = new List<List<MessagingSystem.MessageWithHandler>>();
+            private List<List<NetworkMessageManager.MessageWithHandler>> m_CachedMessages = new List<List<NetworkMessageManager.MessageWithHandler>>();
 
             public void Dispose()
             {
                 foreach (var cachedItem in m_CachedMessages)
                 {
-                    // Clear out any references to MessagingSystem.MessageWithHandlers
+                    // Clear out any references to NetworkMessageManager.MessageWithHandlers
                     cachedItem.Clear();
                 }
+
                 m_CachedMessages.Clear();
             }
 
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                var messageList = new List<MessagingSystem.MessageWithHandler>
+                var messageList = new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessage),
-                        Handler = MessagingSystem.ReceiveMessage<TestMessage>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
+                        Handler = NetworkMessageManager.ReceiveMessage<TestMessage>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
                     }
                 };
                 // Track messages sent
@@ -80,7 +82,7 @@ namespace Unity.Netcode.EditorTests
 
         private TestMessageProvider m_TestMessageProvider;
         private TestMessageSender m_MessageSender;
-        private MessagingSystem m_MessagingSystem;
+        private NetworkMessageManager m_MessageManager;
         private ulong[] m_Clients = { 0 };
 
         [SetUp]
@@ -89,16 +91,16 @@ namespace Unity.Netcode.EditorTests
             TestMessage.Serialized = false;
             m_MessageSender = new TestMessageSender();
             m_TestMessageProvider = new TestMessageProvider();
-            m_MessagingSystem = new MessagingSystem(m_MessageSender, this, m_TestMessageProvider);
-            m_MessagingSystem.ClientConnected(0);
-            m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
+            m_MessageManager = new NetworkMessageManager(m_MessageSender, this, m_TestMessageProvider);
+            m_MessageManager.ClientConnected(0);
+            m_MessageManager.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
         }
 
         [TearDown]
         public void TearDown()
         {
             m_TestMessageProvider.Dispose();
-            m_MessagingSystem.Dispose();
+            m_MessageManager.Dispose();
         }
 
         private TestMessage GetMessage()
@@ -116,7 +118,7 @@ namespace Unity.Netcode.EditorTests
         public void WhenSendingMessage_SerializeIsCalled()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             Assert.IsTrue(TestMessage.Serialized);
         }
 
@@ -124,7 +126,7 @@ namespace Unity.Netcode.EditorTests
         public void WhenSendingMessage_NothingIsSentBeforeProcessingSendQueue()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             Assert.IsEmpty(m_MessageSender.MessageQueue);
         }
 
@@ -132,9 +134,9 @@ namespace Unity.Netcode.EditorTests
         public void WhenProcessingSendQueue_MessageIsSent()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
         }
 
@@ -142,11 +144,11 @@ namespace Unity.Netcode.EditorTests
         public void WhenSendingMultipleMessages_MessagesAreBatched()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
         }
 
@@ -155,40 +157,42 @@ namespace Unity.Netcode.EditorTests
         {
             var message = GetMessage();
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < (1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size; ++i)
+            for (var i = 0; i < (m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size; ++i)
             {
-                m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+                m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             }
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
         }
 
         [Test]
-        public void WhenExceedingBatchSize_NewBatchesAreCreated()
+        public void WhenExceedingBatchSize_NewBatchesAreCreated([Values(500, 1000, 1300, 2000)] int maxMessageSize)
         {
             var message = GetMessage();
+            m_MessageManager.NonFragmentedMessageMaxSize = maxMessageSize;
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
+            for (var i = 0; i < ((m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size) + 1; ++i)
             {
-                m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+                m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             }
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(2, m_MessageSender.MessageQueue.Count);
         }
 
         [Test]
-        public void WhenExceedingMTUSizeWithFragmentedDelivery_NewBatchesAreNotCreated()
+        public void WhenExceedingMTUSizeWithFragmentedDelivery_NewBatchesAreNotCreated([Values(500, 1000, 1300, 2000)] int maxMessageSize)
         {
             var message = GetMessage();
+            m_MessageManager.NonFragmentedMessageMaxSize = maxMessageSize;
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
+            for (var i = 0; i < ((m_MessageManager.NonFragmentedMessageMaxSize - UnsafeUtility.SizeOf<NetworkBatchHeader>()) / size) + 1; ++i)
             {
-                m_MessagingSystem.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
+                m_MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
             }
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
         }
 
@@ -196,11 +200,11 @@ namespace Unity.Netcode.EditorTests
         public void WhenSwitchingDelivery_NewBatchesAreCreated()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Unreliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Unreliable, m_Clients);
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(2, m_MessageSender.MessageQueue.Count);
         }
 
@@ -208,11 +212,11 @@ namespace Unity.Netcode.EditorTests
         public void WhenSwitchingChannel_NewBatchesAreNotCreated()
         {
             var message = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
         }
 
@@ -221,22 +225,22 @@ namespace Unity.Netcode.EditorTests
         {
             var message = GetMessage();
             var message2 = GetMessage();
-            m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
-            m_MessagingSystem.SendMessage(ref message2, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
+            m_MessageManager.SendMessage(ref message2, NetworkDelivery.Reliable, m_Clients);
 
-            m_MessagingSystem.ProcessSendQueues();
+            m_MessageManager.ProcessSendQueues();
             var reader = new FastBufferReader(m_MessageSender.MessageQueue[0], Allocator.Temp);
             using (reader)
             {
-                reader.ReadValueSafe(out BatchHeader header);
+                reader.ReadValueSafe(out NetworkBatchHeader header);
                 Assert.AreEqual(2, header.BatchCount);
 
-                MessageHeader messageHeader;
+                NetworkMessageHeader messageHeader;
 
                 ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageType);
                 ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageSize);
 
-                Assert.AreEqual(m_MessagingSystem.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
+                Assert.AreEqual(m_MessageManager.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
                 Assert.AreEqual(UnsafeUtility.SizeOf<TestMessage>(), messageHeader.MessageSize);
                 reader.ReadValueSafe(out TestMessage receivedMessage);
                 Assert.AreEqual(message, receivedMessage);
@@ -244,24 +248,24 @@ namespace Unity.Netcode.EditorTests
                 ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageType);
                 ByteUnpacker.ReadValueBitPacked(reader, out messageHeader.MessageSize);
 
-                Assert.AreEqual(m_MessagingSystem.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
+                Assert.AreEqual(m_MessageManager.GetMessageType(typeof(TestMessage)), messageHeader.MessageType);
                 Assert.AreEqual(UnsafeUtility.SizeOf<TestMessage>(), messageHeader.MessageSize);
                 reader.ReadValueSafe(out TestMessage receivedMessage2);
                 Assert.AreEqual(message2, receivedMessage2);
             }
         }
 
-        private class TestNoHandlerMessageProvider : IMessageProvider
+        private class TestNoHandlerMessageProvider : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(TestMessage),
                         Handler = null,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<TestMessage>
                     }
                 };
             }
@@ -270,25 +274,26 @@ namespace Unity.Netcode.EditorTests
         [Test]
         public void WhenReceivingAMessageWithoutAHandler_ExceptionIsLogged()
         {
-            // If a MessagingSystem already exists then dispose of it before creating a new MessagingSystem (otherwise memory leak)
-            if (m_MessagingSystem != null)
+            // If a NetworkMessageManager already exists then dispose of it before creating a new NetworkMessageManager (otherwise memory leak)
+            if (m_MessageManager != null)
             {
-                m_MessagingSystem.Dispose();
-                m_MessagingSystem = null;
+                m_MessageManager.Dispose();
+                m_MessageManager = null;
             }
 
-            // Since m_MessagingSystem is disposed during teardown we don't need to worry about that here.
-            m_MessagingSystem = new MessagingSystem(new NopMessageSender(), this, new TestNoHandlerMessageProvider());
-            m_MessagingSystem.ClientConnected(0);
+            // Since m_MessageManager is disposed during teardown we don't need to worry about that here.
+            m_MessageManager = new NetworkMessageManager(new NopMessageSender(), this, new TestNoHandlerMessageProvider());
+            m_MessageManager.ClientConnected(0);
 
-            var messageHeader = new MessageHeader
+            var messageHeader = new NetworkMessageHeader
             {
                 MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
-                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+                MessageType = m_MessageManager.GetMessageType(typeof(TestMessage)),
             };
+
             var message = GetMessage();
 
-            var writer = new FastBufferWriter(1300, Allocator.Temp);
+            var writer = new FastBufferWriter(m_MessageManager.NonFragmentedMessageMaxSize, Allocator.Temp);
             using (writer)
             {
                 writer.TryBeginWrite(FastBufferWriter.GetWriteSize(message));
@@ -297,7 +302,7 @@ namespace Unity.Netcode.EditorTests
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
-                    m_MessagingSystem.HandleMessage(messageHeader, reader, 0, 0, 0);
+                    m_MessageManager.HandleMessage(messageHeader, reader, 0, 0, 0);
                     LogAssert.Expect(LogType.Exception, new Regex(".*HandlerNotRegisteredException.*"));
                 }
             }

Tests/Editor/Messaging/MessageVersioningTests.cs

@@ -15,7 +15,7 @@ namespace Unity.Netcode.EditorTests
         private const int k_DefaultD = 15;
         private const long k_DefaultE = 20;
 
-        private struct VersionedTestMessage_v0 : INetworkMessage, INetworkSerializeByMemcpy
+        private struct VersionedTestMessageV0 : INetworkMessage, INetworkSerializeByMemcpy
         {
             public int A;
             public int B;
@@ -23,7 +23,7 @@ namespace Unity.Netcode.EditorTests
             public static bool Serialized;
             public static bool Deserialized;
             public static bool Handled;
-            public static List<VersionedTestMessage_v0> DeserializedValues = new List<VersionedTestMessage_v0>();
+            public static List<VersionedTestMessageV0> DeserializedValues = new List<VersionedTestMessageV0>();
 
             public void Serialize(FastBufferWriter writer, int targetVersion)
             {
@@ -53,7 +53,7 @@ namespace Unity.Netcode.EditorTests
             public int Version => 0;
         }
 
-        private struct VersionedTestMessage_v1 : INetworkMessage, INetworkSerializeByMemcpy
+        private struct VersionedTestMessageV1 : INetworkMessage, INetworkSerializeByMemcpy
         {
             public int A;
             public int B;
@@ -64,14 +64,14 @@ namespace Unity.Netcode.EditorTests
             public static bool Downgraded;
             public static bool Upgraded;
             public static bool Handled;
-            public static List<VersionedTestMessage_v1> DeserializedValues = new List<VersionedTestMessage_v1>();
+            public static List<VersionedTestMessageV1> DeserializedValues = new List<VersionedTestMessageV1>();
 
             public void Serialize(FastBufferWriter writer, int targetVersion)
             {
                 if (targetVersion < Version)
                 {
                     Downgraded = true;
-                    var v0 = new VersionedTestMessage_v0 { A = A, B = B, C = C };
+                    var v0 = new VersionedTestMessageV0 { A = A, B = B, C = C };
                     v0.Serialize(writer, targetVersion);
                     return;
                 }
@@ -87,7 +87,7 @@ namespace Unity.Netcode.EditorTests
             {
                 if (receivedMessageVersion < Version)
                 {
-                    var v0 = new VersionedTestMessage_v0();
+                    var v0 = new VersionedTestMessageV0();
                     v0.Deserialize(reader, ref context, receivedMessageVersion);
                     A = v0.A;
                     B = v0.B;
@@ -131,7 +131,7 @@ namespace Unity.Netcode.EditorTests
                 if (targetVersion < Version)
                 {
                     Downgraded = true;
-                    var v1 = new VersionedTestMessage_v1 { A = A, B = k_DefaultB, C = k_DefaultC, D = (int)D };
+                    var v1 = new VersionedTestMessageV1 { A = A, B = k_DefaultB, C = k_DefaultC, D = (int)D };
                     v1.Serialize(writer, targetVersion);
                     return;
                 }
@@ -146,7 +146,7 @@ namespace Unity.Netcode.EditorTests
             {
                 if (receivedMessageVersion < Version)
                 {
-                    var v1 = new VersionedTestMessage_v1();
+                    var v1 = new VersionedTestMessageV1();
                     v1.Deserialize(reader, ref context, receivedMessageVersion);
                     A = v1.A;
                     D = v1.D;
@@ -171,55 +171,55 @@ namespace Unity.Netcode.EditorTests
             public int Version => 2;
         }
 
-        private class TestMessageProvider_v0 : IMessageProvider
+        private class TestMessageProviderV0 : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
-                        MessageType = typeof(VersionedTestMessage_v0),
-                        Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v0>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v0>
+                        MessageType = typeof(VersionedTestMessageV0),
+                        Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessageV0>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessageV0>
                     }
                 };
             }
         }
 
-        private class TestMessageProvider_v1 : IMessageProvider
+        private class TestMessageProviderV1 : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
-                        MessageType = typeof(VersionedTestMessage_v1),
-                        Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage_v1>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage_v1>
+                        MessageType = typeof(VersionedTestMessageV1),
+                        Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessageV1>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessageV1>
                     }
                 };
             }
         }
 
-        private class TestMessageProvider_v2 : IMessageProvider
+        private class TestMessageProviderV2 : INetworkMessageProvider
         {
-            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            public List<NetworkMessageManager.MessageWithHandler> GetMessages()
             {
-                return new List<MessagingSystem.MessageWithHandler>
+                return new List<NetworkMessageManager.MessageWithHandler>
                 {
-                    new MessagingSystem.MessageWithHandler
+                    new NetworkMessageManager.MessageWithHandler
                     {
                         MessageType = typeof(VersionedTestMessage),
-                        Handler = MessagingSystem.ReceiveMessage<VersionedTestMessage>,
-                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<VersionedTestMessage>
+                        Handler = NetworkMessageManager.ReceiveMessage<VersionedTestMessage>,
+                        GetVersion = NetworkMessageManager.CreateMessageAndGetVersion<VersionedTestMessage>
                     }
                 };
             }
         }
 
-        private class TestMessageSender : IMessageSender
+        private class TestMessageSender : INetworkMessageSender
         {
             public List<byte[]> MessageQueue = new List<byte[]>();
 
@@ -229,14 +229,14 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
-        private MessagingSystem m_MessagingSystem_v0;
-        private MessagingSystem m_MessagingSystem_v1;
-        private MessagingSystem m_MessagingSystem_v2;
+        private NetworkMessageManager m_MessageManagerV0;
+        private NetworkMessageManager m_MessageManagerV1;
+        private NetworkMessageManager m_MessageManagerV2;
         private TestMessageSender m_MessageSender;
 
-        private void CreateFakeClients(MessagingSystem system, uint hash)
+        private void CreateFakeClients(NetworkMessageManager system, uint hash)
         {
-            // Create three fake clients for each messaging system
+            // Create three fake clients for each NetworkMessageManager
             // client 0 has version 0, client 1 has version 1, and client 2 has version 2
             system.ClientConnected(0);
             system.ClientConnected(1);
@@ -249,16 +249,16 @@ namespace Unity.Netcode.EditorTests
         [SetUp]
         public void SetUp()
         {
-            VersionedTestMessage_v0.Serialized = false;
-            VersionedTestMessage_v0.Deserialized = false;
-            VersionedTestMessage_v0.Handled = false;
-            VersionedTestMessage_v0.DeserializedValues.Clear();
-            VersionedTestMessage_v1.Serialized = false;
-            VersionedTestMessage_v1.Deserialized = false;
-            VersionedTestMessage_v1.Downgraded = false;
-            VersionedTestMessage_v1.Upgraded = false;
-            VersionedTestMessage_v1.Handled = false;
-            VersionedTestMessage_v1.DeserializedValues.Clear();
+            VersionedTestMessageV0.Serialized = false;
+            VersionedTestMessageV0.Deserialized = false;
+            VersionedTestMessageV0.Handled = false;
+            VersionedTestMessageV0.DeserializedValues.Clear();
+            VersionedTestMessageV1.Serialized = false;
+            VersionedTestMessageV1.Deserialized = false;
+            VersionedTestMessageV1.Downgraded = false;
+            VersionedTestMessageV1.Upgraded = false;
+            VersionedTestMessageV1.Handled = false;
+            VersionedTestMessageV1.DeserializedValues.Clear();
             VersionedTestMessage.Serialized = false;
             VersionedTestMessage.Deserialized = false;
             VersionedTestMessage.Downgraded = false;
@@ -267,35 +267,35 @@ namespace Unity.Netcode.EditorTests
             VersionedTestMessage.DeserializedValues.Clear();
             m_MessageSender = new TestMessageSender();
 
-            m_MessagingSystem_v0 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v0());
-            m_MessagingSystem_v1 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v1());
-            m_MessagingSystem_v2 = new MessagingSystem(m_MessageSender, this, new TestMessageProvider_v2());
+            m_MessageManagerV0 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV0());
+            m_MessageManagerV1 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV1());
+            m_MessageManagerV2 = new NetworkMessageManager(m_MessageSender, this, new TestMessageProviderV2());
 
-            CreateFakeClients(m_MessagingSystem_v0, XXHash.Hash32(typeof(VersionedTestMessage_v0).FullName));
-            CreateFakeClients(m_MessagingSystem_v1, XXHash.Hash32(typeof(VersionedTestMessage_v1).FullName));
-            CreateFakeClients(m_MessagingSystem_v2, XXHash.Hash32(typeof(VersionedTestMessage).FullName));
+            CreateFakeClients(m_MessageManagerV0, XXHash.Hash32(typeof(VersionedTestMessageV0).FullName));
+            CreateFakeClients(m_MessageManagerV1, XXHash.Hash32(typeof(VersionedTestMessageV1).FullName));
+            CreateFakeClients(m_MessageManagerV2, XXHash.Hash32(typeof(VersionedTestMessage).FullName));
 
             // Make sure that all three messages got the same IDs...
             Assert.AreEqual(
-                m_MessagingSystem_v0.GetMessageType(typeof(VersionedTestMessage_v0)),
-                m_MessagingSystem_v1.GetMessageType(typeof(VersionedTestMessage_v1)));
+                m_MessageManagerV0.GetMessageType(typeof(VersionedTestMessageV0)),
+                m_MessageManagerV1.GetMessageType(typeof(VersionedTestMessageV1)));
             Assert.AreEqual(
-                m_MessagingSystem_v0.GetMessageType(typeof(VersionedTestMessage_v0)),
-                m_MessagingSystem_v2.GetMessageType(typeof(VersionedTestMessage)));
+                m_MessageManagerV0.GetMessageType(typeof(VersionedTestMessageV0)),
+                m_MessageManagerV2.GetMessageType(typeof(VersionedTestMessage)));
         }
 
         [TearDown]
         public void TearDown()
         {
-            m_MessagingSystem_v0.Dispose();
-            m_MessagingSystem_v1.Dispose();
-            m_MessagingSystem_v2.Dispose();
+            m_MessageManagerV0.Dispose();
+            m_MessageManagerV1.Dispose();
+            m_MessageManagerV2.Dispose();
         }
 
-        private VersionedTestMessage_v0 GetMessage_v0()
+        private VersionedTestMessageV0 GetMessage_v0()
         {
             var random = new Random();
-            return new VersionedTestMessage_v0
+            return new VersionedTestMessageV0
             {
                 A = random.Next(),
                 B = random.Next(),
@@ -303,10 +303,10 @@ namespace Unity.Netcode.EditorTests
             };
         }
 
-        private VersionedTestMessage_v1 GetMessage_v1()
+        private VersionedTestMessageV1 GetMessage_v1()
         {
             var random = new Random();
-            return new VersionedTestMessage_v1
+            return new VersionedTestMessageV1
             {
                 A = random.Next(),
                 B = random.Next(),
@@ -328,10 +328,10 @@ namespace Unity.Netcode.EditorTests
 
         public void CheckPostSendExpectations(int sourceLocalVersion, int remoteVersion)
         {
-            Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 0, VersionedTestMessage_v0.Serialized);
-            Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 1, VersionedTestMessage_v1.Serialized);
+            Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 0, VersionedTestMessageV0.Serialized);
+            Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 1, VersionedTestMessageV1.Serialized);
             Assert.AreEqual(Math.Min(sourceLocalVersion, remoteVersion) == 2, VersionedTestMessage.Serialized);
-            Assert.AreEqual(sourceLocalVersion >= 1 && remoteVersion < 1, VersionedTestMessage_v1.Downgraded);
+            Assert.AreEqual(sourceLocalVersion >= 1 && remoteVersion < 1, VersionedTestMessageV1.Downgraded);
             Assert.AreEqual(sourceLocalVersion >= 2 && remoteVersion < 2, VersionedTestMessage.Downgraded);
 
             Assert.AreEqual(1, m_MessageSender.MessageQueue.Count);
@@ -340,14 +340,14 @@ namespace Unity.Netcode.EditorTests
 
         public void CheckPostReceiveExpectations(int sourceLocalVersion, int remoteVersion)
         {
-            Assert.AreEqual(SentVersion == 0, VersionedTestMessage_v0.Deserialized);
-            Assert.AreEqual(SentVersion == 1, VersionedTestMessage_v1.Deserialized);
+            Assert.AreEqual(SentVersion == 0, VersionedTestMessageV0.Deserialized);
+            Assert.AreEqual(SentVersion == 1, VersionedTestMessageV1.Deserialized);
             Assert.AreEqual(SentVersion == 2, VersionedTestMessage.Deserialized);
-            Assert.AreEqual(remoteVersion >= 1 && sourceLocalVersion < 1, VersionedTestMessage_v1.Upgraded);
+            Assert.AreEqual(remoteVersion >= 1 && sourceLocalVersion < 1, VersionedTestMessageV1.Upgraded);
             Assert.AreEqual(remoteVersion >= 2 && sourceLocalVersion < 2, VersionedTestMessage.Upgraded);
 
-            Assert.AreEqual((remoteVersion == 0 ? 1 : 0), VersionedTestMessage_v0.DeserializedValues.Count);
-            Assert.AreEqual((remoteVersion == 1 ? 1 : 0), VersionedTestMessage_v1.DeserializedValues.Count);
+            Assert.AreEqual((remoteVersion == 0 ? 1 : 0), VersionedTestMessageV0.DeserializedValues.Count);
+            Assert.AreEqual((remoteVersion == 1 ? 1 : 0), VersionedTestMessageV1.DeserializedValues.Count);
             Assert.AreEqual((remoteVersion == 2 ? 1 : 0), VersionedTestMessage.DeserializedValues.Count);
 
             Assert.AreEqual(SentVersion, ReceivedVersion);
@@ -355,23 +355,23 @@ namespace Unity.Netcode.EditorTests
 
         private void SendMessageWithVersions<T>(T message, int fromVersion, int toVersion) where T : unmanaged, INetworkMessage
         {
-            MessagingSystem sendSystem;
+            NetworkMessageManager sendSystem;
             switch (fromVersion)
             {
-                case 0: sendSystem = m_MessagingSystem_v0; break;
-                case 1: sendSystem = m_MessagingSystem_v1; break;
-                default: sendSystem = m_MessagingSystem_v2; break;
+                case 0: sendSystem = m_MessageManagerV0; break;
+                case 1: sendSystem = m_MessageManagerV1; break;
+                default: sendSystem = m_MessageManagerV2; break;
             }
             sendSystem.SendMessage(ref message, NetworkDelivery.Reliable, (ulong)toVersion);
             sendSystem.ProcessSendQueues();
             CheckPostSendExpectations(fromVersion, toVersion);
 
-            MessagingSystem receiveSystem;
+            NetworkMessageManager receiveSystem;
             switch (toVersion)
             {
-                case 0: receiveSystem = m_MessagingSystem_v0; break;
-                case 1: receiveSystem = m_MessagingSystem_v1; break;
-                default: receiveSystem = m_MessagingSystem_v2; break;
+                case 0: receiveSystem = m_MessageManagerV0; break;
+                case 1: receiveSystem = m_MessageManagerV1; break;
+                default: receiveSystem = m_MessageManagerV2; break;
             }
             receiveSystem.HandleIncomingData((ulong)fromVersion, new ArraySegment<byte>(m_MessageSender.MessageQueue[0]), 0.0f);
             receiveSystem.ProcessIncomingMessageQueue();
@@ -387,7 +387,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 0, 0);
 
-            var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(message.B, receivedMessage.B);
             Assert.AreEqual(message.C, receivedMessage.C);
@@ -400,7 +400,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 0, 1);
 
-            var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(message.B, receivedMessage.B);
             Assert.AreEqual(message.C, receivedMessage.C);
@@ -427,7 +427,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 1, 0);
 
-            var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(message.B, receivedMessage.B);
             Assert.AreEqual(message.C, receivedMessage.C);
@@ -440,7 +440,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 1, 1);
 
-            var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(message.B, receivedMessage.B);
             Assert.AreEqual(message.C, receivedMessage.C);
@@ -467,7 +467,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 2, 0);
 
-            var receivedMessage = VersionedTestMessage_v0.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV0.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(k_DefaultB, receivedMessage.B);
             Assert.AreEqual(k_DefaultC, receivedMessage.C);
@@ -480,7 +480,7 @@ namespace Unity.Netcode.EditorTests
 
             SendMessageWithVersions(message, 2, 1);
 
-            var receivedMessage = VersionedTestMessage_v1.DeserializedValues[0];
+            var receivedMessage = VersionedTestMessageV1.DeserializedValues[0];
             Assert.AreEqual(message.A, receivedMessage.A);
             Assert.AreEqual(k_DefaultB, receivedMessage.B);
             Assert.AreEqual(k_DefaultC, receivedMessage.C);

Tests/Editor/Messaging/NopMessageSender.cs

@@ -1,6 +1,6 @@
 namespace Unity.Netcode.EditorTests
 {
-    internal class NopMessageSender : IMessageSender
+    internal class NopMessageSender : INetworkMessageSender
     {
         public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
         {

Tests/Editor/NetworkManagerConfigurationTests.cs

@@ -107,7 +107,7 @@ namespace Unity.Netcode.EditorTests
             networkManager.OnValidate();
 
             // Expect a warning
-            LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.Prefabs.Prefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
+            LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkPrefabHandler.PrefabDebugHelper(networkManager.NetworkConfig.Prefabs.Prefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
 
             // Clean up
             Object.DestroyImmediate(networkManagerObject);
@@ -305,5 +305,164 @@ namespace Unity.Netcode.EditorTests
             Assert.IsTrue(sharedList.Contains(object2.gameObject));
             Assert.IsTrue(sharedList.Contains(object3.gameObject));
         }
+
+        [Test]
+        public void WhenCallingInitializeAfterAddingAPrefabUsingPrefabsAPI_ThePrefabStillExists()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
+            networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsFalse(sharedList.Contains(object2.gameObject));
+            Assert.IsFalse(sharedList.Contains(object3.gameObject));
+        }
+
+        [Test]
+        public void WhenShuttingDownAndReinitializingPrefabs_RuntimeAddedPrefabsStillExists()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
+            networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
+
+            networkManager.ShutdownInternal();
+            networkManager2.ShutdownInternal();
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsFalse(sharedList.Contains(object2.gameObject));
+            Assert.IsFalse(sharedList.Contains(object3.gameObject));
+        }
+
+        [Test]
+        public void WhenCallingInitializeMultipleTimes_NothingBreaks()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
+            networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.Initialize();
+            networkManager2.NetworkConfig.Prefabs.Initialize();
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsFalse(sharedList.Contains(object2.gameObject));
+            Assert.IsFalse(sharedList.Contains(object3.gameObject));
+        }
     }
 }

Tests/Editor/Serialization/BaseFastBufferReaderWriterTest.cs

@@ -1,5 +1,6 @@
 using System;
 using NUnit.Framework;
+using Unity.Collections;
 using UnityEngine;
 using Random = System.Random;
 
@@ -11,50 +12,50 @@ namespace Unity.Netcode.EditorTests
         {
             A,
             B,
-            C
-        };
+            C = byte.MaxValue
+        }
         protected enum SByteEnum : sbyte
         {
             A,
             B,
-            C
-        };
+            C = sbyte.MaxValue
+        }
         protected enum ShortEnum : short
         {
             A,
             B,
-            C
-        };
+            C = short.MaxValue
+        }
         protected enum UShortEnum : ushort
         {
             A,
             B,
-            C
-        };
+            C = ushort.MaxValue
+        }
         protected enum IntEnum : int
         {
             A,
             B,
-            C
-        };
+            C = int.MaxValue
+        }
         protected enum UIntEnum : uint
         {
             A,
             B,
-            C
-        };
+            C = uint.MaxValue
+        }
         protected enum LongEnum : long
         {
             A,
             B,
-            C
-        };
+            C = long.MaxValue
+        }
         protected enum ULongEnum : ulong
         {
             A,
             B,
-            C
-        };
+            C = ulong.MaxValue
+        }
 
         protected struct TestStruct : INetworkSerializeByMemcpy
         {
@@ -85,23 +86,32 @@ namespace Unity.Netcode.EditorTests
 
         protected abstract void RunTypeArrayTestSafe<T>(T[] valueToTest) where T : unmanaged;
 
+        protected abstract void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest) where T : unmanaged;
+
+        protected abstract void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest) where T : unmanaged;
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        protected abstract void RunTypeNativeListTest<T>(NativeList<T> valueToTest) where T : unmanaged;
+
+        protected abstract void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest) where T : unmanaged;
+#endif
+
+        private Random m_Random = new Random();
         protected TestStruct GetTestStruct()
         {
-            var random = new Random();
-
             var testStruct = new TestStruct
             {
-                A = (byte)random.Next(),
-                B = (short)random.Next(),
-                C = (ushort)random.Next(),
-                D = random.Next(),
-                E = (uint)random.Next(),
-                F = ((long)random.Next() << 32) + random.Next(),
-                G = ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                A = (byte)m_Random.Next(),
+                B = (short)m_Random.Next(),
+                C = (ushort)m_Random.Next(),
+                D = m_Random.Next(),
+                E = (uint)m_Random.Next(),
+                F = ((long)m_Random.Next() << 32) + m_Random.Next(),
+                G = ((ulong)m_Random.Next() << 32) + (ulong)m_Random.Next(),
                 H = true,
                 I = '\u263a',
-                J = (float)random.NextDouble(),
-                K = random.NextDouble(),
+                J = (float)m_Random.NextDouble(),
+                K = m_Random.NextDouble(),
             };
 
             return testStruct;
@@ -600,5 +610,695 @@ namespace Unity.Netcode.EditorTests
                 Assert.Fail("No type handler was provided for this type in the test!");
             }
         }
+
+        public void BaseNativeArrayTypeTest(Type testType, WriteType writeType)
+        {
+            var random = new Random();
+            void RunTypeTestLocal<T>(NativeArray<T> val, WriteType wt) where T : unmanaged
+            {
+                switch (wt)
+                {
+                    case WriteType.WriteDirect:
+                        RunTypeNativeArrayTest(val);
+                        break;
+                    case WriteType.WriteSafe:
+                        RunTypeNativeArrayTestSafe(val);
+                        break;
+                }
+            }
+
+            if (testType == typeof(byte))
+            {
+                RunTypeTestLocal(new NativeArray<byte>(new[]{
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(sbyte))
+            {
+                RunTypeTestLocal(new NativeArray<sbyte>(new[]{
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(short))
+            {
+                RunTypeTestLocal(new NativeArray<short>(new[]{
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ushort))
+            {
+                RunTypeTestLocal(new NativeArray<ushort>(new[]{
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(int))
+            {
+                RunTypeTestLocal(new NativeArray<int>(new[]{
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(uint))
+            {
+                RunTypeTestLocal(new NativeArray<uint>(new[]{
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(long))
+            {
+                RunTypeTestLocal(new NativeArray<long>(new[]{
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ulong))
+            {
+                RunTypeTestLocal(new NativeArray<ulong>(new[]{
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(bool))
+            {
+                RunTypeTestLocal(new NativeArray<bool>(new[]{
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(char))
+            {
+                RunTypeTestLocal(new NativeArray<char>(new[]{
+                    'a',
+                    '\u263a'
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(float))
+            {
+                RunTypeTestLocal(new NativeArray<float>(new[]{
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(double))
+            {
+                RunTypeTestLocal(new NativeArray<double>(new[]{
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ByteEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ByteEnum>(new[]{
+                    ByteEnum.C,
+                    ByteEnum.A,
+                    ByteEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(SByteEnum))
+            {
+                RunTypeTestLocal(new NativeArray<SByteEnum>(new[]{
+                    SByteEnum.C,
+                    SByteEnum.A,
+                    SByteEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ShortEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ShortEnum>(new[]{
+                    ShortEnum.C,
+                    ShortEnum.A,
+                    ShortEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(UShortEnum))
+            {
+                RunTypeTestLocal(new NativeArray<UShortEnum>(new[]{
+                    UShortEnum.C,
+                    UShortEnum.A,
+                    UShortEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(IntEnum))
+            {
+                RunTypeTestLocal(new NativeArray<IntEnum>(new[]{
+                    IntEnum.C,
+                    IntEnum.A,
+                    IntEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(UIntEnum))
+            {
+                RunTypeTestLocal(new NativeArray<UIntEnum>(new[]{
+                    UIntEnum.C,
+                    UIntEnum.A,
+                    UIntEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(LongEnum))
+            {
+                RunTypeTestLocal(new NativeArray<LongEnum>(new[]{
+                    LongEnum.C,
+                    LongEnum.A,
+                    LongEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ULongEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ULongEnum>(new[]{
+                    ULongEnum.C,
+                    ULongEnum.A,
+                    ULongEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector2))
+            {
+                RunTypeTestLocal(new NativeArray<Vector2>(new[]{
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector3))
+            {
+                RunTypeTestLocal(new NativeArray<Vector3>(new[]{
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector2Int))
+            {
+                RunTypeTestLocal(new NativeArray<Vector2Int>(new[]{
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector3Int))
+            {
+                RunTypeTestLocal(new NativeArray<Vector3Int>(new[]{
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector4))
+            {
+                RunTypeTestLocal(new NativeArray<Vector4>(new[]{
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Quaternion))
+            {
+                RunTypeTestLocal(new NativeArray<Quaternion>(new[]{
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Color))
+            {
+                RunTypeTestLocal(new NativeArray<Color>(new[]{
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Color32))
+            {
+                RunTypeTestLocal(new NativeArray<Color32>(new[]{
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Ray))
+            {
+                RunTypeTestLocal(new NativeArray<Ray>(new[]{
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Ray2D))
+            {
+                RunTypeTestLocal(new NativeArray<Ray2D>(new[]{
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(TestStruct))
+            {
+                RunTypeTestLocal(new NativeArray<TestStruct>(new[] {
+                    GetTestStruct(),
+                    GetTestStruct(),
+                    GetTestStruct(),
+                }, Allocator.Temp), writeType);
+            }
+            else
+            {
+                Assert.Fail("No type handler was provided for this type in the test!");
+            }
+        }
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        public void BaseNativeListTypeTest(Type testType, WriteType writeType)
+        {
+            var random = new Random();
+            void RunTypeTestLocal<T>(NativeArray<T> val, WriteType wt) where T : unmanaged
+            {
+                var lst = new NativeList<T>(val.Length, Allocator.Temp);
+                foreach (var item in val)
+                {
+                    lst.Add(item);
+                }
+                switch (wt)
+                {
+                    case WriteType.WriteDirect:
+                        RunTypeNativeListTest(lst);
+                        break;
+                    case WriteType.WriteSafe:
+                        RunTypeNativeListTestSafe(lst);
+                        break;
+                }
+            }
+
+            if (testType == typeof(byte))
+            {
+                RunTypeTestLocal(new NativeArray<byte>(new[]{
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next(),
+                    (byte) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(sbyte))
+            {
+                RunTypeTestLocal(new NativeArray<sbyte>(new[]{
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next(),
+                    (sbyte) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(short))
+            {
+                RunTypeTestLocal(new NativeArray<short>(new[]{
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next(),
+                    (short) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ushort))
+            {
+                RunTypeTestLocal(new NativeArray<ushort>(new[]{
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next(),
+                    (ushort) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(int))
+            {
+                RunTypeTestLocal(new NativeArray<int>(new[]{
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next(),
+                    random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(uint))
+            {
+                RunTypeTestLocal(new NativeArray<uint>(new[]{
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next(),
+                    (uint) random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(long))
+            {
+                RunTypeTestLocal(new NativeArray<long>(new[]{
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
+                    ((long)random.Next() << 32) + random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ulong))
+            {
+                RunTypeTestLocal(new NativeArray<ulong>(new[]{
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next(),
+                    ((ulong)random.Next() << 32) + (ulong)random.Next()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(bool))
+            {
+                RunTypeTestLocal(new NativeArray<bool>(new[]{
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(char))
+            {
+                RunTypeTestLocal(new NativeArray<char>(new[]{
+                    'a',
+                    '\u263a'
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(float))
+            {
+                RunTypeTestLocal(new NativeArray<float>(new[]{
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble(),
+                    (float)random.NextDouble()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(double))
+            {
+                RunTypeTestLocal(new NativeArray<double>(new[]{
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble(),
+                    random.NextDouble()
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ByteEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ByteEnum>(new[]{
+                    ByteEnum.C,
+                    ByteEnum.A,
+                    ByteEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(SByteEnum))
+            {
+                RunTypeTestLocal(new NativeArray<SByteEnum>(new[]{
+                    SByteEnum.C,
+                    SByteEnum.A,
+                    SByteEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ShortEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ShortEnum>(new[]{
+                    ShortEnum.C,
+                    ShortEnum.A,
+                    ShortEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(UShortEnum))
+            {
+                RunTypeTestLocal(new NativeArray<UShortEnum>(new[]{
+                    UShortEnum.C,
+                    UShortEnum.A,
+                    UShortEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(IntEnum))
+            {
+                RunTypeTestLocal(new NativeArray<IntEnum>(new[]{
+                    IntEnum.C,
+                    IntEnum.A,
+                    IntEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(UIntEnum))
+            {
+                RunTypeTestLocal(new NativeArray<UIntEnum>(new[]{
+                    UIntEnum.C,
+                    UIntEnum.A,
+                    UIntEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(LongEnum))
+            {
+                RunTypeTestLocal(new NativeArray<LongEnum>(new[]{
+                    LongEnum.C,
+                    LongEnum.A,
+                    LongEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(ULongEnum))
+            {
+                RunTypeTestLocal(new NativeArray<ULongEnum>(new[]{
+                    ULongEnum.C,
+                    ULongEnum.A,
+                    ULongEnum.B
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector2))
+            {
+                RunTypeTestLocal(new NativeArray<Vector2>(new[]{
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector3))
+            {
+                RunTypeTestLocal(new NativeArray<Vector3>(new[]{
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Vector3((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector2Int))
+            {
+                RunTypeTestLocal(new NativeArray<Vector2Int>(new[]{
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector2Int((int) random.NextDouble(), (int) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector3Int))
+            {
+                RunTypeTestLocal(new NativeArray<Vector3Int>(new[]{
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                    new Vector3Int((int) random.NextDouble(), (int) random.NextDouble(), (int) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Vector4))
+            {
+                RunTypeTestLocal(new NativeArray<Vector4>(new[]{
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Vector4((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Quaternion))
+            {
+                RunTypeTestLocal(new NativeArray<Quaternion>(new[]{
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                    new Quaternion((float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble(), (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Color))
+            {
+                RunTypeTestLocal(new NativeArray<Color>(new[]{
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                    new Color((float) random.NextDouble(), (float) random.NextDouble(), (float) random.NextDouble(),
+                        (float) random.NextDouble()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Color32))
+            {
+                RunTypeTestLocal(new NativeArray<Color32>(new[]{
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                    new Color32((byte) random.Next(), (byte) random.Next(), (byte) random.Next(), (byte) random.Next()),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Ray))
+            {
+                RunTypeTestLocal(new NativeArray<Ray>(new[]{
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                    new Ray(
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble()),
+                        new Vector3((float) random.NextDouble(), (float) random.NextDouble(),
+                            (float) random.NextDouble())),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(Ray2D))
+            {
+                RunTypeTestLocal(new NativeArray<Ray2D>(new[]{
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                    new Ray2D(
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble()),
+                        new Vector2((float) random.NextDouble(), (float) random.NextDouble())),
+                }, Allocator.Temp), writeType);
+            }
+            else if (testType == typeof(TestStruct))
+            {
+                RunTypeTestLocal(new NativeArray<TestStruct>(new[] {
+                    GetTestStruct(),
+                    GetTestStruct(),
+                    GetTestStruct(),
+                }, Allocator.Temp), writeType);
+            }
+            else
+            {
+                Assert.Fail("No type handler was provided for this type in the test!");
+            }
+        }
+#endif
     }
 }

Tests/Editor/Serialization/FastBufferReaderTests.cs

@@ -69,6 +69,10 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -110,6 +114,10 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -134,6 +142,90 @@ namespace Unity.Netcode.EditorTests
             method.Invoke(writer, args);
         }
 
+        private void RunWriteMethod<T>(string methodName, FastBufferWriter writer, in NativeArray<T> value) where T : unmanaged
+        {
+            MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeArray<T>) });
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            for (var i = 1; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(writer, args);
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private void RunWriteMethod<T>(string methodName, FastBufferWriter writer, in NativeList<T> value) where T : unmanaged
+        {
+            MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeList<T>) });
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            for (var i = 1; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(writer, args);
+        }
+#endif
+
         private void RunReadMethod<T>(string methodName, FastBufferReader reader, out T value) where T : unmanaged
         {
             MethodInfo method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(T).MakeByRefType() });
@@ -151,6 +243,10 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -203,6 +299,10 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -230,6 +330,112 @@ namespace Unity.Netcode.EditorTests
             value = (T[])args[0];
         }
 
+        private void RunReadMethod<T>(string methodName, FastBufferReader reader, out NativeArray<T> value) where T : unmanaged
+        {
+            MethodInfo method = null;
+
+            try
+            {
+                method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(NativeArray<T>).MakeByRefType(), typeof(Allocator) });
+            }
+            catch (AmbiguousMatchException)
+            {
+                // skip.
+            }
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferReader).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length < 2 || (candidateMethod.GetParameters().Length > 2 && !candidateMethod.GetParameters()[2].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            value = new NativeArray<T>();
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            args[1] = Allocator.Temp;
+            for (var i = 2; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(reader, args);
+            value = (NativeArray<T>)args[0];
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private void RunReadMethod<T>(string methodName, FastBufferReader reader, ref NativeList<T> value) where T : unmanaged
+        {
+            MethodInfo method = null;
+
+            try
+            {
+                method = typeof(FastBufferReader).GetMethod(methodName, new[] { typeof(NativeList<T>).MakeByRefType() });
+            }
+            catch (AmbiguousMatchException)
+            {
+                // skip.
+            }
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferReader).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            for (var i = 1; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(reader, args);
+        }
+#endif
+
         protected override unsafe void RunTypeTest<T>(T valueToTest)
         {
             var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -288,6 +494,28 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
+        private void VerifyArrayEquality<T>(NativeArray<T> value, NativeArray<T> compareValue, int offset) where T : unmanaged
+        {
+            Assert.AreEqual(value.Length, compareValue.Length);
+
+            for (var i = 0; i < value.Length; ++i)
+            {
+                Assert.AreEqual(value[i], compareValue[i]);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private void VerifyArrayEquality<T>(NativeList<T> value, NativeList<T> compareValue, int offset) where T : unmanaged
+        {
+            Assert.AreEqual(value.Length, compareValue.Length);
+
+            for (var i = 0; i < value.Length; ++i)
+            {
+                Assert.AreEqual(value[i], compareValue[i]);
+            }
+        }
+#endif
+
         protected override unsafe void RunTypeArrayTest<T>(T[] valueToTest)
         {
             var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -340,6 +568,114 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
+        protected override unsafe void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+                Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
+
+                RunWriteMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
+
+                WriteCheckBytes(writer, writeSize);
+
+                var reader = new FastBufferReader(writer, Allocator.Temp);
+                using (reader)
+                {
+                    VerifyPositionAndLength(reader, writer.Length);
+
+                    Assert.IsTrue(reader.TryBeginRead(writeSize));
+                    RunReadMethod(nameof(FastBufferReader.ReadValue), reader, out NativeArray<T> result);
+                    VerifyArrayEquality(valueToTest, result, 0);
+
+                    VerifyCheckBytes(reader, writeSize);
+                }
+            }
+        }
+
+        protected override unsafe void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+
+                RunWriteMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
+
+                WriteCheckBytes(writer, writeSize);
+
+                var reader = new FastBufferReader(writer, Allocator.Temp);
+                using (reader)
+                {
+                    VerifyPositionAndLength(reader, writer.Length);
+
+                    RunReadMethod(nameof(FastBufferReader.ReadValueSafe), reader, out NativeArray<T> result);
+                    VerifyArrayEquality(valueToTest, result, 0);
+
+                    VerifyCheckBytes(reader, writeSize);
+                }
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        protected override unsafe void RunTypeNativeListTest<T>(NativeList<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+                Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
+
+                RunWriteMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
+
+                WriteCheckBytes(writer, writeSize);
+
+                var reader = new FastBufferReader(writer, Allocator.Temp);
+                using (reader)
+                {
+                    VerifyPositionAndLength(reader, writer.Length);
+
+                    Assert.IsTrue(reader.TryBeginRead(writeSize));
+                    var result = new NativeList<T>(Allocator.Temp);
+                    RunReadMethod(nameof(FastBufferReader.ReadValueInPlace), reader, ref result);
+                    VerifyArrayEquality(valueToTest, result, 0);
+
+                    VerifyCheckBytes(reader, writeSize);
+                }
+            }
+        }
+
+        protected override unsafe void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+
+                RunWriteMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
+
+                WriteCheckBytes(writer, writeSize);
+
+                var reader = new FastBufferReader(writer, Allocator.Temp);
+                using (reader)
+                {
+                    VerifyPositionAndLength(reader, writer.Length);
+
+                    var result = new NativeList<T>(Allocator.Temp);
+                    RunReadMethod(nameof(FastBufferReader.ReadValueSafeInPlace), reader, ref result);
+                    VerifyArrayEquality(valueToTest, result, 0);
+
+                    VerifyCheckBytes(reader, writeSize);
+                }
+            }
+        }
+#endif
+
         [Test]
         public void GivenFastBufferWriterContainingValue_WhenReadingUnmanagedType_ValueMatchesWhatWasWritten(
             [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
@@ -368,6 +704,35 @@ namespace Unity.Netcode.EditorTests
             BaseArrayTypeTest(testType, writeType);
         }
 
+        [Test]
+        public void GivenFastBufferWriterContainingValue_WhenReadingNativeArrayOfUnmanagedElementType_ValueMatchesWhatWasWritten(
+            [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
+                typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
+                typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
+            Type testType,
+            [Values] WriteType writeType)
+        {
+            BaseNativeArrayTypeTest(testType, writeType);
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [Test]
+        public void GivenFastBufferWriterContainingValue_WhenReadingNativeListOfUnmanagedElementType_ValueMatchesWhatWasWritten(
+            [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
+                typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
+                typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
+            Type testType,
+            [Values] WriteType writeType)
+        {
+            BaseNativeListTypeTest(testType, writeType);
+        }
+#endif
 
         public unsafe void RunFixedStringTest<T>(T fixedStringValue, int numBytesWritten, WriteType writeType) where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {

Tests/Editor/Serialization/FastBufferWriterTests.cs

@@ -2,6 +2,7 @@ using System;
 using System.Reflection;
 using NUnit.Framework;
 using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
 using UnityEngine;
 using Random = System.Random;
 
@@ -80,6 +81,11 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -121,6 +127,10 @@ namespace Unity.Netcode.EditorTests
                         {
                             continue;
                         }
+                        if (candidateMethod.GetParameters()[0].ParameterType.IsGenericType)
+                        {
+                            continue;
+                        }
                         try
                         {
                             method = candidateMethod.MakeGenericMethod(typeof(T));
@@ -145,6 +155,90 @@ namespace Unity.Netcode.EditorTests
             method.Invoke(writer, args);
         }
 
+        private void RunMethod<T>(string methodName, FastBufferWriter writer, in NativeArray<T> value) where T : unmanaged
+        {
+            MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeArray<T>) });
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeArray"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            for (var i = 1; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(writer, args);
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private void RunMethod<T>(string methodName, FastBufferWriter writer, in NativeList<T> value) where T : unmanaged
+        {
+            MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(NativeList<T>) });
+            if (method == null)
+            {
+                foreach (var candidateMethod in typeof(FastBufferWriter).GetMethods())
+                {
+                    if (candidateMethod.Name == methodName && candidateMethod.IsGenericMethodDefinition)
+                    {
+                        if (candidateMethod.GetParameters().Length == 0 || (candidateMethod.GetParameters().Length > 1 && !candidateMethod.GetParameters()[1].HasDefaultValue))
+                        {
+                            continue;
+                        }
+                        if (!candidateMethod.GetParameters()[0].ParameterType.Name.Contains("NativeList"))
+                        {
+                            continue;
+                        }
+                        try
+                        {
+                            method = candidateMethod.MakeGenericMethod(typeof(T));
+                            break;
+                        }
+                        catch (ArgumentException)
+                        {
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            Assert.NotNull(method);
+
+            object[] args = new object[method.GetParameters().Length];
+            args[0] = value;
+            for (var i = 1; i < args.Length; ++i)
+            {
+                args[i] = method.GetParameters()[i].DefaultValue;
+            }
+            method.Invoke(writer, args);
+        }
+#endif
+
 
         protected override unsafe void RunTypeTest<T>(T valueToTest)
         {
@@ -199,6 +293,34 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
+        private unsafe void VerifyArrayEquality<T>(NativeArray<T> value, byte* unsafePtr, int offset) where T : unmanaged
+        {
+            int* sizeValue = (int*)(unsafePtr + offset);
+            Assert.AreEqual(value.Length, *sizeValue);
+
+            var asTPointer = (T*)value.GetUnsafePtr();
+            var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
+            for (var i = 0; i < value.Length; ++i)
+            {
+                Assert.AreEqual(asTPointer[i], underlyingTArray[i]);
+            }
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        private unsafe void VerifyArrayEquality<T>(NativeList<T> value, byte* unsafePtr, int offset) where T : unmanaged
+        {
+            int* sizeValue = (int*)(unsafePtr + offset);
+            Assert.AreEqual(value.Length, *sizeValue);
+
+            var asTPointer = (T*)value.GetUnsafePtr();
+            var underlyingTArray = (T*)(unsafePtr + sizeof(int) + offset);
+            for (var i = 0; i < value.Length; ++i)
+            {
+                Assert.AreEqual(asTPointer[i], underlyingTArray[i]);
+            }
+        }
+#endif
+
         protected override unsafe void RunTypeArrayTest<T>(T[] valueToTest)
         {
             var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -242,6 +364,96 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
+
+        protected override unsafe void RunTypeNativeArrayTest<T>(NativeArray<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+                Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
+
+                RunMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
+                VerifyPositionAndLength(writer, writeSize);
+
+                WriteCheckBytes(writer, writeSize);
+
+                VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
+
+                var underlyingArray = writer.ToArray();
+                VerifyCheckBytes(underlyingArray, writeSize);
+            }
+        }
+
+        protected override unsafe void RunTypeNativeArrayTestSafe<T>(NativeArray<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+
+                RunMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
+                VerifyPositionAndLength(writer, writeSize);
+
+                WriteCheckBytes(writer, writeSize);
+
+                VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
+
+                var underlyingArray = writer.ToArray();
+                VerifyCheckBytes(underlyingArray, writeSize);
+            }
+        }
+
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        protected override unsafe void RunTypeNativeListTest<T>(NativeList<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+                Assert.IsTrue(writer.TryBeginWrite(writeSize + 2), "Writer denied write permission");
+
+                RunMethod(nameof(FastBufferWriter.WriteValue), writer, valueToTest);
+                VerifyPositionAndLength(writer, writeSize);
+
+                WriteCheckBytes(writer, writeSize);
+
+                VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
+
+                var underlyingArray = writer.ToArray();
+                VerifyCheckBytes(underlyingArray, writeSize);
+            }
+        }
+
+        protected override unsafe void RunTypeNativeListTestSafe<T>(NativeList<T> valueToTest)
+        {
+            var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
+            var writer = new FastBufferWriter(writeSize + 2, Allocator.Temp);
+            using (writer)
+            {
+
+                Assert.AreEqual(sizeof(int) + sizeof(T) * valueToTest.Length, writeSize);
+
+                RunMethod(nameof(FastBufferWriter.WriteValueSafe), writer, valueToTest);
+                VerifyPositionAndLength(writer, writeSize);
+
+                WriteCheckBytes(writer, writeSize);
+
+                VerifyArrayEquality(valueToTest, writer.GetUnsafePtr(), 0);
+
+                var underlyingArray = writer.ToArray();
+                VerifyCheckBytes(underlyingArray, writeSize);
+            }
+        }
+#endif
+
         [Test, Description("Tests")]
         public void WhenWritingUnmanagedType_ValueIsWrittenCorrectly(
             [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
@@ -270,6 +482,36 @@ namespace Unity.Netcode.EditorTests
             BaseArrayTypeTest(testType, writeType);
         }
 
+        [Test]
+        public void WhenWritingNativeArrayOfUnmanagedElementType_NativeArrayIsWrittenCorrectly(
+            [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
+                typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
+                typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
+            Type testType,
+            [Values] WriteType writeType)
+        {
+            BaseNativeArrayTypeTest(testType, writeType);
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        [Test]
+        public void WhenWritingNativeListOfUnmanagedElementType_NativeListIsWrittenCorrectly(
+            [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
+                typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
+                typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
+                typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3),
+                typeof(Vector2Int), typeof(Vector3Int), typeof(Vector4), typeof(Quaternion), typeof(Color),
+                typeof(Color32), typeof(Ray), typeof(Ray2D), typeof(TestStruct))]
+            Type testType,
+            [Values] WriteType writeType)
+        {
+            BaseNativeListTypeTest(testType, writeType);
+        }
+#endif
+
         [TestCase(false, WriteType.WriteDirect)]
         [TestCase(false, WriteType.WriteSafe)]
         [TestCase(true, WriteType.WriteDirect)]

Tests/Editor/Transports/UnityTransportTests.cs

@@ -116,14 +116,14 @@ namespace Unity.Netcode.EditorTests
             transport.Initialize();
 
             transport.SetConnectionData("127.0.0.", 4242, "127.0.0.");
+
             Assert.False(transport.StartServer());
 
             LogAssert.Expect(LogType.Error, "Invalid network endpoint: 127.0.0.:4242.");
+            LogAssert.Expect(LogType.Error, "Network listen address (127.0.0.) is Invalid!");
 #if UTP_TRANSPORT_2_0_ABOVE
             LogAssert.Expect(LogType.Error, "Socket creation failed (error Unity.Baselib.LowLevel.Binding+Baselib_ErrorState: Invalid argument (0x01000003) <argument name stripped>");
 #endif
-            LogAssert.Expect(LogType.Error, "Server failed to bind. This is usually caused by another process being bound to the same port.");
-
             transport.SetConnectionData("127.0.0.1", 4242, "127.0.0.1");
             Assert.True(transport.StartServer());
 
@@ -143,6 +143,22 @@ namespace Unity.Netcode.EditorTests
             transport.Shutdown();
         }
 
+        // Check that StartClient returns false with bad connection data.
+        [Test]
+        public void UnityTransport_StartClientFailsWithBadAddress()
+        {
+            UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
+            transport.Initialize();
+
+            transport.SetConnectionData("foobar", 4242);
+            Assert.False(transport.StartClient());
+
+            LogAssert.Expect(LogType.Error, "Invalid network endpoint: foobar:4242.");
+            LogAssert.Expect(LogType.Error, "Target server network address (foobar) is Invalid!");
+
+            transport.Shutdown();
+        }
+
 #if UTP_TRANSPORT_2_0_ABOVE
         [Test]
         public void UnityTransport_EmptySecurityStringsShouldThrow([Values("", null)] string cert, [Values("", null)] string secret)

Tests/Runtime/ClientApprovalDenied.cs

@@ -0,0 +1,72 @@
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine.TestTools;
+
+
+namespace Unity.Netcode.RuntimeTests
+{
+    public class ClientApprovalDenied : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 2;
+        private bool m_ApproveConnection = true;
+        private ulong m_PendingClientId = 0;
+        private ulong m_DisconnectedClientId = 0;
+
+        private List<ulong> m_DisconnectedClientIdentifiers = new List<ulong>();
+
+        private void ConnectionApproval(NetworkManager.ConnectionApprovalRequest connectionApprovalRequest, NetworkManager.ConnectionApprovalResponse connectionApprovalResponse)
+        {
+            connectionApprovalResponse.Approved = m_ApproveConnection;
+            connectionApprovalResponse.CreatePlayerObject = true;
+            // When denied, store the client identifier to use for validating the client disconnected notification identifier matches
+            if (!m_ApproveConnection)
+            {
+                m_PendingClientId = connectionApprovalRequest.ClientNetworkId;
+            }
+        }
+
+        protected override void OnNewClientCreated(NetworkManager networkManager)
+        {
+            networkManager.NetworkConfig.ConnectionApproval = true;
+            base.OnNewClientCreated(networkManager);
+        }
+
+        protected override bool ShouldWaitForNewClientToConnect(NetworkManager networkManager)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Validates that when a pending client is denied approval the server-host
+        /// OnClientDisconnected method will return the valid pending client identifier.
+        /// </summary>
+        [UnityTest]
+        public IEnumerator ClientDeniedAndDisconnectionNotificationTest()
+        {
+            m_ServerNetworkManager.NetworkConfig.ConnectionApproval = true;
+            m_ServerNetworkManager.ConnectionApprovalCallback = ConnectionApproval;
+            m_ApproveConnection = false;
+            m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;
+            yield return CreateAndStartNewClient();
+            yield return WaitForConditionOrTimeOut(() => m_PendingClientId == m_DisconnectedClientId);
+            AssertOnTimeout($"Timed out waiting for disconnect notification for pending Client-{m_PendingClientId}!");
+
+            // Validate that we don't get multiple disconnect notifications for clients being disconnected
+            // Have a client disconnect remotely
+            m_ClientNetworkManagers[0].Shutdown();
+
+            // Have the server disconnect a client
+            m_ServerNetworkManager.DisconnectClient(m_ClientNetworkManagers[1].LocalClientId);
+            m_ServerNetworkManager.OnClientDisconnectCallback -= OnClientDisconnectCallback;
+        }
+
+        private void OnClientDisconnectCallback(ulong clientId)
+        {
+            Assert.False(m_DisconnectedClientIdentifiers.Contains(clientId), $"Received two disconnect notifications from Client-{clientId}!");
+            m_DisconnectedClientIdentifiers.Add(clientId);
+            m_DisconnectedClientId = clientId;
+        }
+    }
+}

Tests/Runtime/ClientApprovalDenied.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e46e2cb14a6d49c48bc8c33094467961
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/Runtime/Components/NetworkVariableTestComponent.cs

@@ -6,10 +6,19 @@ using UnityEngine;
 
 namespace Unity.Netcode.RuntimeTests
 {
+    public class EmbeddedManagedNetworkSerializableType : INetworkSerializable
+    {
+        public int Int;
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            serializer.SerializeValue(ref Int);
+        }
+    }
     public class ManagedNetworkSerializableType : INetworkSerializable, IEquatable<ManagedNetworkSerializableType>
     {
         public string Str = "";
         public int[] Ints = Array.Empty<int>();
+        public EmbeddedManagedNetworkSerializableType Embedded = new EmbeddedManagedNetworkSerializableType();
         public int InMemoryValue;
 
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
@@ -28,6 +37,8 @@ namespace Unity.Netcode.RuntimeTests
                 serializer.SerializeValue(ref val);
                 Ints[i] = val;
             }
+
+            serializer.SerializeValue(ref Embedded);
         }
 
         public bool Equals(ManagedNetworkSerializableType other)
@@ -60,6 +71,11 @@ namespace Unity.Netcode.RuntimeTests
                 }
             }
 
+            if (Embedded.Int != other.Embedded.Int)
+            {
+                return false;
+            }
+
             return true;
         }
 
@@ -280,7 +296,8 @@ namespace Unity.Netcode.RuntimeTests
             m_NetworkVariableManaged = new NetworkVariable<ManagedNetworkSerializableType>(new ManagedNetworkSerializableType
             {
                 Str = "1234567890",
-                Ints = new[] { 1, 2, 3, 4, 5 }
+                Ints = new[] { 1, 2, 3, 4, 5 },
+                Embedded = new EmbeddedManagedNetworkSerializableType { Int = 6 }
             });
 
             // Use this nifty class: NetworkVariableHelper
@@ -386,7 +403,8 @@ namespace Unity.Netcode.RuntimeTests
             Assert.IsTrue(m_NetworkVariableManaged.Value.Equals(new ManagedNetworkSerializableType
             {
                 Str = "ManagedNetworkSerializableType",
-                Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 }
+                Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
+                Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
             }));
         }
 
@@ -433,7 +451,8 @@ namespace Unity.Netcode.RuntimeTests
                         m_NetworkVariableManaged.Value = new ManagedNetworkSerializableType
                         {
                             Str = "ManagedNetworkSerializableType",
-                            Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 }
+                            Ints = new[] { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 },
+                            Embedded = new EmbeddedManagedNetworkSerializableType { Int = 20000 }
                         };
 
                         //Set the timeout (i.e. how long we will wait for all NetworkVariables to have registered their changes)

Tests/Runtime/ConnectionApprovalTimeoutTests.cs

@@ -60,7 +60,7 @@ namespace Unity.Netcode.RuntimeTests
             if (m_ApprovalFailureType == ApprovalTimedOutTypes.ServerDoesNotRespond)
             {
                 // We catch (don't process) the incoming approval message to simulate the server not sending the approved message in time
-                m_ClientNetworkManagers[0].MessagingSystem.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
+                m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionApprovedMessage>(m_ClientNetworkManagers[0]));
                 m_ExpectedLogMessage = new Regex("Timed out waiting for the server to approve the connection request.");
                 m_LogType = LogType.Log;
             }
@@ -68,7 +68,7 @@ namespace Unity.Netcode.RuntimeTests
             {
                 // We catch (don't process) the incoming connection request message to simulate a transport connection but the client never
                 // sends (or takes too long to send) the connection request.
-                m_ServerNetworkManager.MessagingSystem.Hook(new MessageCatcher<ConnectionRequestMessage>(m_ServerNetworkManager));
+                m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new MessageCatcher<ConnectionRequestMessage>(m_ServerNetworkManager));
 
                 // For this test, we know the timed out client will be Client-1
                 m_ExpectedLogMessage = new Regex("Server detected a transport connection from Client-1, but timed out waiting for the connection request message.");
@@ -86,16 +86,18 @@ namespace Unity.Netcode.RuntimeTests
             // Verify we haven't received the time out message yet
             NetcodeLogAssert.LogWasNotReceived(LogType.Log, m_ExpectedLogMessage);
 
-            // Wait for 3/4s of the time out period to pass (totaling 1.25x the wait period)
-            yield return new WaitForSeconds(k_TestTimeoutPeriod * 0.75f);
+            yield return new WaitForSeconds(k_TestTimeoutPeriod * 1.5f);
 
             // We should have the test relative log message by this time.
             NetcodeLogAssert.LogWasReceived(m_LogType, m_ExpectedLogMessage);
 
+            Debug.Log("Checking connected client count");
             // It should only have the host client connected
             Assert.AreEqual(1, m_ServerNetworkManager.ConnectedClients.Count, $"Expected only one client when there were {m_ServerNetworkManager.ConnectedClients.Count} clients connected!");
-            Assert.AreEqual(0, m_ServerNetworkManager.PendingClients.Count, $"Expected no pending clients when there were {m_ServerNetworkManager.PendingClients.Count} pending clients!");
-            Assert.True(!m_ClientNetworkManagers[0].IsApproved, $"Expected the client to not have been approved, but it was!");
+
+
+            Assert.AreEqual(0, m_ServerNetworkManager.ConnectionManager.PendingClients.Count, $"Expected no pending clients when there were {m_ServerNetworkManager.ConnectionManager.PendingClients.Count} pending clients!");
+            Assert.True(!m_ClientNetworkManagers[0].LocalClient.IsApproved, $"Expected the client to not have been approved, but it was!");
         }
     }
 }

Tests/Runtime/DeferredMessagingTests.cs

@@ -50,7 +50,7 @@ namespace Unity.Netcode.RuntimeTests
             return ret;
         }
 
-        public int DeferredMessageCountForType(IDeferredMessageManager.TriggerType trigger)
+        public int DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType trigger)
         {
             var count = 0;
             if (m_Triggers.TryGetValue(trigger, out var dict))
@@ -68,7 +68,7 @@ namespace Unity.Netcode.RuntimeTests
             return count;
         }
 
-        public int DeferredMessageCountForKey(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public int DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             if (m_PurgedKeys.Contains(key))
             {
@@ -85,20 +85,20 @@ namespace Unity.Netcode.RuntimeTests
             return 0;
         }
 
-        public override void DeferMessage(IDeferredMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        public override void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
         {
             OnBeforeDefer?.Invoke(this, key);
             DeferMessageCalled = true;
             base.DeferMessage(trigger, key, reader, ref context);
         }
 
-        public override void ProcessTriggers(IDeferredMessageManager.TriggerType trigger, ulong key)
+        public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
         {
             ProcessTriggersCalled = true;
             base.ProcessTriggers(trigger, key);
         }
 
-        protected override void PurgeTrigger(IDeferredMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        protected override void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
         {
             OnBeforePurge?.Invoke(this, key);
             base.PurgeTrigger(triggerType, key, triggerInfo);
@@ -207,13 +207,13 @@ namespace Unity.Netcode.RuntimeTests
             m_UseHost = false;
 
             // Replace the IDeferredMessageManager component with our test one in the component factory
-            ComponentFactory.Register<IDeferredMessageManager>(networkManager => new TestDeferredMessageManager(networkManager));
+            ComponentFactory.Register<IDeferredNetworkMessageManager>(networkManager => new TestDeferredMessageManager(networkManager));
         }
 
         protected override void OnInlineTearDown()
         {
             // Revert the IDeferredMessageManager component to its default (DeferredMessageManager)
-            ComponentFactory.Deregister<IDeferredMessageManager>();
+            ComponentFactory.Deregister<IDeferredNetworkMessageManager>();
             m_ClientSpawnCatchers.Clear();
         }
 
@@ -294,7 +294,7 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var catcher = new MessageCatcher<CreateObjectMessage>(client);
                 m_ClientSpawnCatchers.Add(catcher);
-                client.MessagingSystem.Hook(catcher);
+                client.ConnectionManager.MessageManager.Hook(catcher);
             }
         }
 
@@ -303,7 +303,7 @@ namespace Unity.Netcode.RuntimeTests
             for (var i = 0; i < m_ClientNetworkManagers.Length; ++i)
             {
                 // Unhook first so the spawn catcher stops catching spawns
-                m_ClientNetworkManagers[i].MessagingSystem.Unhook(m_ClientSpawnCatchers[i]);
+                m_ClientNetworkManagers[i].ConnectionManager.MessageManager.Unhook(m_ClientSpawnCatchers[i]);
                 m_ClientSpawnCatchers[i].ReleaseMessages();
             }
             m_ClientSpawnCatchers.Clear();
@@ -343,9 +343,9 @@ namespace Unity.Netcode.RuntimeTests
         private void AssertSpawnTriggerCountForObject(TestDeferredMessageManager manager, GameObject serverObject, int expectedCount = 1)
         {
             Assert.AreEqual(expectedCount, manager.DeferredMessageCountTotal());
-            Assert.AreEqual(expectedCount, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-            Assert.AreEqual(expectedCount, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-            Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
+            Assert.AreEqual(expectedCount, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+            Assert.AreEqual(expectedCount, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+            Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
         }
 
         private void WaitForAllClientsToReceive<T>() where T : INetworkMessage
@@ -505,9 +505,9 @@ namespace Unity.Netcode.RuntimeTests
                 Assert.IsTrue(manager.DeferMessageCalled);
                 Assert.IsFalse(manager.ProcessTriggersCalled);
                 Assert.AreEqual(1, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
+                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
 
                 var component = GetComponentForClient<DeferredMessageTestRpcComponent>(client.LocalClientId);
                 Assert.IsNull(component);
@@ -672,9 +672,9 @@ namespace Unity.Netcode.RuntimeTests
                 Assert.IsFalse(manager.ProcessTriggersCalled);
 
                 Assert.AreEqual(4, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
+                Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
                 AddPrefabsToClient(client);
             }
 
@@ -731,9 +731,9 @@ namespace Unity.Netcode.RuntimeTests
                 Assert.IsFalse(manager.ProcessTriggersCalled);
 
                 Assert.AreEqual(2, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
-                Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
+                Assert.AreEqual(0, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
+                Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
                 AddPrefabsToClient(client);
             }
 
@@ -816,10 +816,10 @@ namespace Unity.Netcode.RuntimeTests
 
                 Assert.AreEqual(5, manager.DeferredMessageCountTotal());
 
-                Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnAddPrefab));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
+                Assert.AreEqual(4, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(4, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, serverObject.GetComponent<NetworkObject>().GlobalObjectIdHash));
                 AddPrefabsToClient(client);
             }
 
@@ -890,7 +890,7 @@ namespace Unity.Netcode.RuntimeTests
 
             foreach (var unused in m_ClientNetworkManagers)
             {
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
             }
 
             int purgeCount = 0;
@@ -903,8 +903,8 @@ namespace Unity.Netcode.RuntimeTests
                     Debug.Log(client.RealTimeProvider.GetType().FullName);
                     Assert.GreaterOrEqual(elapsed, timeout);
                     Assert.AreEqual(1, manager.DeferredMessageCountTotal());
-                    Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
+                    Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
                     Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
                 };
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -986,7 +986,7 @@ namespace Unity.Netcode.RuntimeTests
 
             foreach (var unused in m_ClientNetworkManagers)
             {
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
             }
 
             int purgeCount = 0;
@@ -998,8 +998,8 @@ namespace Unity.Netcode.RuntimeTests
                     var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
                     Assert.GreaterOrEqual(elapsed, timeout);
                     Assert.AreEqual(3, manager.DeferredMessageCountTotal());
-                    Assert.AreEqual(3, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                    Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
+                    Assert.AreEqual(3, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                    Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
                     Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
                 };
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1092,8 +1092,8 @@ namespace Unity.Netcode.RuntimeTests
             foreach (var unused in m_ClientNetworkManagers)
             {
 
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject2.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject2.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
             }
 
             int purgeCount = 0;
@@ -1106,8 +1106,8 @@ namespace Unity.Netcode.RuntimeTests
                     var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
                     Assert.GreaterOrEqual(elapsed, timeout - 0.25f);
                     Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountTotal());
-                    Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                    Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
+                    Assert.AreEqual(remainingMessagesTotalThisClient, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                    Assert.AreEqual(3, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
                     remainingMessagesTotalThisClient -= 3;
                 };
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1167,8 +1167,8 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
                 Assert.AreEqual(1, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
             }
 
             serverObject.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId);
@@ -1178,13 +1178,13 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
                 Assert.AreEqual(2, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
             }
 
             foreach (var unused in m_ClientNetworkManagers)
             {
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
             }
 
             int purgeCount = 0;
@@ -1196,8 +1196,8 @@ namespace Unity.Netcode.RuntimeTests
                     var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
                     Assert.GreaterOrEqual(elapsed, timeout - 0.05f);
                     Assert.AreEqual(2, manager.DeferredMessageCountTotal());
-                    Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                    Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, key));
+                    Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                    Assert.AreEqual(2, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, key));
                     Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
                 };
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
@@ -1262,9 +1262,9 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
                 Assert.AreEqual(1, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
             }
 
             serverObject2.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.LocalClientId);
@@ -1274,14 +1274,14 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
                 Assert.AreEqual(2, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
             }
 
             foreach (var unused in m_ClientNetworkManagers)
             {
-                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
+                LogAssert.Expect(LogType.Warning, $"[Netcode] Deferred messages were received for a trigger of type {IDeferredNetworkMessageManager.TriggerType.OnSpawn} with key {serverObject.GetComponent<NetworkObject>().NetworkObjectId}, but that trigger was not received within within {timeout} second(s).");
             }
 
             int purgeCount = 0;
@@ -1293,10 +1293,10 @@ namespace Unity.Netcode.RuntimeTests
                     var elapsed = client.RealTimeProvider.RealTimeSinceStartup - start;
                     Assert.GreaterOrEqual(elapsed, timeout - 0.05f);
                     Assert.AreEqual(2, manager.DeferredMessageCountTotal());
-                    Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
+                    Assert.AreEqual(2, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
 
-                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
+                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                    Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
 
                     Assert.AreEqual(serverObject.GetComponent<NetworkObject>().NetworkObjectId, key);
                 };
@@ -1316,9 +1316,9 @@ namespace Unity.Netcode.RuntimeTests
             {
                 var manager = (TestDeferredMessageManager)client.DeferredMessageManager;
                 Assert.AreEqual(1, manager.DeferredMessageCountTotal());
-                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredMessageManager.TriggerType.OnSpawn));
-                Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
-                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForType(IDeferredNetworkMessageManager.TriggerType.OnSpawn));
+                Assert.AreEqual(0, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject.GetComponent<NetworkObject>().NetworkObjectId));
+                Assert.AreEqual(1, manager.DeferredMessageCountForKey(IDeferredNetworkMessageManager.TriggerType.OnSpawn, serverObject2.GetComponent<NetworkObject>().NetworkObjectId));
             }
             foreach (var client in m_ClientNetworkManagers)
             {