blocks|key|849265|text|让我来分析一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|849266|按键检索信息|ordered-list-item|849267|耐久存储|849268|不希望在1值更改时回写整个文件。|849269|应该能挺过崩溃|849270|我想你想要一个数据库。|849271|编辑:我想你找错东西了。搜索符合您要求的数据库。并且改变你的一些要求，因为我认为很难全部满足它们。|849272|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|S|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|T|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|U|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|V|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|W|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|P|$]]

Let me analyze this:

<ol>
<li>Retrieve information by key</li>
<li>Persistant storage</li>
<li>Do not want to write back the whole file when 1 value changes</li>
<li>Should survive crashes</li>
</ol>

I think you want a database.

Edit: I think you are searching for the wrong thing. Search for a database that fits your requirements. And change some of your requirements, because I think it will be difficult to meet them all.

blocks|key|849237|text|一种方法是使用内置在windoows中的可扩展存储引擎来存储您的东西。它是一个支持索引、事务等的本地win数据库.|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|849238|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms684493(VS.85).aspx^0|K|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

one way is to use the <a href="http://msdn.microsoft.com/en-us/library/ms684493(VS.85).aspx" rel="noreferrer">Extensible Storage Engine</a> built into windoows to store your stuff. It's a native win database that supports indexing, transactions etc...

blocks|key|849342|text|我正在将EHCache移植到.NET上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|849343|http://sourceforge.net/projects/thecache/|offset|length|849344|持久缓存是已经实现的核心功能。所有主要单元测试都通过了。我在分布式缓存上有点卡住了，但是您不需要这个部分。|849345|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|15|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

I was working on porting EHCache to .NET. Take a look at the project 

<a href="http://sourceforge.net/projects/thecache/" rel="nofollow noreferrer">http://sourceforge.net/projects/thecache/</a>

Persistent caching is core functionality that is already implemented. All main Unit Tests are passing. I got a bit stuck on distributed caching, but you do not need that part.

blocks|key|845000|text|听起来很酷，但是如何避免对存储的值(如果是引用类型)本身的更改？如果它是不可变的，那么一切都很好，但如果不是，你就有点被塞了:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|845001|如果您没有处理不可变的值，我会怀疑一种更好的方法是在值级别处理持久性，并根据需要重新构建字典。|845002|(编辑以增加澄清)|845003|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|$]]

Sounds cool, but how will you get around changes to the stored value (if it was a reference type) itself? If its immutable then all is well but if not you're kinda stuffed :-)

If you're not dealing with immutable values, I would suspect a better approach would be to handle persistence at the value level and to just rebuild the dictionary as necessary.

(edited to add a clarification)

blocks|key|165034|text|我认为你的问题很可能是最后一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|165035|当设置或清除一个值时，它不应该重写整个基础文件，而是应该查找文件中的位置并更新该值。|blockquote|165036|这正是DB所做的-您基本上是在描述一个简单的基于文件的表结构。|165037|我们可以通过查看字符串来说明这个问题。|165038|内存中的字符串是灵活的--在声明字符串类型时，不需要知道C#中字符串的长度。|165039|在数据存储中，字符串和其他一切都是固定大小的。按顺序，磁盘上保存的字典只是字节的集合。|165040|如果在中间替换一个值，它要么必须大小完全相同，要么必须重写后面的每个字节。|165041|这就是为什么大多数数据库将文本和blob字段限制为固定大小的原因。Sql+varchar(max)/varbinary(max)等新特性实际上是对行的巧妙简化，实际上只存储指向实际数据的指针。|offset|length|style|CODE|165042|您不能在示例中使用固定大小，因为它是通用的--您不知道要存储哪种类型，因此无法将值压缩到最大大小。|165043|你可以这样做：|165044|class+PersistantDictionary<T,V>+:+Dictionary<T,V>
++++where+V:struct|code-block|syntax|javascript|165045|...as值类型在存储大小上不会有变化，不过您必须小心实现，以便为每种类型保存适当的存储量。|165046|但是，您的模型的性能不会很好--如果您查看SQL+server和Oracle处理表更改的方式，它们不会像这样更改值。相反，它们将旧记录标记为鬼，并添加具有新值的新记录。当DB不那么繁忙时，旧的幽灵记录会被清理掉。|165047|我想你是想重新发明轮子：|165048|如果您正在处理大量的数据，那么您确实需要使用一个完整的DB来检查。MySql或SqlLite都很好，但是您不会找到一个好的、简单的、开源的和低层次的实现。|unordered-list-item|165049|如果您没有处理大量的数据，那么我将进行整个文件序列化，并且这里已经有很多关于如何做到这一点的好建议。|165050|entityMap^0|0|0|0|0|0|0|0|11|C|1E|E|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1H|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|1I|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1J|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1K|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1L|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1M|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1N|8|@$Q|1O|R|1P|S|T]|$Q|1Q|R|1R|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1S|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1T|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|10|7|1U|8|@]|9|@]|A|$11|12]]|$1|13|3|14|5|6|7|1V|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|1W|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|1X|8|@]|9|@]|A|$]]|$1|19|3|1A|5|1B|7|1Y|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|1B|7|1Z|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|1F|$]]

