Accediendo a un Diccionario.Claves Clave a través de un índice numérico

Puede usar un OrderedDictionary.

Representa una colección de clave/valor pares que son accesibles por la tecla o índice.

Un diccionario es una tabla Hash, ¡así que no tienes idea del orden de inserción!

Si desea conocer la última clave insertada, le sugeriría ampliar el Diccionario para incluir un valor LastKeyInserted.

Ej:

public MyDictionary<K, T> : IDictionary<K, T>
{
    private IDictionary<K, T> _InnerDictionary;

    public K LastInsertedKey { get; set; }

    public MyDictionary()
    {
        _InnerDictionary = new Dictionary<K, T>();
    }

    #region Implementation of IDictionary

    public void Add(KeyValuePair<K, T> item)
    {
        _InnerDictionary.Add(item);
        LastInsertedKey = item.Key;

    }

    public void Add(K key, T value)
    {
        _InnerDictionary.Add(key, value);
        LastInsertedKey = key;
    }

    .... rest of IDictionary methods

    #endregion

}

Sin embargo, se encontrará con problemas cuando use .Remove(), por lo que para superar esto tendrá que mantener una lista ordenada de las claves insertadas.

¿Por qué no extiende la clase dictionary para agregar una propiedad de última clave insertada? ¿Algo como lo siguiente tal vez?

public class ExtendedDictionary : Dictionary<string, int>
{
    private int lastKeyInserted = -1;

    public int LastKeyInserted
    {
        get { return lastKeyInserted; }
        set { lastKeyInserted = value; }
    }

    public void AddNew(string s, int i)
    {
        lastKeyInserted = i;

        base.Add(s, i);
    }
}

Siempre puedes hacer esto:

string[] temp = new string[mydict.count];
mydict.Keys.CopyTo(temp, 0)
int LastCount = mydict[temp[mydict.count - 1]]

Pero no lo recomendaría. No hay garantía de que la última clave insertada esté al final de la matriz. El pedido de Claves en MSDN no está especificado y está sujeto a cambios. En mi prueba muy breve, parece estar en orden de inserción, pero sería mejor construir en la contabilidad adecuada como una pila as como sugiere (aunque no veo la necesidad de una estructura basada en sus otras declaraciones) cache o caché de una sola variable si solo necesito saber la última clave.

Creo que puedes hacer algo como esto, la sintaxis podría estar mal, no he usado C# en un tiempo Para obtener el último elemento

Dictionary<string, int>.KeyCollection keys = mydict.keys;
string lastKey = keys.Last();

O use Max en lugar de Last para obtener el valor max, no sé cuál se ajusta mejor a su código.

Una alternativa sería KeyedCollection si la clave está incrustada en el valor.

Simplemente cree una implementación básica en una clase sellada para usar.

Así que para reemplazar Dictionary<string, int> (que no es un muy buen ejemplo, ya que no hay una clave clara para un int).

private sealed class IntDictionary : KeyedCollection<string, int>
{
    protected override string GetKeyForItem(int item)
    {
        // The example works better when the value contains the key. It falls down a bit for a dictionary of ints.
        return item.ToString();
    }
}

KeyedCollection<string, int> intCollection = new ClassThatContainsSealedImplementation.IntDictionary();

intCollection.Add(7);

int valueByIndex = intCollection[0];

Estoy de acuerdo con la segunda parte de la respuesta de Patrick. Incluso si en algunas pruebas parece mantener el orden de inserción, la documentación (y el comportamiento normal para diccionarios y hashes) indica explícitamente que el orden no está especificado.

Solo estás buscando problemas dependiendo del orden de las llaves. Agregue su propia contabilidad (como dijo Patrick, solo una variable para la última clave agregada) para estar seguro. Además, no se sienta tentado por todos los métodos como Last y Max en el diccionario como esos son probablemente en relación con el comparador clave (no estoy seguro de eso).

En caso de que decida usar código peligroso que está sujeto a rotura, esta función de extensión obtendrá una clave de un Dictionary<K,V> de acuerdo con su indexación interna (que para Mono y.NET actualmente parece estar en el mismo orden que obtiene al enumerar la propiedad Keys).

Es mucho preferible usar Linq: dict.Keys.ElementAt(i), pero esa función iterará O(N); lo siguiente es O(1) pero con una penalización de rendimiento de reflexión.

using System;
using System.Collections.Generic;
using System.Reflection;

