使用C#与cRIO交互时，NetworkVariableManager是否应长期连接？

Great question—let’s break down the tradeoffs between your current short-lived connection approach and maintaining a persistent connection for your RIOVar<T> class.

First, the downsides of your current implementation #

Right now, you’re creating a new NetworkVariableReader<T>/NetworkVariableWriter<T>, connecting, performing the operation, and disposing it every time you call Get() or Write(). This works, but it introduces unnecessary overhead:

• TCP connection handshake overhead: Every connect/disconnect requires TCP setup/teardown, which adds latency, especially if you’re reading/writing frequently.
• GC overhead: Creating and disposing these objects repeatedly will generate more garbage collection pressure over time.
• Missed optimization opportunities: NI’s Network Variable system is designed for ongoing communication—short-lived connections don’t leverage its full capabilities (like subscribing to variable changes without polling).

Why a persistent connection is generally better #

Keeping the reader/writer connected as class members (initialized in the constructor) is absolutely a valid and often preferred approach, and it shouldn’t cause the issues you’re worried about:

• Better performance: No repeated connection setup means faster read/write operations, which is critical if you’re interacting with the cRIO frequently.
• Resource usage is manageable: A single persistent connection uses minimal system resources (a socket, small memory footprint). NI’s client libraries are built to handle this—you won’t run into resource exhaustion unless you’re creating hundreds of unnecessary connections.
• Supports advanced features: If you later want to add event-based variable change notifications (instead of polling Get()), a persistent connection is required.

Key considerations for persistent connections #

While persistent connections are better, there are a few things you need to handle to make the implementation robust:

1. Connection resilience: Network blips, cRIO restarts, or power cycles will drop the connection. You’ll need to add reconnection logic—for example, check if the reader/writer is connected before performing an operation, or subscribe to connection status events to trigger automatic reconnection.
2. Thread safety: NI’s NetworkVariableReader/NetworkVariableWriter classes are not thread-safe by default. If multiple threads will be calling Get() or Write(), wrap these operations in a lock to avoid race conditions.
3. Proper resource cleanup: Implement IDisposable on your RIOVar<T> class to ensure the reader/writer is disconnected and disposed when your RIOVar instance is no longer needed. This prevents orphaned connections.

Example optimized implementation #

Here’s a rough sketch of how you could refactor your class to use persistent connections:

public class RIOVar<T> : IDisposable
{
    private readonly string _location;
    private NetworkVariableReader<T>? _reader;
    private NetworkVariableWriter<T>? _writer;
    private readonly object _lockObj = new object();
    private bool _disposed = false;

    public RIOVar(string location)
    {
        _location = location;
        InitializeConnections();
    }

    private void InitializeConnections()
    {
        lock (_lockObj)
        {
            _reader?.Dispose();
            _writer?.Dispose();

            _reader = new NetworkVariableReader<T>(_location);
            _writer = new NetworkVariableWriter<T>(_location);
            
            // Add error handling here for failed connection attempts
            _reader.Connect();
            _writer.Connect();
        }
    }

    public T Get()
    {
        lock (_lockObj)
        {
            EnsureConnected();
            return _reader!.ReadData().GetValue();
        }
    }

    public void Write(T value)
    {
        lock (_lockObj)
        {
            EnsureConnected();
            _writer!.WriteValue(value);
        }
    }

    private void EnsureConnected()
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(RIOVar<T>));

        if (!_reader!.IsConnected || !_writer!.IsConnected)
        {
            InitializeConnections();
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            lock (_lockObj)
            {
                _reader?.Disconnect();
                _reader?.Dispose();
                _writer?.Disconnect();
                _writer?.Dispose();
            }
        }

        _disposed = true;
    }
}

Final call #

• If your application reads/writes to the cRIO frequently (e.g., multiple times per second), go with the persistent connection approach—it’s faster and more efficient.
• If you only interact with the cRIO occasionally (e.g., once every few minutes), your current short-lived connection setup is acceptable, though the persistent approach still offers better maintainability for future changes.

内容的提问来源于stack exchange，提问作者Jon Burr