refactor: reference channels as bytes through the transport layer (#455)

mattwalsh-unity · web-flow · commit b2045f122304 · 2021-01-27T17:43:25.000-08:00
diff --git a/com.unity.multiplayer.mlapi/Runtime/Core/NetworkingManager.cs b/com.unity.multiplayer.mlapi/Runtime/Core/NetworkingManager.cs
@@ -789,10 +789,7 @@ private void NetworkPreUpdate()
                         do
                         {
                             processedEvents++;
-                            eventType = NetworkConfig.NetworkTransport.PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime);
-                            // [MTT-443] This can be improved if the Transport implementations return the channel as a byte vs. string
-                            //  Holding off on this; refactoring the Transport package will be a separate step
-                            byte channel = Transport.GetChannelByte(channelName);
+                            eventType = NetworkConfig.NetworkTransport.PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime);
                             HandleRawTransportPoll(eventType, clientId, channel, payload, receiveTime);
 
                             // Only do another iteration if: there are no more messages AND (there is no limit to max events or we have processed less than the maximum)
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageSender.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/InternalMessageSender.cs
@@ -24,10 +24,7 @@ internal static void Send(ulong clientId, byte messageType, byte channel, BitStr
                 NetworkProfiler.StartEvent(TickType.Send, (uint) stream.Length, channel,
                     MLAPIConstants.MESSAGE_NAMES[messageType]);
 
-                // [MTT-433] refactor so that the transports receive a byte, not a string
-                //  saving for a separate effort since transports live in their own package
-                string channelName = Transport.GetChannelString(channel);
-                NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
+                NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                 ProfilerStatManager.bytesSent.Record((int)stream.Length);
 
                 NetworkProfiler.EndEvent();
@@ -58,10 +55,7 @@ internal static void Send(byte messageType, byte channel, BitStream messageStrea
                         if (NetworkingManager.Singleton.IsServer && NetworkingManager.Singleton.ConnectedClientsList[i].ClientId == NetworkingManager.Singleton.ServerClientId)
                             continue;
 
-                        // [MTT-433] refactor so that the transports receive a byte, not a string
-                        //  saving for a separate effort since transports live in their own package
-                        string channelName = Transport.GetChannelString(channel);
-                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
+                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
@@ -99,10 +93,7 @@ internal static void Send(byte messageType, byte channel, List<ulong> clientIds,
                         if (NetworkingManager.Singleton.IsServer && clientIds[i] == NetworkingManager.Singleton.ServerClientId)
                             continue;
 
-                        // [MTT-433] refactor so that the transports receive a byte, not a string
-                        //  saving for a separate effort since transports live in their own package
-                        string channelName = Transport.GetChannelString(channel);
-                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientIds[i], new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
+                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientIds[i], new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
@@ -138,10 +129,7 @@ internal static void Send(byte messageType, byte channel, ulong clientIdToIgnore
                             (NetworkingManager.Singleton.IsServer && NetworkingManager.Singleton.ConnectedClientsList[i].ClientId == NetworkingManager.Singleton.ServerClientId))
                             continue;
 
-                        // [MTT-433] refactor so that the transports receive a byte, not a string
-                        //  saving for a separate effort since transports live in their own package
-                        string channelName = Transport.GetChannelString(channel);
-                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channelName);
+                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length), channel);
                         ProfilerStatManager.bytesSent.Record((int)stream.Length);
                     }
                     NetworkProfiler.EndEvent();
diff --git a/com.unity.multiplayer.mlapi/Runtime/Messaging/RPCQueue/RPCQueueProcessing.cs b/com.unity.multiplayer.mlapi/Runtime/Messaging/RPCQueue/RPCQueueProcessing.cs
@@ -215,9 +215,7 @@ private static void SendCallback(ulong clientId, MLAPI.MessageBatcher.SendStream
             var bytes = sendStream.Stream.GetBuffer();
             ArraySegment<byte> sendBuffer = new ArraySegment<byte>(bytes, 0, length);
 
-            // [MTT-433] refactor so that the transports receive a byte, not a string
-            //  saving for a separate effort since transports live in their own package
-            NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, Transport.GetChannelString(sendStream.channel));
+            NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, sendStream.channel);
         }
 
         /// <summary>
