create NStream to be Stream extension?

alec1o · alec1o · commit b41e995663ea · 2025-09-10T14:46:59.000+02:00
diff --git a/src/netly/NStream.cs b/src/netly/NStream.cs
@@ -0,0 +1,25 @@
+using System.IO;
+
+namespace Netly
+{
+    public static class NStream
+    {
+        public static byte[] GetBytes(this Stream stream)
+        {
+            var position = stream.Position;
+
+            stream.Position = 0;
+            var bytes = new byte[stream.Length];
+            stream.Write(bytes, 0, bytes.Length);
+            stream.Position = position;
+            return bytes;
+        }
+
+        public static void FillWithBytes(this Stream stream, byte[] bytes)
+        {
+            stream.Position = 0;
+            stream.Write(bytes, 0, bytes.Length);
+            stream.Position = 0;
+        }
+    }
+}
diff --git a/src/tcp/interfaces/ITCP.ClientOn.cs b/src/tcp/interfaces/ITCP.ClientOn.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.IO;
 using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Cryptography.X509Certificates;
@@ -9,8 +10,8 @@ public static partial class ITCP
     {
         public interface ClientOn : IOn<Socket>
         {
-            void Data(Action<byte[]> callback);
-            void Event(Action<string, byte[]> callback);
+            void Data(Action<Stream> callback);
+            void Event(Action<string, Stream> callback);
             void Encryption(Func<X509Certificate, X509Chain, SslPolicyErrors, bool> callback);
         }
     }
diff --git a/src/tcp/partials/TCP.ClientOn.cs b/src/tcp/partials/TCP.ClientOn.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Cryptography.X509Certificates;
@@ -15,9 +16,9 @@ internal class ClientOn : ITCP.ClientOn
                 new List<Func<X509Certificate, X509Chain, SslPolicyErrors, bool>>();
 
             public EventHandler OnClose;
-            public EventHandler<byte[]> OnData;
+            public EventHandler<Stream> OnData;
             public EventHandler<Exception> OnError;
-            public EventHandler<(string name, byte[] buffer)> OnEvent;
+            public EventHandler<(string name, Stream buffer)> OnEvent;
             public EventHandler<Socket> OnModify;
             public EventHandler OnOpen;
 
@@ -42,12 +43,12 @@ public void Modify(Action<Socket> callback)
                 OnModify += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e));
             }
 
-            public void Data(Action<byte[]> callback)
+            public void Data(Action<Stream> callback)
             {
                 OnData += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e));
             }
 
-            public void Event(Action<string, byte[]> callback)
+            public void Event(Action<string, Stream> callback)
             {
                 OnEvent += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e.name, e.buffer));
             }
diff --git a/src/tcp/partials/TCP.ClientTo.cs b/src/tcp/partials/TCP.ClientTo.cs
@@ -106,7 +106,9 @@ public async Task Open(NHost host)
 
                     InitReceiver();
 
-                    _isOpening = false; // allow client send data on OnOpen callback.
+                    _isOpening = false;
+
+                    // allow client send data on OnOpen callback.
                     On.OnOpen?.Invoke(null, null);
                 }
                 catch (Exception e)
@@ -164,7 +166,7 @@ public void Data(byte[] data)
             {
                 if (CanSend == false || data == null || data.Length <= 0) return;
 
-                //SendDispatch(data);
+                SendDispatch(data);
             }
 
             public void Encryption(bool enable)
@@ -188,35 +190,40 @@ public void Data(string data)
             {
                 if (CanSend == false || string.IsNullOrEmpty(data)) return;
 
-                //  SendDispatch(data.GetBytes());
+                SendDispatch(data.GetBytes());
             }
 
             public void Data(string data, Encoding encoding)
             {
                 if (CanSend == false || string.IsNullOrEmpty(data)) return;
 
-                //SendDispatch(data.GetBytes(encoding));
+                SendDispatch(data.GetBytes(encoding));
             }
 
             public void Event(string name, byte[] data)
             {
                 if (CanSend == false || string.IsNullOrEmpty(name) || data == null || data.Length <= 0) return;
 
-                // SendDispatch(NetlyEnvironment.EventManager.Create(name, data));
+                var header = NMessage.Create(name, data.LongLength);
+                SendDispatch(header, data);
             }
 
             public void Event(string name, string data)
             {
                 if (CanSend == false || string.IsNullOrEmpty(data) || string.IsNullOrEmpty(name)) return;
 
-                //SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes()));
+                var bytes = data.GetBytes();
+                var header = NMessage.Create(name, bytes.LongLength);
+                SendDispatch(header, bytes);
             }
 
             public void Event(string name, string data, Encoding encoding)
             {
                 if (CanSend == false || string.IsNullOrEmpty(name) || string.IsNullOrEmpty(data)) return;
 
-                //SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes(encoding)));
+                var bytes = data.GetBytes(encoding);
+                var header = NMessage.Create(name, bytes.LongLength);
+                SendDispatch(header, bytes);
             }
 
             /* ---- INTERFACE --- */
