// Disposes the Tcp connection. protected virtual void Dispose(bool disposing) { if (Interlocked.CompareExchange(ref _disposed, 1, 0) == 0) { if (disposing) { IDisposable?dataStream = _dataStream; if (dataStream != null) { dataStream.Dispose(); } else { // If the NetworkStream wasn't created, the Socket might // still be there and needs to be closed. In the case in which // we are bound to a local IPEndPoint this will remove the // binding and free up the IPEndPoint for later uses. Socket chkClientSocket = Volatile.Read(ref _clientSocket); if (chkClientSocket != null) { try { chkClientSocket.InternalShutdown(SocketShutdown.Both); } finally { chkClientSocket.Close(); } } } GC.SuppressFinalize(this); } } }
protected virtual void Dispose(bool disposing) { if (disposing) { if (NetEventSource.IsEnabled) { NetEventSource.Info(this); } // The only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. if (_disposed) { return; } Socket chkClientSocket = _clientSocket; if (chkClientSocket != null) { // If the NetworkStream wasn't retrieved, the Socket might // still be there and needs to be closed to release the effect // of the Bind() call and free the bound IPEndPoint. chkClientSocket.InternalShutdown(SocketShutdown.Both); chkClientSocket.Dispose(); _clientSocket = null !; } _disposed = true; GC.SuppressFinalize(this); } }
protected override void Dispose(bool disposing) { if (Interlocked.Exchange(ref _disposed, 1) != 0) { return; } if (disposing) { // The only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. _readable = false; _writeable = false; if (_ownsSocket) { // If we own the Socket (false by default), close it // ignoring possible exceptions (eg: the user told us // that we own the Socket but it closed at some point of time, // here we would get an ObjectDisposedException) _streamSocket.InternalShutdown(SocketShutdown.Both); _streamSocket.Close(_closeTimeout); } } base.Dispose(disposing); }
private void FreeResources() { // // only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. // if (m_CleanedUp) { return; } Socket chkClientSocket = Client; if (chkClientSocket != null) { // // if the NetworkStream wasn't retrieved, the Socket might // still be there and needs to be closed to release the effect // of the Bind() call and free the bound IPEndPoint. // chkClientSocket.InternalShutdown(SocketShutdown.Both); chkClientSocket.Close(); Client = null; } m_CleanedUp = true; }
protected override void Dispose(bool disposing) { #if DEBUG using (DebugThreadTracking.SetThreadKind(ThreadKinds.User)) { #endif // Mark this as disposed before changing anything else. bool cleanedUp = _cleanedUp; _cleanedUp = true; if (!cleanedUp && disposing) { // The only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. _readable = false; _writeable = false; if (_ownsSocket) { // If we own the Socket (false by default), close it // ignoring possible exceptions (eg: the user told us // that we own the Socket but it closed at some point of time, // here we would get an ObjectDisposedException) _streamSocket.InternalShutdown(SocketShutdown.Both); _streamSocket.Close(_closeTimeout); } } #if DEBUG } #endif base.Dispose(disposing); }
// Disposes the Tcp connection. protected virtual void Dispose(bool disposing) { if (NetEventSource.Log.IsEnabled()) { NetEventSource.Enter(NetEventSource.ComponentType.Socket, this, nameof(Dispose), ""); } if (_cleanedUp) { if (NetEventSource.Log.IsEnabled()) { NetEventSource.Exit(NetEventSource.ComponentType.Socket, this, nameof(Dispose), ""); } return; } if (disposing) { IDisposable dataStream = _dataStream; if (dataStream != null) { dataStream.Dispose(); } else { // If the NetworkStream wasn't created, the Socket might // still be there and needs to be closed. In the case in which // we are bound to a local IPEndPoint this will remove the // binding and free up the IPEndPoint for later uses. Socket chkClientSocket = _clientSocket; if (chkClientSocket != null) { try { chkClientSocket.InternalShutdown(SocketShutdown.Both); } finally { chkClientSocket.Dispose(); _clientSocket = null; } } } DisposeCore(); // platform-specific disposal work GC.SuppressFinalize(this); } _cleanedUp = true; if (NetEventSource.Log.IsEnabled()) { NetEventSource.Exit(NetEventSource.ComponentType.Socket, this, nameof(Dispose), ""); } }
// Disposes the Tcp connection. protected virtual void Dispose(bool disposing) { if (Logging.On) { Logging.Enter(Logging.Sockets, this, "Dispose", ""); } if (_cleanedUp) { if (Logging.On) { Logging.Exit(Logging.Sockets, this, "Dispose", ""); } return; } if (disposing) { IDisposable dataStream = _dataStream; if (dataStream != null) { dataStream.Dispose(); } else { // If the NetworkStream wasn't created, the Socket might // still be there and needs to be closed. In the case in which // we are bound to a local IPEndPoint this will remove the // binding and free up the IPEndPoint for later uses. Socket chkClientSocket = Client; if (chkClientSocket != null) { try { chkClientSocket.InternalShutdown(SocketShutdown.Both); } finally { chkClientSocket.Dispose(); Client = null; } } } GC.SuppressFinalize(this); } _cleanedUp = true; if (Logging.On) { Logging.Exit(Logging.Sockets, this, "Dispose", ""); } }
private void FreeResources() { if (!this.m_CleanedUp) { Socket client = this.Client; if (client != null) { client.InternalShutdown(SocketShutdown.Both); client.Close(); this.Client = null; } this.m_CleanedUp = true; } }
protected virtual void Dispose(bool disposing) { if (Logging.On) { Logging.Enter(Logging.Sockets, this, "Dispose", ""); } if (this.m_CleanedUp) { if (Logging.On) { Logging.Exit(Logging.Sockets, this, "Dispose", ""); } } else { if (disposing) { IDisposable dataStream = this.m_DataStream; if (dataStream != null) { dataStream.Dispose(); } else { Socket client = this.Client; if (client != null) { try { client.InternalShutdown(SocketShutdown.Both); } finally { client.Close(); this.Client = null; } } } GC.SuppressFinalize(this); } this.m_CleanedUp = true; if (Logging.On) { Logging.Exit(Logging.Sockets, this, "Dispose", ""); } } }
/// <include file='doc\NetworkStream.uex' path='docs/doc[@for="NetworkStream.Dispose"]/*' /> protected virtual void Dispose(bool disposing) { if (m_CleanedUp) { return; } if (disposing) { //no managed objects to cleanup } // // only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. // if (m_StreamSocket != null) { m_Readable = false; m_Writeable = false; if (m_OwnsSocket) { // // if we own the Socket (false by default), close it // swallowing possible exceptions (eg: the user told us // that we own the Socket but it closed at some point of time, // here we would get an ObjectDisposedException) // Socket chkStreamSocket = m_StreamSocket; if (chkStreamSocket != null) { chkStreamSocket.InternalShutdown(SocketShutdown.Both); chkStreamSocket.Close(); } } // // at this point dereference the Socket anyway // m_StreamSocket = null; } m_CleanedUp = true; }
protected override void Dispose(bool disposing) { #if DEBUG using (GlobalLog.SetThreadKind(ThreadKinds.User)) { #endif if (!m_CleanedUp && disposing) { // // only resource we need to free is the network stream, since this // is based on the client socket, closing the stream will cause us // to flush the data to the network, close the stream and (in the // NetoworkStream code) close the socket as well. // if (m_StreamSocket != null) { m_Readable = false; m_Writeable = false; if (m_OwnsSocket) { // // if we own the Socket (false by default), close it // swallowing possible exceptions (eg: the user told us // that we own the Socket but it closed at some point of time, // here we would get an ObjectDisposedException) // Socket chkStreamSocket = m_StreamSocket; if (chkStreamSocket != null) { chkStreamSocket.InternalShutdown(SocketShutdown.Both); chkStreamSocket.Close(m_CloseTimeout); } } } } m_CleanedUp = true; #if DEBUG } #endif base.Dispose(disposing); }
/// <devdoc> /// <para> /// Establishes a connection to the specified port on the /// specified host. /// </para> /// </devdoc> public void Connect(string hostname, int port) { // // parameter validation // if (m_CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } if (!ValidationHelper.ValidateTcpPort(port)) { throw new ArgumentOutOfRangeException("port"); } // // IPv6 Changes: instead of just using the first address in the list, // we must now look for addresses that use a compatible // address family to the client socket. // However, in the case of the <hostname,port> constructor // we will have deferred creating the socket and will // do that here instead. // In addition, the redundant CheckForBroadcast call was // removed here since it is called from Connect(). // IPAddress[] addresses = Dns.GetHostAddresses(hostname); foreach (IPAddress address in addresses) { if (m_ClientSocket == null) { // // We came via the <hostname,port> constructor. Set the // address family appropriately, create the socket and // try to connect. // m_Family = address.AddressFamily; createClientSocket(); try { // // Attempt to connect to the host // Connect(new IPEndPoint(address, port)); break; } catch (SocketException) { // // Destroy the client socket here for retry with // the next address. // try{ m_ClientSocket.InternalShutdown(SocketShutdown.Both); } finally{ m_ClientSocket.Close(); } } } else if (address.AddressFamily == m_Family) { // // Only use addresses with a matching family // try { // // Attempt to connect to the host // Connect(new IPEndPoint(address, port)); break; } catch (SocketException) { // // Intentionally empty - all set to retry the next address // } } } // // m_Active tells us whether we managed to connect // if (!m_Active) { throw new SocketException(SocketError.NotConnected); } }