public async Task SendMessageAsync(string message) { try { if (_messageWriter == null) { throw new Exception("SendMessageAsync: no writer"); } _messageWriter.WriteString(message); using (var cancellationTokenSource = new CancellationTokenSource(5000)) { await _messageWriter.StoreAsync().AsTask(cancellationTokenSource.Token).ContinueWith((antecedent) => { if (antecedent.Status != TaskStatus.RanToCompletion) { throw new Exception("SendMessageAsync cancelled due to timeout"); } }); } } catch (Exception e) { Logger.Error("SendMessageAsync: " + e.Message); ConnectionClosed = true; _messageWriter?.Dispose(); } }
public void Shutdown() { this.Log("Stopping push server"); _runningTokenSource?.Cancel(); _inboundReader?.Dispose(); _outboundWriter?.DetachStream(); _outboundWriter?.Dispose(); }
public void Shutdown() { this.Log("Stopping realtime server"); NetworkInformation.NetworkStatusChanged -= OnNetworkStatusChanged; _runningTokenSource?.Cancel(); _inboundReader?.Dispose(); _outboundWriter?.DetachStream(); _outboundWriter?.Dispose(); }
private void Cleanup() { connectTimeoutCTS?.Cancel(); connectTimeoutCTS = null; connectCTS?.Cancel(); connectCTS = null; readCTS?.Cancel(); readCTS = null; sendCTS?.Cancel(); sendCTS = null; tlsUpgradeCTS?.Cancel(); tlsUpgradeCTS = null; try { dataWriter?.DetachStream(); dataWriter?.Dispose(); dataWriter = null; } catch (Exception) { } try { dataReader?.DetachStream(); dataReader?.Dispose(); dataReader = null; } catch (Exception) { } socket?.Dispose(); socket = null; }
public static void IndexUimfFile(string uimfFileLocation) { bool indexed = false; using (var uimfReader = new DataReader(uimfFileLocation)) { if (uimfReader.DoesContainBinCentricData()) { indexed = true; Console.WriteLine("Bin centric data found in dataset {0}.", uimfFileLocation); } else { Console.WriteLine("No bin centric data found for file {0}.", uimfFileLocation); } uimfReader.Dispose(); } if (!indexed) { Console.WriteLine("Creating bin centric data for {0}.", uimfFileLocation); using (DataWriter dataWriter = new DataWriter(uimfFileLocation)) { dataWriter.CreateBinCentricTables(); dataWriter.Dispose(); } } }
public void disconnect() { if (state == ConnectionState.DISCONNECTED) { return; } setState(ConnectionState.DISCONNECTING); Logger.Info("[TCPConnection2]: Disconnecting"); connectingCTS?.Cancel(); readingCTS?.Cancel(); tlsUpgradeCTS?.Cancel(); sendCTS?.Cancel(); try { dataReader?.DetachStream(); dataReader?.Dispose(); dataReader = null; dataWriter?.DetachStream(); dataWriter?.Dispose(); dataWriter = null; } catch (Exception) { } socket?.Dispose(); socket = null; setState(ConnectionState.DISCONNECTED); Logger.Info("[TCPConnection2]: Disconnected"); }
public void Dispose() { Listening = false; _eventLoopCancellationTokenSource.Cancel(false); DataWriter?.Dispose(); DataReader?.Dispose(); }
public void Shutdown() { Log("Stopping realtime server"); try { NetworkInformation.NetworkStatusChanged -= OnNetworkStatusChanged; } catch { } try { _runningTokenSource?.Cancel(); } catch { } try { _inboundReader?.Dispose(); _outboundWriter?.DetachStream(); _outboundWriter?.Dispose(); } catch { } try { Socket?.Dispose(); } catch { } }
public void Dispose() { _writer?.Dispose(); _writer = null; _tcpSocket?.Dispose(); _tcpSocket = null; }
public async Task <bool> Send(byte[] data) { DataWriter writer = null; try { writer = new DataWriter(_port.OutputStream); writer.WriteBytes(data); Task <UInt32> storeAsyncTask; lock (_mutex) { if (_closeTokenSrc == null || _closeTokenSrc.IsCancellationRequested) { throw new OperationCanceledException(); } storeAsyncTask = writer.StoreAsync().AsTask(_closeTokenSrc.Token); } uint bytesWritten = await storeAsyncTask; return(bytesWritten == data.Length); } catch (OperationCanceledException) { if (_disposing) { FreeResources(); } return(false); } finally { writer?.DetachStream(); writer?.Dispose(); } }
private void DeInitialiseSerialDevice() { lock (_serialDeviceLock) { if (Enabled) { Enabled = false; _readCancellationTokenSource?.Cancel(); _listenTask?.Wait(); _listenTask = null; _readCancellationTokenSource?.Dispose(); _readCancellationTokenSource = null; _dataReader?.DetachStream(); _dataReader?.Dispose(); _dataReader = null; _dataWriter?.DetachStream(); _dataWriter?.Dispose(); _dataWriter = null; _serialDevice?.Dispose(); _serialDevice = null; } } }
public void Shutdown() { _runningTokenSource?.Cancel(); _inboundReader = null; _outboundWriter?.DetachStream(); _outboundWriter?.Dispose(); _outboundWriter = null; Log($"[{_instaApi.GetLoggedUser().UserName}] " + "Stopped pinging push server"); }
/// <summary> /// Closes any open pipes. /// </summary> private void ShutdownIo() { // Close all pipes InPipe?.Dispose(); OutPipe?.Dispose(); CtrlPipe?.Dispose(); }
/// <summary> /// Dispose all the serial communication objects associated with this device. We may or may not try to /// reconnect after this. /// </summary> public virtual void DisposeSerialObjeccts() { Log($"Disposing serial I/O objects of {DeviceLabel}"); _dataWriter?.Dispose(); _dataWriter = null; _dataReader?.Dispose(); _dataReader = null; _serialDevice?.Dispose(); _serialDevice = null; }
public async Task Unbind() { Socket?.Dispose(); mDataWriter?.Dispose(); mDataReader?.Dispose(); Socket = null; mDataWriter = null; mDataReader = null; }
public void Unbind() { Socket?.Dispose(); mDataWriter?.Dispose(); mDataReader?.Dispose(); Socket = null; mDataWriter = null; mDataReader = null; }
private async Task <bool> OpenNetworkAsync() { if (_sensorConnection != null) { return(true); } // TODO winsock/Socket with IOCP vs. UWP sockets try { _sensorConnection = new StreamSocket(); await _sensorConnection.ConnectAsync(_sensorAddress); _dataReader = new DataReader(_sensorConnection.InputStream); _dataWriter = new DataWriter(_sensorConnection.OutputStream); _dataWriter.ByteOrder = ByteOrder.LittleEndian; _dataReader.ByteOrder = ByteOrder.LittleEndian; // write header/ protocol version/ connection config var helloPacket = new HelloPacket(1); helloPacket.Write(_dataWriter); await _dataWriter.StoreAsync(); await _dataWriter.FlushAsync(); // read the response from the server var asyncOperation = _dataReader.LoadAsync(8); // TODO: timeout handling if (!asyncOperation.AsTask().Wait(50000)) { asyncOperation.Close(); asyncOperation.Cancel(); } helloPacket = HelloPacket.Read(_dataReader); // TODO: compare protocol versions // Start receive loop } catch (Exception) { _sensorConnection?.Dispose(); _sensorConnection = null; _dataReader?.Dispose(); _dataReader = null; _dataWriter?.Dispose(); _dataWriter = null; return(false); } return(true); }
public async void SendMessageAsync(string message) { try { _messageWriter.WriteString(message); await _messageWriter.StoreAsync(); } catch (Exception e) { ConnectionClosed = true; _messageWriter?.Dispose(); } }
public void Dispose() { Cancel(); Task.Delay(TimeSpan.FromSeconds(CancelTimeoutSeconds)); _dataReader?.DetachBuffer(); _dataReader?.DetachStream(); _dataReader?.Dispose(); _dataWriter?.DetachBuffer(); _dataWriter?.DetachStream(); _dataWriter?.Dispose(); _snocModule?.Dispose(); _readCancellationTokenSource.Dispose(); }
public virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { _disposed = true; _dataReader?.Dispose(); _dataWriter?.Dispose(); _streamSocket?.Dispose(); } }
public async Task SendAsync(byte[] message) { try { if (_state == State.Running) { _serialPortStream.WriteBytes(message); await _serialPortStream.StoreAsync(); } } catch { SetDeviceState(State.Broken); try { _serialPortStream?.Dispose(); _device?.Dispose(); } catch { } } }
public void DisconnectDevice(NanoDeviceBase device) { if (FindDevice(((device as NanoDevice <NanoSerialDevice>).Device.DeviceInformation as SerialDeviceInformation).DeviceInformation.Id) != null) { EventHandlerForSerialDevice.Current.CloseDevice(); inputStreamReader?.DetachStream(); inputStreamReader?.DetachBuffer(); inputStreamReader?.Dispose(); outputStreamWriter?.DetachStream(); outputStreamWriter?.DetachBuffer(); outputStreamWriter?.Dispose(); } }
private async Task CharGenUdpAsync(DataWriter dw, string remotePort) { var start = rnd.Next(0, 95); var str = MakePattern(start, 72); Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: reply with CharGen <<{str}>> to remote port {remotePort}"); dw.WriteString(str); await dw.StoreAsync(); await dw.FlushAsync(); // NOTE: this flush doesn't actually do anything useful Interlocked.Increment(ref Stats.NResponses); dw.Dispose(); Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP closing down the current writing socket for {str}"); }
private async void SendSocketData(int packetlength, short magic, short ver, int action, int param = 1, string body = "") { try { var playload = Encoding.UTF8.GetBytes(body); if (packetlength == 0) { packetlength = playload.Length + 16; } var buffer = new byte[packetlength]; using (var ms = new MemoryStream(buffer)) { //Array.Reverse(a) var b = BitConverter.GetBytes(buffer.Length).ToArray().Reverse().ToArray(); ms.Write(b, 0, 4); b = BitConverter.GetBytes(magic).ToArray().Reverse().ToArray(); ms.Write(b, 0, 2); b = BitConverter.GetBytes(ver).ToArray().Reverse().ToArray(); ms.Write(b, 0, 2); b = BitConverter.GetBytes(action).ToArray().Reverse().ToArray(); ms.Write(b, 0, 4); b = BitConverter.GetBytes(param).ToArray().Reverse().ToArray(); ms.Write(b, 0, 4); if (playload.Length > 0) { ms.Write(playload, 0, playload.Length); } DataWriter writer = new DataWriter(_clientSocket.OutputStream); //实例化writer对象,以StreamSocket的输出流作为writer的方向 // string content = "ABCDEFGH"; //发送一字符串 //byte[] data = Encoding.UTF8.GetBytes(content); //将字符串转换为字节类型,完全可以不用转换 writer.WriteBytes(buffer); //写入字节流,当然可以使用WriteString直接写入字符串 await writer.StoreAsync(); //异步发送数据 writer.DetachStream(); //分离 writer.Dispose(); //结束writer // _netStream.WriteAsync(buffer, 0, buffer.Length); // _netStream.FlushAsync(); } } catch (Exception) { } }
static async void multicastSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs eventArguments) { try { HostName remoteHostAddress = eventArguments.RemoteAddress; uint len = eventArguments.GetDataReader().UnconsumedBufferLength; string message = eventArguments.GetDataReader().ReadString(len).Trim(); int p = message.IndexOf(':'); if (p != -1) { string serverLogToken = message.Substring(0, p); int port = Int32.Parse(message.Substring(p + 1)); if (serverLogToken == logToken && port > 0 && port < 65535) { Debug.WriteLine("[LOGGER] Found a Titanium log server: " + remoteHostAddress.DisplayName + ":" + port); try { tcpSocket = new StreamSocket(); tcpSocket.Control.KeepAlive = true; await tcpSocket.ConnectAsync(remoteHostAddress, port.ToString()); tcpWriter = new DataWriter(tcpSocket.OutputStream); // shutdown the multicast socket and start the tcp connection multicastSocket.Dispose(); } catch { if (tcpWriter != null) { tcpWriter.Dispose(); tcpWriter = null; } if (tcpSocket != null) { tcpSocket.Dispose(); tcpSocket = null; } } } } } catch (Exception ex) { if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) { throw; } Debug.WriteLine(ex.ToString()); } }
/// <summary> /// Выполняет закрытие потоков чтения, записи, соединения с сервером и очистку /// </summary> private void Clear() { StatusId = ConnectionStatus.ConnectionError; if (_datareader != null) { _datareader.Dispose(); } if (_datawriter != null) { _datawriter.Dispose(); } if (_socket != null) { _socket.Dispose(); } }
/// <summary> /// This is the click handler for the 'CloseSockets' button. /// </summary> /// <param name="sender">Object for which the event was generated.</param> /// <param name="e">Event's parameters.</param> private void CloseSockets_Click(object sender, RoutedEventArgs e) { object outValue; if (CoreApplication.Properties.TryGetValue("clientDataWriter", out outValue)) { // Remove the data writer from the list of application properties as we are about to close it. CoreApplication.Properties.Remove("clientDataWriter"); DataWriter dataWriter = (DataWriter)outValue; // To reuse the socket with other data writer, application has to detach the stream from the writer // before disposing it. This is added for completeness, as this sample closes the socket in // very next block. dataWriter.DetachStream(); dataWriter.Dispose(); } if (CoreApplication.Properties.TryGetValue("clientSocket", out outValue)) { // Remove the socket from the list of application properties as we are about to close it. CoreApplication.Properties.Remove("clientSocket"); DatagramSocket socket = (DatagramSocket)outValue; socket.Dispose(); } if (CoreApplication.Properties.TryGetValue("listener", out outValue)) { // Remove the listener from the list of application properties as we are about to close it. CoreApplication.Properties.Remove("listener"); DatagramSocket listener = (DatagramSocket)outValue; listener.Dispose(); } if (CoreApplication.Properties.ContainsKey("remotePeer")) { // Remove the remote perr from the list of application properties. CoreApplication.Properties.Remove("remotePeer"); } if (CoreApplication.Properties.ContainsKey("connected")) { CoreApplication.Properties.Remove("connected"); } rootPage.NotifyUser("Socket and listener closed", NotifyType.StatusMessage); }
static void CloseConnection() { hasConnected = false; clientSocket.Dispose(); if (_Writer != null) { _Writer.DetachStream(); _Writer.Dispose(); } if (_Reader != null) { _Reader.DetachStream(); _Reader.Dispose(); } _Writer = null; _Reader = null; }
public void Close() { try { sr?.Dispose(); dw?.Dispose(); streamSocket?.Dispose(); sr = null; dw = null; streamSocket = null; } catch (Exception exc) { System.Diagnostics.Debug.WriteLine(exc.ToString()); System.Diagnostics.Debugger.Break(); } }
private async void SendButton_Click(object sender, RoutedEventArgs e) { try { DataWriter writer = new DataWriter(connectedSocket.OutputStream); writer.WriteBytes(Encoding.UTF8.GetBytes(SendMessageTextBox.Text)); SendMessageTextBox.Text = ""; await writer.StoreAsync(); writer.DetachStream(); writer.Dispose(); } catch (Exception exception) { rootPage.NotifyUser(exception.Message, NotifyType.ErrorMessage); } }
private bool disposedValue = false; // To detect redundant calls void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { // TODO: dispose managed state (managed objects). dataWriteObject.Dispose(); _ARE.Dispose(); } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. // TODO: set large fields to null. disposedValue = true; } }