इकाई ढांचे और अद्वितीय बाधाओं के साथ काम करते समय कुछ अप्राप्य हैक के बारे में

कुछ साल पहले, जब पेड़ बड़े और हरे होते थे, तो दुष्ट दानी मेरे पास आते और कहते - हाँ, मुझे मिल गया! मुझे एक बहुत ही अजीब प्रोजेक्ट में अपने सहयोगियों की मदद करनी थी।

अर्थात् - अंकों का एक गुच्छा , जो विश्लेषकों ने महीने में एक बार अपने पसंदीदा एमएस ऑफिस पैकेज में बनाया है। और महीने में एक बार इन नंबरों को चबाने और एमएस SQL ​​चलाने वाले डेटाबेस में लोड करने की आवश्यकता थी।

और निश्चित रूप से - इस मेगा-टूल को जल्दी से किया जाना था। फिर समर्थन को मलेशिया या भारतीयों को सस्ते में हस्तांतरित करना। इसलिए इसे यथासंभव स्पष्ट रूप से करने की भी सिफारिश की गई थी।

आपने समस्या का समाधान कैसे शुरू किया?

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

इसलिए, यह इस तरह से किया गया था - डीबी ने दृश्य स्टूडियो को खिसकाया, और इकाई ढांचे के लिए कोड का एक विशाल फ़ुटक्लॉथ मिला। एक आरा के साथ देखने के बजाय और मूल्यों (सौ) में सौ सवालों के साथ एक तैयार कथन संकलित करना - संदर्भ के बाद इकाई वस्तुओं की सामान्य भरने। सेवेचेज ()।

मैं ध्यान देता हूं - सही निर्णय। और समय से पहले अनुकूलन को बुराई माना जाता है।

इस दृष्टिकोण के साथ क्या आया

मुझे जलने की गंध आती है। मैं रसोई में जाती हूं, मांस को लटकी से निकालती हूं। मैंने दो हाथों वाली तलवार से एक को जला दिया और उसे तुरंत निगल लिया, क्योंकि उग्लेक कमरे में घुस गया। हॉट! लेकिन मैं चित्रित करता हूं।
"यह क्या है, मास्टर?"
- स्टीमी चाइनीज। नवीनतम सनक!
- बाढ़ न करें - आप केवल शब्दकोश से फैशन के बारे में जानते हैं, - यह कोशिश करता है। "हालांकि वास्तव में स्वादिष्ट!"


यह कागज पर चिकना था ... अद्वितीय बाधाओं, सभी tsiferki खाने के लिए सहमत नहीं थे।

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

और हां, इसे और अधिक दिलचस्प बनाने के लिए - विभिन्न संदर्भों से वस्तुओं को मिश्रित नहीं किया जा सकता है।

कई मामलों में मनोरंजन का समर्थन करना गैर-तुच्छ था, और मलेशियाई इन हैक का समर्थन कैसे करेंगे यह एक बड़ा सवाल है।

और इस पल में, इन बुरी आत्माओं ने एक लोहा और एक सोल्डरिंग लोहा लाया! मेरे पास पहुँच गया।

क्या करना था

करपेट अभद्र है।
- हानिकारक! उन्होंने एक सौ किलोग्राम ऊर्जा मांगी, लेकिन कितनी! आप मुझे इतना बताएं - आपको बहुत कुछ चाहिए, क्यों करपेट को धोखा दें? मुझे खेद नहीं है, मुझे पाँच टन चाहिए - बस, कहो, करपेट, हमें पाँच टन दें ... वे हानिकारक और हानिकारक हैं!

जैसा कि यह निकला, कैंसचेंज इकाइयां इकाई ढांचे में प्रदान नहीं की जाती हैं। और इसकी उपस्थिति जटिल होने का मौका नहीं देगी।

जैसा कि आप अनुमान लगा सकते हैं, मुझे आविष्कार करना था।

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

कहाँ लेटाओगे?

- अफा, अपने आप को एक साथ खींचो!
मैं खुद को बाहों में लपेटता हूं, खुद को बायोग्रॉव पर फर्श से फाड़ देता हूं।
- मैंने ले लिया। कहाँ लेटाओगे?


उदाहरणों में, मैंने सबसे स्पष्ट के रूप में सम्मिलन पर ध्यान केंद्रित किया। अपडेट को भी उसी तरह से पार्स किया गया है। मैं एक फुटक्लॉथ नहीं लाता, क्योंकि यह ऊपर से बहुत अलग नहीं है, और अपडेट का ट्रैक रखना आसान है। हमारे पास केवल डिलीट नहीं है - यह व्यामोह है, बैंकरों के साथी, मैं डेटाबेस से कुछ कैसे हटा सकता हूं? नहीं, नहीं!

