rename NUtils to NHelper

alec1o · alec1o · commit 7356bddb9655 · 2025-09-28T04:19:05.000+02:00
diff --git a/src/http/partials/Websocket/HTTP.WebSocketTo.cs b/src/http/partials/Websocket/HTTP.WebSocketTo.cs
@@ -299,10 +299,10 @@ private async void ReceiveJob(object _)
                             ? MessageType.Text
                             : MessageType.Binary;
 
-                        var stream = NUtils.NewStream(data.LongLength);
+                        var stream = NHelper.NewStream(data.LongLength);
                         await stream.WriteAsync(data, 0, data.Length);
 
-                        if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))
+                        if (NMessage.TryParse(stream, out var name, out var message, NHelper.NewStream))
                         {
                             var reference = new byte[message.Length];
                             message.Position = 0;
diff --git a/src/netly/NEnvironment.cs b/src/netly/NEnvironment.cs
@@ -4,7 +4,7 @@
     ///     Provides general information about the Netly library,
     ///     including its name, version, Git repository, and supported protocols.
     /// </summary>
-    public static partial class NEnvironment
+    public static class NEnvironment
     {
         /// <summary>
         ///     The name of the library.
diff --git a/src/netly/NFraming.cs b/src/netly/NFraming.cs
@@ -159,13 +159,13 @@ public void Write(ArraySegment<byte> segment, Func<long, Stream> getStream)
                                 throw new InvalidDataException($"{nameof(size)}: {size}");
 
                             // get and verify prefix
-                            if (NUtils.ArraySequenced(Prefix, _headerBuffer))
+                            if (NHelper.ArraySequenced(Prefix, _headerBuffer))
                                 _transactions.AddLast(new Transaction(getStream(size), false));
                             else
                                 throw new InvalidDataException(
-                                    $"{nameof(Prefix)}: {NUtils.Format(Prefix)} - {NUtils.Format(_headerBuffer)}");
+                                    $"{nameof(Prefix)}: {NHelper.Format(Prefix)} - {NHelper.Format(_headerBuffer)}");
 
-                            segment = NUtils.SegmentShift(segment, copied);
+                            segment = NHelper.SegmentShift(segment, copied);
                             _size = size;
                             _headerOffset = 0;
                             _transactions.Last.Value.Stream.Position = 0;
@@ -196,7 +196,7 @@ public void Write(ArraySegment<byte> segment, Func<long, Stream> getStream)
 
                             if (left > 0)
                             {
-                                segment = NUtils.SegmentShift(segment, count);
+                                segment = NHelper.SegmentShift(segment, count);
                                 continue; // REQUIRED: Read new stream again!
                             }
                         }
