Class destroyed automatically

The issue you’re experiencing might be due to the garbage collector in .NET. If the class that opens the COM port is not referenced anywhere else in your code, the garbage collector might see it as eligible for collection and destroy it, especially if your application is under memory pressure.

To prevent this, you can try to maintain a reference to the class that opens the COM port in a scope that lives as long as you need the serial port open. For example, you could store it as a static field in your program.

Here’s an example:

public static class Program
{
    public static SerialPort serialPort;

    public static void Main()
    {
        serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
        serialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceived);
        serialPort.Open();

        // Rest of your code
    }

    private static void DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        // Your code here
    }
}

In this example, serialPort is a static field in the Program class, so it will not be garbage collected until the program ends. This should prevent the class from being destroyed unexpectedly. Remember to close the serial port when you’re done with it to free up the resource. You can do this in a finally block or use serialPort.Dispose() when you’re done with it. 

Thanks

Perhaps you can create the SerialPort instance in the main program and pass it as a parameter for the thread.

The automatic destruction of the class that opens the COM port could be due to various reasons. One common issue is related to the management of resources and thread safety. When working with serial ports in .NET, it's crucial to ensure proper resource handling and thread synchronization.

To address this problem, consider implementing proper error handling mechanisms, ensuring that resources are correctly released, and handling exceptions gracefully. Additionally, verify that the thread managing the serial port operations is appropriately synchronized to prevent conflicts that could lead to unexpected behavior or resource leaks.

By reviewing the resource management, error handling, and thread synchronization in your code, you can enhance the stability of the serial port connection and prevent the premature destruction of the class responsible for managing it.