I think your issue is likely to be that last point:

<blockquote>
 When setting or clearing a value it should not re-write the entire underlying file, instead it should seek to the position in the file and update the value.
</blockquote>

This is exactly what a DB does - you're basically describing a simple file based table structure.

We can illustrate the problem by looking at strings.

Strings in memory are flexible things - you don't need to know the length of a string in C# when you declare its type.

In data storage strings and everything else are fixed sizes. Your saved dictionary on disk is just a collection of bytes, in order.

If you replace a value in the middle it either has to be exactly the same size or you will have to rewrite every byte that comes after it.

This is why most databases restrict text and blob fields to fixed sizes. New features like <code>varchar(max)</code>/<code>varbinary(max)</code> in Sql 2005+ are actually clever simplifications to the row only actually storing a pointer to the real data.

You can't use the fixed sizes with your example because it's generic - you don't know what type you're going to be storing so you can't pad the values out to a maximum size.

You could do:

<pre><code>class PersistantDictionary&lt;T,V&gt; : Dictionary&lt;T,V&gt;
 where V:struct
</code></pre>

...as value types don't vary in storage size, although you would have to be careful with your implementation to save the right amount of storage for each type.

However your model wouldn't be very performant - if you look at how SQL server and Oracle deal with table changes they don't change the values like this. Instead they flag the old record as a ghost, and add a new record with the new value. Old ghosted records are cleaned up later when the DB is less busy.

I think you're trying to reinvent the wheel: 

<ul>
<li>If you're dealing with large amounts of data then you really need to check out using a full-blown DB. MySql or SqlLite are both good, but you're not going to find a good, simple, open-source and lite implementation.</li>
<li>If you aren't dealing with loads of data then I'd go for whole file serialisation, and there are already plenty of good suggestions here on how to do that.</li>
</ul>

