c# - Fruit Basket，如何使用Linq从篮子或水果的角度查看？

Question

这个问题与金融产品、利率和决定某种产品的利息的两个属性有关。但我认为水果和篮子更容易形象化。

首先，我们有水果。水果可以有特定的大小(小、中、大)和颜色(红、绿、蓝)。这将是两个不同的枚举。篮子里装着各种水果，但没有两种水果的颜色或形状是完全相同的。但是每一种可能的组合都会在篮子里。因为我们有三种尺寸和三种颜色，所以我们最终会在每个篮子里放 9 个水果。如果我们有 4 种颜色，我们最终会得到 12 件。

我们存储每个篮子的篮子信息。每个篮子都有一个 Dictionary<{Size, Color}, Fruit> 它定义了篮子里所有的水果。然而，这个字典可能不是完全满的，在这种情况下所有其他组合都是苹果。字典只收录了不同种类的水果。 (尽管它们也可以包含苹果。)除了苹果，我们还有梨和香蕉。是的，它们可能是红色的，但我想知道用什么样的油漆使它们变成红色。请记住，这只是为了形象化问题。 :-)

无论如何，我现在有一个篮子列表，每个篮子都有一个水果列表。默认情况下是苹果、梨或香蕉(如果它们在字典中)。但我需要从不同的角度来看待这些信息。

我需要将此结构转换为水果列表和每个水果可以找到它们的篮子，以及特定水果的大小和颜色。因此，香蕉在篮子 1({small，yellow}，{small，red}，{medium，red})，篮子 3(...)，篮子 4、8 和 10 中。与梨相同，但我不能篮子 1 中没有黄梨，因为那个已经被定义为香蕉。

我有一个很大的优势:这些结构都没有明确定义!但是，我需要篮 subview 作为向转换过程提供信息的方式。我需要 Fruit View 进行进一步计算，因为我需要根据水果本身进行额外的数学运算，而不是它们的大小或颜色或它们来自的篮子...

那么，对于转换前后的结构以及如何在 C# 中使用 Linq 本身进行转换，有什么好的建议吗？

---

实际上，篮子是产品。尺寸和颜色是产品上较小的差异。结果是利率，我只需要这个利率来计算。通过按利率对产品进行分组，我可以将计算次数减少到几个。我们正在处理 1600 多种产品，每种产品大约 (10x10) 100 种不同的变体，因此总共有 160.000 种利率。利率本身通常在 3% 到 7.5% 之间，四舍五入到 1/20%。因此，大约 90 种不同的速率导致 90 次计算而不是 160.000 次计算...

而且我需要说服管理层采取这一步骤，因为他们担心这需要大量工作，变得不可读或难以维护。

---

根据利率，你可以根据一个人在一定条件下每月愿意花多少钱来计算他可以贷款多少钱。这种优化将使我能够更快地比较不同的产品。太糟糕了，我是公司里第一个注意到这个有趣优化的人! :-)

Answer 1

好吧，一旦开始，我就必须编写整个代码。也许它不能解决您的根本问题，但我认为它解决了水果篮问题。

public enum FruitSize{Small, Medium, Large}
public enum FruitColor {Red, Green, Blue}

  // immutable struct is important for use as dictionary keys
public struct FruitDescription
{
    readonly FruitSize _size;
    public FruitSize Size {get{return _size;}}
    readonly FruitColor _color;
    public FruitColor Color { get { return _color; } }
    public FruitDescription(FruitSize size, FruitColor color)
    {
        _size = size;
        _color = color;
    }
}
    //abstract parent class ...
public abstract class Fruit
{ public FruitDescription Description {get;set;} }
    //... and children
public class Apple : Fruit{}
public class Banana : Fruit{}
public class Pear : Fruit{}

public class Basket
{
    private Dictionary<FruitDescription, Fruit> internalFruits =
        new Dictionary<FruitDescription, Fruit>();

    public void AddFruit(Fruit addme)
    {
        internalFruits[addme.Description] = addme;
    }

    public IEnumerable<FruitDescription> AllDescriptions()
    {
        foreach (FruitSize size in Enum.GetValues(typeof(FruitSize)))
        {
            foreach (FruitColor color in Enum.GetValues(typeof(FruitColor)))
            {
                FruitDescription desc = new FruitDescription(size, color);
                yield return desc;
            }
        }
    }

    public Apple GetDefaultApple(FruitDescription desc)
    {
        return new Apple() { Description = desc };
    }

    public IEnumerable<Fruit> GetFruits()
    {
        IEnumerable<Fruit> result = AllDescriptions()
            .Select(desc =>
              internalFruits.ContainsKey(desc) ?
              internalFruits[desc] :
              GetDefaultApple(desc));
        return result;
    }
}

public class Pair<T, U>
{
    public T First { get; set; }
    public U Second { get; set; }
}

public class TestClass
{
    public static void Test()
    {
        Basket b1 = new Basket();
        b1.AddFruit(new Banana() { Description =
            new FruitDescription(FruitSize.Medium, FruitColor.Blue) });
        b1.AddFruit(new Banana() { Description =
            new FruitDescription(FruitSize.Medium, FruitColor.Green) });

        Basket b2 = new Basket();
        b2.AddFruit(new Pear() { Description =
            new FruitDescription(FruitSize.Medium, FruitColor.Green) });

        List<Basket> source = new List<Basket>();
        source.Add(b1);
        source.Add(b2);

        //the main event - a query.
        List<Pair<Fruit, Basket>> result =
        (
          from basket in source
          from fruit in basket.GetFruits()
          select new Pair<Fruit, Basket>()
          { First = fruit, Second = basket }
        ).ToList();

        //a second results structure for fun
        ILookup<Type, Basket> resultByType = result.ToLookup
        (
            p => p.First.GetType(),
            p => p.Second
        );

        Console.WriteLine("Number of fruit: {0}",
            result.Count);
        Console.WriteLine("Number of apples: {0}",
            resultByType[typeof(Apple)].Count());
        Console.WriteLine("Number of baskets with apples: {0}",
            resultByType[typeof(Apple)].Distinct().Count());
        Console.WriteLine("Number of bananas: {0}",
            resultByType[typeof(Banana)].Count());
        Console.WriteLine("Number of baskets with bananas: {0}",
            resultByType[typeof(Banana)].Distinct().Count());
    }

}

有了这些结果:

Number of fruit: 18
Number of apples: 15
Number of baskets with apples: 2
Number of bananas: 2
Number of baskets with bananas: 1