एएसपी.नेट एमवीसी 3 और इकाई फ्रेमवर्क कोड पहला आर्किटेक्चर

Question

My previous question मुझे परतों, भंडार, निर्भरता इंजेक्शन और इस तरह की वास्तुशिल्प सामग्री के बारे में फिर से सोचने लगा।

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

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

इन चीजों को बहुत तेज़ी से खत्म करना शुरू होता है ... कई दृष्टिकोण और "पैटन" ... यह बहुत अधिक शोर और बेकार कोड बनाता है।

क्या एंटिटी फ्रेमवर्क के साथ बनाने और एएसपी.नेट एमवीसी 3 एप्लिकेशन के लिए कोई सरल और टेस्टेबल आर्किटेक्चर है?

Answer 1

यदि आप टीडीडी (या उच्च परीक्षण कवरेज के साथ कोई अन्य परीक्षण दृष्टिकोण) और ईएफ का उपयोग करना चाहते हैं तो आपको एकीकरण या अंत-टू-एंड परीक्षण लिखना होगा। यहां समस्या यह है कि या तो संदर्भ या भंडार का मजाक करने वाला कोई भी दृष्टिकोण सिर्फ परीक्षण बनाता है जो आपके ऊपरी परत तर्क (जो उन मॉक्स का उपयोग करता है) का परीक्षण कर सकता है लेकिन आपका आवेदन नहीं।

सरल उदाहरण:

public interface IGenericRepository<TEntity> 
{ 
    IQueryable<TEntity> GetQuery(); 
    ... 
} 

और कुछ व्यापार विधि लिखने की सुविधा देता है:

public IEnumerable<MyEntity> DoSomethingImportant() 
{ 
    var data = MyEntityRepo.GetQuery().Select((e, i) => e); 
    ... 
} 

अब अगर आप भंडार नकली आप Linq-हैं- उपयोग करेगा

के सामान्य भंडार को परिभाषित करते हैं ऑब्जेक्ट्स और आपके पास एक हरा परीक्षण होगा, लेकिन यदि आप लिंक-टू-एंटिटीज के साथ एप्लिकेशन चलाते हैं तो आपको अपवाद मिलेगा क्योंकि इंडेक्स के साथ ओवरलोड का चयन L2E में समर्थित नहीं है।

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

कहानी का एक और हिस्सा आलसी लोडिंग के साथ समस्याएं हैं जो मोक्स के खिलाफ यूनिट परीक्षणों के साथ शायद ही कभी पता लगाया जा सकता है।

इसके कारण आपको एकीकरण या अंत-टू-एंड परीक्षण भी पेश करना चाहिए जो असली ईएफ संदर्भ एनी एल 2 ई का उपयोग करके वास्तविक डेटाबेस के खिलाफ काम करेगा। Btw। टीडीडी का सही उपयोग करने के लिए एंड-टू-एंड परीक्षणों का उपयोग करना आवश्यक है। एएसपी.नेट एमवीसी में एंड-टू-एंड टेस्ट लिखने के लिए आप WatiN और संभावित रूप से SpecFlow बीडीडी के लिए भी कर सकते हैं लेकिन यह वास्तव में बहुत सारे काम को जोड़ देगा लेकिन आपके आवेदन में वास्तव में परीक्षण किया जाएगा। यदि आप टीडीडी के बारे में अधिक पढ़ना चाहते हैं तो मैं this book की सिफारिश करता हूं (केवल नुकसान यह है कि उदाहरण जावा में हैं)।

यदि आप जेनेरिक रिपोजिटरी का उपयोग नहीं करते हैं और आप कुछ कक्षाओं में अपने प्रश्न छुपाते हैं तो IQueryable का पर्दाफाश नहीं करेंगे लेकिन सीधे डेटा लौटाएंगे, लेकिन एकीकरण परीक्षण समझ में आता है।

उदाहरण:

public interface IMyEntityRepository 
{ 
    MyEntity GetById(int id); 
    MyEntity GetByName(string name); 
} 

अब आप सिर्फ इस भंडार के कार्यान्वयन का परीक्षण करने क्योंकि प्रश्नों इस वर्ग में छिपे हुए हैं और ऊपरी परत के संपर्क में नहीं एकीकरण परीक्षण लिख सकते हैं। लेकिन इस प्रकार के भंडार को किसी भी तरह से संग्रहीत प्रक्रियाओं के साथ पुराने कार्यान्वयन के रूप में माना जाता है। आप इस कार्यान्वयन के साथ बहुत सारी ओआरएम सुविधाओं को खो देंगे या आपको बहुत अधिक काम करना होगा - उदाहरण के लिए ऊपरी परत में क्वेरी को परिभाषित करने में सक्षम होने के लिए specification pattern जोड़ें।