@@ -338,32 +345,35 @@ await _sslStream.AuthenticateAsServerAsync
 
             private void PublishData(Stream stream)
             {
-                /*
-                if (Package.ParseMessage(bytes, out var name, out var data))
-                    On.OnEvent?.Invoke(null, (name, data));
+                if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))
+                {
+                    message.Position = 0;
+                    On.OnEvent?.Invoke(null, (name, message));
+                }
                 else
-                    On.OnData?.Invoke(null, bytes);*/
+                {
+                    stream.Position = 0;
+                    On.OnData?.Invoke(null, stream);
+                }
             }
 
-            private void SendDispatch(object package)
+            private void SendDispatch(params byte[][] buffers)
             {
-/*
                 if (_socket == null || _netStream == null || (IsEncrypted && _sslStream == null))
                 {
-                    package.Clear();
                     return;
                 }
 
                 try
                 {
-                    if (package == null || package.Count <= 0) return;
                     var stream = IsEncrypted ? (Stream)_sslStream : (Stream)_netStream;
-                    foreach (var segment in package.Segments) stream.WriteAsync(segment, 0, segment.Length);
+                    foreach (var bytes in buffers)
+                        stream.WriteAsync(bytes, 0, bytes.Length);
                 }
                 catch (Exception e)
                 {
-                    NetlyEnvironment.Logger.Create(e);
-                }*/
+                    NLogger.Singleton.Submit(e);
+                }
             }
 
             private void InitReceiver()
@@ -423,7 +433,7 @@ private void ReceiveHandler(IAsyncResult result)
                     }
                     else
                     {
-                        var stream = NUtils.NewStream(size); 
+                        var stream = NUtils.NewStream(size);
                         stream.Write(_buffer, 0, size);
                         PublishData(stream);
                     }
diff --git a/test/tcp/FixTcp.Broadcast.cs b/test/tcp/FixTcp.Broadcast.cs
@@ -90,8 +90,8 @@ void Client(NHost host)
             client.On.Close(() => isClose = true);
             client.On.Error(_ => isError = true);
             client.On.Modify(_ => isModify = true);
