/// <summary>
 /// Send response
 /// </summary>
 /// <param name="size"></param>
 protected void SendResponse(int size)
 {
     try
     {
         messageManager.Send(socket, responseObject, 0, size);
     }
     catch
     {
         responseObject.Dispose();
     }
 }
Beispiel #2
0
    public void SendMessage(Message msg, bool startTimer = false)
    {
        msg.ctrl = (byte)ESAFlag.Seq;
        UInt16 len = msg.GetLength();

        msg.len = len;
        msg.seq = GetCliSeq();
        _ringSendMsgAckBuffer[msg.seq] = msg;

        _sender.Send(msg);
    }
Beispiel #3
0
        /// <summary>
        /// Send response
        /// </summary>
        /// <param name="size"></param>
        protected void SendResponse(int size)
        {
            var _r = responseObject;

            responseObject = null;
            try
            {
                messageManager.Send(socket, _r, 0, size);
            }
            catch
            {
                messageManager.Return(_r);
            }
        }
Beispiel #4
0
        private void ChunkedSend(NetworkSender sender, byte[] buffer)
        {
            int tosend = buffer.Length;
            int pos    = 0;

            while (tosend > 0)
            {
                int chunksize = tosend;
                if (chunksize > MaxMessageSize)
                {
                    if (OnOverflow == OverflowAction.Discard)
                    {
                        return;
                    }

                    if (OnOverflow == OverflowAction.Error)
                    {
                        throw new OverflowException("Attempted to send a message larger than MaxMessageSize(" + MaxMessageSize + "). Actual size was: " + buffer.Length + ". Adjust OnOverflow and MaxMessageSize parameters accordingly.");
                    }

                    chunksize = MaxMessageSize;
                }
                sender.Send(buffer, pos, chunksize);
                tosend -= chunksize;
                pos    += chunksize;
            }
        }
		static void Main(string[] args)
		{
			Stack<String> container = new Stack<string>();

			container.Push("Message 1");
			container.Push("Message 2");
			container.Push("Message 3");
			container.Push(ConstantsHelper.ERROR_SIGNAL);
			container.Push("Message 4");
			container.Push("Message 5");

			INetworkSender<string> sender = new NetworkSender(new NetworkService());

			sender.Sent += Sender_Sent;

			sender.AddToBuffer(container);

			sender.AddToBuffer("Message 6");
			sender.AddToBuffer("Message 7");

			//To find the error code generation find a comment.
			//"HACK: For generate error."

			try
			{
				sender.Send();
			}
			catch (Exception ex)
			{
				Console.WriteLine();
				Console.WriteLine(ex.ToString());
				Console.WriteLine();
			}

			sender.Send();

			sender.Sent -= Sender_Sent;

			(sender as IDisposable)?.Dispose();

			Console.ReadKey();
		}
Beispiel #6
0
        private void ChunkedSend(NetworkSender sender, byte[] buffer, AsyncContinuation continuation)
        {
            int tosend = buffer.Length;
            int pos    = 0;

            AsyncContinuation sendNextChunk = null;



            sendNextChunk = ex =>
            {
                if (ex != null)
                {
                    continuation(ex);
                    return;
                }
                InternalLogger.Trace("Sending chunk, position: {0}, length: {1}", pos, tosend);
                if (tosend <= 0)
                {
                    continuation(null);
                    return;
                }

                int chunksize = tosend;
                if (chunksize > MaxMessageSize)
                {
                    if (OnOverflow == NetworkTargetOverflowAction.Discard)
                    {
                        InternalLogger.Trace("discard because chunksize > this.MaxMessageSize");
                        continuation(null);
                        return;
                    }

                    if (OnOverflow == NetworkTargetOverflowAction.Error)
                    {
                        continuation(new OverflowException("Attempted to send a message larger than MaxMessageSize (" + MaxMessageSize + "). Actual size was: " + buffer.Length + ". Adjust OnOverflow and MaxMessageSize parameters accordingly."));
                        return;
                    }

                    chunksize = MaxMessageSize;
                }

                int pos0 = pos;
                tosend -= chunksize;
                pos    += chunksize;

                sender.Send(buffer, pos0, chunksize, sendNextChunk);
            };

            sendNextChunk(null);
        }
Beispiel #7
0
        private void ChunkedSend(NetworkSender sender, byte[] buffer, AsyncContinuation continuation)
        {
            var tosend = buffer.Length;
            var pos    = 0;

            AsyncContinuation sendNextChunk = null;

            sendNextChunk = ex =>
            {
                if (ex != null)
                {
                    continuation(ex);
                    return;
                }

                if (tosend <= 0)
                {
                    continuation(null);
                    return;
                }

                var chunksize = tosend;
                if (chunksize > MaxMessageSize)
                {
                    if (OnOverflow == NetworkTargetOverflowAction.Discard)
                    {
                        continuation(null);
                        return;
                    }

                    if (OnOverflow == NetworkTargetOverflowAction.Error)
                    {
                        continuation(new OverflowException("Attempted to send a message larger than MaxMessageSize (" + MaxMessageSize + "). Actual size was: " + buffer.Length + ". Adjust OnOverflow and MaxMessageSize parameters accordingly."));
                        return;
                    }

                    chunksize = MaxMessageSize;
                }

                var pos0 = pos;
                tosend -= chunksize;
                pos    += chunksize;

                sender.Send(buffer, pos0, chunksize, sendNextChunk);
            };

            sendNextChunk(null);
        }
 protected void SendResponse(int size) => messageManager.Send(socket, responseObject, 0, size);
Beispiel #9
0
        private void ChunkedSend(NetworkSender sender, byte[] buffer, AsyncContinuation continuation)
        {
            int tosend = buffer.Length;

            if (tosend <= MaxMessageSize)
            {
                // Chunking is not needed, no need to perform delegate capture
                InternalLogger.Trace("Sending chunk, position: {0}, length: {1}", 0, tosend);
                if (tosend <= 0)
                {
                    continuation(null);
                    return;
                }

                sender.Send(buffer, 0, tosend, continuation);
            }
            else
            {
                int pos = 0;

                AsyncContinuation sendNextChunk = null;

                sendNextChunk = ex =>
                {
                    if (ex != null)
                    {
                        continuation(ex);
                        return;
                    }
                    InternalLogger.Trace("NetworkTarget(Name={0}): Sending chunk, position: {1}, length: {2}", Name, pos, tosend);
                    if (tosend <= 0)
                    {
                        continuation(null);
                        return;
                    }

                    int chunksize = tosend;
                    if (chunksize > MaxMessageSize)
                    {
                        if (OnOverflow == NetworkTargetOverflowAction.Discard)
                        {
                            InternalLogger.Trace("NetworkTarget(Name={0}): Discard because chunksize > this.MaxMessageSize", Name);
                            continuation(null);
                            return;
                        }

                        if (OnOverflow == NetworkTargetOverflowAction.Error)
                        {
                            continuation(new OverflowException($"Attempted to send a message larger than MaxMessageSize ({MaxMessageSize}). Actual size was: {buffer.Length}. Adjust OnOverflow and MaxMessageSize parameters accordingly."));
                            return;
                        }

                        chunksize = MaxMessageSize;
                    }

                    int pos0 = pos;
                    tosend -= chunksize;
                    pos    += chunksize;

                    sender.Send(buffer, pos0, chunksize, sendNextChunk);
                };

                sendNextChunk(null);
            }
        }
Beispiel #10
0
 // Send
 public void Send(ServerMessage messageType, params object[] arguments)
 {
     NetworkSender.Send(connectionId, (MessageType)messageType, arguments);
 }