MemoryCache कॉन्फ़िगरेशन में मेमोरी सीमा का पालन नहीं करता है


87

मैं एक आवेदन में .NET 4.0 मेमोरीकैच क्लास के साथ काम कर रहा हूं और अधिकतम कैश आकार को सीमित करने की कोशिश कर रहा हूं, लेकिन मेरे परीक्षणों में ऐसा नहीं लगता कि कैश वास्तव में सीमा का पालन कर रहा है।

मैं उन सेटिंग्स का उपयोग कर रहा हूं, जो MSDN के अनुसार , कैश आकार को सीमित करने वाली हैं:

  1. CacheMoryoryLimitMegabytes : मेगाबाइट में अधिकतम मेमोरी साइज़, जो किसी ऑब्जेक्ट की आवृत्ति को बढ़ा सकता है। "
  2. PhysicalMemoryLimitPercentage : "भौतिक मेमोरी का वह प्रतिशत जिसे कैश उपयोग कर सकते हैं, को पूर्णांक मान के रूप में 1 से 100 तक व्यक्त किया जाता है। डिफ़ॉल्ट शून्य है, जो इंगित करता है कि MemoryCache इंस्टेंस स्मृतिकी मात्रा के आधार परअपनी स्वयं की मेमोरी 1 का प्रबंधनकरता है जोकि इंस्टॉल की गई मेमोरी पर आधारित है संगणक।" 1. यह पूरी तरह से सही नहीं है - 4 से नीचे के किसी भी मूल्य को अनदेखा किया जाता है और 4 से बदल दिया जाता है।

मैं समझता हूं कि ये मूल्य अनुमानित नहीं हैं और कठोर सीमा नहीं है क्योंकि कैश को शुद्ध करने वाले धागे को हर एक्स सेकंड में निकाल दिया जाता है और यह मतदान अंतराल और अन्य अनिर्दिष्ट चर पर भी निर्भर है। हालाँकि, इन भिन्नताओं को ध्यान में रखते हुए, मैं कैशली असंगत कैश साइज़ देख रहा हूँ, जब CacheMemoryLimitMegabytes और PhysicalMemoryLimitPercentage या एक परीक्षण ऐप में एकवचन सेट करने के बाद पहला आइटम कैश से निकाला जा रहा है । यह सुनिश्चित करने के लिए कि मैंने प्रत्येक परीक्षण को 10 बार चलाया और औसत आंकड़ा की गणना की।

ये 3 जीबी रैम के साथ 32-बिट विंडोज 7 पीसी पर नीचे दिए गए उदाहरण कोड के परीक्षण के परिणाम हैं। पहली कॉल के बाद कैश का आकार लिया जाता है प्रत्येक परीक्षण पर CacheItemRemoved () के । (मुझे पता है कि कैश का वास्तविक आकार इससे बड़ा होगा)

MemLimitMB    MemLimitPct     AVG Cache MB on first expiry    
   1            NA              84
   2            NA              84
   3            NA              84
   6            NA              84
  NA             1              84
  NA             4              84
  NA            10              84
  10            20              81
  10            30              81
  10            39              82
  10            40              79
  10            49              146
  10            50              152
  10            60              212
  10            70              332
  10            80              429
  10           100              535
 100            39              81
 500            39              79
 900            39              83
1900            39              84
 900            41              81
 900            46              84

 900            49              1.8 GB approx. in task manager no mem errros
 200            49              156
 100            49              153
2000            60              214
   5            60              78
   6            60              76
   7           100              82
  10           100              541

यहाँ परीक्षण आवेदन है:

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Runtime.Caching;
using System.Text;
namespace FinalCacheTest
{       
    internal class Cache
    {
        private Object Statlock = new object();
        private int ItemCount;
        private long size;
        private MemoryCache MemCache;
        private CacheItemPolicy CIPOL = new CacheItemPolicy();

        public Cache(long CacheSize)
        {
            CIPOL.RemovedCallback = new CacheEntryRemovedCallback(CacheItemRemoved);
            NameValueCollection CacheSettings = new NameValueCollection(3);
            CacheSettings.Add("CacheMemoryLimitMegabytes", Convert.ToString(CacheSize)); 
            CacheSettings.Add("physicalMemoryLimitPercentage", Convert.ToString(49));  //set % here
            CacheSettings.Add("pollingInterval", Convert.ToString("00:00:10"));
            MemCache = new MemoryCache("TestCache", CacheSettings);
        }

