2

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

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

我们存储每个篮子的篮子信息。每个篮子都有一个 Dictionary<{Size, Color}, Fruit> 定义篮子里所有的水果。但是，这本字典可能并不完全，在这种情况下，所有其他组合都是苹果。字典只包含不同种类的水果。（虽然它们也可以包含苹果。）除了苹果，我们还有梨和香蕉。是的，它们可能是红色的，但我想知道用什么颜料使它们变红。请记住，这只是将问题可视化。:-)

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

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

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

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

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

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

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

4

1 回答 1

2

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

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
于 2009-09-01T01:52:11.307 回答