Buscando una implementación de diccionario persistente independiente simple en C# [cerrado]

Permítanme analizar esto:

1. Recuperar información por clave
2. Almacenamiento persistente
3. No desea escribir todo el archivo cuando cambia 1 valor
4. Debería sobrevivir a los accidentes

Creo que quieres una base de datos.

Editar: Creo que estás buscando lo incorrecto. Busque una base de datos que se ajuste a sus necesidades. Y cambie algunos de sus requisitos, porque creo que será difícil cumplirlos todos.

He implementado el tipo de PersistedDictionary que está buscando. El almacenamiento subyacente es el motor de base de datos ESENT que está integrado en Windows. El código está disponible aquí:

Http://managedesent.codeplex.com /

Una forma es usar el Extensible Storage Engine integrado en windoows para almacenar tus cosas. Es una base de datos nativa de win que admite indexación, transacciones, etc...

Estaba trabajando en portar EHCache a. NET. Echa un vistazo al proyecto

Http://sourceforge.net/projects/thecache /

El almacenamiento en caché persistente es la funcionalidad principal que ya está implementada. Todas las pruebas Unitarias están pasando. Me quedé un poco atascado en el almacenamiento en caché distribuido, pero no necesita esa parte.

Suena bien, pero ¿cómo evitará los cambios en el valor almacenado (si fuera un tipo de referencia) en sí? Si es inmutable, entonces todo está bien, pero si no estás un poco relleno : -)

Si no está tratando con valores inmutables, sospecharía que un mejor enfoque sería manejar la persistencia a nivel de valor y reconstruir el diccionario según sea necesario.

(editado para añadir una aclaración)

Encontré este enlace y suena como lo que estás buscando. Está programado en Java, pero no debería ser tan difícil portarlo a C#:

Http://www.javaworld.com/javaworld/jw-01-1999/jw-01-step.html

Creo que su problema es probable que sea ese último punto:

Al establecer o borrar un valor, no debe reescribir todo el archivo subyacente, sino que debe buscar la posición en el archivo y actualizar el valor.

Esto es exactamente lo que hace una base de datos: básicamente estás describiendo una estructura de tabla simple basada en archivos.

Podemos ilustrar el problema mirando las cadenas.

Las cadenas en la memoria son cosas flexibles - no necesita saber la longitud de una cadena en C# cuando se declara su tipo.

En las cadenas de almacenamiento de datos y todo lo demás son tamaños fijos. Su diccionario guardado en el disco es solo una colección de bytes, en orden.

Si reemplaza un valor en el medio, tiene que ser exactamente del mismo tamaño o tendrá que reescribir cada byte que viene después de.

Esta es la razón por la que la mayoría de las bases de datos restringen los campos de texto y blob a tamaños fijos. Nuevas características como varchar(max)/varbinary(max) en Sql 2005 + son realmente inteligentes simplificaciones a la fila solo almacenan realmente un puntero a los datos reales.

No puede usar los tamaños fijos con su ejemplo porque es genérico: no sabe qué tipo va a almacenar, por lo que no puede rellenar los valores a un tamaño máximo.

Usted podría hacer:

class PersistantDictionary<T,V> : Dictionary<T,V>
    where V:struct

As como los tipos de valor no varían en tamaño de almacenamiento, aunque tendría que tener cuidado con su implementación para guardar la cantidad correcta de almacenamiento para cada tipo.

Sin embargo su modelo no sería muy eficiente: si observa cómo SQL Server y Oracle manejan los cambios de tabla, no cambian los valores de esta manera. En su lugar, marcan el registro antiguo como un fantasma y agregan un nuevo registro con el nuevo valor. Los viejos registros fantasma se limpian más tarde cuando la base de datos está menos ocupada.

Creo que estás tratando de reinventar la rueda:

• Si estás tratando con grandes cantidades de datos, entonces realmente necesitas revisar usando una base de datos completa. MySQL o SQLLite son ambos bien, pero no vas a encontrar una implementación buena, simple, de código abierto y lite.

• Si no estás lidiando con un montón de datos, entonces iría por la serialización de archivos completos, y ya hay muchas buenas sugerencias aquí sobre cómo hacerlo.

Yo mismo escribí una implementación basada en un requisito muy similar (creo que idéntico) que tenía en otro proyecto hace un tiempo. Cuando lo hice, una cosa que me di cuenta fue que la mayoría de las veces que vas a hacer escribe, solo haces una lectura rara vez cuando el programa se bloquea o cuando está cerrado. Así que la idea es hacer las escrituras lo más rápido posible. Lo que hice fue hacer una clase muy simple que simplemente escribiría un registro de todas las operaciones (adiciones y eliminaciones) al diccionario como cosas ocurrir. Así que después de un tiempo se obtiene un montón de repetición entre las teclas. Debido a eso, una vez que el objeto detecta una cierta cantidad de repetición, borrará el registro y lo reescribirá para que cada clave y su valor solo aparezcan una vez.

Desafortunadamente, no puedes usar el diccionario de subclases porque no puedes anular nada en él. Esta es mi implementación simple, no la he probado, aunque lo siento, pensé que podría querer la idea. Siéntase libre de usarlo y cambiarlo tanto como desee.

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() {
        ++this.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;
}

Yo recomendaría SQL Server Express u otra base de datos.

• Es gratis.
• Se integra muy bien con C#, incluyendo LINQ.
• Es más rápido que una solución casera.
• Es más confiable que una solución casera.
• Es mucho más potente que una simple estructura de datos basada en disco, por lo que será fácil hacer más en el futuro.
• SQL es un estándar de la industria, por lo que otros desarrolladores entenderán su programa más fácilmente, y tendrá un habilidad que es útil en el futuro.

Echa un vistazo a este blog:

Http://ayende.com/Blog/archive/2009/01/17/rhino.dht-ndash-persistent-amp-distributed-storage.aspx

Parece ser exactamente lo que estás buscando.

Simplemente use serialización. Mira la clase BinaryFormatter.

No se nada para resolver tu problema. Tendrá que ser una estructura de tamaño fijo, para que pueda cumplir con los requisitos de poder reescribir registros sin reescribir todo el archivo.

Esto significa que las cadenas normales están fuera.

Como dijo Douglas, necesitas saber el tamaño fijo de tus tipos (tanto T como V). Además, las instancias de longitud variable en la cuadrícula de objetos a las que hace referencia cualquiera de esas instancias están fuera.

Aún así, implementar un diccionario respaldado por un archivo es bastante simple y puede usar la clase BinaryWriter para escribir los tipos en el disco, después de heredar o encapsular la clase Dictionary<TKey, TValue>.

Considere un archivo mapeado de memoria. No estoy seguro de si hay soporte directo en.NET, pero podría pinvoke las llamadas Win32.

En realidad no lo he usado, pero este proyecto aparentemente proporciona una implementación similar a mmap () en C#

Mmap

No soy un gran programador, pero no crearía un formato XML realmente simple para almacenar sus datos hacer el truco?

<dico> 
   <dicEntry index="x">
     <key>MyKey</key>
     <val type="string">My val</val>
   </dicEntry>
   ...
</dico>

Desde allí, carga el archivo XML DOM y llena tu diccionario como quieras,

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
}

Luego, cuando lo desee, puede actualizar el DOM y guardarlo en el disco.

xdocDico.save(sXMLfile);

Si puede permitirse el lujo de mantener el DOM en memoria en cuanto al rendimiento, es bastante fácil de tratar. Dependiendo de sus requisitos, es posible que ni siquiera necesite el diccionario en todo.