        public void AddItem(string Name, string Value)
        {
            CacheItem CI = new CacheItem(Name, Value);
            MemCache.Add(CI, CIPOL);

            lock (Statlock)
            {
                ItemCount++;
                size = size + (Name.Length + Value.Length * 2);
            }

        }

        public void CacheItemRemoved(CacheEntryRemovedArguments Args)
        {
            Console.WriteLine("Cache contains {0} items. Size is {1} bytes", ItemCount, size);

            lock (Statlock)
            {
                ItemCount--;
                size = size - 108;
            }

            Console.ReadKey();
        }
    }
}

namespace FinalCacheTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            int MaxAdds = 5000000;
            Cache MyCache = new Cache(1); // set CacheMemoryLimitMegabytes

            for (int i = 0; i < MaxAdds; i++)
            {
                MyCache.AddItem(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
            }

            Console.WriteLine("Finished Adding Items to Cache");
        }
    }
}

MemoryCache कॉन्फ़िगर की गई स्मृति सीमाओं का पालन क्यों नहीं कर रहा है?


2
के लिए पाश गलत है, बिना मैं ++
xiaoyifang

4
मैंने इस बग के लिए एक MS Connect रिपोर्ट जोड़ी है (हो सकता है कि किसी और ने पहले से ही, लेकिन फिर भी ...) connect.microsoft.com/VisualStudio/feedback/details/806334/…
ब्रूनो ब्रेंट

3
यह ध्यान देने योग्य है कि Microsoft ने अब (9/2014 के अनुसार) ऊपर दिए गए कनेक्ट टिकट पर काफी गहन प्रतिक्रिया दी। इसका TLDR यह है कि MemoryCache हर ऑपरेशन पर इन सीमाओं को स्वाभाविक रूप से जांच नहीं करता है , बल्कि यह है कि सीमाएं केवल आंतरिक कैश ट्रिमिंग पर सम्मानित की जाती हैं, जो समय-समय पर गतिशील आंतरिक टाइमर पर आधारित होती है।
डस्टी

5
ऐसा लगता है कि उन्होंने MemoryCache.CacheMemoryLimit के लिए डॉक्स अपडेट कर दिए हैं: "MemoryCache तुरंत CacheMemoryLimit को लागू नहीं करता है जब भी कोई नया आइटम MemoryCache इंस्टेंस में जोड़ा जाता है। मेमोरी कार्ड
सुल्ली

1
@Zeus, मुझे लगता है कि MSFT ने इस मुद्दे को हटा दिया। किसी भी स्थिति में, मेरे साथ कुछ चर्चा के बाद MSFT ने इस मुद्दे को बंद कर दिया, जहां उन्होंने मुझे बताया कि सीमा केवल पूलिंगटाइम समाप्त होने के बाद लागू होती है।
ब्रूनो ब्रांट

जवाबों:


100

वाह, तो मैंने सीएलआर में परावर्तक के साथ खुदाई करने के लिए बस पूरी तरह से बहुत अधिक समय बिताया, लेकिन मुझे लगता है कि आखिरकार यहां क्या चल रहा है, इस पर मेरे पास एक अच्छा हैंडल है।

सेटिंग्स को सही तरीके से पढ़ा जा रहा है, लेकिन लगता है कि सीएलआर में ही एक गहरी बैठी हुई समस्या है जो दिखता है कि यह अनिवार्य रूप से बेकार की मेमोरी सीमा को प्रस्तुत करेगा।

CacheMemoryMonitor वर्ग के लिए निम्न कोड System.Runtime.Caching DLL से बाहर परिलक्षित होता है (एक समान वर्ग है जो भौतिक मेमोरी की निगरानी करता है और अन्य सेटिंग से संबंधित है, लेकिन यह अधिक महत्वपूर्ण है):

protected override int GetCurrentPressure()
{
  int num = GC.CollectionCount(2);
  SRef ref2 = this._sizedRef;
  if ((num != this._gen2Count) && (ref2 != null))
  {
    this._gen2Count = num;
    this._idx ^= 1;
    this._cacheSizeSampleTimes[this._idx] = DateTime.UtcNow;
    this._cacheSizeSamples[this._idx] = ref2.ApproximateSize;
    IMemoryCacheManager manager = s_memoryCacheManager;
    if (manager != null)
    {
      manager.UpdateCacheSize(this._cacheSizeSamples[this._idx], this._memoryCache);
    }
  }
  if (this._memoryLimit <= 0L)
  {
    return 0;
  }
  long num2 = this._cacheSizeSamples[this._idx];
  if (num2 > this._memoryLimit)
  {
    num2 = this._memoryLimit;
  }
  return (int) ((num2 * 100L) / this._memoryLimit);
}

