懒惰地建立一个可枚举的，中间有中断

Question

我有一个对象集合IEnumerable<object> obs。 我还有另一个对象集合IEnumerable<object> data。

对于obs 中的每个ob，我需要在data 中找到与ob 在某个属性中具有相同值的第一项。例如，我可能正在寻找data 中与ob 具有相同ToString() 值的第一项。当找到属性值匹配的第一项时，我对找到的数据项执行一些操作，然后检查obs 中的下一个ob。如果没有找到，我会抛出一个错误。

这是一个幼稚的方法：

foreach (object ob in obs)
{
    foreach (object dataOb in data)
        if (ob.ToString() == dataOb.ToString())
        {
            ... // do something with dataOb
            goto ContinueOuter;
        }
    throw new Exception("No matching data found.");

    ContinueOuter: ;
}

缺点是我每次都计算dataOb.ToString()，没必要。 我可以缓存它：

IDictionary<object, string> dataToDataStr = new Dictionary<object, string>();
foreach (object dataObj in data) // collect all ToString values in advance
    dataToDataStr.Add(dataObj, dataObj.ToString());

foreach (object ob in obs)
{
    foreach (object dataOb in dataToDataStr.Keys)
        if (ob.ToString() == dataToDataStr[dataOb])
        {
            ... // do something with dataOb
            goto ContinueOuter;
        }
    throw new Exception("No matching data found.");

    ContinueOuter: ;
}

缺点是我计算了所有ToString() 值，即使它可能不是必需的。我可能会在数据收集的前半部分找到所有匹配的数据对象。

我怎样才能懒惰地构建dataToDataStr 字典（或任何其他可让我检索对象及其唯一一次计算的 ToString 值的可枚举数据结构）？

这是我想到的代码（与伪代码混合）：

IDictionary<object, string> dataToDataStr = new Dictionary<object, string>();
object lastProcessedDataOb = null;

foreach (object ob in obs)
{
    foreach (object dataOb in dataToDataStr.Keys)
        if (ob.ToString() == dataToDataStr[dataOb])
        {
            ... // do something with dataOb
            goto ContinueOuter;
        }

    foreach (object dataOb in data STARTING AFTER lastProcessedDataOb)
    // if lastProcessedDataOb == null, start with the first entry of data
    {
        dataToDataStr.Add(dataOb, dataOb.ToString();
        lastProcessedDataOb = dataOb;

        if (ob.ToString() == dataToDataStr[dataOb])
        {
            ... // do something with dataOb
            goto ContinueOuter;
        }
    }
    throw new Exception("No matching data found.");

    ContinueOuter: ;
}

我知道如果 data 是 LinkedList 或任何具有索引访问的集合（然后我可以将链表节点或索引存储为 lastProcessedDataOb），这很容易，但事实并非如此 - 它是IEnumerable。也许这里可以使用yield return？

Answer 1

如果您的集合非常大，并且您真的不想为data 的每个项目评估ToString，您可以使用以下方法：

1. 为已计算的项目创建缓存
2. 如果在我的缓存中找到了某个项目 - 太好了，我们找到了匹配项。

3. 否则 - 通过迭代 data 集合继续填充缓存，直到找到匹配项。这可以通过手动控制数据收集的**Enumerator**（而不是使用foreach）来有效地完成。

   IEnumerable<object> obs;
   IEnumerable<object> data;
   Dictionary<string, object> dataCache = new Dictionary<string, object>();
   
   var dataIterator = data.GetEnumerator();
   foreach (var ob in obs)
   {
       var obText = ob.ToString();
       object matchingDataItem = null;
       if (!dataCache.TryGetValue(obText, out matchingDataItem))
       {
           while (dataIterator.MoveNext())
           {
               var currentData = dataIterator.Current;
               var currentDataText = currentData.ToString();
               if (!dataCache.ContainsKey(currentDataText)) // Handle the case when data collection contains duplicates
               {
                   dataCache.Add(currentDataText, currentData);
                   if (currentDataText == obText)
                   {
                       matchingDataItem = currentData;
                       break;
                   }
               }
           }
       }
       if (matchingDataItem != null)
       {
           Console.WriteLine("Matching item found for " + obText);
       }
       else
       {
           throw new Exception("No matching data found.");
       }
   }
   

这样，您可以保证仅在找到所有 obs 项目时迭代 data 集合，并且您不会为每个项目评估 ToString 一次以上。

PS：我希望“ToString”只是一个例子，你在那里有一些复杂的计算，值得这么复杂......

Answer 2

完全忘记了 LINQ 使用惰性求值... 这应该可以工作（我使用 C# 7 的新值元组表示法）：

IEnumerable<(object, string)> objStrPairs = data.Select(o => (o, o.ToString()));
foreach (object ob in obs)
{
    foreach ((object, string) dataPair in objStrPairs)
        if (ob.ToString() == objStrPairs.Item2)
        {
            ... // do something with objStrPairs.Item1
            goto ContinueOuter;
        }
    throw new Exception("No matching data found.");

    ContinueOuter: ;
}