Beispiel #1
0
        private void StartSending(Package package)
        {
            var buffer    = package.ToByteArray();
            var container = new SocketContainer(_deviceSocket, buffer);

            _deviceSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, SendingCallback, container);
        }
Beispiel #2
0
 protected virtual void _RecieveData(Socket connectedSocket)
 {
     Console.WriteLine(string.Format("[SERVER] - Ready to recieve on {0}", connectedSocket.LocalEndPoint));
     byte[]          buffer    = new byte[8192];
     SocketContainer container = new SocketContainer(connectedSocket, buffer);
     IAsyncResult    result    = connectedSocket.BeginReceive(container.Buffer, 0, container.Buffer.Length, SocketFlags.None, new AsyncCallback(OnRecievDataCallback), container);
 }
Beispiel #3
0
 private void ReceiveData(Socket connectedSocket)
 {
     var buffer    = new byte[BufferSize];
     var container = new SocketContainer(connectedSocket, buffer);
     var result    = connectedSocket.BeginReceive(container.Buffer, 0, container.Buffer.Length, SocketFlags.None,
                                                  OnReceiveDataCallback, container);
 }
Beispiel #4
0
 private static void _StartRecieving(Socket socket)
 {
     //  Console.WriteLine("[CLIENT] - Ready to recieve");
     byte[]       buffer    = new byte[8192];
     var          container = new SocketContainer(socket, buffer);
     IAsyncResult result    = socket.BeginReceive(buffer, 0, 8192, SocketFlags.None, new AsyncCallback(_OnRecievingCallback), container);
 }
Beispiel #5
0
        protected virtual void OnRecievDataCallback(IAsyncResult result)
        {
            SocketContainer container     = (SocketContainer)result.AsyncState;
            int             bytesRecieved = 0;

            try
            {
                bytesRecieved = container.ConnectionSocket.EndReceive(result);
            }
            catch (SocketException ex)
            {
                if (OnWrite != null)
                {
                    OnWrite(string.Format("[SERVER] - {0}", ex.Message));
                }
            }

            string buff = Encoding.UTF8.GetString(container.Buffer, 0, bytesRecieved);
            string cont = string.Format("[SERVER {0}] - Received message: ", Port) + buff;

            ProcessMsg(buff);
            OnWrite(cont);

            RecieveData(container.ConnectionSocket);
        }
Beispiel #6
0
 private void SendingData(SocketContainer container, int currentPosition)
 {
     IAsyncResult result =
         container
         .ConnectionSocket
         .BeginSend(container.Buffer, 0, currentPosition + 1, SocketFlags.None, new AsyncCallback(OnSendingCallback), container);
 }
Beispiel #7
0
        protected void StartSending(Socket socket, string msg)
        {
            byte[]          buffer    = Encoding.ASCII.GetBytes(msg);
            SocketContainer container = new SocketContainer(socket, buffer);

            socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(_OnSendingCallback), container);
        }
Beispiel #8
0
        protected virtual void OnRecievDataCallback(IAsyncResult result)
        {
            SocketContainer container     = (SocketContainer)result.AsyncState;
            int             bytesRecieved = 0;

            try
            {
                bytesRecieved = container.ConnectionSocket.EndReceive(result);
            }
            catch (SocketException ex)
            {
                Console.WriteLine(string.Format("[SERVER] - {0}", ex.Message));
            }

            Console.WriteLine(string.Format("[SERVER] - Received {0} bytes", bytesRecieved));
            Console.WriteLine();

            Console.WriteLine("[SERVER] - Buffer contents:");
            for (int i = 0; i < bytesRecieved; i++)
            {
                Console.Write(container.Buffer[i]);
            }
            Console.WriteLine();

            Console.WriteLine("[SERVER] - Buffer contents:");
            for (int i = 0; i < bytesRecieved; i++)
            {
                Console.Write((char)container.Buffer[i]);
            }
            Console.WriteLine();

            _RecieveData(container.ConnectionSocket);
        }
Beispiel #9
0
        protected static void _StartSending(Socket socket)
        {
            byte[]          buffer    = Encoding.ASCII.GetBytes("Hello, world!");
            SocketContainer container = new SocketContainer(socket, buffer);

            // Console.WriteLine("[CLIENT] - Begin sending data");
            socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(_OnSendingCallback), container);
        }
Beispiel #10
0
        protected void _OnSendingCallback(IAsyncResult result)
        {
            SocketContainer container = (SocketContainer)result.AsyncState;
            int             bytesSent = 0;

            try
            {
                bytesSent = container.ConnectionSocket.EndSend(result);
            }
            catch (SocketException ex)
            {
                //Console.WriteLine(string.Format("[CLIENT {1}] - {0}", ex.Message, Id));
            }
        }
