blocks|key|330739|text|它是一个介于IGrouping和字典之间的混合体。它允许您通过一个键将项分组在一起，然后通过该键以一种有效的方式访问它们(而不是像GroupBy允许的那样，只是遍历所有项)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|330740|例如，您可以加载.NET类型并按名称空间构建查找...然后非常容易地获取特定名称空间中的所有类型：|330741|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Xml;

public+class+Test
{
++++static+void+Main()
++++{
++++++++//+Just+types+covering+some+different+assemblies
++++++++Type[]+sampleTypes+=+new[]+{+typeof(List<>),+typeof(string),+
+++++++++++++++++++++++++++++++++++++typeof(Enumerable),+typeof(XmlReader)+};

++++++++//+All+the+types+in+those+assemblies
++++++++IEnumerable<Type>+allTypes+=+sampleTypes.Select(t+=>+t.Assembly)
+++++++++++++++++++++++++++++++++++++++++++++++.SelectMany(a+=>+a.GetTypes());

++++++++//+Grouped+by+namespace,+but+indexable
++++++++ILookup<string,+Type>+lookup+=+allTypes.ToLookup(t+=>+t.Namespace);

++++++++foreach+(Type+type+in+lookup["System"])
++++++++{
++++++++++++Console.WriteLine("{0}:+{1}",+
++++++++++++++++++++++++++++++type.FullName,+type.Assembly.GetName().Name);
++++++++}
++++}
}|code-block|syntax|javascript|330742|(我通常会在普通代码中对这些声明中的大多数使用var。)|330743|entityMap^0|6|9|1T|7|0|0|0|N|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

It's a cross between an <code>IGrouping</code> and a dictionary. It lets you group items together by a key, but then access them via that key in an efficient manner (rather than just iterating over them all, which is what <code>GroupBy</code> lets you do).

For example, you could take a load of .NET types and build a lookup by namespace... then get to all the types in a particular namespace very easily:

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;

public class Test
{
 static void Main()
 {
 // Just types covering some different assemblies
 Type[] sampleTypes = new[] { typeof(List&lt;&gt;), typeof(string), 
 typeof(Enumerable), typeof(XmlReader) };

 // All the types in those assemblies
 IEnumerable&lt;Type&gt; allTypes = sampleTypes.Select(t =&gt; t.Assembly)
 .SelectMany(a =&gt; a.GetTypes());

 // Grouped by namespace, but indexable
 ILookup&lt;string, Type&gt; lookup = allTypes.ToLookup(t =&gt; t.Namespace);

 foreach (Type type in lookup["System"])
 {
 Console.WriteLine("{0}: {1}", 
 type.FullName, type.Assembly.GetName().Name);
 }
 }
}
</code></pre>

(I'd normally use <code>var</code> for most of these declarations, in normal code.)

blocks|key|3303896|text|我以前没有成功地使用过它，但这是我的go：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3303897|Lookup<TKey,+TElement>的行为非常类似于没有唯一约束的表上的(关系)数据库索引。在与其他地方相同的地方使用它。|offset|length|style|CODE|3303898|entityMap^0|0|0|M|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I haven't successfully used it before, but here is my go:

A <code>Lookup&lt;TKey, TElement&gt;</code> would behave pretty much like a (relational) database index on a table without a unique constraint. Use it in the same places you would use the other.

blocks|key|3303900|text|考虑这个问题的一种方法是：Lookup<TKey,+TElement>类似于Dictionary<TKey,+Collection<TElement>>。基本上，可以通过相同的键返回一个包含零个或多个元素的列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3303901|namespace+LookupSample
{
++++using+System;
++++using+System.Collections.Generic;
++++using+System.Linq;

++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++List<string>+names+=+new+List<string>();
++++++++++++names.Add("Smith");
++++++++++++names.Add("Stevenson");
++++++++++++names.Add("Jones");

++++++++++++ILookup<char,+string>+namesByInitial+=+names.ToLookup((n)+=>+n[0]);

++++++++++++//+count+the+names
++++++++++++Console.WriteLine("J's:+{0}",+namesByInitial['J'].Count());+//+1
++++++++++++Console.WriteLine("S's:+{0}",+namesByInitial['S'].Count());+//+2
++++++++++++Console.WriteLine("Z's:+{0}",+namesByInitial['Z'].Count());+//+0,+does+not+throw
++++++++}
++++}
}|code-block|syntax|javascript|3303902|entityMap^0|D|M|12|12|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

One way to think about it is this: <code>Lookup&lt;TKey, TElement&gt;</code> is similar to <code>Dictionary&lt;TKey, Collection&lt;TElement&gt;&gt;</code>. Basically a list of zero or more elements can be returned via the same key.

<pre><code>namespace LookupSample
{
 using System;
 using System.Collections.Generic;
 using System.Linq;

 class Program
 {
 static void Main(string[] args)
 {
 List&lt;string&gt; names = new List&lt;string&gt;();
 names.Add("Smith");
 names.Add("Stevenson");
 names.Add("Jones");

 ILookup&lt;char, string&gt; namesByInitial = names.ToLookup((n) =&gt; n[0]);

 // count the names
 Console.WriteLine("J's: {0}", namesByInitial['J'].Count()); // 1
 Console.WriteLine("S's: {0}", namesByInitial['S'].Count()); // 2
 Console.WriteLine("Z's: {0}", namesByInitial['Z'].Count()); // 0, does not throw
 }
 }
}
</code></pre>

