关于c＃：获取下一个KeyValuePair＆lt;，＆gt;


Get the next KeyValuePair<,> from a Dictionary<,> without index

在没有index或类似物的情况下，是否可以在Dictionary<,>或下一个物体内获得给定KeyValuePair<,>的位置？

例如，假设我有以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
Dictionary<Object, String>
    dictionary = new Dictionary<Object, String>() {
        { new Object(),"String A" },
        { new Object(),"String B" },
        { new Object(),"String C" },
        { new Object(),"String D" },
        { new Object(),"String E" },
        { new Object(),"String F" },
    };

String
    knownValue ="String C";

从那里，我应该如何继续获得具有"String D"值的KeyValuePair指数或KeyValuePair？

更新更多信息

在给出的例子和我想做的地方，Keys和Values都是独一无二的。我正在使用Dictionary<,>跟踪两个对象，同时知道哪个对象与之相关。

更详细的一点，我使用这个Dictionary<,>来跟踪一个位置和一个android应用程序上的Marker。我被要求在选择了一个Marker并弹出一张包含该位置基本信息的小卡片后，启用刷卡并显示下一个或上一个位置。

这就是这个问题的切入点。我从一个服务器收到一个位置列表，这个列表必须保存。处理完这个列表后，我将每个位置与地图上的Marker相关联。

此时，每当用户单击Marker时，我使用LINQ表达式查找Dictionary<,>上的Marker并检索相关位置。

相关讨论

  • 钥匙必须是唯一的。值…没那么多。如果用另一个String C替换String E，那么"正确"的答案是什么？
  • 我已经更新了问题。另外，Key和Value都是独一无二的，我可以保证Value在任何时候都不会改变。即使它确实改变了，我也有办法跟踪它。
  • 措辞是强制性的吗？我建议换一种更适合你指数化问题的方法

字典中的顺序是不确定的。

参见：字典中元素的顺序

但是，您可以使用OrderedDictionary(https://msdn.microsoft.com/en-us/library/system.collections.specialized.orderedDictionary(v=vs.110).aspx)

相关讨论

  • 我为我将要说的话道歉，但如果我循环通过Dictionary，我会不会遇到相同的顺序相同的条目？如果我用foreach迭代Dictionary，我会不会先遇到"String A"，然后是"String B"等，顺序相同？
  • 引自msdn：为了枚举，字典中的每个项都被视为keyValuePair结构，表示一个值及其键。返回项目的顺序未定义。

Dictionary(TKey,TValue)不以列表格式存储它的数据，它(非常非常简单)散列密钥并将其存储在bucket中，因此它没有"下一步"的概念。也许你可以考虑使用SortedDictionary(tkey，tvalue)。然后，您可以使用迭代器按需要的任何顺序移动元素。

相关讨论

  • 正如我在更新中提到的，必须保留订单。不幸的是，这不是我想要的解决方案。
  • 如果使用SortedDictionary，则控制用于对元素排序的IComparer实现…如果您希望订单是添加它们的订单，那么可以这样做：)

在c中，Dictionary没有索引对象这样的东西——对象没有特殊的顺序。这是因为字典是如何工作的，它们根据键的散列值将键和值放在所谓的"bucket"中。

如果需要对元素进行排序，可以使用SortedDictionary。

也许您只需要枚举所有元素，在这种情况下，您应该这样做：

1
2
3
4
5
foreach (var kvp in dictionary)
{
    if ("String D".Equals(kvp.Value))
    ; //do stuff
}

如果您需要能够按关键字和值进行搜索，那么不同的结构可能更适合。例如，请参见此处

问题编辑后：

