C # .NET में C # कार्यान्वयन

स्थानीय कैश, लगातार स्थानीय कैश, और वितरित कैश

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

आदिम कार्यान्वयन

public class NaiveCache<TItem>
{
    Dictionary<object, TItem> _cache = new Dictionary<object, TItem>();
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        if (!_cache.ContainsKey(key))
        {
            _cache[key] = createItem();
        }
        return _cache[key];
    }
}

var _avatarCache = new NaiveCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

1. एक कैश बहुत सारी मेमोरी लेना शुरू कर सकता है, जो अंततः इसकी कमी और क्रैश के कारण अपवादों की ओर जाता है।
2. उच्च मेमोरी खपत से मेमोरी दबाव (जिसे GC दबाव भी कहा जाता है ) हो सकता है। इस अवस्था में, कचरा संग्रहकर्ता को चाहिए की तुलना में बहुत अधिक काम करता है, जो प्रदर्शन को कम करता है।
3. डेटा बदलने पर कैश को अपडेट करना पड़ सकता है। हमारे कैशिंग इन्फ्रास्ट्रक्चर को इस सुविधा का समर्थन करना चाहिए।

• एक निरपेक्ष समाप्ति नीति जो निश्चित समय के बाद कैश से एक आइटम को हटा देती है, चाहे जो भी हो।
• एक निश्चित समय के लिए उपयोग नहीं किया गया है, तो एक स्लाइडिंग समाप्ति नीति जो कैश से एक आइटम को निकालता है। यही है, अगर मैं समाप्ति का समय 1 मिनट निर्धारित करता हूं, तो आइटम कैश में रहेगा, जबकि मैं इसे हर 30 सेकंड में उपयोग करता हूं। यदि मैं एक मिनट से अधिक समय तक इसका उपयोग नहीं करता हूं, तो आइटम हटा दिया जाएगा।
• आकार सीमा नीति , जो कैश के आकार को सीमित करेगी।

बेहतर समाधान

System.Runtime.Caching / MemoryCache बनाम Microsoft.Extensions.Caching.Memory

public class SimpleMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry)) //    .
        {
            //    ,   .
            cacheEntry = createItem();
            
            //    . 
            _cache.Set(key, cacheEntry);
        }
        return cacheEntry;
    }
}

var _avatarCache = new SimpleMemoryCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

public class MemoryCacheWithPolicy<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions()
    {
        SizeLimit = 1024
    });
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            //    ,   . 
            cacheEntry = createItem();
 
            var cacheEntryOptions = new MemoryCacheEntryOptions()
         	.SetSize(1)// 
         	//        (  )
                .SetPriority(CacheItemPriority.High)
                //       ,    .
                 .SetSlidingExpiration(TimeSpan.FromSeconds(2))
                //       ,    .
                .SetAbsoluteExpiration(TimeSpan.FromSeconds(10));
 
            //    .
            _cache.Set(key, cacheEntry, cacheEntryOptions);
        }
        return cacheEntry;
    }
}

1. MemoryCacheOptions जोड़ा गया है SizeLimit। यह हमारे कैश कंटेनर में आकार सीमा नीति जोड़ता है। रिकॉर्ड के आकार को मापने के लिए कैश में एक तंत्र नहीं है। इसलिए, हमें प्रत्येक कैश प्रविष्टि के आकार को सेट करने की आवश्यकता है। इस स्थिति में, हर बार हम आकार को 1 के साथ सेट करते हैं SetSize(1)। इसका मतलब है कि हमारे कैश में 1024 तत्वों की सीमा होगी।
2. , ? .SetPriority (CacheItemPriority.High). : Low (), Normal (), High () NeverRemove ( ).
3. SetSlidingExpiration(TimeSpan.FromSeconds(2)) 2 . , 2 , .
4. SetAbsoluteExpiration(TimeSpan.FromSeconds(10)) 10 . , 10 , .

समस्याओं और लापता सुविधाओं

1. जब आप एक आकार सीमा निर्धारित कर सकते हैं, तो कैशिंग वास्तव में स्मृति दबाव को नियंत्रित नहीं करता है। यदि हम निगरानी करते हैं, तो हम उच्च दबाव के साथ नीति को कम कर सकते हैं और कम के साथ नीति को कमजोर कर सकते हैं।
2. , . . , , , 10 . 2 , , ( ), .

public class WaitToFinishMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
    private ConcurrentDictionary<object, SemaphoreSlim> _locks = new ConcurrentDictionary<object, SemaphoreSlim>();
 
    public async Task<TItem> GetOrCreate(object key, Func<Task<TItem>> createItem)
    {
        TItem cacheEntry;
 
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            SemaphoreSlim mylock = _locks.GetOrAdd(key, k => new SemaphoreSlim(1, 1));
 
            await mylock.WaitAsync();
            try
            {
                if (!_cache.TryGetValue(key, out cacheEntry))
                {
                    //    ,   .
                    cacheEntry = await createItem();
                    _cache.Set(key, cacheEntry);
                }
            }
            finally
            {
                mylock.Release();
            }
        }
        return cacheEntry;
    }
}

var _avatarCache = new WaitToFinishMemoryCache<byte[]>();
// ...
var myAvatar =
await _avatarCache.GetOrCreate(userId, async () => await _database.GetAvatar(userId));

कोड पार्सिंग

कब इस्तेमाल करें WaitToFinishMemoryCache

• जब किसी वस्तु के निर्माण समय का कोई मूल्य होता है, और आप यथासंभव रचनाओं की संख्या को कम से कम करना चाहते हैं।
• जब किसी वस्तु को बनाने का समय बहुत लंबा हो।
• जब प्रत्येक कुंजी के लिए एक बार एक आइटम बनाया जाना चाहिए।

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

सारांश