-            client.On.Data(bytes => client.To.Data(bytes));
-            client.On.Event((name, bytes) => client.To.Event(name, bytes));
+            client.On.Data(stream => client.To.Data(stream.GetBytes()));
+            client.On.Event((name, stream) => client.To.Event(name, stream.GetBytes()));
             {
                 Assert.False(client.IsOpened);
                 Assert.False(isOpen);
diff --git a/test/tcp/FixTcp.SendAndReceive.cs b/test/tcp/FixTcp.SendAndReceive.cs
@@ -28,7 +28,7 @@ async Task Server()
             {
                 client.On.Data(data =>
                 {
-                    client.To.Data(data);
+                    client.To.Data(data.GetBytes());
 
                     lock (dataLock)
                     {
@@ -38,7 +38,7 @@ async Task Server()
 
                 client.On.Event((name, data) =>
                 {
-                    client.To.Event(name, data);
+                    client.To.Event(name, data.GetBytes());
 
                     lock (eventLock)
                     {
@@ -101,8 +101,8 @@ void Client(NHost host, out Action check)
             client.On.Close(() => isClose = true);
             client.On.Error(_ => isError = true);
             client.On.Modify(_ => isModify = true);
-            client.On.Data(bytes => dataReceived.AddRange(bytes));
-            client.On.Event((name, bytes) => eventReceived = (name, bytes));
+            client.On.Data(stream => dataReceived.AddRange(stream.GetBytes()));
+            client.On.Event((name, stream) => eventReceived = (name, stream.GetBytes()));
             {
                 Assert.False(client.IsOpened);
                 Assert.False(isOpen);

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System;`
	`2`	`+using System.IO;`
`2`	`3`	`using System.Net.Security;`
`3`	`4`	`using System.Net.Sockets;`
`4`	`5`	`using System.Security.Cryptography.X509Certificates;`
`@@ -9,8 +10,8 @@ public static partial class ITCP`
`9`	`10`	`{`
`10`	`11`	`public interface ClientOn : IOn<Socket>`
`11`	`12`	`{`
`12`		`- void Data(Action<byte[]> callback);`
`13`		`- void Event(Action<string, byte[]> callback);`
	`13`	`+ void Data(Action<Stream> callback);`
	`14`	`+ void Event(Action<string, Stream> callback);`
`14`	`15`	`void Encryption(Func<X509Certificate, X509Chain, SslPolicyErrors, bool> callback);`
`15`	`16`	`}`
`16`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.IO;`
`3`	`4`	`using System.Net.Security;`
`4`	`5`	`using System.Net.Sockets;`
`5`	`6`	`using System.Security.Cryptography.X509Certificates;`
`@@ -15,9 +16,9 @@ internal class ClientOn : ITCP.ClientOn`
`15`	`16`	`new List<Func<X509Certificate, X509Chain, SslPolicyErrors, bool>>();`
`16`	`17`
`17`	`18`	`public EventHandler OnClose;`
`18`		`- public EventHandler<byte[]> OnData;`
	`19`	`+ public EventHandler<Stream> OnData;`
`19`	`20`	`public EventHandler<Exception> OnError;`
`20`		`- public EventHandler<(string name, byte[] buffer)> OnEvent;`
	`21`	`+ public EventHandler<(string name, Stream buffer)> OnEvent;`
`21`	`22`	`public EventHandler<Socket> OnModify;`
`22`	`23`	`public EventHandler OnOpen;`
`23`	`24`
`@@ -42,12 +43,12 @@ public void Modify(Action<Socket> callback)`
`42`	`43`	`OnModify += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e));`
`43`	`44`	`}`
`44`	`45`
`45`		`- public void Data(Action<byte[]> callback)`
	`46`	`+ public void Data(Action<Stream> callback)`
`46`	`47`	`{`
`47`	`48`	`OnData += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e));`
`48`	`49`	`}`
`49`	`50`
`50`		`- public void Event(Action<string, byte[]> callback)`
	`51`	`+ public void Event(Action<string, Stream> callback)`
`51`	`52`	`{`
`52`	`53`	`OnEvent += (@object, e) => NDispatcher.Singleton.Submit(() => callback?.Invoke(e.name, e.buffer));`
`53`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,9 @@ public async Task Open(NHost host)`
`106`	`106`
`107`	`107`	`InitReceiver();`
`108`	`108`
`109`		`- _isOpening = false; // allow client send data on OnOpen callback.`
	`109`	`+ _isOpening = false;`
	`110`	`+`
	`111`	`+ // allow client send data on OnOpen callback.`
`110`	`112`	`On.OnOpen?.Invoke(null, null);`
`111`	`113`	`}`
`112`	`114`	`catch (Exception e)`
`@@ -164,7 +166,7 @@ public void Data(byte[] data)`
`164`	`166`	`{`
`165`	`167`	`if (CanSend == false \|\| data == null \|\| data.Length <= 0) return;`
`166`	`168`
`167`		`- //SendDispatch(data);`
	`169`	`+ SendDispatch(data);`
`168`	`170`	`}`
`169`	`171`
`170`	`172`	`public void Encryption(bool enable)`
`@@ -188,35 +190,40 @@ public void Data(string data)`
`188`	`190`	`{`
`189`	`191`	`if (CanSend == false \|\| string.IsNullOrEmpty(data)) return;`
`190`	`192`
`191`		`- // SendDispatch(data.GetBytes());`
	`193`	`+ SendDispatch(data.GetBytes());`
`192`	`194`	`}`
`193`	`195`
`194`	`196`	`public void Data(string data, Encoding encoding)`
`195`	`197`	`{`
`196`	`198`	`if (CanSend == false \|\| string.IsNullOrEmpty(data)) return;`
`197`	`199`
`198`		`- //SendDispatch(data.GetBytes(encoding));`
	`200`	`+ SendDispatch(data.GetBytes(encoding));`
`199`	`201`	`}`
`200`	`202`
`201`	`203`	`public void Event(string name, byte[] data)`
`202`	`204`	`{`
`203`	`205`	`if (CanSend == false \|\| string.IsNullOrEmpty(name) \|\| data == null \|\| data.Length <= 0) return;`
`204`	`206`
`205`		`- // SendDispatch(NetlyEnvironment.EventManager.Create(name, data));`
	`207`	`+ var header = NMessage.Create(name, data.LongLength);`
	`208`	`+ SendDispatch(header, data);`
`206`	`209`	`}`
`207`	`210`
`208`	`211`	`public void Event(string name, string data)`
`209`	`212`	`{`
`210`	`213`	`if (CanSend == false \|\| string.IsNullOrEmpty(data) \|\| string.IsNullOrEmpty(name)) return;`
`211`	`214`
`212`		`- //SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes()));`
	`215`	`+ var bytes = data.GetBytes();`
	`216`	`+ var header = NMessage.Create(name, bytes.LongLength);`
	`217`	`+ SendDispatch(header, bytes);`
`213`	`218`	`}`
`214`	`219`
`215`	`220`	`public void Event(string name, string data, Encoding encoding)`
`216`	`221`	`{`
`217`	`222`	`if (CanSend == false \|\| string.IsNullOrEmpty(name) \|\| string.IsNullOrEmpty(data)) return;`
`218`	`223`
`219`		`- //SendDispatch(NetlyEnvironment.EventManager.Create(name, data.GetBytes(encoding)));`
	`224`	`+ var bytes = data.GetBytes(encoding);`
	`225`	`+ var header = NMessage.Create(name, bytes.LongLength);`
	`226`	`+ SendDispatch(header, bytes);`
`220`	`227`	`}`
`221`	`228`
`222`	`229`	`/* ---- INTERFACE --- */`
`@@ -338,32 +345,35 @@ await _sslStream.AuthenticateAsServerAsync`
`338`	`345`
`339`	`346`	`private void PublishData(Stream stream)`
`340`	`347`	`{`
`341`		`- /*`
`342`		`- if (Package.ParseMessage(bytes, out var name, out var data))`
`343`		`- On.OnEvent?.Invoke(null, (name, data));`
	`348`	`+ if (NMessage.TryParse(stream, out var name, out var message, NUtils.NewStream))`
	`349`	`+ {`
	`350`	`+ message.Position = 0;`
	`351`	`+ On.OnEvent?.Invoke(null, (name, message));`
	`352`	`+ }`
`344`	`353`	`else`
`345`		`- On.OnData?.Invoke(null, bytes);*/`
	`354`	`+ {`
	`355`	`+ stream.Position = 0;`
	`356`	`+ On.OnData?.Invoke(null, stream);`
	`357`	`+ }`
`346`	`358`	`}`
`347`	`359`
`348`		`- private void SendDispatch(object package)`
	`360`	`+ private void SendDispatch(params byte[][] buffers)`
`349`	`361`	`{`
`350`		`-/*`
`351`	`362`	`if (_socket == null \|\| _netStream == null \|\| (IsEncrypted && _sslStream == null))`
`352`	`363`	`{`
`353`		`- package.Clear();`
`354`	`364`	`return;`
`355`	`365`	`}`
`356`	`366`
`357`	`367`	`try`
`358`	`368`	`{`
`359`		`- if (package == null \|\| package.Count <= 0) return;`
`360`	`369`	`var stream = IsEncrypted ? (Stream)_sslStream : (Stream)_netStream;`
`361`		`- foreach (var segment in package.Segments) stream.WriteAsync(segment, 0, segment.Length);`
	`370`	`+ foreach (var bytes in buffers)`
	`371`	`+ stream.WriteAsync(bytes, 0, bytes.Length);`
`362`	`372`	`}`
`363`	`373`	`catch (Exception e)`
`364`	`374`	`{`
`365`		`- NetlyEnvironment.Logger.Create(e);`
`366`		`- }*/`
	`375`	`+ NLogger.Singleton.Submit(e);`
	`376`	`+ }`
`367`	`377`	`}`
`368`	`378`
`369`	`379`	`private void InitReceiver()`
`@@ -423,7 +433,7 @@ private void ReceiveHandler(IAsyncResult result)`
`423`	`433`	`}`
`424`	`434`	`else`
`425`	`435`	`{`
`426`		`- var stream = NUtils.NewStream(size);`
	`436`	`+ var stream = NUtils.NewStream(size);`
`427`	`437`	`stream.Write(_buffer, 0, size);`
`428`	`438`	`PublishData(stream);`
`429`	`439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ async Task Server()`
`28`	`28`	`{`
`29`	`29`	`client.On.Data(data =>`
`30`	`30`	`{`
`31`		`- client.To.Data(data);`
	`31`	`+ client.To.Data(data.GetBytes());`
`32`	`32`
`33`	`33`	`lock (dataLock)`
`34`	`34`	`{`
`@@ -38,7 +38,7 @@ async Task Server()`
`38`	`38`
`39`	`39`	`client.On.Event((name, data) =>`
`40`	`40`	`{`
`41`		`- client.To.Event(name, data);`
	`41`	`+ client.To.Event(name, data.GetBytes());`
`42`	`42`
`43`	`43`	`lock (eventLock)`
`44`	`44`	`{`
`@@ -101,8 +101,8 @@ void Client(NHost host, out Action check)`
`101`	`101`	`client.On.Close(() => isClose = true);`
`102`	`102`	`client.On.Error(_ => isError = true);`
`103`	`103`	`client.On.Modify(_ => isModify = true);`
`104`		`- client.On.Data(bytes => dataReceived.AddRange(bytes));`
`105`		`- client.On.Event((name, bytes) => eventReceived = (name, bytes));`
	`104`	`+ client.On.Data(stream => dataReceived.AddRange(stream.GetBytes()));`
	`105`	`+ client.On.Event((name, stream) => eventReceived = (name, stream.GetBytes()));`
`106`	`106`	`{`
`107`	`107`	`Assert.False(client.IsOpened);`
`108`	`108`	`Assert.False(isOpen);`