blocks|key|3303906|text|我猜您可能会这样争论:假设您正在创建一个数据结构来保存电话簿的内容。你想先按lastName键，然后按firstName键。在这里使用字典将是危险的，因为许多人可能具有相同的名字。因此，字典最多只能映射到单个值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3303907|Lookup可能会映射到几个值。|3303908|查找“Smith”将是一个大小为十亿的集合。|3303909|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I guess you could argue it this way: imagine you're creating a data structure to hold the contents of a phone book. You want to key by lastName and then by firstName. Using a dictionary here would be dangerous because many people can have the same name. So a Dictionary will always, at most, map to a single value. 

A Lookup will map to potentially several values. 

Lookup["Smith"]["John"] will be a collection of size one billion.

blocks|key|3091091|text|Lookup的一个用途可能是逆转Dictionary。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3091092|假设您有一个实现为Dictionary的电话簿，其中有一组(唯一的)姓名作为键，每个姓名都与一个电话号码相关联。但是两个名字不同的人可能会共享同一个电话号码。这对于Dictionary来说不是问题，因为它不关心两个键对应于相同的值。|3091093|现在，您需要一种查找给定电话号码属于谁的方法。您构建一个Lookup，添加来自您的Dictionary的所有KeyValuePairs，但是向后添加，将值作为关键字，并将关键字作为值。现在，您可以查询电话号码，并获得其电话号码为的所有人员的姓名列表。使用相同的数据构建Dictionary可能会丢失数据(或者失败，这取决于您是如何做到的)，因为这样做|3091094|dictionary["555-6593"]+=+"Dr.+Emmett+Brown";
dictionary["555-6593"]+=+"Marty+McFly";|code-block|syntax|javascript|3091095|表示第二个条目覆盖第一个条目-文档不再列出。|3091096|尝试以稍微不同的方式写入相同的数据：|3091097|dictionary.Add("555-6593",+"Dr.+Emmett+Brown");
dictionary.Add("555-6593",+"Marty+McFly");|3091098|会在第二行抛出一个异常，因为你不能Add一个已经在Dictionary中的键。|3091099|当然，您可能希望使用其他一些单一数据结构在两个方向上进行查找，等等。这个示例意味着每次Dictionary发生更改时，您都必须从它重新生成Lookup。但对于某些数据来说，这可能是正确的解决方案。|3091100|entityMap^0|0|6|G|A|0|9|A|2A|A|0|S|6|15|A|1I|D|3Q|A|0|0|0|0|0|H|3|P|A|0|17|A|1X|6|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1K|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1L|8|@]|D|@]|E|$]]|$1|S|3|T|5|L|7|1M|8|@]|D|@]|E|$M|N]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|Z|$]]

One use of <code>Lookup</code> could be to reverse a <code>Dictionary</code>.

Suppose you have a phonebook implemented as a <code>Dictionary</code> with a bunch of (unique) names as keys, each name associated with a phone number. But two people with different names might share the same phone number. This isn't a problem for a <code>Dictionary</code>, which doesn't care that two keys correspond to the same value.

Now you want a way of looking up who a given phone number belongs to. You build a <code>Lookup</code>, adding all the <code>KeyValuePairs</code> from your <code>Dictionary</code>, but backwards, with the value as the key and the key as the value. You can now query a phone number, and obtain a list of names of all the people whose phone number that is. Building a <code>Dictionary</code> with the same data would drop data (or fail, depending on how you did it), since doing

<pre><code>dictionary["555-6593"] = "Dr. Emmett Brown";
dictionary["555-6593"] = "Marty McFly";
</code></pre>

means that the second entry overwrites the first - the Doc is no longer listed.

Trying to write the same data in a slightly different way:

<pre><code>dictionary.Add("555-6593", "Dr. Emmett Brown");
dictionary.Add("555-6593", "Marty McFly");
</code></pre>

would throw an exception on the second line since you can't <code>Add</code> a key which is already in the <code>Dictionary</code>.

[Of course, you might want to use some other single data structure to do lookups in both directions, etc. This example means that you have to regenerate the <code>Lookup</code> from the <code>Dictionary</code> each time the latter changes. But for some data it could be the right solution.]

The MSDN explains Lookup like this:

<blockquote>
 A <a href="http://msdn.microsoft.com/en-us/library/bb460184%28v=vs.90%29.aspx" rel="noreferrer"><code>Lookup&lt;TKey, TElement&gt;</code></a>
 resembles a <a href="http://msdn.microsoft.com/en-us/library/xfhwa508.aspx" rel="noreferrer"><code>Dictionary&lt;TKey,
 TValue&gt;</code></a>. The difference is that a
 Dictionary&lt;TKey, TValue&gt; maps keys to single values, whereas a
 Lookup&lt;TKey, TElement&gt; maps keys to collections of values.
</blockquote>

I don't find that explanation particularly helpful. What is Lookup used for?

What is the point of Lookup<TKey, TElement>?

数据结构

数据库

MSDN对Lookup的解释如下： 类似于。不同之处在于Dictionary<TKey，TValue>将键映射到单个值，而Lookup<TKey，TElement>将键映射到值的集合。我不认为这种解释有什么特别的帮助。Lookup的用途是什么？

问TElement>，Lookup<TKey有什么意义？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问TElement>，Lookup<TKey有什么意义？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问TElement>，Lookup<TKey有什么意义？
EN