0

对于 2 值集数据，很明显我可以使用 Dictionary。例如：如果我有“名称”和“位置”作为键值对，我可以使用字典。

3值集呢？我应该使用什么合适的数据集？我有Name, level, position. 唯一独特的是位置。

IE

Item1, port0, line20; 
Item1, port1, line21; 
Item2, port0, line22; 
Item2, port1, line23;
4

7 回答 7

3

为什么不创建一个合适的类呢？很简单，很短，很有意义。

public class FooBar
{
    public string Name {get; set;}
    public string Level {get; set;}
    public string Position {get; set;}
}

然后将其放入List<FooBar>or Dictionary<string, FooBar>（其中关键是Position）。

创建ListorDictionary允许您通过其属性轻松获取项目

var list = new List<FooBar>() {..., ..., ...};
var item = list.Single(f => f.Position == "line21"); // etc.
var other = list.Single(f => f.Name == "Item1");
于 2012-09-12T14:48:16.440 回答
3

您不想创建自己的类型，这就是classandstruct关键字的用途。

public struct My3ValueThing
{
    public string Name;
    public int Level;
    public string Position;
}

然后你可以做

ISet<My3ValueThing> dataset = new HashSet<My3ValueThing>();

如果您想将数据保存在 a 中Dictionary并通过某个唯一键查找您的项目，假设Position您可以这样做，

IDictionary<string, My3ValueThing> data = 
    new Dictionary<string, My3ValueThing>();

并添加这样的项目

var newItem = new My3ValueThing
    {
        Name = "Item1",
        Port = 0,
        Position = "Line20"
    };

data.Add(newItem.Position, newItem);
于 2012-09-12T14:48:45.457 回答
1

我不确定这是否是您的意思，但请尝试使用Tuple类。

它是一个通用类，最多可以容纳 8 个不同类型的值

例如：Tuple<Item, string, string>

于 2012-09-12T14:44:46.860 回答
1

您可以考虑使用Tuple.

Tuple<string, string, string> myTuple = new Tuple<string, string, string>();

您可能遇到的唯一问题是它们并不像Dictionary可能那样独特。

MSDN 文档在这里

于 2012-09-12T14:46:00.870 回答
1

构建一个自定义对象，用值填充它。构建实例数组。然后使用字典作为散列到数组中。（字典，其中 int 是实例的索引。）

老实说，这个问题有很多答案，有很多警告，几乎不可能回答这个问题。您可能需要考虑向我们提供有关您要完成的任务的更多详细信息。

于 2012-09-12T14:48:59.323 回答
1

您也可以只创建一个类来建模您的数据并将其存储在任何IEnumerable（例如List）

public class Item
{
    public Item(int item, int port, int line)
    {
        ItemNum = item;
        PortNum = port;
        LineNum = item;
    }

    public int ItemNum;
    public int PortNum;
    public int LineNum;
}

List<Item> l = new List<Item>();
l.Add(new Item(1, 0, 20));
l.Add(new Item(1, 1, 21));
...
于 2012-09-12T14:49:54.020 回答
0

对于二值集合数据，我们将使用 2-Tuple ( ) 的集合（HashSet<T>或另一个ISet<T>明显可能的实现，如果我们要做任何集合操作）Tuple<T1, T2>，一个匿名类（在方便时 - 通常特别是在涉及 linq 时）或相关数据的自定义类。

我们将使用字典进行一键单值查找。

对于三值集数据，我们将使用一组 3-Tuple ( Tuple<T1, T2, T3>) 和匿名类，或用于相关数据的自定义类。

如果你想要一个二元组键，一个值查找，然后使用Dictionary<Tuple<T1, T2> TValue>.

编辑：如果您以前使用过框架版本Tuple，那么您的工具包中确实应该有某种元组类，因为它经常出现。使用这样的东西作为起点：

public static class Tuple
{
    public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
    {
        return new Tuple<T1, T2>(item1, item2);
    }
    public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
    {
        return new Tuple<T1, T2, T3>(item1, item2, item3);
    }
}
public class Tuple<T1, T2> : IEquatable<Tuple<T1, T2>>
{
    private readonly T1 _item1;
    private readonly T2 _item2;
    public Tuple(T1 item1, T2 item2)
    {
        _item1 = item1;
        _item2 = item2;
    }
    public T1 Item1 { get { return _item1; } }
    public T2 Item2 { get { return _item2; } }
    public bool Equals(Tuple<T1, T2> other)
    {
        return
            ReferenceEquals(this, other)
            ||
            (
                other != null
                && (ReferenceEquals(_item1, other._item1) || (_item1 != null && _item1.Equals(other._item1)))
                && (ReferenceEquals(_item2, other._item2) || (_item2 != null && _item2.Equals(other._item2)))
            );
    }
    public override bool Equals(object obj)
    {
        return Equals(obj as Tuple<T1, T2>);
    }
    public override int GetHashCode()
    {
        int h1 = _item1 == null ? 0 : _item1.GetHashCode();
        int h2 = _item2 == null ? 0 : _item2.GetHashCode();
        return ((h1 << 5) + h1) ^ h2;
    }
}
public class Tuple<T1, T2, T3> : IEquatable<Tuple<T1, T2, T3>>
{
    private readonly T1 _item1;
    private readonly T2 _item2;
    private readonly T3 _item3;
    public Tuple(T1 item1, T2 item2, T3 item3)
    {
        _item1 = item1;
        _item2 = item2;
        _item3 = item3;
    }
    public T1 Item1 { get { return _item1; } }
    public T2 Item2 { get { return _item2; } }
    public T3 Item3 { get { return _item3; } }
    public bool Equals(Tuple<T1, T2, T3> other)
    {
        return
            ReferenceEquals(this, other)
            ||
            (
                other != null
                && (ReferenceEquals(_item1, other._item1) || (_item1 != null && _item1.Equals(other._item1)))
                && (ReferenceEquals(_item2, other._item2) || (_item2 != null && _item2.Equals(other._item2)))
                && (ReferenceEquals(_item3, other._item3) || (_item3 != null && _item2.Equals(other._item3)))
            );
    }
    public override bool Equals(object obj)
    {
        return Equals(obj as Tuple<T1, T2, T3>);
    }
    public override int GetHashCode()
    {
        int h1 = _item1 == null ? 0 : _item1.GetHashCode();
        int h2 = _item2 == null ? 0 : _item2.GetHashCode();
        int h3 = _item3 == null ? 0 : _item3.GetHashCode();
        int h = ((h1 << 5) + h1) ^ h2;
        return ((h << 5) + h) ^ h3;
    }
}
于 2012-09-12T14:51:20.470 回答