पहली चीज़ जो आप देख सकते हैं कि यह Gen2 कचरा संग्रहण के बाद तक कैश के आकार को देखने की कोशिश नहीं करता है, बजाय इसके कि कैशसाइज़मैन्स में मौजूदा संग्रहीत आकार के मूल्य पर वापस गिर रहा है। इसलिए आप कभी भी लक्ष्य को सही तरीके से नहीं मार पाएंगे, लेकिन अगर बाकी काम किया तो हम कम से कम एक आकार माप लेंगे इससे पहले कि हम वास्तविक परेशानी में पड़ें।

इसलिए मान लें कि एक Gen2 GC हुआ है, हम समस्या 2 में भाग लेते हैं, जो कि ref2.ApproximateSize वास्तव में कैश के आकार का अनुमान लगाने का एक भयानक काम करता है। सीएलआर कबाड़ के माध्यम से स्लोगन मैंने पाया कि यह एक System.SizedReference है, और यह वह है जो मूल्य प्राप्त करने के लिए कर रहा है (IntPtr एक मेमोरी मेमोरी ऑब्जेक्ट के लिए खुद को संभालता है):

[SecurityCritical]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern long GetApproximateSizeOfSizedRef(IntPtr h);

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

तीसरी ध्यान देने योग्य बात यह है कि manager.UpdateCacheSize में कॉल है जो लगता है कि उसे कुछ करना चाहिए। दुर्भाग्य से किसी भी सामान्य नमूने में यह कैसे काम करना चाहिए s_memoryCacheManager हमेशा शून्य रहेगा। फ़ील्ड को सार्वजनिक स्थैतिक सदस्य ObjectCache.Host से सेट किया गया है। यह उपयोगकर्ता के साथ खिलवाड़ करने के लिए उजागर होता है यदि वह ऐसा करता है, और मैं वास्तव में इस काम को करने में सक्षम था जैसे कि यह अपने स्वयं के IMemoryCacheManager कार्यान्वयन को एक साथ करने से माना जाता है, यह ObjectCache.Host पर सेट करता है, और फिर नमूना चला रहा है । उस बिंदु पर, ऐसा लगता है जैसे आप बस अपना खुद का कैश कार्यान्वयन कर सकते हैं और यह सब सामान के साथ परेशान भी नहीं करते हैं, खासकर जब से मुझे अपना कोई विचार नहीं करना है, तो अपना स्वयं का वर्ग ObjectCache.Host पर सेट करें (स्थैतिक)

मेरा मानना ​​है कि कम से कम इसका हिस्सा (यदि एक जोड़ी नहीं) तो बस एक सीधा बग है। एमएस से किसी से यह सुनना अच्छा होगा कि इस चीज़ के साथ क्या सौदा हुआ था।

इस विशाल उत्तर का TLDR संस्करण: मान लें कि CacheMemoryLimitMegabytes इस समय इस बिंदु पर पूरी तरह से समाप्त हो गया है। आप इसे 10 एमबी पर सेट कर सकते हैं, और फिर कैश को ~ 2GB तक भरने के लिए आगे बढ़ सकते हैं और आइटम हटाने के ट्रिपिंग के साथ मेमोरी अपवाद को बाहर उड़ा सकते हैं।


4
एक अच्छा जवाब धन्यवाद। मैंने यह पता लगाने की कोशिश की कि यह क्या हो रहा था और इसके बजाय अब / आउट और कॉलिंग में आइटमों को गिनकर कैश आकार का प्रबंधन करें। () मैन्युअल रूप से आवश्यकतानुसार। मैंने सोचा था कि System.Runtime.Caching मेरे ऐप के लिए एक आसान विकल्प था, क्योंकि यह व्यापक रूप से उपयोग किया जा रहा है और मुझे लगा कि इसलिए कुछ बड़े कीड़े नहीं होंगे।
कैनाकोरेस

