定时删除DataTable旧行时DataGridView出现不可捕获异常

Hey there! Let's dig into those random errors you're seeing—your original DataTable setup has been rock solid for years, so the issue almost certainly ties to the new timer-based cleanup introducing concurrent access conflicts or a small oversight in the deletion logic. Here's how to diagnose and fix it:

Most Likely Culprit: Concurrent Thread Access #

DataTable isn't thread-safe for simultaneous read/write operations. Your original code adds rows from an internet data source (presumably running on one thread), and now the timer is triggering cleanup on a separate thread. When these two operations collide (e.g., adding a row while the timer is iterating to delete old ones), you'll get unpredictable errors like InvalidOperationException (collection modified during enumeration) or IndexOutOfRangeException.

Fix: Add Thread Synchronization #

Wrap every operation that touches the DataTable—both adding rows and deleting old ones—in a lock to ensure only one thread accesses it at a time:

// Create a dedicated lock object (declare this at the class level)
private readonly object _dataTableSyncLock = new object();

// When adding rows (your existing stable code)
lock (_dataTableSyncLock)
{
    var newRow = yourDataTable.NewRow();
    newRow["Timestamp"] = DateTime.UtcNow; // Use UTC to avoid timezone issues
    // Populate other columns with internet data
    yourDataTable.Rows.Add(newRow);
}

// Timer cleanup callback
private void CleanupOldRows(object state)
{
    lock (_dataTableSyncLock)
    {
        // Iterate BACKWARDS to avoid skipping rows when deleting
        for (int i = yourDataTable.Rows.Count - 1; i >= 0; i--)
        {
            var row = yourDataTable.Rows[i];
            var rowTimestamp = (DateTime)row["Timestamp"];
            var age = DateTime.UtcNow - rowTimestamp;
            
            // Compare against user-defined interval (e.g., TimeSpan.FromHours(24))
            if (age > userDefinedRetentionInterval)
            {
                yourDataTable.Rows.RemoveAt(i);
            }
        }
    }
}

Other Potential Issues to Check #

• Forward Iteration Bug: If you're iterating from the start of the rows collection to the end while deleting, removing a row shifts the index of subsequent rows—you'll skip some entries and get unexpected behavior (or errors). Always iterate backwards when modifying a collection during traversal.
• Timezone Mismatches: If your timestamp uses local time but the interval calculation uses UTC (or vice versa), you might get incorrect "expired" checks that lead to partial deletions or unexpected row states. Stick with DateTime.UtcNow for both timestamping and age calculation to avoid this.
• Uncaught Exceptions in Timer Callback: If your timer code doesn't have exception handling, a single failed deletion could cause subsequent timer triggers to fail silently (or throw unhandled exceptions). Wrap the cleanup logic in a try/catch block to log errors and keep the timer running:

private void CleanupOldRows(object state)
{
    try
    {
        lock (_dataTableSyncLock)
        {
            // Cleanup logic here
        }
    }
    catch (Exception ex)
    {
        // Log the error (e.g., to a file or monitoring system)
        Console.WriteLine($"Cleanup failed: {ex.Message}");
    }
}

Next Steps #

1. Add the lock around all DataTable operations first—this will eliminate 90% of random concurrent access errors.
2. Verify you're iterating backwards when deleting rows.
3. Check your error logs for specific exception messages (if you have them)—they'll point directly to the root cause if the lock doesn't fix it.

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