编辑让它变得有趣，这应该对你有用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class SortedBiDcit<T1, T2> //this assumes T1 and T2 are different (and not int for indexer) and values are unique
{
    Dictionary<T1, Tuple<T2, int>> dict1 = new Dictionary<T1, Tuple<T2, int>>();
    Dictionary<T2, T1> dict2 = new Dictionary<T2, T1>();

    List<T1> indices = new List<T1>();

    public int Count { get { return indices.Count; } }

    public T2 this[T1 arg]
    {
        get { return dict1[arg].Item1; }
    }

    public T1 this[T2 arg]
    {
        get { return dict2[arg]; }
    }

    public Tuple<T1, T2> this[int index]
    {
        get
        {
            T1 arg1 = indices[index];
            return new Tuple<T1, T2>(arg1, dict1[arg1].Item1);
        }
    }

    public void Add(T1 arg1, T2 arg2)
    {
        dict1[arg1] = new Tuple<T2, int>(arg2, indices.Count);
        dict2[arg2] = arg1;

        indices.Add(arg1);
    }

    public void Remove(T1 arg)
    {
        var arg2 = dict1[arg];
        dict1.Remove(arg);
        dict2.Remove(arg2.Item1);
        indices.RemoveAt(arg2.Item2);
    }

    public void Remove(T2 arg)
    {
        var arg2 = dict2[arg];
        var arg1 = dict1[arg2];

        dict1.Remove(arg2);
        dict2.Remove(arg1.Item1);
        indices.RemoveAt(arg1.Item2);
    }
}

号

它缺乏基本的错误检查，但您可以从中获得它。它应该允许您这样使用它：

1
2
3
4
5
6
7
8
9
var test = new SortedBiDcit<object, string>();
test.Add(new object(),"test");
for (int i = 0; i < test.Count; ++i)
{
    var tuple = test[i];
    var str = test[tuple.Item1]; //retrieve T2
    var obj = test[tuple.Item2]; //retrieve T1
    Console.WriteLine(tuple.Item2); //prints"test"
}

希望有帮助！

相关讨论

  • 使用foreach迭代每个条目是我计划要做的，但不幸的是，Dictionary有1000多个条目(我仍在测试beta数据，我假设这个数字与最终版本相比将是零)。问题是：它由于需要迭代的数据量而锁定。
  • @不幸的是，在Dictionary中没有其他方法按值搜索，请考虑基于两个字典的结构，如链接问题，否则您将不得不更改设计。另一方面，如果只在1000条记录上显著减慢速度，那么瓶颈可能在其他地方，因为枚举这样数量的条目不应该是一个问题？
  • @奥曼我举编辑的答案，包括解决方案，你的编辑。它仍然需要一些工作，但希望概念是明确的。
  • 我已经提出了这个问题的解决方案。只是做些修改，然后我会把它贴在这里。

从技术上讲，有一种方法可以在字典中找到值的索引。

dictionary.Values字段是从IEnumerable继承的Dictionary.ValueCollection字段。

作为一个IEnumerable，您可以使用foreach迭代它，或者使用类似的东西

1
2
3
4
IEnumerable<Int32> idxs = dictionary.values.SelectMany(
    (string value, Int32 idx) =>
    (value =="insertStringHere") ? (new int[]{ idx }) : {new int[]{}}
);

。

选择要查找的值的索引(或所有索引，如果存在重复项)。

不过，我不建议这样做，因为Dictionary并不保证价值顺序。不过，它可能对SortedDictionary或SortedList起作用。