3
वाह। इसलिए मैं एसओ से प्यार करता हूं। मैं उसी व्यवहार में भाग गया, एक परीक्षण ऐप लिखा और अपने पीसी को कई बार क्रैश करने में कामयाब रहा, भले ही मतदान का समय 10 सेकंड से कम था और कैश मेमोरी की सीमा 1 एमबी थी। सभी अंतर्दृष्टि के लिए धन्यवाद।
ब्रूनो ब्रांट

7
मुझे पता है कि मैंने अभी इसका उल्लेख वहाँ किया है, लेकिन पूर्णता के लिए, मैं यहाँ फिर से इसका उल्लेख करूँगा। मैंने इसके लिए कनेक्ट पर एक समस्या खोली है। connect.microsoft.com/VisualStudio/feedback/details/806334/…
ब्रूनो ब्रेंट

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

क्या यह अभी भी .NET कोर में एक मुद्दा है?
Павле

29

मुझे पता है कि यह उत्तर देर से पागल है, लेकिन पहले से कहीं ज्यादा देर से बेहतर है। मैं आपको बताना चाहता हूं कि मैंने एक संस्करण लिखा है MemoryCacheजो आपके लिए जनरल 2 संग्रह के मुद्दों को स्वचालित रूप से हल करता है। इसीलिए जब भी मतदान अंतराल स्मृति दबाव को इंगित करता है तो यह दुखद होता है। यदि आप इस समस्या का सामना कर रहे हैं, तो इसे दें!

http://www.nuget.org/packages/SharpMemoryCache

आप इसे GitHub पर भी पा सकते हैं यदि आप उत्सुक हैं कि मैंने इसे कैसे हल किया। कोड कुछ सरल है।

https://github.com/haneytron/sharpmemorycache


2
यह इरादा के अनुसार काम करता है, एक जनरेटर के साथ परीक्षण किया जाता है जो 1000 वर्णों के तारों के भार के साथ कैश को भरता है। हालांकि, कैश में 100 एमबी की तरह क्या होना चाहिए, इसे जोड़ने पर कैश में वास्तव में 200 - 300 एमबी जुड़ जाता है, जो मुझे काफी अजीब लगा। शायद कुछ ओवरहेड्स मैं गिन नहीं रहा हूं।
कार्ल कसार

5
.NET में @KarlCassar स्ट्रिंग्स लगभग 2n + 20बाइट्स के संबंध में आकार में हैं , जहां nस्ट्रिंग की लंबाई है। यह ज्यादातर यूनिकोड समर्थन के कारण है।
हैनी

4

मैंने @Canacourse के उदाहरण और @woany के संशोधन के साथ कुछ परीक्षण किए हैं और मुझे लगता है कि कुछ महत्वपूर्ण कॉल हैं जो मेमोरी कैश की सफाई को अवरुद्ध करती हैं।

public void CacheItemRemoved(CacheEntryRemovedArguments Args)
{
    // this WriteLine() will block the thread of
    // the MemoryCache long enough to slow it down,
    // and it will never catch up the amount of memory
    // beyond the limit
    Console.WriteLine("...");

    // ...

    // this ReadKey() will block the thread of 
    // the MemoryCache completely, till you press any key
    Console.ReadKey();
}

लेकिन @woany का संशोधन स्मृति को समान स्तर पर रखने के लिए क्यों लगता है? सबसे पहले, RemoveedCallback सेट नहीं है और कोई कंसोल आउटपुट या इनपुट का इंतजार नहीं कर रहा है जो मेमोरी कैश के थ्रेड को ब्लॉक कर सकता है।

दूसरी बात यह है ...

public void AddItem(string Name, string Value)
{
    // ...

    // this WriteLine will block the main thread long enough,
    // so that the thread of the MemoryCache can do its work more frequently
    Console.WriteLine("...");
}

एक थ्रेड। सो (1) हर ~ 1000 वां AddItem () का एक ही प्रभाव होगा।

खैर, यह समस्या की बहुत गहरी जांच नहीं है, लेकिन ऐसा लगता है जैसे कि MemoryCache के धागे को सफाई के लिए पर्याप्त सीपीयू समय नहीं मिलता है, जबकि कई नए तत्व जोड़े जाते हैं।


4

मैंने इस मुद्दे का भी सामना किया है। मैं उन वस्तुओं को कैशिंग कर रहा हूं जिन्हें मेरी प्रक्रिया में प्रति सेकंड दर्जनों बार निकाल दिया जाता है।