एएसपी.नेट एमवीसी में आप आंशिक रूप से नियंत्रक स्तर पर एकीकरण परीक्षण के साथ अंत-से-अंत परीक्षणों को प्रतिस्थापित कर सकते हैं।

संपादित करें टिप्पणी के आधार पर:

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

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

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

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

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

तो आप गलत सवाल पूछ रहे हैं। सवाल यह नहीं है कि क्या आसान है? सवाल यह है कि अंत में आपकी क्या मदद करेगा और आपके आवेदन में कौन सी जटिलता फिट बैठती है? यदि आप आसानी से यूनिट परीक्षण एप्लिकेशन और व्यवसाय तर्क चाहते हैं तो आपको कुछ अन्य वर्गों में ईएफ कोड लपेटना चाहिए जिसे मजाक किया जा सकता है। लेकिन एक ही समय में आपको यह सुनिश्चित करने के लिए अन्य प्रकार के परीक्षण शुरू करना चाहिए कि ईएफ कोड काम करता है।

मैं तुम्हें नहीं कह सकता कि दृष्टिकोण अपने वातावरण/परियोजना/टीम/आदि फिट होगा लेकिन मैं अपने अतीत परियोजना से उदाहरण व्याख्या कर सकते हैं:

मैं दोनों के साथ लगभग 5-6 महीने के लिए परियोजना पर काम सहकर्मियों। यह परियोजना एएसपी.नेट एमवीसी 2 + jQuery + ईएफवी 4 पर आधारित थी और इसे वृद्धिशील और पुनरावृत्त तरीके से विकसित किया गया था। इसमें बहुत जटिल व्यवसाय तर्क और बहुत जटिल डेटाबेस प्रश्न थे। हमने जेनेरिक रिपॉजिटरीज और उच्च कोड कवरेज के साथ यूनिट परीक्षण + एकीकरण परीक्षण मैपिंग को मान्य करने के लिए शुरू किया (डालने, हटाने, अद्यतन करने और इकाई का चयन करने के लिए सरल परीक्षण)। कुछ महीनों के बाद हमने पाया कि हमारा दृष्टिकोण काम नहीं करता है। हमारे पास 1.200 यूनिट परीक्षण, कोड कवरेज लगभग 60% (जो बहुत अच्छा नहीं है) और बहुत सारी प्रतिक्रियाएं हैं।ईएफ मॉडल में कुछ भी बदलना उन हिस्सों में अप्रत्याशित समस्याओं का परिचय दे सकता है जो कई हफ्तों तक छुआ नहीं थे। हमने पाया कि हम अपने आवेदन तर्क के लिए एकीकरण परीक्षण या अंत-टू-एंड परीक्षण खो रहे हैं। एक ही निष्कर्ष एक अन्य परियोजना पर काम करने वाली समांतर टीम पर किया गया था और एकीकरण परीक्षण का उपयोग नई परियोजनाओं के लिए सिफारिश के रूप में माना जाता था।

Answer 2

क्या रिपोजिटरी पैटर्न का उपयोग जटिलता को जोड़ता है? आपके परिदृश्य में मुझे ऐसा नहीं लगता है। यह टीडीडी को आसान बनाता है और आपका कोड अधिक प्रबंधनीय बनाता है। अधिक अलगाव और क्लीनर कोड के लिए जेनेरिक रिपोजिटरी पैटर्न का उपयोग करने का प्रयास करें।

आप इकाई की रूपरेखा में TDD और डिजाइन पैटर्न के बारे में अधिक जानने के लिए, पर एक नज़र डालें चाहते हैं: http://msdn.microsoft.com/en-us/ff714955.aspx

हालांकि ऐसा लगता है तुम नकली परीक्षण इकाई की रूपरेखा के लिए एक दृष्टिकोण के लिए देख रहे हैं। एक समाधान डेटाबेस प्रारंभिकरण पर डेटा उत्पन्न करने के लिए वर्चुअल बीज विधि का उपयोग करेगा। बीज अनुभाग पर एक नज़र डालें: http://blogs.msdn.com/b/adonet/archive/2010/09/02/ef-feature-ctp4-dbcontext-and-databases.aspx

इसके अलावा आप कुछ मॉकिंग फ्रेमवर्क का उपयोग कर सकते हैं। सबसे प्रसिद्ध लोगों मैं जानता हूँ कि इस प्रकार हैं:

• Rhino Mocks
• Moq
• Typemock (वाणिज्यिक)

नेट मजाक चौखटे की एक और पूरी सूची देखने के लिए, बाहर की जाँच: https://stackoverflow.com/questions/37359/what-c-mocking-framework-to-use