@@ -231,9 +229,7 @@ private void SendFrameQueueItem(FrameQueueItem queueItem)
             {
                 case RpcQueueContainer.QueueItemType.ServerRpc:
                 {
-                    // [MTT-433] refactor so that the transports receive a byte, not a string
-                    //  saving for a separate effort since transports live in their own package
-                    NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(queueItem.networkId, queueItem.messageData, Transport.GetChannelString(queueItem.channel));
+                    NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(queueItem.networkId, queueItem.messageData, queueItem.channel);
 
                     //For each packet sent, we want to record how much data we have sent
                     ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);
@@ -244,9 +240,7 @@ private void SendFrameQueueItem(FrameQueueItem queueItem)
                 {
                     foreach (ulong clientid in queueItem.clientIds)
                     {
-                        // [MTT-433] refactor so that the transports receive a byte, not a string
-                        //  saving for a separate effort since transports live in their own package
-                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientid, queueItem.messageData, Transport.GetChannelString(queueItem.channel));
+                        NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientid, queueItem.messageData, queueItem.channel);
 
                         //For each packet sent, we want to record how much data we have sent
                         ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);
diff --git a/com.unity.multiplayer.mlapi/Runtime/Transports/MultiplexTransportAdapter.cs b/com.unity.multiplayer.mlapi/Runtime/Transports/MultiplexTransportAdapter.cs
@@ -82,7 +82,7 @@ public override void Init()
             }
         }
 
-        public override NetEventType PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime)
+        public override NetEventType PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime)
         {
             if (_lastProcessedTransportIndex >= Transports.Length - 1)
                 _lastProcessedTransportIndex = 0;
@@ -93,7 +93,7 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam
 
                 if (Transports[i].IsSupported)
                 {
-                    NetEventType @eventType = Transports[i].PollEvent(out ulong connectionId, out channelName, out payload, out receiveTime);
+                    NetEventType @eventType = Transports[i].PollEvent(out ulong connectionId, out channel, out payload, out receiveTime);
 
                     if (@eventType != NetEventType.Nothing)
                     {
@@ -105,18 +105,18 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam
             }
 
             clientId = 0;
-            channelName = null;
+            channel = 0;
             payload = new ArraySegment<byte>();
             receiveTime = 0;
 
             return NetEventType.Nothing;
         }
 
-        public override void Send(ulong clientId, ArraySegment<byte> data, string channelName)
+        public override void Send(ulong clientId, ArraySegment<byte> data, byte channel)
         {
             GetMultiplexTransportDetails(clientId, out byte transportId, out ulong connectionId);
 
-            Transports[transportId].Send(connectionId, data, channelName);
+            Transports[transportId].Send(connectionId, data, channel);
         }
 
         public override void Shutdown()
diff --git a/com.unity.multiplayer.mlapi/Runtime/Transports/Transport.cs b/com.unity.multiplayer.mlapi/Runtime/Transports/Transport.cs
@@ -138,7 +138,7 @@ protected void InvokeOnTransportEvent(NetEventType type, ulong clientId, byte ch
         /// <param name="clientId">The clientId to send to</param>
         /// <param name="data">The data to send</param>
         /// <param name="channelName">The channel to send data to</param>
-        public abstract void Send(ulong clientId, ArraySegment<byte> data, string channelName);
+        public abstract void Send(ulong clientId, ArraySegment<byte> data, byte channel);
 
         /// <summary>
         /// Polls for incoming events, with an extra output parameter to report the precise time the event was received.
@@ -148,7 +148,7 @@ protected void InvokeOnTransportEvent(NetEventType type, ulong clientId, byte ch
         /// <param name="payload">The incoming data payload</param>
         /// <param name="receiveTime">The time the event was received, as reported by Time.realtimeSinceStartup.</param>
         /// <returns>Returns the event type</returns>
-        public abstract NetEventType PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime);
+        public abstract NetEventType PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime);
 
         /// <summary>
         /// Connects client to server
diff --git a/com.unity.multiplayer.mlapi/Runtime/Transports/UNET/UnetChannel.cs b/com.unity.multiplayer.mlapi/Runtime/Transports/UNET/UnetChannel.cs
@@ -12,11 +12,11 @@ public class UnetChannel
         /// <summary>
         /// The name of the channel
         /// </summary>
-        public string Name;
+        public byte Id;
 
         /// <summary>
         /// The type of channel
         /// </summary>
         public QosType Type;
     }