निम्नानुसार मैनुअल और गुग्लिंग धूम्रपान करने के बाद, हम निम्नलिखित डेटा संरचना को परिभाषित करते हैं:

class MyEntry { public EntityObject entity; // entity object,  public string name; //    EF public Dictionary<string, EntityKey> refmap; // foreign keys -  - ,   //         FK      public Dictionary<string, EntityObject> objmap; //   public Dictionary<EntityObject, string> keymap; //     public MyEntry(string s, EntityObject o) { entity = o; name = s; refmap = new Dictionary<string, EntityKey>(); objmap = new Dictionary<string, EntityObject>(); keymap = new Dictionary<EntityObject, string>(); } } 

अब हम जादू कर सकते हैं। यह इस प्रकार निर्धारित किया जाता है - अंतिम SaveChanges () के बाद संदर्भ में क्या जोड़ा गया था:

  // t  derived class  EntityContext var added = t.ObjectStateManager.GetObjectStateEntries(EntityState.Added); 

ताकि हम अब यह निर्धारित कर सकें कि यह क्या था और इसे विस्तृत परीक्षण के लिए स्थानांतरित कर दिया। कुछ इस तरह।

  List<MyEntry> allDataToProceed = new List<MyEntry>(); //     foreach (var a in added) { //  EF        .  //      if (!(a.IsRelationship)) { //   -    "Foo", Foo a MyEntry e = new MyEntry(a.EntitySet.Name, a.Entity); allDataToProceed.Add(e); //     foreign keys    IEnumerable<IRelatedEnd> relEnds = ((IEntityWithRelationships)a.Entity).RelationshipManager.GetAllRelatedEnds(); foreach (var rel in relEnds) { //     FKs List<EntityObject> fks = new List<EntityObject>(); foreach (var obj in rel) fks.Add((EntityObject)obj); //         -  var relname = rel.RelationshipName; if (fks.Count == 1) { //   -    ,   if (fks[0].EntityKey.EntityKeyValues != null) e.refmap[relname] = fks[0].EntityKey; else { //     -  , //    .  -   //      //       FK     e.keymap[fks[0]] = fks[0].EntityKey.EntitySetName; e.objmap[relname] = fks[0]; } } } } } 

केवल एक चीज बची है जो संदर्भ को जीवन में वापस लाती है।

  //       foreach (var a1 in added) a1.Delete(); t.SaveChanges(); 

और एक भूत भगाने का सत्र शुरू करें - और यह यहाँ क्या अजीब रेंगता है, और सबसे महत्वपूर्ण बात - इसे कहां रखा जाए।

घर पर चिल्लाएं भी नहीं

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


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

  //           FK //       List<EntityObject> usedInRefs = new List<EntityObject>(); foreach (var a1 in allDataToProceed) { foreach (var dup in a1.objmap.Values) usedInRefs.Add(dup); } //   for (int j = 0; j < allDataToProceed.Count; ++j) { if (usedInRefs.Contains(allDataToProceed[j].entity)) { allDataToProceed.RemoveAt(j); --j; } } 

और अंत में, बात छोटी है - यह डेटाबेस में रटना रहता है जिसे आप रटना कर सकते हैं। ऐसा करने के लिए, विदेशी कुंजी की हमारी प्रतिलिपि को पुनर्स्थापित करें और इसे संदर्भ में जोड़ें। क्या आप सफल हुए? उत्कृष्ट, नहीं - इसका मतलब है कि यह हमारा बुरा दांत है।

  //     -      foreach (var a1 in allDataToProceed) { try { //    FKs  master/slave IEnumerable<IRelatedEnd> relEnds = ((IEntityWithRelationships)a1.entity).RelationshipManager.GetAllRelatedEnds(); foreach (var rel in relEnds) { var relname = rel.RelationshipName; EntityKey key = null; //          EF //         if (a1.refmap.ContainsKey(relname)) key = a1.refmap[relname]; EntityObject o = key != null ? o = (EntityObject)t.GetObjectByKey(key) : null; //     -      // master/slave  if (o == null && a1.objmap.ContainsKey(relname)) { o = a1.objmap[relname]; if (a1.keymap.ContainsKey(o)) t.AddObject(a1.keymap[o], o); else o = null; } //    -    if (o != null) rel.Add(o); } //       t.AddObject(a1.name, a1.entity); t.SaveChanges(); } catch (Exception e2) { //        -     //      added = t.ObjectStateManager.GetObjectStateEntries(EntityState.Added); foreach (var a2 in added) a2.Delete(); //   -    ,      } } 

देखा। हमने कर दिखाया!

शायद यह दृष्टिकोण किसी के लिए उपयोगी होगा।