blocks|key|1163998|text|我自己编写了一个实现，它基于一个非常相似(我认为完全相同)的需求，而我不久前在另一个项目上也有类似的需求。当我这么做的时候，我意识到的一件事是，大多数时候你要写的时候，你只在程序崩溃或关闭时很少读。因此，我们的想法是尽可能快地完成写作。我所做的就是创建一个非常简单的类，它只在发生事情时将所有操作(添加和删除)写成日志。所以过了一段时间，你会在按键之间重复很多次。因此，一旦对象检测到一定数量的重复，它将清除日志并重写它，因此每个键及其值只出现一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163999|不幸的是，你不能子类字典，因为你不能覆盖它中的任何东西。这是我的简单实现，我还没有测试它，虽然我很抱歉，我想您可能想要的想法。你可以随意使用它，也可以随意改变它。|1164000|class+PersistentDictManager+{
++++const+int+SaveAllThreshold+=+1000;

++++PersistentDictManager(string+logpath)+{
++++++++this.LogPath+=+logpath;
++++++++this.mydictionary+=+new+Dictionary<string,+string>();
++++++++this.LoadData();
++++}

++++public+string+LogPath+{+get;+private+set;+}

++++public+string+this[string+key]+{
++++++++get{+return+this.mydictionary[key];+}
++++++++set{
++++++++++++string+existingvalue;
++++++++++++if(!this.mydictionary.TryGetValue(key,+out+existingvalue))+{+existingvalue+=+null;+}
++++++++++++if(string.Equals(value,+existingvalue))+{+return;+}
++++++++++++this[key]+=+value;

++++++++++++//+store+in+log
++++++++++++if(existingvalue+!=+null)+{+//+was+an+update+(not+a+create)
++++++++++++++++if(this.IncrementSaveAll())+{+return;+}+//+because+we're+going+to+repeat+a+key+the+log
++++++++++++}
++++++++++++this.LogStore(key,+value);
++++++++}
++++}

++++public+void+Remove(string+key)+{
++++++++if(!this.mydictionary.Remove(key))+{+return;+}
++++++++if(this.IncrementSaveAll())+{+return;+}+//+because+we're+going+to+repeat+a+key+in+the+log
++++++++this.LogDelete(key);
++++}

++++private+void+CreateWriter()+{
++++++++if(this.writer+==+null)+{
++++++++++++this.writer+=+new+BinaryWriter(File.Open(this.LogPath,+FileMode.Open));+
++++++++}
++++}

++++private+bool+IncrementSaveAll()+{
++++++++%2B%2Bthis.saveallcount;
++++++++if(this.saveallcount+>=+PersistentDictManager.SaveAllThreshold)+{
++++++++++++this.SaveAllData();
++++++++++++return+true;
++++++++}
++++++++else+{+return+false;+}
++++}

++++private+void+LoadData()+{
++++++++try{
++++++++++++using(BinaryReader+reader+=+new+BinaryReader(File.Open(LogPath,+FileMode.Open)))+{
++++++++++++++++while(reader.PeekChar()+!=+-1)+{
++++++++++++++++++++string+key+=+reader.ReadString();
++++++++++++++++++++bool+isdeleted+=+reader.ReadBoolean();
++++++++++++++++++++if(isdeleted)+{+this.mydictionary.Remove(key);+}
++++++++++++++++++++else+{
++++++++++++++++++++++++string+value+=+reader.ReadString();
++++++++++++++++++++++++this.mydictionary[key]+=+value;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++++++catch(FileNotFoundException)+{+}
++++}

++++private+void+LogDelete(string+key)+{
++++++++this.CreateWriter();
++++++++this.writer.Write(key);
++++++++this.writer.Write(true);+//+yes,+key+was+deleted
++++}

++++private+void+LogStore(string+key,+string+value)+{
++++++++this.CreateWriter();
++++++++this.writer.Write(key);
++++++++this.writer.Write(false);+//+no,+key+was+not+deleted
++++++++this.writer.Write(value);
++++}

++++private+void+SaveAllData()+{
++++++++if(this.writer+!=+null)+{
++++++++++++this.writer.Close();
++++++++++++this.writer+=+null;
++++++++}
++++++++using(BinaryWriter+writer+=+new+BinaryWriter(File.Open(this.LogPath,+FileMode.Create)))+{
++++++++++++foreach(KeyValuePair<string,+string>+kv+in+this.mydictionary)+{
++++++++++++++++writer.Write(kv.Key);
++++++++++++++++writer.Write(false);+//+is+not+deleted+flag
++++++++++++++++writer.Write(kv.Value);
++++++++++++}
++++++++}
++++}

++++private+readonly+Dictionary<string,+string>+mydictionary;
++++private+int+saveallcount+=+0;
++++private+BinaryWriter+writer+=+null;
}|code-block|syntax|javascript|1164001|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I wrote up an implementation myself based on a very similar (I think identical) requirement I had on another project a while ago. When I did it, one thing I realised was that most of the time you'll be doing writes, you only do a read rarely when the program crashes or when it's closed. So the idea is to make the writes as fast as possible. What I did was make a very simple class which would just write a log of all the operations (additions and deletions) to the dictionary as things occurred. So after a while you get a lot of repeating between keys. Because of that, once the object detects a certain amount of repetition, it'll clear the log and rewrite it so each key and its value only appears once. 

Unfortunately, you can't subclass Dictionary because you can't override anything in it. This is my simple implementation, I haven't tested it though I'm sorry, I thought you might want the idea though. Feel free to use it and change it as much as you like. 

<pre><code>class PersistentDictManager {
 const int SaveAllThreshold = 1000;

 PersistentDictManager(string logpath) {
 this.LogPath = logpath;
 this.mydictionary = new Dictionary&lt;string, string&gt;();
 this.LoadData();
 }

 public string LogPath { get; private set; }

 public string this[string key] {
 get{ return this.mydictionary[key]; }
 set{
 string existingvalue;
 if(!this.mydictionary.TryGetValue(key, out existingvalue)) { existingvalue = null; }
 if(string.Equals(value, existingvalue)) { return; }
 this[key] = value;

 // store in log
 if(existingvalue != null) { // was an update (not a create)
 if(this.IncrementSaveAll()) { return; } // because we're going to repeat a key the log
 }
 this.LogStore(key, value);
 }
 }

 public void Remove(string key) {
 if(!this.mydictionary.Remove(key)) { return; }
 if(this.IncrementSaveAll()) { return; } // because we're going to repeat a key in the log
 this.LogDelete(key);
 }

 private void CreateWriter() {
 if(this.writer == null) {
 this.writer = new BinaryWriter(File.Open(this.LogPath, FileMode.Open)); 
 }
 }

 private bool IncrementSaveAll() {
 ++this.saveallcount;
 if(this.saveallcount &gt;= PersistentDictManager.SaveAllThreshold) {
 this.SaveAllData();
 return true;
 }
 else { return false; }
 }

 private void LoadData() {
 try{
 using(BinaryReader reader = new BinaryReader(File.Open(LogPath, FileMode.Open))) {
 while(reader.PeekChar() != -1) {
 string key = reader.ReadString();
 bool isdeleted = reader.ReadBoolean();
 if(isdeleted) { this.mydictionary.Remove(key); }
 else {
 string value = reader.ReadString();
 this.mydictionary[key] = value;
 }
 }
 }
 }
 catch(FileNotFoundException) { }
 }

 private void LogDelete(string key) {
 this.CreateWriter();
 this.writer.Write(key);
 this.writer.Write(true); // yes, key was deleted
 }

 private void LogStore(string key, string value) {
 this.CreateWriter();
 this.writer.Write(key);
 this.writer.Write(false); // no, key was not deleted
 this.writer.Write(value);
 }

 private void SaveAllData() {
 if(this.writer != null) {
 this.writer.Close();
 this.writer = null;
 }
 using(BinaryWriter writer = new BinaryWriter(File.Open(this.LogPath, FileMode.Create))) {
 foreach(KeyValuePair&lt;string, string&gt; kv in this.mydictionary) {
 writer.Write(kv.Key);
 writer.Write(false); // is not deleted flag
 writer.Write(kv.Value);
 }
 }
 }

 private readonly Dictionary&lt;string, string&gt; mydictionary;
 private int saveallcount = 0;
 private BinaryWriter writer = null;
}
</code></pre>

blocks|key|165258|text|看看这个博客：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|165259|http://ayende.com/Blog/archive/2009/01/17/rhino.dht-ndash-persistent-amp-distributed-storage.aspx|offset|length|165260|看上去就是你要找的。|165261|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|2P|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Check this blog out:

<a href="http://ayende.com/Blog/archive/2009/01/17/rhino.dht-ndash-persistent-amp-distributed-storage.aspx" rel="nofollow noreferrer">http://ayende.com/Blog/archive/2009/01/17/rhino.dht-ndash-persistent-amp-distributed-storage.aspx</a>

Looks to be exactly what you are looking for.

blocks|key|1163703|text|只需使用序列化。看看BinaryFormatter类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163704|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Just use serialization. Look at the BinaryFormatter class.

blocks|key|164820|text|我不知道有什么能解决你的问题。它需要一个固定大小的结构，这样您就可以在不重写整个文件的情况下重写记录。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|164821|这意味着正常的字符串退出了。|164822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I don't know of anything to solve your problem. It will need to be a fixed size structure, so that you can meet the requirements of being able to rewrite records without rewriting the entire file.

This means normal strings are out.

blocks|key|1163744|text|就像道格拉斯说的，你需要知道你的类型的固定大小(包括T和V)。此外，对象网格中任何一个实例引用的可变长度实例都将退出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163745|不过，实现一个由文件支持的字典非常简单，您可以在继承或封装BinaryWriter类之后使用Dictionary<TKey,+TValue>类将这些类型写入磁盘。|offset|length|style|CODE|1163746|entityMap^0|0|T|C|1A|O|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]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

Like Douglas said, you need to know the fixed size of your types (both T and V). Also, variable-length instances in the object grid referenced by any of those instances are out.

Still, implementing a dictionary backed by a file is quite simple and you can use the <code>BinaryWriter</code> class to write the types to disk, after inheriting or encapsulating the <code>Dictionary&lt;TKey, TValue&gt;</code> class.

blocks|key|1163818|text|考虑一个内存映射文件。我不确定.NET中是否有直接支持，但您可以调用Win32调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163819|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider a memory mapped file. I'm not sure if there is direct support in .NET, but you could pinvoke the Win32 calls.

blocks|key|1163842|text|我还没有真正使用它，但是这个项目显然在C#中提供了一个mmap()C#实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163843|Mmap|offset|length|1163844|entityMap|0|LINK|mutability|MUTABLE|url|http://netdev.usr.dico.unimi.it/software/csharp/mmap/index.html^0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I haven't actually used it, but this project apparently provides an mmap()-like implementation in C#

<a href="http://netdev.usr.dico.unimi.it/software/csharp/mmap/index.html" rel="nofollow noreferrer">Mmap</a>

blocks|key|849307|text|我推荐SQL+Server+Express或其他数据库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|849308|这是免费的。|unordered-list-item|849309|它与C#集成得很好，包括LINQ。|849310|它比自制的解决方案要快。|849311|它比自制的解决方案更可靠。|849312|它比一个简单的基于磁盘的数据结构更强大，因此在将来做更多的事情会很容易。|849313|SQL是一个行业标准，因此其他开发人员将更容易地理解您的程序，并且您将拥有一项在将来有用的技能。|849314|entityMap|0|LINK|mutability|MUTABLE|url|http://www.microsoft.com/express/sql/^0|3|I|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$]]|$1|G|3|H|5|F|7|13|8|@]|9|@]|C|$]]|$1|I|3|J|5|F|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|16|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|17|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

I'd recommend <a href="http://www.microsoft.com/express/sql/" rel="nofollow noreferrer">SQL Server Express</a> or other database.

<ul>
<li>It's free.</li>
<li>It integrates very well with C#, including LINQ.</li>
<li>It's faster than a homemade solution.</li>
<li>It's more reliable than a homemade solution.</li>
<li>It's way more powerful than a simple disk-based data structure, so it'll be easy to do more in the future.</li>
<li>SQL is an industry standard, so other developers will understand your program more easily, and you'll have a skill that is useful in the future.</li>
</ul>

blocks|key|1163855|text|我并不是一个程序员，但是创建一个非常简单的XML格式来存储您的数据会有什么效果吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1163856|<dico>+
+++<dicEntry+index="x">
+++++<key>MyKey</key>
+++++<val+type="string">My+val</val>
+++</dicEntry>
+++...
</dico>|code-block|syntax|javascript|1163857|从这里开始，加载XML文件DOM并根据需要填充字典，|1163858|XmlDocument+xdocDico+=+new+XmlDocument();
string+sXMLfile;
public+loadDico(string+sXMLfile,+[other+args...])
{
+++xdocDico.load(sXMLfile);
+++//+Gather+whatever+you+need+and+load+it+into+your+dico
}
public+flushDicInXML(string+sXMLfile,+dictionary+dicWhatever)
{
+++//+Dump+the+dic+in+the+XML+doc+&+save
}
public+updateXMLDOM(index,+key,+value)
{
+++//+Update+a+specific+value+of+the+XML+DOM+based+on+index+or+key
}|1163859|然后，您可以随时更新DOM并将其保存在磁盘上。|1163860|xdocDico.save(sXMLfile);|offset|length|style|CODE|1163861|如果您能够在内存性能上保持DOM的性能，那么很容易处理。根据您的要求，您甚至可能根本不需要字典。|1163862|entityMap^0|0|0|0|0|0|0|O|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I am not much of a programmer, but wouldn't creating a really simple XML format to store your data do the trick?

<pre><code>&lt;dico&gt; 
 &lt;dicEntry index="x"&gt;
 &lt;key&gt;MyKey&lt;/key&gt;
 &lt;val type="string"&gt;My val&lt;/val&gt;
 &lt;/dicEntry&gt;
 ...
&lt;/dico&gt;
</code></pre>

From there, you load the XML file DOM and fill up your dictionary as you like,

<pre><code>XmlDocument xdocDico = new XmlDocument();
string sXMLfile;
public loadDico(string sXMLfile, [other args...])
{
 xdocDico.load(sXMLfile);
 // Gather whatever you need and load it into your dico
}
public flushDicInXML(string sXMLfile, dictionary dicWhatever)
{
 // Dump the dic in the XML doc &amp; save
}
public updateXMLDOM(index, key, value)
{
 // Update a specific value of the XML DOM based on index or key
}
</code></pre>

Then whenever you want, you can update the DOM and save it on disk. 

<code>xdocDico.save(sXMLfile);</code>

If you can afford to keep the DOM in memory performance-wise, it's pretty easy to deal with. Depending on your requirements, you may not even need the dictionary at all.

For an open source project I am looking for a good, simple implementation of a Dictionary that is backed by a file. Meaning, if an application crashes or restarts the dictionary will keep its state. I would like it to update the underlying file every time the dictionary is touched. (Add a value or remove a value). A FileWatcher is not required but it could be useful. 

<pre><code>class PersistentDictionary&lt;T,V&gt; : IDictionary&lt;T,V&gt;
{
 public PersistentDictionary(string filename)
 {

 } 
}
</code></pre>

Requirements: 

<ul>
<li>Open Source, with no dependency on native code (no sqlite) </li>
<li>Ideally a very short and simple implementation</li>
<li>When setting or clearing a value it should not re-write the entire underlying file, instead it should seek to the position in the file and update the value.</li>
</ul>

Similar Questions 

<ul>
<li><a href="https://stackoverflow.com/questions/108435/persistent-binary-tree-hash-table-in-net">Persistent Binary Tree / Hash table in .Net</a></li>
<li><a href="https://stackoverflow.com/questions/408401/disk-backed-dictionary-cache-for-c">Disk backed dictionary/cache for c#</a></li>
<li><a href="http://izlooite.blogspot.com/2011/04/persistent-dictionary.html" rel="noreferrer"><code>PersistentDictionary&lt;Key,Value&gt;</code></a></li>
</ul>

Looking for a simple standalone persistent dictionary implementation in C#

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

对于一个开源项目，我正在寻找一个由文件支持的字典的好的、简单的实现。也就是说，如果应用程序崩溃或重新启动，字典将保持其状态。我希望它每次触摸字典时都会更新底层文件。(添加值或删除值)。FileWatcher不是必需的，但它可能很有用。class PersistentDictionary<T,V> : IDictionary<T,V>{ public PersistentDictionary(

问在C#中寻找一个简单的独立持久字典实现
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中寻找一个简单的独立持久字典实现EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中寻找一个简单的独立持久字典实现
EN