(编辑：或KeyedCollectionApparenty，如https://stackoverflow.com/users/1892381/olivier-albertini指出的那样)

我想你应该使用KeyedCollection，它是为这个设计的……埃多克斯1〔5〕

演示

.NET小提琴示例

在示例中，我使用索引或值作为索引。

源代码的.NET引用

更新

KeyedCollection有一系列效价(List和Dictionary。两者在幕后保持同步。

使用这个的主要参数是当您想从值中提取键时，因为这是您想要的…我认为这对你很有用！

相关讨论

  • 直到现在才有时间检查这个答案，直截了当地说，这不是Dictionary吗？我可能对此视而不见，但除了名字之外，我看不出这和Dictionary有什么区别。想解释一下区别吗？
  • 看我的更新！

因为SortedDictionary是按key排序，不是按add()排序，我相信江户一〔3〕不是你想要的。

也许你想要的是OrderedDictionary，但看起来你是一个wp开发者，OrderedDictionary不是wp的发行版。

你的knownValue是一个值(不是键)，所以我认为最好的方法是：

1
2
3
4
5
6
var list = new List<string>() { .... ,"String C","String D", ... };
// if you still need dict, then:
var dictionary = list.ToDictionary(z => new object());
// whatever, find the"String D"
var knownValue ="String C";
var ret = list.SkipWhile(z => z != knownValue).Skip(1).First();

更新后

为什么不创建一个类呢？

1
2
3
4
5
class A
{
    Marker;
    Location;
}

。

当用户点击它时，你应该得到A，而不是标记。

相关讨论

  • 实际上，这是一个非常好的解决方案！但我想我找到了解决这个问题的办法。这不是最漂亮的解决方案，但有点起作用。每当我觉得这是我想要的解决方案，并且有效时，我都会在这里发帖。

这个问题实际上有一个相当简单的解决方案——虽然不是很好，但它确实起到了作用。

在这种情况下，我试图从Dictionary对象获取下一个或上一个条目。不幸的是，它没有像List那样的IndexOf( ... )，所以我不能做像Dictionary[index + 1]那样的事情。

但是Dictionary对象有一种索引方法。通过Dictionary.Keys或dictionary.Values转换成List后。这不是我们习惯的索引，而是它接近的。

考虑到这一点，我可以创建这样的扩展：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public static KeyValuePair<K, V> After<K, V>( this Dictionary<K, V> dictionary, K key ) {
    Int32 position = dictionary.Keys.ToList().IndexOf( key );

    if( position == -1 )
        throw new ArgumentException("No match.","key" );

    position++;

    if( position >= dictionary.Count )
        position = 0;

    K k = dictionary.Keys.ToList()[ position ];
    V v = dictionary.Values.ToList()[ position ];

    return new KeyValuePair<K, V>( k, v );
}
public static KeyValuePair<K, V> After<K, V>( this Dictionary<K, V> dictionary, V value ) {
    Int32 position = dictionary.Values.ToList().IndexOf( value );

    if( position == -1 )
        throw new ArgumentException("No match.","value" );

    position++;

    if( position >= dictionary.Count )
        position = 0;

    K k = dictionary.Keys.ToList()[ position ];
    V v = dictionary.Values.ToList()[ position ];

    return new KeyValuePair<K, V>( k, v );
}
public static KeyValuePair<K, V> Before<K, V>( this Dictionary<K, V> dictionary, K key ) {
    Int32 position = dictionary.Keys.ToList().IndexOf( key );

    if( position == -1 )
        throw new ArgumentException("No match.","key" );

    position--;

    if( position < 0 )
        position = dictionary.Count - 1;

    K k = dictionary.Keys.ToList()[ position ];
    V v = dictionary.Values.ToList()[ position ];

    return new KeyValuePair<K, V>( k, v );
}
public static KeyValuePair<K, V> Before<K, V>( this Dictionary<K, V> dictionary, V value ) {
    Int32 position = dictionary.Values.ToList().IndexOf( value );

    if( position == -1 )
        throw new ArgumentException("No match.","value" );

    position--;

    if( position < 0 )
        position = dictionary.Count - 1;

    K k = dictionary.Keys.ToList()[ position ];
    V v = dictionary.Values.ToList()[ position ];

    return new KeyValuePair<K, V>( k, v );
}

。

这个扩展适合我需要的。

有了这个，我就可以得到任何给定的key或Value的After或Before条目。

你可以在这里查看。

相关讨论

  • 不幸的是，它不会(总是)起作用。正如在@user1859022的答案下面的注释中所提到的，EDOCX1[0]条目的枚举是未指定的，这里也是如此。请参阅msdn Keys规范备注部分的第一句。
  • 到目前为止，这种方法已经奏效了。我一直在做一些测试，以检查Dictionary何时连同其他订单返回Keys或Values。直到现在，它一直是相同的。如果是100000000分之一的失败，没有太多的休息，我可以跟上损害赔偿。很糟糕，是的。可能影响不大。
  • @Auhmaan字典的顺序将在调整大小或删除&添加项或其他内容后更改，请阅读.NET源代码或msdn文档。
  • @直到这个评论的时候——在一些测试之后——我都没有看到顺序的改变。由于在这两个测试中以及在我要实现这一点的地方，Dictionary并没有改变——没有添加或删除项目——我认为这是一个相当稳定的解决方案。正如我在前面的评论中提到的，我知道这是不稳定的。如果订单发生变化，用户可能不会注意到差异。