Network Library

Einfaches und schnelles Versenden und Empfangen von Daten, ohne auf den Komfort der Objektorientierten Programmierung verzichten zu müssen. Aufgrund der TCP und UDP Protokollunterstützung können Daten sicher und zuverlässig oder schnell an ihr Ziel gelangen.

Funktionsweise

Von “Packet” abgeleitete Objekte können einfach und schnell versendet werden. Die Netzwerk Library extrahiert Mithilfe von Reflection alle Objektdaten und schreibt diese, mit einem Overhead von 48 bit, auf den gewünschten Stream.

Overhead

Eckdaten

  • TCP/UDP und Bluetooth Unterstützung
  • Arbeiten mit Objekten
  • Sorgenloses Senden und Empfangen
    • Automatische Verbindungswiederherstellung
    • TCP RTT: 15 – 30ms (GAN) *
    • UDP RTT: 5 – 10ms (GAN)
    • TCP RTT: 4 – 10ms (LAN)
    • UDP RTT: 4 –  8ms (LAN)
  • Sehr geringer Overhead, trotz Objektorientierung
  • Eventbasiert
  • Maximal 65536 individuelle Pakete möglich
  • Maximale Paketlänge von 4294967296 bytes. (4,096 GB)
  • RSA Verschlüsselung

* Best case

Anforderungen

  • .net 4.6 >
  • .NET Core 2.0 >
  • Mono >= 5.4
  • Xamarin.iOS >= 10.14
  • Xamarin.MAC >= 3.8
  • Xamarin.Andriod >= 8.0
  • UWP >= 10.0.16299
  • .NET Standard 2.0

Unterstützte Datentypen

Folgende Datentypen können in einem Netzwerkpaket verwendet werden.Supported types

Klassendiagramm

ClassDiagram_3.0.0.0_packets

BluetoothClassDiagram

Einfaches Beispiel

Client

    public class AsyncExample
    {
        public async void Demo()
        {
            //1. Establish a connection to the server.
            ClientConnectionContainer container = ConnectionFactory.CreateClientConnectionContainer("127.0.0.1", 1234);
            //2. Register what happens if we get a connection
            container.ConnectionEstablished += async (connection, type) =>
            {
                Console.WriteLine($"{type.ToString()} Connection established");
                //3. Send a request packet async and directly receive an answer.
                CalculationResponse response = await connection.SendAsync<CalculationResponse>(new CalculationRequest(10, 10));
                Console.WriteLine($"Answer received {response.Result}");
            };
        }
    }

Server

    public class Program
    {
        static void Main(string[] args)
        {
            new Program().Demo();
            Console.ReadLine();
        }

        private ServerConnectionContainer serverConnectionContainer;

        public void Demo()
        {
            //1. Start listen on a port
            serverConnectionContainer = ConnectionFactory.CreateServerConnectionContainer(1234);

            //2. Apply optional settings.
            #region Optional settings
            serverConnectionContainer.ConnectionLost += (a, b, c) => Console.WriteLine($"{serverConnectionContainer.Count} {b.ToString()} Connection lost {a.IPRemoteEndPoint.Port}. Reason {c.ToString()}");
            serverConnectionContainer.ConnectionEstablished += connectionEstablished;
            serverConnectionContainer.AllowUDPConnections = true;
            serverConnectionContainer.UDPConnectionLimit = 2;
            #endregion Optional settings
        }

        /// <summary>
        /// We got a connection.
        /// </summary>
        /// <param name="connection">The connection we got. (TCP or UDP)</param>
        private void connectionEstablished(Connection connection, ConnectionType type)
        {
            Console.WriteLine($"{serverConnectionContainer.Count} {connection.GetType()} connected on port {connection.IPRemoteEndPoint.Port}");

            //3. Register packet listeners.
            connection.RegisterStaticPacketHandler<CalculationRequest>(calculationReceived);
        }

        /// <summary>
        /// If the client sends us a calculation request, it will end up here.
        /// </summary>
        /// <param name="packet">The calculation packet.</param>
        /// <param name="connection">The connection who was responsible for the transmission.</param>
        private static void calculationReceived(CalculationRequest packet, Connection connection)
        {
            //4. Handle incoming packets.
            connection.Send(new CalculationResponse(packet.X + packet.Y, packet));
        }
    }
0 0 vote
Article Rating
Subscribe
Notify of
0 Comments
Inline Feedbacks
View all comments