blocks|key|2377171|text|给定的|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2377172|public+class+Something
{
+++public+HashSet<string>+Tags+{+get;+set;+}
}|code-block|syntax|javascript|2377173|使用|2377174|var+list+=+new+List<Something>
+++++++++++++++{
++++++++++++++++++new+Something()
+++++++++++++++++++++{
++++++++++++++++++++++++Tags+=+new+HashSet<string>()+{+"tag1",+"tag2"+}
+++++++++++++++++++++},
++++++++++++++++++new+Something()
+++++++++++++++++++++{
++++++++++++++++++++++++Tags+=+new+HashSet<string>()+{+"tag3",+"tag4"+}
+++++++++++++++++++++}
+++++++++++++++};

var+searchList+=+new+List<string>+{+"tag1",+"tag4"};

var+result+=+list.Where(x+=>+x.Tags.Any(y+=>+searchList.Contains(y)));|2377175|相当标准的内存方法|2377176|如果您想要更多类型，使用枚举(如果您不需要它们的动态)|2377177|entityMap^0|0|3|0|0|0|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Given

<pre><code>public class Something
{
 public HashSet&lt;string&gt; Tags { get; set; }
}
</code></pre>

Usage

<pre><code>var list = new List&lt;Something&gt;
 {
 new Something()
 {
 Tags = new HashSet&lt;string&gt;() { "tag1", "tag2" }
 },
 new Something()
 {
 Tags = new HashSet&lt;string&gt;() { "tag3", "tag4" }
 }
 };

var searchList = new List&lt;string&gt; { "tag1", "tag4"};

var result = list.Where(x =&gt; x.Tags.Any(y =&gt; searchList.Contains(y)));
</code></pre>

Fairly standard in memory approach

If you wanted it more typed, use enums (if you don't need them dynamic)

blocks|key|2377206|text|为什么不使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2377207|Dictionary<List<string>,+HashSet<int>>+taggedDict+=+new+Dictionary<List<string>,+HashSet<int>>();
var+searchList+=+new+List<string>+{+"tag1",+"tag4"+};
var+keys+=+taggedDict.Keys.Where(x+=>+x.Any(y+=>+searchList.Contains(y)));|code-block|syntax|javascript|2377208|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Why not use:

<pre><code>Dictionary&lt;List&lt;string&gt;, HashSet&lt;int&gt;&gt; taggedDict = new Dictionary&lt;List&lt;string&gt;, HashSet&lt;int&gt;&gt;();
var searchList = new List&lt;string&gt; { "tag1", "tag4" };
var keys = taggedDict.Keys.Where(x =&gt; x.Any(y =&gt; searchList.Contains(y)));
</code></pre>

blocks|key|2377250|text|你朝正确的方向前进了。我想说的是，您应该在其他HashSet<T>实例中缓存公共交叉点，以便更快、更简单地处理事情。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2377251|但是，如果从集合中删除了一个对象，那么之后的所有索引现在都是不正确的。|blockquote|2377252|虽然您可以构建一个反向字典Dictionary<int,+HashSet<string>>，以便从标记索引中删除给定的对象，以避免在删除某个对象时迭代整个索引：|2377253|var+tags+=+objectTagMap[394]

foreach(var+tag+in+tags)+
+++tagObjectMap[tag].Remove(394)|code-block|syntax|javascript|2377254|不管怎样，如果你在考虑内存中的索引，为什么不使用Redis呢？Redis为您提供了散列(字典)、集和排序集(以及其他一些数据结构)。|2377255|这是一个非常简单的示例，说明如何在Redis中构建相同的策略：|2377256|#+Store+objects+as+key-value+pairs
set+object:1+{+"id":+1+}
set+object:2+{+"id":+2+}
set+object:3+{+"id":+3+}

//+sadd+(set+add)+to+build+the+tag+index
sadd+tagA+1+2
sadd+tagB+3

//+sunion+to+get+object+ids+from+two+or+more+tags
sunion+tagA+tagB

//+mget+(multiple+get)+to+get+object+data+from+the+result+
//+of+sunion+concatenating+"object:"+with+each+object+id
//+This+is+a+simple+example.+In+a+real+world+system+you+would+use
//+SCAN+to+avoid+bottlenecks+and+being+able+to+leverage+paging.
mget+object:1+object:2+object:3|2377257|entityMap^0|N|A|0|0|D|W|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|K|3|L|5|M|7|14|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|15|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|16|8|@]|D|@]|E|$]]|$1|T|3|U|5|M|7|17|8|@]|D|@]|E|$N|O]]|$1|V|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|W|$]]

