NetAio 0.9.17

NetAio

Netaio is a portable high performance sockets library for .Net. The library is based on Windows IO Completion ports.

Using

Connect to a host

// Inherit from INetEventHandle to handle network events
public class Client : INetEventHandle
{
	public void OnConnect(INetAio aio)
    {    
        Console.WriteLine($"Connect to server success!");
    }

	public void OnDisconnect(INetAio aio)
    {
        Console.WriteLine($"Disconnect from server!");
    }

	public void OnRead(INetAio aio, byte[] data, int size)
    {
        Console.WriteLine($"Received {size} bytes data");
    }

	public void OnError(Error err)
    {
        Console.WriteLine($"{err}");
    }
}

public class Program
{
    bool quit = false;

    static void Main(string[] args)
    {
        // Connect to 127.0.0.1:1111 
        var (c, err) = NetAio.Connect("127.0.0.1:1111", new Client());
        if (err != null)
        {
            return;
        }

        // main loop
        while (!quit)
        {
            // do something
        }

        // Close on quit
        c.Close();
    }
}

Listen an address

// Inherit from INetEventHandle to handle network events, same as Client
public class Server: INetEventHandle
{
	public void OnConnect(INetAio aio)
    {    
        Console.WriteLine($"Client {aio.ID} connected");
    }

	public void OnDisconnect(INetAio aio)
    {
        Console.WriteLine($"Client {aio.ID} disconnected");
    }

	public void OnRead(INetAio aio, byte[] data, int size)
    {
        Console.WriteLine($"Received {size} bytes data from Client {aio.ID} ");
    }

	public void OnError(Error err)
    {
        Console.WriteLine($"{err}");
    }
}

public class Program
{
    bool quit = false;

    static void Main(string[] args)
    {
        // Listen on port 1111 
        var (l, err) = NetAio.Listen("0.0.0.0:1111", new Server());
        if (err != null)
        {
            return;
        }

        // main loop
        while (!quit)
        {
            // do something
        }

        // Close on quit
        l.Close();
    }
}

Interface

INetAio

	public interface INetAio
	{
        // unique ID
		uint ID { get; }

        // Hold your user datas
		object UserData { get; set; }

        // Socket
		Socket Socket { get; }

        // Local end point
		EndPoint LocalEndPoint { get; }

        // Remote end point
		EndPoint RemoteEndPoint { get; }

        // Write all bytes in data array
		void Write(byte[] data);

        // Write data with offset and count
		void Write(byte[] data, int offset, int count);

        // Close netaio
		void Close();

        // Check if closed
		bool Closed { get; }
	}

INetEventHandler

    // Base interface
	public interface INetEventHandler
	{
        // On connect event
		void OnConnect(INetAio aio);

        // On disconnect event
		void OnDisconnect(INetAio aio);

        // On read event
		void OnRead(INetAio aio, byte[] data, int size);

        // On error occurs
		void OnError(Error err);
	}

    // If you don't want extend INetEventHandler, use this instead to register events your own
    public class NetEventHandler : INetEventHandler
    {
		public Action<INetAio> OnConnectEventHandler;
		public Action<INetAio> OnDisconnectEventHandler;
		public Action<INetAio, byte[], int> OnReadEventHandler;
		public Action<Error> OnErrorEventHandler;

		public void OnConnect(INetAio aio)
		{    
			OnConnectEventHandler?.Invoke(aio);
		}

		public void OnDisconnect(INetAio aio)
		{
			OnDisconnectEventHandler?.Invoke(aio);
		}

		public void OnRead(INetAio aio, byte[] data, int size)
		{
			OnReadEventHandler?.Invoke(aio, data, size);
		}

		public void OnError(Error err)
		{
			OnErrorEventHandler?.Invoke(err);
		}
	}

    // If you what handle network event in same thread, use NetEventChanel instead
	public class NetEventChannel : INetEventHandler
	{
        // Construct with your handler
		public NetEventChannel(INetEventHandler handler);

        // Call update in your main thread
		public void Update();
	}

NetAio

	public static class NetAio
	{
        // Listen address
		public static (INetListener, Error) Listen(string address, INetEventHandler handler);

        // Listen address with tcp protcol
		private static (INetListener, Error) ListenTcp(string address, INetEventHandler handler);
        
        // Connect to an address
		public static (INetConnector, Error) Connect(string address, INetEventHandler handler);

        // Connect to an address with tcp protcol
		private static (INetConnector, Error) ConnectTcp(string address, INetEventHandler handler);
	}

PacketQueue

    // This class is use to handle 4 bytes size header lead packet
	public class PacketQueue
	{
        // Remain packet count
		public int Count;

        // Construct with packet max length
		public PacketQueue(int packetMaxLength = 65535);

        // Dequeue a packet
		public byte[] Dequeue();

        // Append data
		public Error AppendBytes(byte[] data, int size);
	}