एक अन्य दृष्टिकोण SQLite जैसे इन-मेमोरी डेटाबेस प्रदाता का उपयोग करना होगा। Is there an in-memory provider for Entity Framework?

अंत में, यूनिट परीक्षण इकाई फ्रेमवर्क के बारे में कुछ अच्छे लिंक यहां दिए गए हैं (कुछ लिंक एंटीटी फ्रेमवर्क 4.0 का संदर्भ देते हैं। लेकिन आपको यह विचार मिल जाएगा।):

http://social.msdn.microsoft.com/Forums/en/adodotnetentityframework/thread/678b5871-bec5-4640-a024-71bd4d5c77ff

http://mosesofegypt.net/post/Introducing-Entity-Framework-Unit-Testing-with-TypeMock-Isolator.aspx

What is the way to go to fake my database layer in a unit test?

Answer 3

मैं अपने MVC आवेदन के सामान्य डिजाइन पर निर्णय लेने से एक ही समस्या हो रही थी। This शिजु वर्गीस द्वारा कोडप्लेक्स परियोजना बहुत मददगार थी। यह एएसपीनेट एमवीसी 3, ईएफ कोड फर्स्ट में किया जाता है और साथ ही सर्विस लेयर और रिपोजिटरी लेयर का भी उपयोग करता है। एकता का उपयोग करके निर्भरता इंजेक्शन किया जाता है। यह पालन करना आसान और बहुत आसान है। यह कुछ 4 बहुत अच्छी ब्लॉग पोस्टों का भी समर्थन करता है। इसकी जांच करने लायक है। और, भंडार पर मत छोड़ो..हाँ।

Answer 4

मैं क्या करता हूं मैं एक साधारण ISession और EFSession ऑब्जेक्ट का उपयोग करता हूं, चुड़ैल मेरे नियंत्रक में नकली करना आसान है, लिंक के साथ आसानी से उपयोग करना और दृढ़ता से टाइप करना आसान है। निनजेक्ट का उपयोग कर डीआई के साथ इंजेक्ट करें।

public interface ISession : IDisposable 
    { 
     void CommitChanges(); 
     void Delete<T>(Expression<Func<T, bool>> expression) where T : class, new(); 
     void Delete<T>(T item) where T : class, new(); 
     void DeleteAll<T>() where T : class, new(); 
     T Single<T>(Expression<Func<T, bool>> expression) where T : class, new(); 
     IQueryable<T> All<T>() where T : class, new(); 
     void Add<T>(T item) where T : class, new(); 
     void Add<T>(IEnumerable<T> items) where T : class, new(); 
     void Update<T>(T item) where T : class, new(); 
    } 

public class EFSession : ISession 
    { 
     DbContext _context; 

     public EFSession(DbContext context) 
     { 
      _context = context; 
     } 


     public void CommitChanges() 
     { 
      _context.SaveChanges(); 
     } 

     public void Delete<T>(System.Linq.Expressions.Expression<Func<T, bool>> expression) where T : class, new() 
     { 

      var query = All<T>().Where(expression); 
      foreach (var item in query) 
      { 
       Delete(item); 
      } 
     } 

     public void Delete<T>(T item) where T : class, new() 
     { 
      _context.Set<T>().Remove(item); 
     } 

     public void DeleteAll<T>() where T : class, new() 
     { 
      var query = All<T>(); 
      foreach (var item in query) 
      { 
       Delete(item); 
      } 
     } 

     public void Dispose() 
     { 
      _context.Dispose(); 
     } 

     public T Single<T>(System.Linq.Expressions.Expression<Func<T, bool>> expression) where T : class, new() 
     { 
      return All<T>().FirstOrDefault(expression); 
     } 

     public IQueryable<T> All<T>() where T : class, new() 
     { 
      return _context.Set<T>().AsQueryable<T>(); 
     } 

     public void Add<T>(T item) where T : class, new() 
     { 
      _context.Set<T>().Add(item); 
     } 

     public void Add<T>(IEnumerable<T> items) where T : class, new() 
     { 
      foreach (var item in items) 
      { 
       Add(item); 
      } 
     } 

     /// <summary> 
     /// Do not use this since we use EF4, just call CommitChanges() it does not do anything 
     /// </summary> 
     /// <typeparam name="T"></typeparam> 
     /// <param name="item"></param> 
     public void Update<T>(T item) where T : class, new() 
     { 
      //nothing needed here 
     } 

मैं के MongoDB कहना जाने के लिए EF4 से स्विच करना चाहते हैं, तो मैं केवल एक MongoSession कि ISession को लागू करना है ...