You've headed in the right direction. I would say that you should cache common intersections in other <code>HashSet&lt;T&gt;</code> instances to even speed up and simplifiy things more. 

<blockquote>
 however, if an object is removed from the collection, all the indexes
 after that point are now incorrect.
</blockquote>

Although you can build an inverse dictionary <code>Dictionary&lt;int, HashSet&lt;string&gt;&gt;</code> in order to remove a given object from the tag index to avoid iterating the entire index when some object is removed:

<pre><code>var tags = objectTagMap[394]

foreach(var tag in tags) 
 tagObjectMap[tag].Remove(394)
</code></pre>

Anyway, if you're thinking about an in-memory index, why don't you use Redis? Redis provides you both hashes (dictionaries), sets and sorted sets (and some other data structures).

This is a very very simplified sample of how you would build the same strategy in Redis:

<pre><code># Store objects as key-value pairs
set object:1 { "id": 1 }
set object:2 { "id": 2 }
set object:3 { "id": 3 }

// sadd (set add) to build the tag index
sadd tagA 1 2
sadd tagB 3

// sunion to get object ids from two or more tags
sunion tagA tagB

// mget (multiple get) to get object data from the result 
// of sunion concatenating "object:" with each object id
// This is a simple example. In a real world system you would use
// SCAN to avoid bottlenecks and being able to leverage paging.
mget object:1 object:2 object:3
</code></pre>

blocks|key|1319029|text|这不是最好的方法，但我现在使用的方式(直到它成为一个问题)只是一个由两个字典组成的集合；Dictionary<string,+Hashset<T>>用于获取带有标记的对象，而Dictionary<T,+Hashset<string>>用于获取对象上的标记。它既简单又实用，应该足以满足较小的集合。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1319030|entityMap^0|18|U|2F|U|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

This isn't the best way, but the way I'm using for now until it becomes a problem is simply a collection consisting of two dictionaries; <code>Dictionary&lt;string, Hashset&lt;T&gt;&gt;</code> to get objects with a tag, and <code>Dictionary&lt;T, Hashset&lt;string&gt;&gt;</code> to get the tags on an object. It's simple and functional, and should suffice for smaller collections.

I need a collection that can store and retrieve objects with multiple, potentially shared tags. I need to be able to store one object with multiple tags, and retrieve all objects that have one or more tags.

My first idea was for the collection to store an array of objects, and a <code>Dictionary&lt;string, Hashset&lt;int&gt;&gt;</code> where the key is the tag and the value is the indexes that tag applies to. 

<ul>
<li>For multiple tags, get the intersection of the index collections</li>
<li>To remove a tag from an object, remove that index from the collection</li>
</ul>

however, if an object is removed from the collection, all the indexes after that point are now incorrect.

Am I heading in the right direction? Is there an existing implementation of this that I'm unaware of, or a standard approach to collections that would help here?

Building a collection of objects retrievable via tags

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要一个可以存储和检索具有多个潜在共享标记的对象的集合。我需要能够存储一个具有多个标记的对象，并检索所有具有一个或多个标记的对象。我的第一个想法是让集合存储一个对象数组，以及一个Dictionary<string, Hashset<int>>，其中键是标记，值是标记应用到的索引。对于多个标记，获取索引集合的交集。若要...

问构建可通过标记检索的对象集合
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问构建可通过标记检索的对象集合EN