Beispiel #11
0
        private static void _OnSendingCallback(IAsyncResult result)
        {
            SocketContainer container = (SocketContainer)result.AsyncState;
            int             bytesSent = 0;

            try
            {
                bytesSent = container.ConnectionSocket.EndSend(result);
                Console.WriteLine(string.Format("[SERVER] - Sent {0} bytes", bytesSent));
            }
            catch (SocketException ex)
            {
                Console.WriteLine(string.Format("[SERVER] - {0}", ex.Message));
            }
        }
Beispiel #12
0
        public void _OnRecievingCallback(IAsyncResult result)
        {
            SocketContainer container     = (SocketContainer)result.AsyncState;
            int             bytesRecieved = 0;

            try
            {
                bytesRecieved = container.ConnectionSocket.EndReceive(result);
            }
            catch (SocketException ex)
            {
                OnWrite(string.Format("[CLIENT {1}] - {0}", ex.Message, Id));
            }
            OnWrite(string.Format("[SERVER] - {0}", Encoding.UTF8.GetString(container.Buffer, 0, bytesRecieved)));
            StartRecieving(container.ConnectionSocket);
        }
Beispiel #13
0
        public static void _OnRecievingCallback(IAsyncResult result)
        {
            SocketContainer container     = (SocketContainer)result.AsyncState;
            int             bytesRecieved = 0;

            try
            {
                bytesRecieved = container.ConnectionSocket.EndReceive(result);
                //    Console.WriteLine(string.Format("[CLIENT] - Recieved {0} bytes", bytesRecieved));
            }
            catch (SocketException ex)
            {
                Console.WriteLine(string.Format("[CLIENT] - {0}", ex.Message));
            }
            //    Console.WriteLine("Bytes were:");
            Console.WriteLine(string.Format("[SERVER] - {0}", Encoding.UTF8.GetString(container.Buffer, 0, bytesRecieved)));
            _StartRecieving(container.ConnectionSocket);
        }
Beispiel #14
0
        private void OnSendingCallback(IAsyncResult result)
        {
            SocketContainer container = (SocketContainer)result.AsyncState;
            int             bytesSent = 0;

            try
            {
                bytesSent = container.ConnectionSocket.EndSend(result);
                if (OnWrite != null)
                {
                    OnWrite(string.Format("[SERVER {1}] - Sent {0} bytes\n", bytesSent, Port));
                }
            }
            catch (SocketException ex)
            {
                if (OnWrite != null)
                {
                    OnWrite(string.Format("[SERVER] - {0}", ex.Message));
                }
            }
        }
Beispiel #15
0
 protected static void _StartSending(Socket socket)
 {
     byte[] buffer = Encoding.ASCII.GetBytes("Hello, world!");
      SocketContainer container = new SocketContainer(socket, buffer);
      // Console.WriteLine("[CLIENT] - Begin sending data");
      socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(_OnSendingCallback), container);
 }
Beispiel #16
0
 private void StartRecieving(Socket socket)
 {
     byte[]       buffer    = new byte[8192];
     var          container = new SocketContainer(socket, buffer);
     IAsyncResult result    = socket.BeginReceive(buffer, 0, 8192, SocketFlags.None, new AsyncCallback(_OnRecievingCallback), container);
 }
Beispiel #17
0
 protected virtual void RecieveData(Socket connectedSocket)
 {
     byte[]          buffer    = new byte[8192];
     SocketContainer container = new SocketContainer(connectedSocket, buffer);
     IAsyncResult    result    = connectedSocket.BeginReceive(container.Buffer, 0, container.Buffer.Length, SocketFlags.None, new AsyncCallback(OnRecievDataCallback), container);
 }
Beispiel #18
0
 private static void _SendingData(SocketContainer container, int currentPosition)
 {
     IAsyncResult result =
     container
     .ConnectionSocket
     .BeginSend(container.Buffer, 0, currentPosition + 1, SocketFlags.None, new AsyncCallback(_OnSendingCallback), container);
 }
Beispiel #19
0
 protected virtual void _RecieveData(Socket connectedSocket)
 {
     Console.WriteLine(string.Format("[SERVER] - Ready to recieve on {0}", connectedSocket.LocalEndPoint));
      byte[] buffer = new byte[8192];
      SocketContainer container = new SocketContainer(connectedSocket, buffer);
      IAsyncResult result = connectedSocket.BeginReceive(container.Buffer, 0, container.Buffer.Length, SocketFlags.None, new AsyncCallback(OnRecievDataCallback), container);
 }
Beispiel #20
0
 private static void _StartRecieving(Socket socket)
 {
     //  Console.WriteLine("[CLIENT] - Ready to recieve");
      byte[] buffer = new byte[8192];
      var container = new SocketContainer(socket, buffer);
      IAsyncResult result = socket.BeginReceive(buffer, 0, 8192, SocketFlags.None, new AsyncCallback(_OnRecievingCallback), container);
 }