public static class Extensions
{
    public static TKey KeyByIndex<TKey,TValue>(this Dictionary<TKey, TValue> dict, int idx)
    {
        Type type = typeof(Dictionary<TKey, TValue>);
        FieldInfo info = type.GetField("entries", BindingFlags.NonPublic | BindingFlags.Instance);
        if (info != null)
        {
            // .NET
            Object element = ((Array)info.GetValue(dict)).GetValue(idx);
            return (TKey)element.GetType().GetField("key", BindingFlags.Public | BindingFlags.Instance).GetValue(element);
        }
        // Mono:
        info = type.GetField("keySlots", BindingFlags.NonPublic | BindingFlags.Instance);
        return (TKey)((Array)info.GetValue(dict)).GetValue(idx);
    }
};

La forma en que redactó la pregunta me lleva a creer que el int en el Diccionario contiene la "posición" del ítem en el Diccionario. A juzgar por la afirmación de que las claves no se almacenan en el orden en que se agregan, si esto es correcto, eso significaría que las claves.Count (o .Count-1, si está utilizando basado en cero) todavía debe ser siempre el número de la última clave introducida?

Si eso es correcto, ¿hay alguna razón por la que no pueda usar Dictionary para que pueda usar mydict [mydict.Claves.Conde]?

No se si esto funcionaría porque estoy bastante seguro de que las claves no se almacenan en el orden en que se agregan, pero podría enviar la KeysCollection a una Lista y luego obtener la última clave en la lista... pero valdría la pena echar un vistazo.

La única otra cosa que se me ocurre es almacenar las claves en una lista de búsqueda y agregar las claves a la lista antes de agregarlas al diccionario... no es bonito.

Para ampliar la publicación de Daniels y sus comentarios con respecto a la clave, ya que la clave está incrustada dentro del valor de todos modos, podría recurrir a usar un KeyValuePair<TKey, TValue> como valor. El principal razonamiento para esto es que, en general, la Clave no es necesariamente derivable directamente del valor.

Entonces se vería así:

public sealed class CustomDictionary<TKey, TValue>
  : KeyedCollection<TKey, KeyValuePair<TKey, TValue>>
{
  protected override TKey GetKeyForItem(KeyValuePair<TKey, TValue> item)
  {
    return item.Key;
  }
}

Para usar esto como en el ejemplo anterior, debes hacer:

CustomDictionary<string, int> custDict = new CustomDictionary<string, int>();

custDict.Add(new KeyValuePair<string, int>("key", 7));

int valueByIndex = custDict[0].Value;
int valueByKey = custDict["key"].Value;
string keyByIndex = custDict[0].Key;

También puede usar SortedList y su contraparte genérica. Estas dos clases y en Andrew Peters answer mentioned OrderedDictionary son clases de diccionario en las que se puede acceder a los elementos por índice (posición), así como por clave. Cómo usar estas clases puedes encontrar: Clase SortedList , SortedList Clase genérica .

Un diccionario puede no ser muy intuitivo para usar index como referencia, pero puede tener operaciones similares con una matriz de KeyValuePair :

Ex. KeyValuePair<string, string>[] filters;

La opción de usuario de Visual Studio proporciona un enlace a la implementación genérica de OrderedDictionary de dotmore.

Pero si solo necesita obtener pares clave/valor por índice y no necesita obtener valores por claves, puede usar un truco simple. Declare alguna clase genérica (la llamé ListArray) de la siguiente manera:

class ListArray<T> : List<T[]> { }

También puede declararlo con constructores:

class ListArray<T> : List<T[]>
{
    public ListArray() : base() { }
    public ListArray(int capacity) : base(capacity) { }
}

Por ejemplo, usted lee algunos pares clave / valor de un archivo y solo desea almacenarlos en el orden en que fueron leídos para obtenerlos más tarde por índice:

ListArray<string> settingsRead = new ListArray<string>();
using (var sr = new StreamReader(myFile))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        string[] keyValueStrings = line.Split(separator);
        for (int i = 0; i < keyValueStrings.Length; i++)
            keyValueStrings[i] = keyValueStrings[i].Trim();
        settingsRead.Add(keyValueStrings);
    }
}
// Later you get your key/value strings simply by index
string[] myKeyValueStrings = settingsRead[index];

Como puede haber notado, no necesariamente puede tener solo pares de clave/valor en su ListArray. Los arrays item pueden ser de cualquier longitud, como en el array dentado.