Add a single unified “OnNetworkStarted” event to NetworkManager

The problem

There’s no single event that fires once when networking starts, regardless of mode
Currently you need to handle both OnServerStarted and OnClientConnectedCallback, which leads to redundant or missing calls depending on the mode (client/server)
Using per-connection callbacks for this is unreliable, and managing timing around the singleton or validation properties(e.g IsListening) adds unnecessary complexity

Unless i am missing something, to me this dont feels right

Current workflow

The current workaround is using coroutines or polling to wait until the singleton exists and the NetworkManager is listening.
This adds overhead and makes initialization logic fragile, even more for singleplayer sessions where the code may keep waiting forever as no connections are made

Example (based on forums suggestions):

void OnEnable()
{
   StartCoroutine(SubscribeToNetworkManagerEvents());
}

IEnumerator SubscribeToNetworkManagerEvents()
{
   yield return new WaitUntil(() => NetworkManager.Singleton); //This is fragile, and may add other problems, and no mention to cancelations
   NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnectedCallback; //called on clients but unclear about standalone server
   NetworkManager.Singleton.OnServerStarted += OnServerStarted; //never called on non host client
}

void OnDestroy()
{
   if (NetworkManager.Singleton)
   {
      NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnectedCallback;
      NetworkManager.Singleton.OnServerStarted -= OnServerStarted;
   }
   initialized = false;
}

void OnClientConnectedCallback(parameters)
{
   RegisterMessageHandler();
}

void OnServerStarted(parameters)
{
   RegisterMessageHandler();
}

bool initialized;
//Both on client connected callback and server started calls this other method
void RegisterMessageHandler()
{
   if(initialized)
      return;
//For example
		NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("a", B);
// In this case, Singleton can be null and CustomMessagingManager also can be null, thats why we need the yield
   initialized = true;
}

These yields are required only because there is no dedicated lifecycle event indicating when the NetworkManager and its subsystems (like CustomMessagingManager) are fully initialized
As result, developers must manually simulate this missing initialization phase using coroutines or polling, which makes code more complex

Posible solution

Add new public static Action<NetworkManager> OnNetworkStarted event to NetworkManager
Triggered once when the network stack has been initialized and the transport is ready, regardless of whether it’s running as server, client, or host.
Passing the Network manager initialized (as after working on the last pull request, i saw on the tests part and other parts of code might exist more than one NetworkManager)

This would change the workflow to a much more convenient one like this

NetworkManager networkManager;

void OnEnable()
{
   NetworkManager.OnNetworkStarted += OnNetworkStarted;
}

void OnNetworkStarted(NetworkManager networkManager) 
{
   this.networkManager = networkManager; 
   networkManager.CustomMessagingManager.RegisterNamedMessageHandler("a", B);
}


void OnDestroy()
{
   if (networkManager)
      networkManager.CustomMessagingManager.UnregisterNamedMessageHandler("a");
}

[!NOTE]
While NetworkBehaviour.OnNetworkSpawn can be used for components, this event would support use cases where no scene objects are involved (e.g ScriptableObjects or systems initialized outside scene contexts). It provides a clean, unified hook for all modes.

This change would mostly take 2 lines

1. public static Action<NetworkManager> OnNetworkStarted on NetworkManager class
2. OnNetworkStarter?.Invoke(This); at the very end of NetworkManager's internal void Initialize(bool server) method

It only may cause problems on having it static with the editor reloading feature, but that could be arranged cleaning the event with the [RuntimeInitializeOnLoadAttribute]

Commencez dans NetworkManager, en particulier dans internal Initialize(bool server), et examinez les chemins de cycle de vie existants OnServerStarted et OnClientConnectedCallback ainsi que les tests associés. C’est terminé lorsqu’un événement unique est déclenché une seule fois après que la pile réseau et le transport sont prêts dans les modes serveur, client et hôte, avec un comportement couvrant plusieurs instances de NetworkManager et les rechargements de l’éditeur.