diff --git a/src/netly/NHelper.cs b/src/netly/NHelper.cs
@@ -4,18 +4,18 @@
 
 namespace Netly
 {
-    public static class NUtils
+    public static class NHelper
     {
         /// <summary>
-        /// Returns a new <see cref="ArraySegment{T}"/> shifted by the specified number of elements.
-        /// If the shift is greater than or equal to the segment count, an empty segment at the end is returned.
+        ///     Returns a new <see cref="ArraySegment{T}" /> shifted by the specified number of elements.
+        ///     If the shift is greater than or equal to the segment count, an empty segment at the end is returned.
         /// </summary>
         /// <typeparam name="T">The type of elements in the array segment.</typeparam>
         /// <param name="segment">The original array segment.</param>
         /// <param name="shift">The number of elements to skip from the start.</param>
         /// <returns>A new array segment representing the shifted portion.</returns>
-        /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="shift"/> is negative.</exception>
-        /// <exception cref="ArgumentNullException">Thrown if the array in <paramref name="segment"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="shift" /> is negative.</exception>
+        /// <exception cref="ArgumentNullException">Thrown if the array in <paramref name="segment" /> is null.</exception>
         public static ArraySegment<T> SegmentShift<T>(ArraySegment<T> segment, int shift)
         {
             if (shift < 0)
@@ -30,15 +30,15 @@ public static ArraySegment<T> SegmentShift<T>(ArraySegment<T> segment, int shift
         }
 
         /// <summary>
-        /// Compares all elements in the given array to determine if they are equal.
-        /// For arrays with more than one element, returns true if all elements are the same.
+        ///     Compares all elements in the given array to determine if they are equal.
+        ///     For arrays with more than one element, returns true if all elements are the same.
         /// </summary>
         /// <typeparam name="T">The type of elements in the array. Must support equality comparison.</typeparam>
         /// <param name="array">The array of elements to compare.</param>
         /// <returns>
-        /// True if all elements are equal or the array has zero or one element; otherwise, false.
+        ///     True if all elements are equal or the array has zero or one element; otherwise, false.
         /// </returns>
-        /// <exception cref="ArgumentNullException">Thrown if <paramref name="array"/> is null.</exception>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="array" /> is null.</exception>
         public static bool ArraySequenced<T>(params T[][] array)
         {
             if (array == null)
@@ -57,7 +57,7 @@ public static bool ArraySequenced<T>(params T[][] array)
         }
 
         /// <summary>
-        /// Returns a string representation of an array in the format [elem1,elem2,...].
+        ///     Returns a string representation of an array in the format [elem1,elem2,...].
         /// </summary>
         /// <typeparam name="T">The type of elements in the array.</typeparam>
         /// <param name="elements">The array to format.</param>
@@ -68,13 +68,13 @@ public static string Format<T>(T[] elements)
         }
 
         /// <summary>
-        /// Concatenates all elements of the given array into a new array.
-        /// This is mainly useful if you want a copy of the array or to combine multiple arrays later.
+        ///     Concatenates all elements of the given array into a new array.
+        ///     This is mainly useful if you want a copy of the array or to combine multiple arrays later.
         /// </summary>
         /// <typeparam name="T">The type of elements in the array.</typeparam>
         /// <param name="elements">The array of elements to concatenate.</param>
         /// <returns>A new array containing all elements from the input array in order.</returns>
-        /// <exception cref="ArgumentNullException">Thrown if <paramref name="elements"/> is null.</exception>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="elements" /> is null.</exception>
         public static T[] ArrayConcat<T>(params T[][] elements)
         {
             if (elements == null)
@@ -99,7 +99,7 @@ public static T[] ArrayConcat<T>(params T[][] elements)
         ///     Throws <see cref="InternalBufferOverflowException" /> if the size exceeds the default maximum.
         /// </summary>
         /// <param name="size">The desired size of the stream.</param>
-        /// <returns>A <see cref="Stream"/> with the specified size.</returns>
+        /// <returns>A <see cref="Stream" /> with the specified size.</returns>
         public static Stream NewStream(long size)
         {
             if (size <= 1024 * 1024 * 20) // 20.00 MB
diff --git a/src/netly/NLogger.cs b/src/netly/NLogger.cs
@@ -69,8 +69,8 @@ public void Submit<T>(T value)
         /// </summary>
         /// <param name="callback">The action to call with each log message.</param>
         /// <param name="forceImmediateDispatcherMode">
-        ///     If true, the callback is executed immediately on the submitting thread.<br/>
-        ///     If false, the callback is enqueued using the available <see cref="NDispatcher"/> instance.
+        ///     If true, the callback is executed immediately on the submitting thread.<br />
+        ///     If false, the callback is enqueued using the available <see cref="NDispatcher" /> instance.
         /// </param>
         public void OnSubmit(Action<string> callback, bool forceImmediateDispatcherMode = false)
         {
diff --git a/src/netly/NMessage.cs b/src/netly/NMessage.cs
@@ -126,7 +126,7 @@ public static bool TryParse(Stream stream, out string name, out Stream message,
 
                 var offset = 0;
 
-                if (!NUtils.ArraySequenced(Prefix, header))
+                if (!NHelper.ArraySequenced(Prefix, header))
                     return false;
 
                 offset += Prefix.Length;
diff --git a/src/netly/tcp/NTcp.Client.cs b/src/netly/tcp/NTcp.Client.cs
@@ -4,7 +4,6 @@ public partial class NTcp
     {
         public class Client
         {
-            
         }
     }
 }
diff --git a/src/netly/tcp/NTcp.cs b/src/netly/tcp/NTcp.cs
@@ -2,6 +2,5 @@ namespace Netly
 {
     public partial class NTcp
     {
-        
     }
 }
diff --git a/src/package/NTcpClient.cs b/src/package/NTcpClient.cs
@@ -34,7 +34,7 @@ public class NTcpClient : INTcpClient
         private NTcpClient()
         {
             _server = null;
-            _onStream = NUtils.NewStream;
+            _onStream = NHelper.NewStream;
             Host = NHost.Default;
             IsConnected = false;
             SecureProtocol = SslProtocols.Default;
diff --git a/src/package/NTcpServer.cs b/src/package/NTcpServer.cs
@@ -33,7 +33,7 @@ private NTcpServer()
             IsFraming = false;
             AllowUnsecured = false;
             FramingSize = NFraming.DefaultSize;
-            OnStreamObject = NUtils.NewStream;
+            OnStreamObject = NHelper.NewStream;
             OnSecureObject = new List<Func<X509Certificate, X509Chain, SslPolicyErrors, bool>>();
             Socket = null;
             Certificate = new X509Certificate();
diff --git a/src/rudp/partials/RUDP.ClientTo.cs b/src/rudp/partials/RUDP.ClientTo.cs
@@ -183,7 +183,7 @@ public void Event(string name, byte[] data, MessageType messageType)
                 try
                 {
                     var header = NMessage.Create(name, data.LongLength);
-                    _connection?.Send(NUtils.ArrayConcat(header, data), messageType);
+                    _connection?.Send(NHelper.ArrayConcat(header, data), messageType);
                 }
                 catch (Exception e)
                 {
@@ -199,7 +199,7 @@ public void Event(string name, string data, MessageType messageType)
                 {
                     var bytes = data.GetBytes();
                     var header = NMessage.Create(name, bytes.LongLength);
-                    _connection?.Send(NUtils.ArrayConcat(header, bytes), messageType);
+                    _connection?.Send(NHelper.ArrayConcat(header, bytes), messageType);
                 }
                 catch (Exception e)
                 {
@@ -215,7 +215,7 @@ public void Event(string name, string data, MessageType messageType, Encoding en
                 {
                     var bytes = data.GetBytes(encoding);
                     var header = NMessage.Create(name, bytes.LongLength);
-                    _connection?.Send(NUtils.ArrayConcat(header, bytes), messageType);
+                    _connection?.Send(NHelper.ArrayConcat(header, bytes), messageType);
                 }
                 catch (Exception e)
                 {
diff --git a/src/rudp/partials/utils/RUDP.Connection.cs b/src/rudp/partials/utils/RUDP.Connection.cs
@@ -95,10 +95,10 @@ private void OnRawDataHandler(byte[] data, MessageType messageType)
 
                 if (IsOpened)
                 {
-                    var stream = NUtils.NewStream(data.LongLength);
+                    var stream = NHelper.NewStream(data.LongLength);
                     stream.Write(data, 0, data.Length);
 
-                    if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))
+                    if (NMessage.TryParse(stream, out var name, out var message, NHelper.NewStream))
                     {
                         var reference = new byte[message.Length];
                         message.Position = 0;
diff --git a/src/tcp/partials/TCP.ClientTo.cs b/src/tcp/partials/TCP.ClientTo.cs
@@ -345,7 +345,7 @@ await _sslStream.AuthenticateAsServerAsync
 
             private void PublishData(Stream stream)
             {
-                if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))
+                if (NMessage.TryParse(stream, out var name, out var message, NHelper.NewStream))
                 {
                     message.Position = 0;
                     On.OnEvent?.Invoke(null, (name, message));
@@ -427,13 +427,13 @@ private void ReceiveHandler(IAsyncResult result)
 
                     if (IsFraming)
                     {
-                        _framing.Write(new ArraySegment<byte>(_buffer, 0, size), NUtils.NewStream);
+                        _framing.Write(new ArraySegment<byte>(_buffer, 0, size), NHelper.NewStream);
                         while (_framing.Read(out var stream))
                             PublishData(stream);
                     }
                     else
                     {
-                        var stream = NUtils.NewStream(size);
+                        var stream = NHelper.NewStream(size);
                         stream.Write(_buffer, 0, size);
                         PublishData(stream);
                     }
diff --git a/src/udp/partials/UDP.ClientTo.cs b/src/udp/partials/UDP.ClientTo.cs
@@ -174,11 +174,11 @@ public void InitServerSide()
 
                 private void PushResult(ref byte[] bytes)
                 {
-                    var stream = NUtils.NewStream(bytes.LongLength);
+                    var stream = NHelper.NewStream(bytes.LongLength);
                     stream.Position = 0;
                     stream.Write(bytes, 0, bytes.Length);
 
-                    if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))
+                    if (NMessage.TryParse(stream, out var name, out var message, NHelper.NewStream))
                     {
                         var buffer = new byte[message.Length];
                         message.Position = 0;
diff --git a/test/Netly/NFramingTest.cs b/test/Netly/NFramingTest.cs
@@ -23,13 +23,13 @@ public void Start()
         for (var i = 0; i < 10; i++)
         {
             // first deploy
-            framing.Write(new ArraySegment<byte>(header), NUtils.NewStream);
+            framing.Write(new ArraySegment<byte>(header), NHelper.NewStream);
             var deploy1 = framing.Read(out var stream1);
             Assert.False(deploy1);
             Assert.Null(stream1);
 
             // last deploy
-            framing.Write(new ArraySegment<byte>(message), NUtils.NewStream);
+            framing.Write(new ArraySegment<byte>(message), NHelper.NewStream);
             var deploy2 = framing.Read(out var stream2);
             Assert.True(deploy2);
             Assert.NotNull(stream2);
@@ -72,7 +72,7 @@ public void Multiples()
             messages.Add(message);
         }
 
-        framing.Write(new ArraySegment<byte>(buffer.ToArray()), NUtils.NewStream);
+        framing.Write(new ArraySegment<byte>(buffer.ToArray()), NHelper.NewStream);
         buffer.Clear();
 
         var count = 0;
diff --git a/test/Netly/NHelperTest.cs b/test/Netly/NHelperTest.cs
@@ -1,14 +1,14 @@
 namespace NetlyTest.Netly;
 
-public class NUtilsTest
+public class NHelperTest
 {
     [Fact]
     public void SegmentShift_ShiftsCorrectly()
     {
         var array = new[] { 1, 2, 3, 4, 5 };
         var segment = new ArraySegment<int>(array, 0, array.Length);
 
-        var shifted = NUtils.SegmentShift(segment, 2);
+        var shifted = NHelper.SegmentShift(segment, 2);
 
         Assert.Equal(3, shifted.Count);
         Assert.Equal(3, shifted.Array![shifted.Offset]);
@@ -22,7 +22,7 @@ public void SegmentShift_ShiftGreaterThanCount_ReturnsEmpty()
         var array = new[] { 1, 2, 3 };
         var segment = new ArraySegment<int>(array);
 
-        var shifted = NUtils.SegmentShift(segment, 5);
+        var shifted = NHelper.SegmentShift(segment, 5);
 
         Assert.Equal(0, shifted.Count);
         Assert.Equal(array, shifted.Array);
@@ -34,7 +34,7 @@ public void SegmentShift_NegativeShift_Throws()
     {
         var array = new[] { 1, 2 };
         var segment = new ArraySegment<int>(array);
-        Assert.Throws<ArgumentOutOfRangeException>(() => NUtils.SegmentShift(segment, -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => NHelper.SegmentShift(segment, -1));
     }
 
     [Fact]
@@ -44,7 +44,7 @@ public void ArraySequenced_AllEqual_ReturnsTrue()
         var a2 = new[] { 1, 2, 3 };
         var a3 = new[] { 1, 2, 3 };
 
-        var result = NUtils.ArraySequenced(a1, a2, a3);
+        var result = NHelper.ArraySequenced(a1, a2, a3);
         Assert.True(result);
     }
 
@@ -54,15 +54,15 @@ public void ArraySequenced_NotAllEqual_ReturnsFalse()
         var a1 = new[] { 1, 2 };
         var a2 = new[] { 1, 3 };
 
-        var result = NUtils.ArraySequenced(a1, a2);
+        var result = NHelper.ArraySequenced(a1, a2);
         Assert.False(result);
     }
 
     [Fact]
     public void Format_ReturnsCorrectString()
     {
         var arr = new[] { 1, 2, 3 };
-        var result = NUtils.Format(arr);
+        var result = NHelper.Format(arr);
         Assert.Equal("[1,2,3]", result);
     }
 
@@ -73,21 +73,21 @@ public void ArrayConcat_ConcatenatesArrays()
         var a2 = new[] { 3, 4 };
         var a3 = new[] { 5 };
 
-        var result = NUtils.ArrayConcat(a1, a2, a3);
+        var result = NHelper.ArrayConcat(a1, a2, a3);
         Assert.Equal(new[] { 1, 2, 3, 4, 5 }, result);
     }
 
     [Fact]
     public void ArrayConcat_Null_Throws()
     {
-        Assert.Throws<ArgumentNullException>(() => NUtils.ArrayConcat<int>(null));
+        Assert.Throws<ArgumentNullException>(() => NHelper.ArrayConcat<int>(null));
     }
 
     [Fact]
     public void NewStream_SizeUnderLimit_CreatesMemoryStream()
     {
         var size = 1024 * 1024 * 20; // 20 MB
-        using var stream = NUtils.NewStream(size);
+        using var stream = NHelper.NewStream(size);
         Assert.IsType<MemoryStream>(stream);
         Assert.Equal(size, ((MemoryStream)stream).Capacity);
     }
@@ -96,6 +96,6 @@ public void NewStream_SizeUnderLimit_CreatesMemoryStream()
     public void NewStream_SizeOverLimit_Throws()
     {
         var size = 1024 * 1024 * 21; // 21 MB
-        Assert.Throws<InternalBufferOverflowException>(() => NUtils.NewStream(size));
+        Assert.Throws<InternalBufferOverflowException>(() => NHelper.NewStream(size));
     }
 }
diff --git a/test/Netly/NMessageTest.cs b/test/Netly/NMessageTest.cs
@@ -15,13 +15,13 @@ public void Start()
     {
         var header = NMessage.Create(Name, Message.LongLength);
         Assert.NotEmpty(header);
-        var payload = NUtils.ArrayConcat(header, Message);
+        var payload = NHelper.ArrayConcat(header, Message);
         Assert.NotEmpty(payload);
 
-        var stream = NUtils.NewStream(payload.LongLength);
+        var stream = NHelper.NewStream(payload.LongLength);
         stream.Write(payload);
         Assert.Equal(payload.LongLength, stream.Position);
-        Assert.True(NMessage.TryParse(stream, out var myName, out var myMessage, NUtils.NewStream));
+        Assert.True(NMessage.TryParse(stream, out var myName, out var myMessage, NHelper.NewStream));
         stream.Close();
         Assert.Equal(Name, myName);
         var data = new byte[myMessage.Length];

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`/// Provides general information about the Netly library,`
`5`	`5`	`/// including its name, version, Git repository, and supported protocols.`
`6`	`6`	`/// </summary>`
`7`		`- public static partial class NEnvironment`
	`7`	`+ public static class NEnvironment`
`8`	`8`	`{`
`9`	`9`	`/// <summary>`
`10`	`10`	`/// The name of the library.`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@ public partial class NTcp`
`4`	`4`	`{`
`5`	`5`	`public class Client`
`6`	`6`	`{`
`7`		`-`
`8`	`7`	`}`
`9`	`8`	`}`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,5 @@ namespace Netly`
`2`	`2`	`{`
`3`	`3`	`public partial class NTcp`
`4`	`4`	`{`
`5`		`-`
`6`	`5`	`}`
`7`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public class NTcpClient : INTcpClient`
`34`	`34`	`private NTcpClient()`
`35`	`35`	`{`
`36`	`36`	`_server = null;`
`37`		`- _onStream = NUtils.NewStream;`
	`37`	`+ _onStream = NHelper.NewStream;`
`38`	`38`	`Host = NHost.Default;`
`39`	`39`	`IsConnected = false;`
`40`	`40`	`SecureProtocol = SslProtocols.Default;`