मैंने पाया है कि निम्नलिखित कॉन्फ़िगरेशन और उपयोग हर बार हर 5 सेकंड में वस्तुओं को मुक्त करता है

app.config:

कैशमेमोरीलिमिटमैगेबाइट्स पर ध्यान दें । जब यह शून्य पर सेट किया गया था, तो शुद्ध दिनचर्या उचित समय में आग नहीं लगाएगा।

   <system.runtime.caching>
    <memoryCache>
      <namedCaches>
        <add name="Default" cacheMemoryLimitMegabytes="20" physicalMemoryLimitPercentage="0" pollingInterval="00:00:05" />
      </namedCaches>
    </memoryCache>
  </system.runtime.caching>  

कैश में जोड़ना:

MemoryCache.Default.Add(someKeyValue, objectToCache, new CacheItemPolicy { AbsoluteExpiration = DateTime.Now.AddSeconds(5), RemovedCallback = cacheItemRemoved });

कैश निकालने की पुष्टि करना काम कर रहा है:

void cacheItemRemoved(CacheEntryRemovedArguments arguments)
{
    System.Diagnostics.Debug.WriteLine("Item removed from cache: {0} at {1}", arguments.CacheItem.Key, DateTime.Now.ToString());
}

3

जब मैं पहली बार MemoryCache का उपयोग करने का प्रयास कर रहा था, तो मैं (शुक्र है) कल इस उपयोगी पोस्ट से टकरा गया। मुझे लगा कि यह मूल्यों को स्थापित करने और कक्षाओं का उपयोग करने का एक सरल मामला होगा लेकिन मुझे ऊपर उल्लिखित समान मुद्दों का सामना करना पड़ा। कोशिश करने और यह देखने के लिए कि मैं क्या कर रहा था मैंने ILSpy का उपयोग करके स्रोत निकाला और फिर एक परीक्षण स्थापित किया और कोड के माध्यम से कदम रखा। मेरा परीक्षण कोड ऊपर दिए गए कोड के समान था इसलिए मैं इसे पोस्ट नहीं करूंगा। अपने परीक्षणों से मैंने देखा कि कैश आकार का माप कभी भी सटीक नहीं था (जैसा कि ऊपर बताया गया है) और वर्तमान में दिए गए कार्यान्वयन कभी भी मज़बूती से काम नहीं करेंगे। हालाँकि, शारीरिक माप ठीक था और यदि भौतिक स्मृति को हर सर्वेक्षण में मापा गया था, तो मुझे ऐसा लग रहा था कि कोड मज़बूती से काम करेगा। इसलिए, मैंने MemoryCacheStatistics के भीतर जनरल 2 कचरा संग्रह जांच को हटा दिया;

एक परीक्षण परिदृश्य में यह स्पष्ट रूप से एक बड़ा अंतर बनाता है क्योंकि कैश लगातार हिट हो रहा है इसलिए वस्तुओं को कभी भी जीन प्राप्त करने का मौका नहीं मिलता है। मुझे लगता है कि हम इस dll के संशोधित निर्माण का उपयोग अपनी परियोजना पर करने जा रहे हैं और आधिकारिक MS का उपयोग करेंगे .net 4.5 का निर्माण तब होता है जब (जो ऊपर उल्लिखित कनेक्ट लेख के अनुसार ठीक होना चाहिए)। तार्किक रूप से मैं देख सकता हूं कि जीन 2 की जांच क्यों की गई है, लेकिन व्यवहार में मुझे यकीन नहीं है कि यह बहुत समझ में आता है। यदि मेमोरी 90% (या जो भी सीमा निर्धारित की गई है) तक पहुंचती है, तो इससे कोई फर्क नहीं पड़ता कि एक जनरल 2 संग्रह में गिरावट आई है या नहीं, आइटम को बेदखल किया जाना चाहिए।

मैंने अपना परीक्षण कोड लगभग 15 मिनट के लिए चालू कर दिया, जिसमें एक भौतिकमेमोरीलिमिटपेरेंटेज 65% है। मैंने देखा कि परीक्षण के दौरान मेमोरी का उपयोग 65-68% के बीच रहता है और देखा कि चीजों को ठीक से निकाला जा रहा है। अपने परीक्षण में मैंने 5 सेकंड के लिए मतदान केंद्र को निर्धारित किया है, और इसे डिफ़ॉल्ट करने के लिए physicalMemoryLimitPercentage को 65 और physicalMemoryLimitPercentage को 0 पर सेट किया है।

