C# 前后访问持续更新的列表

我有一个非常特殊的问题，很难把它分解成几行代码和几句话，但我会尽量这样做。 我目前正在开发一个软件，用于过程工厂警报的实时优化。每次出现新警报时，软件都会从服务器接收新警报。其中几个报警具有相同的根本原因，我的软件分析这些报警，并将它们分组（如果它们彼此相关）。 我的问题是比较新闹钟和旧闹钟。我将旧报警存储在全局列表中，并在新报警出现时将其附加到此列表中。 必须对新警报进行分析，以确定它们是否可以与其自身和旧警报进行分组。旧警报不需要重新组合。 例如，我有三个旧（o）报警和三个新（n）报警。 列表将看起来像o1 o2 o3 n1 n2 n3。现在必须将n1与o1、o2、o3、n2和n3进行比较。n2必须与o1、o2、o3和n3等进行比较

我使用以下代码来执行此操作：

    List<ALARM_ITEM> puffer = new List<ALARM_ITEM>();
            puffer.AddRange(localOldAlarmList);
            puffer.AddRange(localNewAlarmList);
            localMergedList = puffer;



    int mainListCounter = localOldAlarmList.Count;

    for (; mainListCounter < localMergedList.Count; mainListCounter++)
                {
                    /*if there are new elements just these elemnts will be used as static items*/
                    ALARM_ITEM staticAlarmItem = localMergedList[mainListCounter];

        for (int j = -1; j <= 1; j += 2)
        {

                            if (j < 0)
                                counterRunner = localOldAlarmListLength - 1;
                            else
                                counterRunner = mainListCounter + 1;



                            //Check against any ALARM_ITEM in timeframe
                            bool inTimeframe = true;

                            while (inTimeframe)
                            {

                                if ((counterRunner >= localMergedList.Count) || (counterRunner) < 0)
                                        break;

                                 ALARM_ITEM groupCandidate = new ALARM_ITEM();
                                    groupCandidate = localMergedList[counterRunner];


                                 //... several if clauses

                                MergeTwoAlarmGroups(staticAlarmItem, groupCandidate);

                                 if (j < 0)
                                        counterRunner -= 1;
                                    else
                                        counterRunner += 1;

                }
            }
        } 

List puffer=new List（）；
puffer.AddRange（localOldAlarmList）；
puffer.AddRange（localNewAlarmList）；
localMergedList=puffer；
int mainListCounter=localoldallarmlist.Count；
对于（；mainListCounter

现在我该怎么说。。。我修改了这个方法，现在可以工作36个小时，但是软件只是比较新的报警，而没有将它与旧的报警联系起来。分组算法有好几页长，我尽量把它分解。如果有人能给我一个建议我做错了什么，我会非常高兴，因为我对这个问题很生气。这是我第一次真正陷入这个项目中，而且我已经为这个软件编程三个多月了

问候

---

拉里莫

我不完全理解你的算法。我会使用

Dictionary<ALARM_ITEM, HashSet<ALARM_ITEM>>

---

字典，所以算法会起作用。
我不完全理解你的算法。我会使用

Dictionary<ALARM_ITEM, HashSet<ALARM_ITEM>>

Dictionary，因此该算法将起作用。
好的……让我们看看是否可以尝试一下，其中大部分将是伪代码，因此如下所示：

List listOfAllAlarms //a specific subset contianing a representative instance of EACH old alarm GROUP!!, and the new alarms
List listOfNewAlarms //Only the new alarms

foreach (alarm a in listOfNewAlarms)
{
    foreach (alarm b in listOfAllAlarms)
    {
        if (a.Equals(b))
            continue;

        Group = //compare a and b

        if (Group != null) //new group
            //Assign a to group b
    }
}       

重要的一点是这两个组，以及循环它们的方式。在外部列表中，您只查看最新的报警。在内部列表中，您可以与全局报警集进行比较。实际上，我更愿意将新报警排除在分组集中，但我确实理解，在新报警列表中可能会出现多个报警，这些报警都属于一个组，但它不是一个已经存在的组。如果你能把它们分开，我会这样做：

List listOfAlarmGroups //a specific subset contianing a representative instance of only the already existing old alarm groups
List listOfNewAlarms //Only the new alarms

foreach (alarm a in listOfNewAlarms)
{
    Group G = null;//set -> ReSet G
    foreach (alarm b in listOfAlarmGroups)
    {
        G = //compare a and b

        if (G != null) 
            break;//found the group
    }

    if (G != null)
        //assign a to group G
    else
    {
        //create new group for a
        //add new group to listOfAlarmGroups
    }
}   

两者之间的区别在于，内部循环只查看组，但从不主动与其他新项进行比较，但如果发现某个项未与现有组进行分组，则会得到一个新组，下一个警报将与该新组以及旧组进行比较。相同的效果，略有不同的算法。
好的……让我们看看我是否可以尝试一下，其中大部分都是伪代码，因此如下所示：

List listOfAllAlarms //a specific subset contianing a representative instance of EACH old alarm GROUP!!, and the new alarms
List listOfNewAlarms //Only the new alarms

foreach (alarm a in listOfNewAlarms)
{
    foreach (alarm b in listOfAllAlarms)
    {
        if (a.Equals(b))
            continue;

        Group = //compare a and b

        if (Group != null) //new group
            //Assign a to group b
    }
}       

重要的一点是这两个组，以及循环它们的方式。在外部列表中，您只查看最新的报警。在内部列表中，您可以与全局报警集进行比较。实际上，我更愿意将新报警排除在分组集中，但我确实理解，在新报警列表中可能会出现多个报警，这些报警都属于一个组，但它不是一个已经存在的组。如果你能把它们分开，我会这样做：

List listOfAlarmGroups //a specific subset contianing a representative instance of only the already existing old alarm groups
List listOfNewAlarms //Only the new alarms

foreach (alarm a in listOfNewAlarms)
{
    Group G = null;//set -> ReSet G
    foreach (alarm b in listOfAlarmGroups)
    {
        G = //compare a and b

        if (G != null) 
            break;//found the group
    }

    if (G != null)
        //assign a to group G
    else
    {
        //create new group for a
        //add new group to listOfAlarmGroups
    }
}   

两者之间的区别在于，内部循环只查看组，但从不主动与其他新项进行比较，但如果发现某个项未与现有组进行分组，则会得到一个新组，下一个警报将与该新组以及旧组进行比较。效果相同，算法略有不同。
分组是否可传递？也就是说，如果您有一组旧警报，您是否必须对照所有警报检查一个新警报，或者仅对照一个警报就足够了？它是对称的吗？如果
a
组与
b
组与
a
？它是自反性的吗？
a
组与
a
组之间有无传递性：我必须对照组中的另一个警报检查一个警报。分组基于特定属性。如果新报警具有这些属性，则可以将其添加到旧组中。它是对称的。检查a和b是否足够。我避免对照a检查a，因为它不是必需的。更准确地说：每个新的警报在开始时都有自己的组。如果组j的一个成员可以与组I的一个成员合并，则会合并这些组。具体故障如下。比较或分组。我有点不清楚您的比较是否失败（新警报从未与旧警报进行过比较），或者分组本身是否失败（旧警报没有获得新的组成员，尽管它们应该这样做）