c# - 如何从迭代方法到递归方法

Question

我有一个迭代 C# 循环，它可以填充最多 5 列的棋盘模式。

这些值是成对的，它始终是一个标题和每列的多个值，并且它将这些值组合成一个非重复的组合。

从我能想到的最简单的解决方案开始，在查看之后，我认为一定有更好的方法通过递归来解决这个问题。

下面是我迄今为止尝试过的示例:

 List<EtOfferVariant> variants = new List<EtOfferVariant>();

 _containers[0].Variant.ForEach(first =>
 {
     if (_containers.Count > 1)
     {
         _containers[1].Variant.ForEach(second =>
         {
             if (_containers.Count > 2)
             {
                 _containers[2].Variant.ForEach(third =>
                     {
                         EtOfferVariant va = new EtOfferVariant();
                         va.OfferVariant1Type = _containers[0].VariantKey;
                         va.OfferVariant1 = first;
                         va.OfferVariant2Type = _containers[1].VariantKey;
                         va.OfferVariant2 = second;
                         va.OfferVariant3Type = third;
                         va.OfferVariant3 = _containers[3].VariantKey;
                         variants.Add(va);
                     });
             }
             else
             {
                 EtOfferVariant va = new EtOfferVariant();
                 va.OfferVariant1Type = _containers[0].VariantKey;
                 va.OfferVariant1 = first;
                 va.OfferVariant2Type = second;
                 va.OfferVariant2 = _containers[1].VariantKey;
                 variants.Add(va);
             }
         });
     }
     else
     {
         EtOfferVariant va = new EtOfferVariant();
         va.OfferVariant1Type = _containers[0].VariantKey;
         va.OfferVariant1 = first;
         variants.Add(va);
     }
 });

容器由字符串列表(值)和键(标题)组成。

它是一个缩短版本 OfferVariant 在真实示例中计数为 5。

我无法更改初始棋盘结构，因为它是由现有数据库提供的。

下面是 2 个容器的数据输入和输出的图示，包括:

容器 1:

• 重点:馅饼
• 值(value)观:
  
  1. 覆盆子
  2. 草莓

容器 2:

• 关键:喝
• 值(value)观:
  1. 可乐，
  2. 咖啡

生成的输出将包含 4 行，包含

编辑，因为它很容易被误解，如图所示

结果将是包含 4 列的数据库中的一行

Column 1 | Column 2  | Column 3 | Column 4
Pie      | Raspberry | Drink    | Cola 
Pie      | Raspberry | Drink    | Coffee
Pie      | Strawberry| Drink    | Cola 
Pie      | Strawberry| Drink    | Coffee

EtOfferVariant 是一个包含这些列的 ORM Poco

Answer 1

感谢您的回复，Martin Liversage 有点引导我的心理，很难，它不是纯笛卡尔积，因为事实是被分组后被压平Cines 方法给了我正确方向的最后一点，我现在通过以下方式解决了这个问题

在第一步中，我为第一个变体生成初始行

    List<EtOfferVariant> row = new List<EtOfferVariant>();
    _containers.First().Variant.ForEach(o =>
    {
        row.Add(new EtOfferVariant() { OfferVariant1 = o, OfferVariant1Type = _containers.First().VariantKey });
    });
  return BuildVariants(row);

然后运行它

  private List<EtOfferVariant> BuildVariants(List<EtOfferVariant> row, int containerIndex = 1)
    {
        List<EtOfferVariant> final = new List<EtOfferVariant>();
        row.ForEach(y =>
        {
            for (int i = 0; i < _containers[containerIndex].Variant.Count; i++)
            {
                var ret = MultiplyFromPrevious(y);
                FillByIndex(ret, _containers[containerIndex].Index, _containers[containerIndex].VariantKey, _containers[containerIndex].Variant[i]);
                final.Add(ret);
            }
        });
        containerIndex++;
        if (containerIndex < _containers.Count)
           return BuildVariants(final, containerIndex);
        return final;
    }

再次感谢Cine

private EtOfferVariant MultiplyFromPrevious(EtOfferVariant variant)
{
    EtOfferVariant ret = new EtOfferVariant();
    ret.OfferVariant1 = variant.OfferVariant1;
    ret.OfferVariant2 = variant.OfferVariant2;
    ret.OfferVariant3 = variant.OfferVariant3;
    ret.OfferVariant4 = variant.OfferVariant4;
    ret.OfferVariant5 = variant.OfferVariant5;

    ret.OfferVariant1Type = variant.OfferVariant1Type;
    ret.OfferVariant2Type = variant.OfferVariant2Type;
    ret.OfferVariant3Type = variant.OfferVariant3Type;
    ret.OfferVariant4Type = variant.OfferVariant4Type;
    ret.OfferVariant5Type = variant.OfferVariant5Type;

    return ret;
}

我还将列拆分为一个自己的方法，但它所做的只是获取索引并将值映射到对象，没什么特别的

再次感谢大家，这真的放松了代码