समांतरता और इकाई फ्रेमवर्क

Question

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

हम आम तौर पर प्रति अनुरोध एक संदर्भ का उपयोग करते हैं और उसके बाद एक भंडार वर्ग है ताकि हम विभिन्न परियोजनाओं में प्रश्नों का पुन: उपयोग कर सकें। जब हम नियंत्रक का निपटारा करते हैं तो हम अनुरोध के अंत में संदर्भ का निपटान करते हैं।

नीचे एक उदाहरण है जो समांतरता का उपयोग करता है, लेकिन अभी भी एक समस्या है!

var fileTask = new Repository().GetFile(id); 
var filesTask = new Repository().GetAllFiles(); 
var productsTask = AllProducts(); 
var versionsTask = new Repository().GetVersions(); 
var termsTask = new Repository().GetTerms(); 

await Task.WhenAll(fileTask, filesTask, productsTask, versionsTask, termsTask); 

प्रत्येक भंडार आंतरिक रूप से अपने स्वयं के संदर्भ पैदा कर रही है, लेकिन जैसा कि अभी है, वे निपटारा नहीं किया जा रहा है। ये एक समस्या है। मुझे पता है कि मैं प्रत्येक रिपोजिटरी पर Dispose पर कॉल कर सकता हूं, लेकिन यह कोड को जल्दी से अव्यवस्थित करना शुरू कर देता है। मैं प्रत्येक क्वेरी के लिए एक रैपर फ़ंक्शन बना सकता हूं जो अपने संदर्भ का उपयोग करता है, लेकिन यह गन्दा लगता है और समस्या के लिए एक दीर्घकालिक समाधान नहीं है।

इस समस्या का समाधान करने का सबसे अच्छा तरीका क्या होगा? मैं क्लाइंट/उपभोक्ता को समांतर में निष्पादित कई प्रश्नों के मामले में प्रत्येक संग्रह/संदर्भ को निपटाने के बारे में चिंता करने की आवश्यकता नहीं है।

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

मैं समानांतरवाद और इकाई की रूपरेखा के आसपास इस तरह के छोटे से चर्चा देख कर हैरान हूँ, इसलिए उम्मीद है कि समुदाय से कुछ अधिक विचारों में आ जाएगा।

संपादित

यहाँ का एक सरल उदाहरण है क्या हमारा भंडार इस तरह दिखता है:

public class Repository : IDisposable { 
    public Repository() { 
     this.context = new Context(); 
     this.context.Configuration.LazyLoadingEnabled = false; 
    } 

    public async Task<File> GetFile(int id) { 
     return await this.context.Files.FirstOrDefaultAsync(f => f.Id == id); 
    } 

    private bool disposed = false; 

    protected virtual void Dispose(bool disposing) { 
     if (!this.disposed) { 
      if (disposing) { 
       context.Dispose(); 
      } 
     } 
     this.disposed = true; 
    } 

    public void Dispose() { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 
} 

जैसा कि आप देख सकते हैं, प्रत्येक भंडार का अपना संदर्भ प्राप्त होता है। इसका मतलब है कि प्रत्येक भंडार का निपटान करने की आवश्यकता है। उदाहरण में मैंने ऊपर दिया, इसका मतलब है कि मुझे Dispose() पर 4 कॉल की आवश्यकता होगी।

समस्या का कारखाना दृष्टिकोण के लिए मेरे विचार की तरह कुछ था निम्नलिखित:

public class RepositoryFactory : IDisposable { 
    private List<IRepository> repositories; 

    public RepositoryFactory() { 
     this.repositories = new List<IRepository>(); 
    } 

    public IRepository CreateRepository() { 
     var repo = new Repository(); 
     this.repositories.Add(repo); 
     return repo;    
    } 

    #region Dispose 
    private bool disposed = false; 

    protected virtual void Dispose(bool disposing) { 
     if (!this.disposed) { 
      if (disposing) { 
       foreach (var repo in repositories) { 
        repo.Dispose(); 
       } 
      } 
     } 
     this.disposed = true; 
    } 

    public void Dispose() { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 
    #endregion 
} 

इस कारखाने मेरी भंडार के उदाहरण बनाने के लिए जिम्मेदार हो सकता है, लेकिन यह भी सभी उदाहरणों यह है का ट्रैक रखने होगा बनाया था। एक बार यह एकल कारखाना वर्ग का निपटारा हो जाने पर यह आंतरिक रूप से बनाए गए प्रत्येक भंडार का निपटान करने के लिए जिम्मेदार होगा।

Answer 1

आप क्लाइंट को Repository के निपटारे व्यवहार को कॉन्फ़िगर करने के लिए कुछ प्रकार के वैकल्पिक (डिफ़ॉल्ट रूप से गलत) autodispose बिट पास करके कॉन्फ़िगर करने की अनुमति दे सकते हैं। एक कार्यान्वयन कुछ इस तरह दिखेगा:

public class Repository : IDisposable 
{ 
    private readonly bool _autodispose = false; 
    private readonly Lazy<Context> _context = new Lazy<Context>(CreateContext); 

    public Repository(bool autodispose = false) { 
     _autodispose = autodispose; 
    } 

    public Task<File> GetFile(int id) { 
     // public query methods are still one-liners 
     return WithContext(c => c.Files.FirstOrDefaultAsync(f => f.Id == id)); 
    } 

    private async Task<T> WithContext<T>(Func<Context, Task<T>> func) { 
     if (_autodispose) { 
      using (var c = CreateContext()) { 
       return await func(c); 
      } 
     } 
     else { 
      return await func(_context.Value); 
     } 
    } 

    private static Context CreateContext() { 
     var c = new Context(); 
     c.Configuration.LazyLoadingEnabled = false; 
     return c; 
    } 

    public void Dispose() { 
     if (_context.IsValueCreated) 
      _context.Value.Dispose(); 
    } 
} 

नोट: मैं निपटान तर्क उदाहरण के लिए सरल रखा, आपको अपने disposed बिट्स को वापस काम करने की आवश्यकता हो सकती है।

आपकी क्वेरी तरीकों अभी भी सरल एक लाइनर्स हैं, और आवश्यकतानुसार ग्राहक बहुत आसानी से निपटान व्यवहार कॉन्फ़िगर कर सकते हैं, और यहां तक ​​कि ऑटो निपटान स्थितियों में एक भंडार उदाहरण का फिर से उपयोग:

var repo = new Repository(autodispose: true); 
var fileTask = repo.GetFile(id); 
var filesTask = repo.GetAllFiles(); 
var productsTask = AllProducts(); 
var versionsTask = repo.GetVersions(); 
var termsTask = repo.GetTerms(); 

await Task.WhenAll(fileTask, filesTask, productsTask, versionsTask, termsTask);