-}
+}
diff --git a/com.unity.multiplayer.mlapi/Runtime/Transports/UNET/UnetTransport.cs b/com.unity.multiplayer.mlapi/Runtime/Transports/UNET/UnetTransport.cs
@@ -41,8 +41,8 @@ public enum SendMode
         private WeakReference temporaryBufferReference;
 
         // Lookup / translation
-        private readonly Dictionary<string, int> channelNameToId = new Dictionary<string, int>();
-        private readonly Dictionary<int, string> channelIdToName = new Dictionary<int, string>();
+        private readonly Dictionary<byte, int> channelNameToId = new Dictionary<byte, int>();
+        private readonly Dictionary<int, byte> channelIdToName = new Dictionary<int, byte>();
         private int serverConnectionId;
         private int serverHostId;
 
@@ -63,19 +63,19 @@ protected void LateUpdate()
             }
         }
 
-        public override void Send(ulong clientId, ArraySegment<byte> data, string channelName)
+        public override void Send(ulong clientId, ArraySegment<byte> data, byte channel)
         {
             GetUnetConnectionDetails(clientId, out byte hostId, out ushort connectionId);
 
             int channelId = 0;
 
-            if (channelNameToId.ContainsKey(channelName))
+            if (channelNameToId.ContainsKey(channel))
             {
-                channelId = channelNameToId[channelName];
+                channelId = channelNameToId[channel];
             }
             else
             {
-                channelId = channelNameToId["MLAPI_INTERNAL"];
+                channelId = channelNameToId[MLAPI_INTERNAL_CHANNEL];
             }
 
             byte[] buffer;
@@ -125,7 +125,7 @@ public void SendQueued(ulong clientId)
             RelayTransport.SendQueuedMessages(hostId, connectionId, out byte error);
         }
 
