分解项目创建方程式链的链(可能使用递归)

第二个答案，针对"从头开始重写"方法。如果只是给出没有先前代码的问题语句，我或多或少会这样做。

abstract class Item
{
    public string Name { get; private set; }
    public abstract IEnumerable<Item> Ingredients { get; }
    public abstract IEnumerable<Item> ParseRecipe();
    protected Item(string name)
    {
        Name = name;
    }
    public static Item GetItem(string _name)
    {
        return items.Find(match => match.Name == _name);
    }
}
class Atom : Item
{
    public Atom(string name) : base(name) { }
    public override IEnumerable<Item> Ingredients { get { return null; } }
    public override IEnumerable<Item> ParseRecipe()
    {
        return new[] { this };
    }
}
class Recipe : Item
{
    public Recipe(string name, params Item[] ingredients) : base(name)
    {
        _ingredients = ingredients;
    }
    public Recipe(string name, params string[] ingredients) : base(name)
    {
        _ingredients = ingredients.Select(x => Item.GetItem(x));
    }
    private IEnumerable<Item> _ingredients;
    public override IEnumerable<Item> Ingredients { get { return _ingredients;} }
    public override IEnumerable<Item> ParseRecipe()
    {
        Console.WriteLine("1 " + this.Name + " = " 
                                 + String.Join(" + ", this.Ingredients.Select(x => "1 " + x.Name)));
        var components = new List<Item>();
        foreach(var ing in Ingredients)
        {
            components.AddRange(ing.ParseRecipe());
        }
        return components;
    } 
}

使用方式：

void Main()
{
    items.Add(new Atom("Foo"));
    items.Add(new Atom("Bar"));
    items.Add(new Atom("Baz"));
    items.Add(new Atom("Qux" ));
    items.Add(new Recipe("Foobar", "Foo", "Bar"));
    items.Add(new Recipe( "Bazqux", "Baz", "Qux" ));
    items.Add(new Recipe( "Foobarbazqux", "Foobar", "Bazqux" ));
    string search = "Foobarbazqux";
    var item = Item.GetItem(search);
    Console.WriteLine("1 " + item.Name + " = " 
                            + String.Join(" + ", item.ParseRecipe().Select(x => "1 " + x.Name)));
}

结果：

1 Foobarbazqux = 1 Foobar + 1 Bazqux
1 Foobar = 1 Foo + 1 Bar
1 Bazqux = 1 Baz + 1 Qux
1 Foobarbazqux = 1 Foo + 1 Bar + 1 Baz + 1 Qux

与原始代码相比，此方法的主要优势与abstract class Item有关。因此，我们只关心初始化期间Atom s和Recipe s之间的差异。之后，所有内容都被视为Item。这意味着递归变得简单得多，因为我们不在乎当前项的Ingredients是原子的、recipies还是它们的混合。这也意味着您可以在任何事情上调用SearchRecipe()，而无需首先检查它是否是Recipe(注意，在这种情况下，为了更好地输出，我稍微编辑了上面的代码。(

对于struct，这是不可能的，因为它们不能相互继承，因此不能被视为父类型。您可以声明一个它们都将实现的interface，但根据这一点，当您将其强制转换到接口时，struct将失去大部分内存优势，而我们一直在这样做。

在求解时，我会将所有component=component[]加载到内存中。我认为这应该不是什么大问题。

首先想到的是，你需要一个最短路径算法：由于一个食谱可以分为多个其他食谱，你可能正在寻找数量最少的食材，并希望确保它完成。

Dijkstra算法的标准实现将所有叶子都作为目标来解决，我想这会很好(或者这是一种变体？(，也会确保你不会绕圈跑。

然后。。。我想你可以使用路径来生成你想要的输出。

我相信总体上有一个更好的设计，但这里有一个小的修改，可以产生你想要的输出(或多或少(：

public static IEnumerable<IEnumerable<Item>> SearchRecipe(string _search)
{
    List<Recipe> item_recipes = recipes.FindAll(match => match.Result.Name == Item.GetItem(_search).Name);
    var ingredients = new List<IEnumerable<Item>>();
    foreach (Recipe recp in item_recipes)
    {
        foreach (Item ingredient in recp.Ingredients)
        {
            if (recipes.FindAll(match2 => match2.Result.Name == ingredient.Name).Count != 0)
            {
                ingredients.Add(SearchRecipe(ingredient.Name).SelectMany(x => x));
            }
            else
            {
                ingredients.Add(new[] { ingredient });
            }
        }
        Console.WriteLine(recp.Result.Name + " = " + String.Join(" + ", ingredients.SelectMany(x => x.Select(y => y.Name))));
    }
    return ingredients;
}

产品：

Foobar = Foo + Bar
Bazqux = Baz + Qux
Foobarbazqux = Foo + Bar + Baz + Qux