我需要一个多维数据结构，其中每个维度都是一个在设计时已知的小列表。

在我程序的不同位置，我希望能够以强类型方式访问按不同维度“切片”的数据。

我在下面放了一些示例代码，适用于使用嵌套界面的 2D 示例，但我想它在 3D 或 4D 中会变得非常可怕。正如@kvb 指出的那样，所需的样板代码将呈指数级增长。

谁有更好的建议？我的意思是，保持代码简单/简短/易于理解，同时仍然保留按照以下几行做事的能力:

Data a = new Data(...)
...
SomeMethodThatOnlyCaresAboutRedThings(a.Red) // takes a IBySize<T>
...
SomeMethodThatOnlyCaresAboutBigThings(a.Big) // takes a IByColour<T>
...

这避免了那些方法必须知道与它们不相关的数据结构部分，从而使它们更容易测试。

我在这里使用颜色/尺寸纯粹作为示例，对于无意中误导任何人这些选择是有意义的，我深表歉意。 T 可以是一个简单的数据项，如 float 或其他一些简单的数据结构。

标记为 F# 和 C#，因为我对其中任何一个的解决方案都很满意。

public interface IByColour<T>
{
    T Green { get; }
    T Red { get; }
    T Blue { get; }
}

public interface IBySize<T>
{
    T Small { get; }
    T Big { get; }
}

internal class ByColour<T> : IByColour<T>
{
    public T Green { get; private set; }
    public T Red { get; private set; }
    public T Blue { get; private set; }

    internal ByColour(T green, T red, T blue)
    {
        Green = green;
        Red = red;
        Blue = blue;
    }
}

internal class BySize<T> : IBySize<T>
{
    public T Small { get; private set; }
    public T Big { get; private set; }

    internal BySize(T small, T big)
    {
        Small = small;
        Big = big;
    }
}

public class Data<T> : IByColour<IBySize<T>>, IBySize<IByColour<T>>
{
    public IBySize<T> Green { get; private set; }
    public IBySize<T> Red { get; private set; }
    public IBySize<T> Blue { get; private set; }

    public IByColour<T> Small { get; private set; }
    public IByColour<T> Big { get; private set; }

    public Data(IBySize<T> green, IBySize<T> red, IBySize<T> blue)
    {
        Green = green;
        Red = red;
        Blue = blue;

        Small = new ByColour<T>(Green.Small, Red.Small, Blue.Small);
        Big = new ByColour<T>(Green.Big, Red.Big, Blue.Big);
    }
}

编辑:澄清我所说的“更好”是什么意思，这是我的解决方案所具有的理想属性，并解释我想如何使用它。

最佳答案

这听起来像是对老式的很好的使用 DataTable .然后，您可以根据需要使用 Linq 进行切片和切 block ，编译器会自动生成由所选列的不同组合创建的任何唯一类型。 DataTable 中的所有列是强类型的，对它们的查询结果也是如此。此外，DataColumns在DataTable可以有任何类型，包括复杂对象或您自己的枚举类型。

如果您想坚持使用更数学/不可变/F# 的处理方式，您可以使用数组或 List的 Tuple<Type1, Type2, .. TypeN> ，这与 DataTable 基本相同。无论如何。

如果您提供更多关于您正在建模的内容的背景信息，我可以提供一个示例。我不确定您发布的代码是否应该表示衣服、图像(RGB 颜色空间)或完全不同的东西。

[一小时后] 好吧，OP 没有更新，所以我将继续使用 List<Tuple<x, y, ..n>> 的示例并假设对象是衣物。

// Some enums
public enum Size { Small, Medium, Large }
public enum Color { Red, Green, Blue, Purple, Brown }
public enum Segment { Men, Women, Boys, Girls, Infants }

// Fetches the actual list of items, where the object
// item is the actual shirt, sock, shoe or whatever object
static List<Tuple<Size, Color, Segment, object>> GetAllItems() {
    return new List<Tuple<Size, Color, Segment, object>> {
        Tuple.Create(Size.Small, Color.Red, Segment.Boys, (object)new { Name="I'm a sock! Just one sock." }),
        Tuple.Create(Size.Large, Color.Blue, Segment.Infants, (object)new { Name="Baby hat, so cute." }),
        Tuple.Create(Size.Large, Color.Green, Segment.Women, (object)new { Name="High heels. In GREEN." }),
    };
}

static void test() {
    var allItems = GetAllItems();

    // Lazy (non-materialized) definition of a "slice" of everything that's Small
    var smallQuery = allItems.Where(x => x.Item1 == Size.Small);

    // Lazy map where the key is the size and the value is 
    // an IEnumerable of all items that are of that size
    var sizeLookup = allItems.ToLookup(x => x.Item1, x => x);

    // Materialize the map as a dictionary the key is the size and the 
    // value is a list of all items that are of that size
    var sizeMap = sizeLookup.ToDictionary(x => x.Key, x => x.ToList());

    // Proof:
    foreach (var size in sizeMap.Keys) {
        var list = sizeMap[size];
        Console.WriteLine("Size {0}:", size);
        foreach (var item in list) {
            Console.WriteLine("  Item: {{ Size={0}, Color={1}, Segment={2}, value={3} }}",
                item.Item1, item.Item2, item.Item3, item.Item4);
        }
    }
}

关于c# - 有没有更好的方法来创建多维强类型数据结构？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12959627/