NegotiateStream.LeaveInnerStreamOpen Property

using System;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;

public class NegotiateStreamExample
{
    public static void Main(string[] args)
    {
        TcpClient client = null;
        NetworkStream networkStream = null;
        NegotiateStream negotiateStream = null;

        try
        {
            // Assume a server is running and a client is connected
            // For demonstration, we'll simulate this setup.
            // In a real scenario, you would establish a connection here.

            // Simulate a connected TcpClient and its underlying stream
            // In a real application, this would come from a successful TcpClient.Connect() or AcceptTcpClient()
            Console.WriteLine("Simulating a client connection...");
            client = new TcpClient();
            // client.Connect("server_address", port); // Uncomment and configure for real connection
            networkStream = new NetworkStream(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)); // Placeholder for real stream

            Console.WriteLine("Creating NegotiateStream...");
            // Assume authentication details are handled
            negotiateStream = new NegotiateStream(networkStream, true); // Start with LeaveInnerStreamOpen = true

            // Set LeaveInnerStreamOpen to true explicitly for clarity
            negotiateStream.LeaveInnerStreamOpen = true;

            // Authenticate (simplified for example)
            // negotiateStream.AuthenticateAsClientAsync(..., CancellationToken.None).GetAwaiter().GetResult();
            Console.WriteLine("Authentication successful (simulated).");

            // Perform secure operations...
            Console.WriteLine("Performing secure communication (simulated).");
            byte[] buffer = Encoding.UTF8.GetBytes("Hello Secure World!");
            // negotiateStream.Write(buffer, 0, buffer.Length);

            // Now, close the NegotiateStream but leave the inner stream open
            Console.WriteLine("Closing NegotiateStream, leaving inner stream open.");
            negotiateStream.Close(); // This will NOT dispose of the networkStream because LeaveInnerStreamOpen is true.

            // You can now use the networkStream for other purposes if needed
            Console.WriteLine("Inner NetworkStream is still available for use.");
            // Example: Send unencrypted data on the inner stream
            // networkStream.Write(Encoding.UTF8.GetBytes("Sending unencrypted message."), 0, Encoding.UTF8.GetBytes("Sending unencrypted message.").Length);
            // networkStream.Flush();

        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
        finally
        {
            // IMPORTANT: If LeaveInnerStreamOpen was true, YOU are responsible for disposing of the inner stream.
            Console.WriteLine("Disposing of the inner NetworkStream manually.");
            networkStream?.Dispose(); // Manually dispose the inner stream

            // The TcpClient itself might also need disposal if it holds resources.
            // client?.Dispose(); // Uncomment if TcpClient was genuinely created and connected.
        }
    }
}