उपरोक्त सलाह के बाद; IMemoryCacheManager का कार्यान्वयन कैश से चीजों को निकालने के लिए किया जा सकता है। हालांकि यह उल्लेख किए गए जीन 2 चेक मुद्दे से पीड़ित होगा। हालांकि, परिदृश्य के आधार पर, यह उत्पादन कोड में समस्या नहीं हो सकती है और लोगों के लिए पर्याप्त रूप से काम कर सकती है।


4
एक अद्यतन: मैं .NET फ्रेमवर्क 4.5 का उपयोग कर रहा हूं और किसी भी तरह से समस्या को ठीक नहीं किया गया है। मशीन को क्रैश करने के लिए कैश काफी बड़ा हो सकता है।
ब्रूनो ब्रांट

एक प्रश्न: क्या आपके पास आपके द्वारा उल्लिखित कनेक्ट लेख का लिंक है?
ब्रूनो ब्रांट


3

यह पता चला है कि यह बग नहीं है, आपको जो कुछ भी करने की ज़रूरत है वह सीमा को लागू करने के लिए पूलिंग समय अवधि निर्धारित कर रहा है, ऐसा लगता है कि यदि आप पूलिंग सेट नहीं करते हैं, तो यह कभी भी ट्रिगर नहीं होगा। मैंने इसे परीक्षण किया है और रैपर्स की आवश्यकता नहीं है या कोई अतिरिक्त कोड:

 private static readonly NameValueCollection Collection = new NameValueCollection
        {
            {"CacheMemoryLimitMegabytes", "20"},
           {"PollingInterval", TimeSpan.FromMilliseconds(60000).ToString()}, // this will check the limits each 60 seconds

        };

PollingIntervalकैश कितनी तेजी से बढ़ रहा है, इसके आधार पर " " का मान सेट करें , अगर यह बहुत तेजी से बढ़ता है तो मतदान की बारंबारता बढ़ जाती है, अन्यथा चेक को बहुत अधिक न रखें ताकि ओवरहेड न हो।


1

यदि आप निम्न संशोधित वर्ग का उपयोग करते हैं और टास्क मैनेजर के माध्यम से मेमोरी की निगरानी करते हैं तो वास्तव में छंटनी होती है:

internal class Cache
{
    private Object Statlock = new object();
    private int ItemCount;
    private long size;
    private MemoryCache MemCache;
    private CacheItemPolicy CIPOL = new CacheItemPolicy();

    public Cache(double CacheSize)
    {
        NameValueCollection CacheSettings = new NameValueCollection(3);
        CacheSettings.Add("cacheMemoryLimitMegabytes", Convert.ToString(CacheSize));
        CacheSettings.Add("pollingInterval", Convert.ToString("00:00:01"));
        MemCache = new MemoryCache("TestCache", CacheSettings);
    }

    public void AddItem(string Name, string Value)
    {
        CacheItem CI = new CacheItem(Name, Value);
        MemCache.Add(CI, CIPOL);

        Console.WriteLine(MemCache.GetCount());
    }
}

क्या आप कह रहे हैं कि यह छंटनी नहीं करता है या नहीं।
१०:११ बजे

हां, यह छंटनी हो जाती है। अजीब, उन सभी समस्याओं को देखते हुए जिनके साथ लोगों को लगता है MemoryCache। मुझे आश्चर्य है कि यह नमूना क्यों काम करता है।
डैनियल लिडस्ट्रॉम

1
मैं इसका पालन नहीं करता। मैंने उदाहरण को दोहराने की कोशिश की, लेकिन कैश अभी भी अनिश्चित रूप से बढ़ता है।
ब्रूनो ब्रेंट

एक भ्रामक उदाहरण वर्ग: "स्टैटलॉक", "आईटमाउंट", "आकार" बेकार हैं ... NameValueCollection (3) में केवल 2 आइटम हैं? ... वास्तव में आपने सिज़लिमिट और पॉटरवाल्टर गुणों के साथ एक कैश बनाया, इससे ज्यादा कुछ नहीं! "नहीं बेदखल करना" वस्तुओं की समस्या को छुआ नहीं गया ...
बर्नहार्ड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.