/// <summary> /// Initializes a new instance of the ReliableUdpConnectionRecord /// to send message /// </summary> /// <param name="key">EndPoint and TransmissionId key</param> /// <param name="tcb">Connection control block. <see cref="ReliableUdpConnectionControlBlock"/></param> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="cToken">CancellationToken</param> /// <param name="asyncResult"><see cref="AsyncResultSendMessage"/></param> /// <exception cref="ArgumentNullException"><paramref name="key"/> or <paramref name="tcb"/> is a null reference</exception> public ReliableUdpConnectionRecord(Tuple <EndPoint, Int32> key, ReliableUdpConnectionControlBlock tcb, ReliableUdpMessage reliableUdpMessage, CancellationToken cToken, AsyncResultSendMessage asyncResult) : this(key, tcb) { if (reliableUdpMessage == null) { throw new ArgumentNullException("reliableUdpMessage"); } if (reliableUdpMessage.Body == null || reliableUdpMessage.Body.Length == 0) { throw new ArgumentNullException("reliableUdpMessage", "reliableUdpMessage.Body can not be null."); } CToken = cToken; this.AsyncResult = asyncResult; this.ReliableUdpMessageType = reliableUdpMessage.Type; this.IsNoAnswerNeeded = reliableUdpMessage.NoAsk; //RU: добавляем содержимое ReliableUdpMessage в словарь ReliableUdpConnectionControlBlock'a //EN: fills the array of outcoming message with message bytes this.OutcomingStream = Tcb.OutcomingStreams.GetOrAdd(key, reliableUdpMessage.Body); //RU: Расчитываем количество пакетов необходимых для отправки сообщения this.NumberOfPackets = (int)Math.Ceiling((double)((double)OutcomingStream.Length / (double)this.BufferSize)); //RU: переключаем состояние на отправку первого пакета //EN: set initial state this.State = Tcb.States.FirstPacketSending; }
/// <summary> /// Passes message to subscribers /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/></param> /// <param name="remoteClient">Endpoint of sender</param> internal void PassMessageToSubscribers(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient) { try { //EN: To protect from calling removed callback delegate System.Threading.Monitor.Enter(m_locker); foreach (ReliableUdpSubscribeObject subscriber in m_subscribers) { bool isRequiredEp = (subscriber.IpEndPoint == null) || ((subscriber.IpEndPoint.Port == 0) && subscriber.IpEndPoint.Address.Equals(remoteClient.Address)) || (subscriber.IpEndPoint.Equals(remoteClient)); bool isRequiredMessageType = (subscriber.ReliableUdpMessageType == ReliableUdpMessageTypes.Any) || (subscriber.ReliableUdpMessageType == reliableUdpMessage.Type); if (isRequiredEp && isRequiredMessageType) { if (subscriber.ReliableUdpMessageCallback != null) { subscriber.ReliableUdpMessageCallback(reliableUdpMessage, remoteClient); } } } } finally { System.Threading.Monitor.Exit(m_locker); } }
public Task <bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken) { TaskFactory <bool> taskFactory = new TaskFactory <bool>(cToken); return(taskFactory.FromAsync(BeginSendTask, EndSend, new WrappedBeginSendParameters(reliableUdpMessage, remoteEndPoint, cToken), null)); }
/// <summary> /// Initializes a new instance of the AsyncResultSendMessage /// </summary> /// <param name="reliableUdpMessage">Message to send</param> /// <param name="endPoint">Remote endpoint</param> /// <param name="asyncCallback">asyncCallback method</param> /// <param name="state">An object that contains state information for this request</param> /// <param name="owner">Object who calls the BeginSend method (instance of <see cref="ReliableUdpConnectionControlBlock"/>)</param> public AsyncResultSendMessage(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, CancellationToken cToken, AsyncCallback asyncCallback, object state, object owner) : base(asyncCallback, state, owner) { ReliableUdpMessage = reliableUdpMessage; EndPoint = endPoint; Token = cToken; }
/// <summary> /// Creates message /// </summary> /// <param name="connectionRecord">Current <see cref="ReliableUdpConnectionRecord"/> (ConnectionRecord)</param> internal static void CreateMessageFromMemoryStream(ReliableUdpConnectionRecord connectionRecord) { ReliableUdpMessage msg = new ReliableUdpMessage(connectionRecord.ReliableUdpMessageType, connectionRecord.Tcb.IncomingStreams[connectionRecord.Key], connectionRecord.IsNoAnswerNeeded); connectionRecord.Tcb.PassMessageToSubscribers(msg, connectionRecord.RemoteClient); Debug.WriteLine("Done {0}!", connectionRecord.TransmissionId); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> asynchronously to the specified endpoint. /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <param name="callback">The <see cref="AsyncCallback"/> delegate.</param> /// <param name="state">An object that contains state information for this request.</param> /// <returns>An IAsyncResult that references the asynchronous send.</returns> public IAsyncResult BeginSend(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback callback, Object state) { //RU: упаковали данные в собственный AsyncResult //EN: wrapped data in our own AsyncResult AsyncResultSendMessage ar = new AsyncResultSendMessage(reliableUdpMessage, remoteEndPoint, CancellationToken.None, callback, state, this); ThreadPool.QueueUserWorkItem(StartTransmissionHelper, ar); return(ar); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> pseudo-synchronously to the specified endpoint. /// </summary> /// <remarks>Asynchronous methods of sending and receiving packets are actually used. /// But initial start of sending is carried out in the current thread. /// If <see cref="ReliableUdpMessage.NoAsk"/> is set to <c>true</c> than method returns only when /// all packets will be sent.</remarks> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public void SendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint) { StartTransmission(reliableUdpMessage, remoteEndPoint, CancellationToken.None, null); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> pseudo-synchronously to the specified endpoint. /// </summary> /// <remarks>Asynchronous methods of sending and receiving packets are actually used. /// But initial start of sending is carried out in the current thread. /// If <see cref="ReliableUdpMessage.NoAsk"/> is set to <c>true</c> than method returns only when /// all packets will be sent.</remarks> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public void SendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint) { m_tcb.SendMessage(reliableUdpMessage, remoteEndPoint); }
public WrappedBeginSendParameters( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken ) { ReliableUdpMessage = reliableUdpMessage; RemoteEndPoint = remoteEndPoint; Token = cToken; }
/// <summary> /// Creates new ReliableUdpConnectionRecord and starts finite state automaton /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="endPoint">Ip endpoint of recipient of the message.</param> /// <param name="asyncResult"><see cref="AsyncResultSendMessage"/> object</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <returns></returns> private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, CancellationToken cToken, AsyncResultSendMessage asyncResult) { try { if (m_isListenerStarted == 0) { if (this.LocalEndpoint == null) { throw new ArgumentNullException( "", "You must use constructor with parameters or start listener before sending message" ); } StartListener(LocalEndpoint); } //RU: создаем ключ для словаря, на основе EndPoint и ReliableUdpHeader.TransmissionId //EN: create key based on EndPoint and ReliableUdpHeader.TransmissionId for dictionary byte[] transmissionId = new byte[4]; //RU: только криптопровайдер! random выдает одинаковые номера для двух одновременно созданных TCB //EN: should use only cryptographic random function. System.Random gives the same values for two //EN: or more ConnnectionControlBlock created at the same time m_randomCrypto.GetBytes(transmissionId); Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); Debug.WriteLine("Transmission Id is {0}", key.Item2); //EN: make two attemps to add key into dictionary if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, cToken, asyncResult))) { m_randomCrypto.GetBytes(transmissionId); key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage,cToken, asyncResult))) throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary"); } //RU: запустили состояние в обработку. //EN: run state handling m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]); } //RU: Все исключения в состояниях обрабатываются отдельно //RU: здесь ловятся только те, которые могут появиться до запуска конечного автомата //EN: All exceptions that raised in states are handled separately catch (ArgumentNullException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ArgumentOutOfRangeException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ArgumentException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ReliableUdpConfigurationException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } }
/// <summary> /// Passes message to subscribers /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/></param> /// <param name="remoteClient">Endpoint of sender</param> internal void PassMessageToSubscribers( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient ) { try { //EN: To protect from calling removed callback delegate System.Threading.Monitor.Enter( m_locker ); foreach ( ReliableUdpSubscribeObject subscriber in m_subscribers ) { bool isRequiredEp = (subscriber.IpEndPoint == null) || ((subscriber.IpEndPoint.Port == 0) && subscriber.IpEndPoint.Address.Equals( remoteClient.Address )) || (subscriber.IpEndPoint.Equals( remoteClient )); bool isRequiredMessageType = (subscriber.ReliableUdpMessageType == ReliableUdpMessageTypes.Any) || (subscriber.ReliableUdpMessageType == reliableUdpMessage.Type); if ( isRequiredEp && isRequiredMessageType ) { if ( subscriber.ReliableUdpMessageCallback != null ) subscriber.ReliableUdpMessageCallback( reliableUdpMessage, remoteClient ); } } } finally { System.Threading.Monitor.Exit( m_locker ); } }
public Task<bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken) { TaskFactory<bool> taskFactory = new TaskFactory<bool>(cToken); return taskFactory.FromAsync(BeginSendTask, EndSend, new WrappedBeginSendParameters(reliableUdpMessage, remoteEndPoint, cToken), null); }
/// <summary> /// Creates message /// </summary> /// <param name="connectionRecord">Current <see cref="ReliableUdpConnectionRecord"/> (ConnectionRecord)</param> internal static void CreateMessageFromMemoryStream(ReliableUdpConnectionRecord connectionRecord) { ReliableUdpMessage msg = new ReliableUdpMessage(connectionRecord.ReliableUdpMessageType, connectionRecord.Tcb.IncomingStreams[connectionRecord.Key], connectionRecord.IsNoAnswerNeeded); connectionRecord.Tcb.PassMessageToSubscribers(msg, connectionRecord.RemoteClient); Debug.WriteLine("Done {0}!", connectionRecord.TransmissionId); }
/// <summary> /// Sends message async (can be used with .net 4 framework) /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <returns><c>true</c> if the message was successfully sent. /// <c>false</c> if sending the message was interrupted on a timeout.</returns> /// <exception cref="AggregateException">Contains one or more errors that occur during application execution.</exception> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public Task <bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint) { return(m_tcb.SendMessageAsync(reliableUdpMessage, remoteEndPoint, CancellationToken.None)); }
/// <summary> /// Creates new ReliableUdpConnectionRecord and starts finite state automaton /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="endPoint">Ip endpoint of recipient of the message.</param> /// <param name="asyncResult"><see cref="AsyncResultSendMessage"/> object</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <returns></returns> private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, CancellationToken cToken, AsyncResultSendMessage asyncResult) { try { if (m_isListenerStarted == 0) { if (this.LocalEndpoint == null) { throw new ArgumentNullException("", "You must use constructor with parameters or start listener before sending message"); } StartListener(LocalEndpoint); } //RU: создаем ключ для словаря, на основе EndPoint и ReliableUdpHeader.TransmissionId //EN: create key based on EndPoint and ReliableUdpHeader.TransmissionId for dictionary byte[] transmissionId = new byte[4]; //RU: только криптопровайдер! random выдает одинаковые номера для двух одновременно созданных TCB //EN: should use only cryptographic random function. System.Random gives the same values for two //EN: or more ConnnectionControlBlock created at the same time m_randomCrypto.GetBytes(transmissionId); Tuple <EndPoint, Int32> key = new Tuple <EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); Debug.WriteLine("Transmission Id is {0}", key.Item2); //EN: make two attemps to add key into dictionary if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, cToken, asyncResult))) { m_randomCrypto.GetBytes(transmissionId); key = new Tuple <EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0)); if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, cToken, asyncResult))) { throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary"); } } //RU: запустили состояние в обработку. //EN: run state handling m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]); } //RU: Все исключения в состояниях обрабатываются отдельно //RU: здесь ловятся только те, которые могут появиться до запуска конечного автомата //EN: All exceptions that raised in states are handled separately catch (ArgumentNullException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ArgumentOutOfRangeException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ArgumentException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } catch (ReliableUdpConfigurationException ex) { if (asyncResult != null) { asyncResult.SetAsCompleted(ex); } else { throw; } } }
/// <summary> /// Sends message async (can be used with .net 4 framework) /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <returns><c>true</c> if the message was successfully sent. /// <c>false</c> if sending the message was interrupted on a timeout.</returns> /// <exception cref="AggregateException">Contains one or more errors that occur during application execution.</exception> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public Task<bool> SendMessageAsync( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint ) { return m_tcb.SendMessageAsync( reliableUdpMessage, remoteEndPoint, CancellationToken.None ); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> pseudo-synchronously to the specified endpoint. /// </summary> /// <remarks>Asynchronous methods of sending and receiving packets are actually used. /// But initial start of sending is carried out in the current thread. /// If <see cref="ReliableUdpMessage.NoAsk"/> is set to <c>true</c> than method returns only when /// all packets will be sent.</remarks> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public void SendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint) { m_tcb.SendMessage(reliableUdpMessage, remoteEndPoint); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> asynchronously to the specified endpoint. /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <param name="asyncCallback">The <see cref="AsyncCallback"/> delegate.</param> /// <param name="state">An object that contains state information for this request.</param> /// <returns>An IAsyncResult that references the asynchronous send.</returns> public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state) { return m_tcb.BeginSend(reliableUdpMessage, remoteEndPoint, asyncCallback, state); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> pseudo-synchronously to the specified endpoint. /// </summary> /// <remarks>Asynchronous methods of sending and receiving packets are actually used. /// But initial start of sending is carried out in the current thread. /// If <see cref="ReliableUdpMessage.NoAsk"/> is set to <c>true</c> than method returns only when /// all packets will be sent.</remarks> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="ReliableUdpConfigurationException"></exception> /// <exception cref="ObjectDisposedException"></exception> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="SocketException"></exception> public void SendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint) { StartTransmission(reliableUdpMessage, remoteEndPoint,CancellationToken.None, null); }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> asynchronously to the specified endpoint. /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <param name="callback">The <see cref="AsyncCallback"/> delegate.</param> /// <param name="state">An object that contains state information for this request.</param> /// <returns>An IAsyncResult that references the asynchronous send.</returns> public IAsyncResult BeginSend(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback callback, Object state) { //RU: упаковали данные в собственный AsyncResult //EN: wrapped data in our own AsyncResult AsyncResultSendMessage ar = new AsyncResultSendMessage(reliableUdpMessage, remoteEndPoint,CancellationToken.None, callback, state, this); ThreadPool.QueueUserWorkItem(StartTransmissionHelper, ar); return ar; }
/// <summary> /// Initializes a new instance of the ReliableUdpConnectionRecord /// to send message /// </summary> /// <param name="key">EndPoint and TransmissionId key</param> /// <param name="tcb">Connection control block. <see cref="ReliableUdpConnectionControlBlock"/></param> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="cToken">CancellationToken</param> /// <param name="asyncResult"><see cref="AsyncResultSendMessage"/></param> /// <exception cref="ArgumentNullException"><paramref name="key"/> or <paramref name="tcb"/> is a null reference</exception> public ReliableUdpConnectionRecord(Tuple<EndPoint, Int32> key, ReliableUdpConnectionControlBlock tcb, ReliableUdpMessage reliableUdpMessage, CancellationToken cToken, AsyncResultSendMessage asyncResult) : this(key, tcb) { if (reliableUdpMessage == null) { throw new ArgumentNullException("reliableUdpMessage"); } if (reliableUdpMessage.Body == null || reliableUdpMessage.Body.Length == 0) { throw new ArgumentNullException("reliableUdpMessage", "reliableUdpMessage.Body can not be null."); } CToken = cToken; this.AsyncResult = asyncResult; this.ReliableUdpMessageType = reliableUdpMessage.Type; this.IsNoAnswerNeeded = reliableUdpMessage.NoAsk; //RU: добавляем содержимое ReliableUdpMessage в словарь ReliableUdpConnectionControlBlock'a //EN: fills the array of outcoming message with message bytes this.OutcomingStream = Tcb.OutcomingStreams.GetOrAdd(key, reliableUdpMessage.Body); //RU: Расчитываем количество пакетов необходимых для отправки сообщения this.NumberOfPackets = (int) Math.Ceiling((double) ((double) OutcomingStream.Length/(double) this.BufferSize)); //RU: переключаем состояние на отправку первого пакета //EN: set initial state this.State = Tcb.States.FirstPacketSending; }
public WrappedBeginSendParameters(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken) { ReliableUdpMessage = reliableUdpMessage; RemoteEndPoint = remoteEndPoint; Token = cToken; }
/// <summary> /// Sends the <paramref name="reliableUdpMessage"/> asynchronously to the specified endpoint. /// </summary> /// <param name="reliableUdpMessage"><see cref="ReliableUdpMessage"/> message to send.</param> /// <param name="remoteEndPoint">Ip endpoint of recipient of the message.</param> /// <param name="asyncCallback">The <see cref="AsyncCallback"/> delegate.</param> /// <param name="state">An object that contains state information for this request.</param> /// <returns>An IAsyncResult that references the asynchronous send.</returns> public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state) { return(m_tcb.BeginSend(reliableUdpMessage, remoteEndPoint, asyncCallback, state)); }