-        public override NetEventType PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime)
+        public override NetEventType PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime)
         {
             NetworkEventType eventType = RelayTransport.Receive(out int hostId, out int connectionId, out int channelId, messageBuffer, messageBuffer.Length, out int receivedSize, out byte error);
 
@@ -159,11 +159,11 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam
 
             if (channelIdToName.ContainsKey(channelId))
             {
-                channelName = channelIdToName[channelId];
+                channel = channelIdToName[channelId];
             }
             else
             {
-                channelName = "MLAPI_INTERNAL";
+                channel = MLAPI_INTERNAL_CHANNEL;
             }
 
             if (connectTask != null && hostId == serverHostId && connectionId == serverConnectionId)
@@ -349,16 +349,16 @@ public ConnectionConfig GetConfig()
             {
                 int channelId = AddMLAPIChannel(MLAPI_CHANNELS[i].Type, config);
 
-                channelIdToName.Add(channelId, MLAPI_CHANNELS[i].Name);
-                channelNameToId.Add(MLAPI_CHANNELS[i].Name, channelId);
+                channelIdToName.Add(channelId, MLAPI_CHANNELS[i].Id);
+                channelNameToId.Add(MLAPI_CHANNELS[i].Id, channelId);
             }
 
             for (int i = 0; i < Channels.Count; i++)
             {
                 int channelId = AddUNETChannel(Channels[i].Type, config);
 
-                channelIdToName.Add(channelId, Channels[i].Name);
-                channelNameToId.Add(Channels[i].Name, channelId);
+                channelIdToName.Add(channelId, Channels[i].Id);
+                channelNameToId.Add(Channels[i].Id, channelId);
             }
 
             config.MaxSentMessageQueueSize = (ushort)MaxSentMessageQueueSize;
diff --git a/com.unity.multiplayer.transport.enet/Runtime/EnetTransport.cs b/com.unity.multiplayer.transport.enet/Runtime/EnetTransport.cs

Original file line number	Diff line number	Diff line change
`@@ -215,9 +215,7 @@ private static void SendCallback(ulong clientId, MLAPI.MessageBatcher.SendStream`
`215`	`215`	`var bytes = sendStream.Stream.GetBuffer();`
`216`	`216`	`ArraySegment<byte> sendBuffer = new ArraySegment<byte>(bytes, 0, length);`
`217`	`217`
`218`		`- // [MTT-433] refactor so that the transports receive a byte, not a string`
`219`		`- // saving for a separate effort since transports live in their own package`
`220`		`- NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, Transport.GetChannelString(sendStream.channel));`
	`218`	`+ NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, sendStream.channel);`
`221`	`219`	`}`
`222`	`220`
`223`	`221`	`/// <summary>`
`@@ -231,9 +229,7 @@ private void SendFrameQueueItem(FrameQueueItem queueItem)`
`231`	`229`	`{`
`232`	`230`	`case RpcQueueContainer.QueueItemType.ServerRpc:`
`233`	`231`	`{`
`234`		`- // [MTT-433] refactor so that the transports receive a byte, not a string`
`235`		`- // saving for a separate effort since transports live in their own package`
`236`		`- NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(queueItem.networkId, queueItem.messageData, Transport.GetChannelString(queueItem.channel));`
	`232`	`+ NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(queueItem.networkId, queueItem.messageData, queueItem.channel);`
`237`	`233`
`238`	`234`	`//For each packet sent, we want to record how much data we have sent`
`239`	`235`	`ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);`
`@@ -244,9 +240,7 @@ private void SendFrameQueueItem(FrameQueueItem queueItem)`
`244`	`240`	`{`
`245`	`241`	`foreach (ulong clientid in queueItem.clientIds)`
`246`	`242`	`{`
`247`		`- // [MTT-433] refactor so that the transports receive a byte, not a string`
`248`		`- // saving for a separate effort since transports live in their own package`
`249`		`- NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientid, queueItem.messageData, Transport.GetChannelString(queueItem.channel));`
	`243`	`+ NetworkingManager.Singleton.NetworkConfig.NetworkTransport.Send(clientid, queueItem.messageData, queueItem.channel);`
`250`	`244`
`251`	`245`	`//For each packet sent, we want to record how much data we have sent`
`252`	`246`	`ProfilerStatManager.bytesSent.Record((int)queueItem.streamSize);`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ public override void Init()`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`- public override NetEventType PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime)`
	`85`	`+ public override NetEventType PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime)`
`86`	`86`	`{`
`87`	`87`	`if (_lastProcessedTransportIndex >= Transports.Length - 1)`
`88`	`88`	`_lastProcessedTransportIndex = 0;`
`@@ -93,7 +93,7 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam`
`93`	`93`
`94`	`94`	`if (Transports[i].IsSupported)`
`95`	`95`	`{`
`96`		`- NetEventType @eventType = Transports[i].PollEvent(out ulong connectionId, out channelName, out payload, out receiveTime);`
	`96`	`+ NetEventType @eventType = Transports[i].PollEvent(out ulong connectionId, out channel, out payload, out receiveTime);`
`97`	`97`
`98`	`98`	`if (@eventType != NetEventType.Nothing)`
`99`	`99`	`{`
`@@ -105,18 +105,18 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`clientId = 0;`
`108`		`- channelName = null;`
	`108`	`+ channel = 0;`
`109`	`109`	`payload = new ArraySegment<byte>();`
`110`	`110`	`receiveTime = 0;`
`111`	`111`
`112`	`112`	`return NetEventType.Nothing;`
`113`	`113`	`}`
`114`	`114`
`115`		`- public override void Send(ulong clientId, ArraySegment<byte> data, string channelName)`
	`115`	`+ public override void Send(ulong clientId, ArraySegment<byte> data, byte channel)`
`116`	`116`	`{`
`117`	`117`	`GetMultiplexTransportDetails(clientId, out byte transportId, out ulong connectionId);`
`118`	`118`
`119`		`- Transports[transportId].Send(connectionId, data, channelName);`
	`119`	`+ Transports[transportId].Send(connectionId, data, channel);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`public override void Shutdown()`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ public enum SendMode`
`41`	`41`	`private WeakReference temporaryBufferReference;`
`42`	`42`
`43`	`43`	`// Lookup / translation`
`44`		`- private readonly Dictionary<string, int> channelNameToId = new Dictionary<string, int>();`
`45`		`- private readonly Dictionary<int, string> channelIdToName = new Dictionary<int, string>();`
	`44`	`+ private readonly Dictionary<byte, int> channelNameToId = new Dictionary<byte, int>();`
	`45`	`+ private readonly Dictionary<int, byte> channelIdToName = new Dictionary<int, byte>();`
`46`	`46`	`private int serverConnectionId;`
`47`	`47`	`private int serverHostId;`
`48`	`48`
`@@ -63,19 +63,19 @@ protected void LateUpdate()`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`		`- public override void Send(ulong clientId, ArraySegment<byte> data, string channelName)`
	`66`	`+ public override void Send(ulong clientId, ArraySegment<byte> data, byte channel)`
`67`	`67`	`{`
`68`	`68`	`GetUnetConnectionDetails(clientId, out byte hostId, out ushort connectionId);`
`69`	`69`
`70`	`70`	`int channelId = 0;`
`71`	`71`
`72`		`- if (channelNameToId.ContainsKey(channelName))`
	`72`	`+ if (channelNameToId.ContainsKey(channel))`
`73`	`73`	`{`
`74`		`- channelId = channelNameToId[channelName];`
	`74`	`+ channelId = channelNameToId[channel];`
`75`	`75`	`}`
`76`	`76`	`else`
`77`	`77`	`{`
`78`		`- channelId = channelNameToId["MLAPI_INTERNAL"];`
	`78`	`+ channelId = channelNameToId[MLAPI_INTERNAL_CHANNEL];`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`byte[] buffer;`
`@@ -125,7 +125,7 @@ public void SendQueued(ulong clientId)`
`125`	`125`	`RelayTransport.SendQueuedMessages(hostId, connectionId, out byte error);`
`126`	`126`	`}`
`127`	`127`
`128`		`- public override NetEventType PollEvent(out ulong clientId, out string channelName, out ArraySegment<byte> payload, out float receiveTime)`
	`128`	`+ public override NetEventType PollEvent(out ulong clientId, out byte channel, out ArraySegment<byte> payload, out float receiveTime)`
`129`	`129`	`{`
`130`	`130`	`NetworkEventType eventType = RelayTransport.Receive(out int hostId, out int connectionId, out int channelId, messageBuffer, messageBuffer.Length, out int receivedSize, out byte error);`
`131`	`131`
`@@ -159,11 +159,11 @@ public override NetEventType PollEvent(out ulong clientId, out string channelNam`
`159`	`159`
`160`	`160`	`if (channelIdToName.ContainsKey(channelId))`
`161`	`161`	`{`
`162`		`- channelName = channelIdToName[channelId];`
	`162`	`+ channel = channelIdToName[channelId];`
`163`	`163`	`}`
`164`	`164`	`else`
`165`	`165`	`{`
`166`		`- channelName = "MLAPI_INTERNAL";`
	`166`	`+ channel = MLAPI_INTERNAL_CHANNEL;`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`if (connectTask != null && hostId == serverHostId && connectionId == serverConnectionId)`
`@@ -349,16 +349,16 @@ public ConnectionConfig GetConfig()`
`349`	`349`	`{`
`350`	`350`	`int channelId = AddMLAPIChannel(MLAPI_CHANNELS[i].Type, config);`
`351`	`351`
`352`		`- channelIdToName.Add(channelId, MLAPI_CHANNELS[i].Name);`
`353`		`- channelNameToId.Add(MLAPI_CHANNELS[i].Name, channelId);`
	`352`	`+ channelIdToName.Add(channelId, MLAPI_CHANNELS[i].Id);`
	`353`	`+ channelNameToId.Add(MLAPI_CHANNELS[i].Id, channelId);`
`354`	`354`	`}`
`355`	`355`
`356`	`356`	`for (int i = 0; i < Channels.Count; i++)`
`357`	`357`	`{`
`358`	`358`	`int channelId = AddUNETChannel(Channels[i].Type, config);`
`359`	`359`
`360`		`- channelIdToName.Add(channelId, Channels[i].Name);`
`361`		`- channelNameToId.Add(Channels[i].Name, channelId);`
	`360`	`+ channelIdToName.Add(channelId, Channels[i].Id);`
	`361`	`+ channelNameToId.Add(Channels[i].Id, channelId);`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`config.MaxSentMessageQueueSize = (ushort)MaxSentMessageQueueSize;`