एक संख्यात्मक अनुक्रमणिका के माध्यम से एक शब्दकोश। कुंजी कुंजी का उपयोग करना

मैं पैट्रिक के जवाब के दूसरे भाग से सहमत हूं। यहां तक ​​कि अगर कुछ परीक्षणों में यह सम्मिलन आदेश रखना प्रतीत होता है, दस्तावेज़ीकरण (और शब्दकोश और हश के लिए सामान्य व्यवहार) स्पष्ट रूप से आदेश देता है कि ऑर्डरिंग अनिर्दिष्ट है।

आप केवल चाबियों के क्रम के आधार पर परेशानी मांग रहे हैं। सुनिश्चित करने के लिए अपनी खुद की बहीखाता जोड़ें (जैसे पैट्रिक ने कहा, अंतिम जोड़ा कुंजी के लिए केवल एक चर)। साथ ही, शब्दकोश पर अंतिम और अधिकतम जैसी सभी विधियों से मोहब्बत न करें क्योंकि वे शायद मुख्य तुलनित्र के संबंध में हैं (मुझे इसके बारे में निश्चित नहीं है)।

मुझे नहीं पता कि यह काम करेगा या नहीं, क्योंकि मुझे पूरा यकीन है कि कुंजी जोड़े गए क्रम में संग्रहीत नहीं हैं, लेकिन आप KeysCollection को किसी सूची में डाल सकते हैं और फिर सूची में अंतिम कुंजी प्राप्त कर सकते हैं ... लेकिन यह एक नजर रखने लायक होगा।

एकमात्र अन्य चीज जो मैं सोच सकता हूं वह कुंजी को लुकअप सूची में स्टोर करना है और सूची में कुंजी जोड़ने से पहले सूची में कुंजी जोड़ना है ... यह बहुत कुछ नहीं है।

जिस तरह से आपने प्रश्न पूछा है, मुझे विश्वास है कि शब्दकोश में int में शब्दकोश की "स्थिति" है। इस धारणा से निर्णय लेते हुए कि कुंजी को जोड़े गए क्रम में संग्रहीत नहीं किया गया है, यदि यह सही है, तो इसका मतलब यह होगा कि चाबियाँ। गणना (या गणना - 1, यदि आप शून्य-आधारित का उपयोग कर रहे हैं) अभी भी हमेशा अंतिम प्रविष्टि कुंजी की संख्या हो?

If that's correct, is there any reason you can't instead use Dictionary so that you can use mydict[ mydict.Keys.Count ]?

आप एक OrderedDictionary का उपयोग कर सकते हैं।

कुंजी / मान का संग्रह दर्शाता है   कुंजी जो कुंजी द्वारा सुलभ हैं   या सूचकांक।

आप हमेशा ऐसा कर सकते हैं:

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

लेकिन मैं इसकी सिफारिश नहीं करता। इस बात की कोई गारंटी नहीं है कि अंतिम डाली गई कुंजी सरणी के अंत में होगी। कुंजी के लिए ऑर्डरिंग एमएसडीएन पर अनिर्दिष्ट है, और परिवर्तन के अधीन है। मेरे बहुत ही संक्षिप्त परीक्षण में, यह सम्मिलन के क्रम में प्रतीत होता है, लेकिन आप एक स्टैक की तरह उचित बहीखाता में निर्माण करना बेहतर होगा - जैसा कि आप सुझाव देते हैं (हालांकि मुझे आपके आधार पर एक संरचना की आवश्यकता नहीं दिखाई दे रही है अन्य कथन) - या एकल परिवर्तनीय कैश यदि आपको केवल नवीनतम कुंजी जानना है।

आखिरी कुंजी डालने वाली संपत्ति में जोड़ने के लिए आप सिर्फ डिक्शनरी क्लास का विस्तार क्यों नहीं करते हैं। शायद कुछ की तरह कुछ?

public class ExtendedDictionary : Dictionary
{
    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);
    }
}

मुझे लगता है कि आप ऐसा कुछ कर सकते हैं, वाक्यविन्यास गलत हो सकता है, थोड़ी देर में सी # का उपयोग किया जाता है अंतिम आइटम प्राप्त करने के लिए

Dictionary.KeyCollection keys = mydict.keys;
string lastKey = keys.Last();

या अधिकतम मूल्य प्राप्त करने के लिए अंतिम के बजाय मैक्स का उपयोग करें, मुझे नहीं पता कि कौन सा आपके कोड को बेहतर बनाता है।

In case you decide to use dangerous code that is subject to breakage, this extension function will fetch a key from a Dictionary according to its internal indexing (which for Mono and .NET currently appears to be in the same order as you get by enumerating the Keys property).

लिंकक का उपयोग करना बहुत बेहतर है: dict.Keys.ElementAt (i) , लेकिन वह फ़ंक्शन ओ (एन) को फिर से चालू करेगा; निम्नलिखित ओ (1) है लेकिन एक प्रतिबिंब प्रदर्शन दंड के साथ।

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

public static class Extensions
{
    public static TKey KeyByIndex(this Dictionary dict, int idx)
    {
        Type type = typeof(Dictionary);
        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);
    }
};

जैसा कि @ फलनवे एक टिप्पणी में बताते हैं, ऐसा कुछ करना गलत है:

int LastCount = mydict.Keys.ElementAt(mydict.Count -1);

आप शब्दकोश में कुंजी के क्रम पर नहीं होना चाहिए निर्भर करते हैं। अगर आपको ऑर्डर करने की आवश्यकता है, तो आपको एक OrderedDictionary , जैसा कि इस उत्तर में सुझाया गया है। इस पृष्ठ पर अन्य उत्तरों भी दिलचस्प हैं।