Question

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

首先，我们有成果。水果可以具有特定尺寸（小，中，大）和颜色（红色，绿色，蓝色）。这些将是两个不同的枚举。篮子将包含所有种类的水果，但没有两种颜色或形状相同。但是每一种可能的组合都会在篮下。由于我们有三种尺寸和三种颜色，我们每个篮子最终会有9块水果。如果我们有4种颜色，我们最终会得到12种颜色。

我们每个篮子存储篮子信息。每个篮子都有一个字典＆lt; {Size，Color}，Fruit＆gt;它定义了篮子里的所有水果。但是，这个词典可能不完整，在这种情况下，所有其他组合都是苹果。字典只包含不同种类的水果。（虽然它们也可以包含苹果。）在苹果旁边，我们还有梨和香蕉。是的，它们可能是红色的，但我想知道用什么样的油漆使它们变红。请记住，这只是为了可视化问题。： - ）

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

我需要将这个结构转换成水果和每个水果的列表，找到它们可以找到的篮子，以及特定水果的大小和颜色。因此，香蕉在篮子1（{小，黄色}，{小，红色}，{中，红色}），篮子3（...），篮子4,8和10.与梨相同，但我可以'在篮子1中有一个黄梨，因为那个已经被定义为香蕉。

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

那么，对于转换前后的结构以及如何在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

水果篮，如何使用Linq从篮子或水果的角度来看？

1 个答案: