ASP.NET MVC में लिंक्ड तालिकाओं के डेटा के साथ काम करना या एक लुकअप घटक विकसित करना

किसी भी व्यावसायिक अनुप्रयोग का विकास एक तरह से या किसी अन्य डेटा के प्रसंस्करण से जुड़ा हुआ है, इन डेटा के बीच संबंधों का निर्माण, साथ ही साथ अन्य सुविधाजनक प्रस्तुति भी। इस लेख में हम ASP.net MVC में इंटर-टेबल इंटरैक्शन के साथ काम करने पर विचार करेंगे, साथ ही साथ इस इंटरैक्शन को विज़ुअलाइज़ करने की संभावनाओं के लिए, हम अपने स्वयं के घटक को विकसित करने की कोशिश करेंगे, एक तरफ यह आपको आवश्यक डेटा को आसानी से चुनने की अनुमति देता है, दूसरी तरफ इसे कॉन्फ़िगर करना आसान है। हम संबंधित डेटा की खोज, छँटाई और चयन को लागू करने के लिए JqGrid का उपयोग करेंगे। हम गतिशील विधेय के गठन पर स्पर्श करेंगे, देखें कि मेटाडाटा का उपयोग HTML सहायक में कैसे किया जा सकता है, और अंत में इस वर्ग के मौजूदा घटकों पर विचार करें।

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

दो संबंधित तालिकाओं से एक उदाहरण पर विचार करें: "उपयोगकर्ता" और "समूह"

public class UserProfile { [Key] public int UserId { get; set; } public string UserName { get; set; } public int? UserGroupId { get; set; } public virtual UserGroup UserGroup { get; set; } } public class UserGroup { [Key] public int UserGroupId { get; set; } [DisplayName("Group Name")] public string GroupName { get; set; } [DisplayName("Group Description")] public string Description { get; set; } public virtual ICollection<UserProfile> Users { get; set; } } 

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

  public ActionResult Index() { var userProfiles = _db.UserProfiles.Include(c => c.UserGroup); return View(userProfiles.ToList()); } 

दरअसल, ऊपर प्रस्तुत कंट्रोलर कोड में, हम उपयोगकर्ता प्रोफ़ाइल डेटा, इस प्रोफ़ाइल से जुड़े एक समूह के अलावा अनुरोध करते हैं। इसके बाद, DisplayNameFor का उपयोग करके इसे हमारे व्यू में प्रदर्शित करें।

  @Html.DisplayNameFor(model => model.UserGroup.GroupName) 

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

1. लुकअप घटक के लिए एचटीएमएल हेल्पर का विकास

ASP.net MVC में Html हेल्पर क्या है? अधिकांश भाग के लिए, ये सामान्य विस्तार विधियाँ हैं जो माता-पिता को HTML सामग्री बनाने के लिए उनकी कक्षा तक पहुँचने की अनुमति देती हैं। हमारे घटक को प्रदर्शित करने के लिए, हम मानक लुकअप नियंत्रण दृश्य, अर्थात् एक पाठ क्षेत्र और एक बटन का उपयोग करेंगे। आईडी रिकॉर्ड एक छिपे हुए क्षेत्र में संग्रहीत किया जाएगा।
Html सामग्री के अलावा, html सहायक आपको उपयोग किए जाने वाले मॉडल और फ़ील्ड के मेटाडेटा तक पहुंचने की अनुमति देता है, इसलिए पहली बात जो हम करते हैं वह एक विशेषता है जो मॉडल में हमारे क्षेत्र को उजागर कर सकता है, साथ ही साथ यह सही ढंग से काम करने के लिए घटक के लिए आवश्यक अतिरिक्त जानकारी प्रदान करता है।

तो नीचे लुकअप एट्रिब्यूट कोड प्रस्तुत किया गया है

  [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)] public sealed class LookupAttribute : Attribute { public Type Model { get; set; } public string NameField { get; set; } } 

यहां सब कुछ सरल है, उस फ़ील्ड को सहेजें जिसे हम संबंधित रिकॉर्ड के पाठ विवरण के रूप में उपयोग करेंगे, साथ ही साथ जिस प्रकार का मॉडल हम संदर्भित करेंगे। तो हमारे मॉडल का कोड थोड़ा रूपांतरित हो सकता है:

 public class UserProfile { [Key] public int UserId { get; set; } public string UserName { get; set; } [Lookup(Model = typeof(UserGroup), NameField = "GroupName")] public int? UserGroupId { get; set; } public virtual UserGroup UserGroup { get; set; } } 

अब यह स्पष्ट है कि हम उपयोगकर्ता समूह मॉडल का उल्लेख करेंगे, जो GroupName के शाब्दिक प्रतिनिधित्व के लिए एक क्षेत्र है। हालाँकि, इस विशेषता को हमारे HTML हेल्पर में उपयोग करने के लिए, हमें इसे दृश्य के लिए मेटाडेटा के संग्रह में जोड़ने की आवश्यकता है। ऐसा करने के लिए, हमें DataAnnotationsModelMetadataProvider से प्राप्त वर्ग को लागू करने और तदनुसार पंजीकरण करने की आवश्यकता है।

  public class LookupMetadataExtension : DataAnnotationsModelMetadataProvider { protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName) { var metadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName); var additionalValues = attributes.OfType<LookupAttribute>().FirstOrDefault(); if (additionalValues != null) { metadata.AdditionalValues.Add(LookupConsts.LookupMetadata, additionalValues); } return metadata; } } 

फ़ील्ड मेटाडेटा का विस्तार करने में सक्षम होने के लिए, आपको DataAnnotationsModelMetadataProvider वर्ग से इनहेरिट करना होगा और CreateMetadata विधि को ओवरराइड करना चाहिए। DataAnnotationsModelMetadataProvider वर्ग ASP.NET MVC के लिए डिफ़ॉल्ट मेटाडेटा मॉडल प्रदाता को लागू करता है।
सब कुछ काफी सरल है। यदि हस्तांतरित विशेषताओं के संग्रह में हमारा स्थान है, तो हमें इसे अतिरिक्त संस्करण मेटाडेटा संग्रह में जोड़ना चाहिए, जिसके बाद हम परिवर्तित संग्रह लौटाते हैं। इस वर्ग को सही ढंग से काम करने के लिए, इसे पंजीकृत होना चाहिए। Global.asax.cs पर जाएं और लाइन जोड़ें:

 ModelMetadataProviders.Current = new LookupMetadataExtension(); 

अब हम अपने HTML सहायक को विकसित करना जारी रखने के लिए तैयार हैं। सामान्य तौर पर, HTML सहायक फ़ंक्शन इस तरह दिखेगा

  public static MvcHtmlString LookupFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string filterAction, Type modelType, String nameField, IDictionary<string, object> htmlAttributes) { var fieldName = ExpressionHelper.GetExpressionText(expression); var commonMetadata = PrepareLookupCommonMetadata( ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData), htmlHelper.ViewData.ModelMetadata, modelType, nameField); var lookupAttribute = commonMetadata.AdditionalValues[LookupConsts.LookupMetadata] as LookupAttribute; return LookupHtmlInternal(htmlHelper, commonMetadata, lookupAttribute, fieldName, filterAction, htmlAttributes); } 

मैं ध्यान देता हूं कि हम उपयोगकर्ता को सीधे दृश्य से मॉडल के प्रकार को निर्दिष्ट करने का अवसर देते हैं। पहली पंक्ति में हमें अपने क्षेत्र का नाम मिलता है, फिर हम तैयारलुकअपकोमोनमेटेटाटा फ़ंक्शन कहते हैं। इस फ़ंक्शन पर बाद में विचार किया जाएगा, मैं सिर्फ यह कहूंगा कि इसका उपयोग मेटाडेटा को संसाधित करने और इस मेटाडेटा के माध्यम से लिंक किए गए तालिका के डेटा तक पहुंचने के लिए किया जाता है। अभिव्यक्ति का उपयोग करते हुए लाइन ModelMetadata.FromLambdaExpression (अभिव्यक्ति, htmlHelper.ViewData) वर्तमान क्षेत्र के मेटाडेटा को प्राप्त करता है, वास्तव में हमारे अतिरिक्त। इसके बाद, लौटी हुई कॉमनमेटटाटा ऑब्जेक्ट से, हम अपना लुकअपआर्ट्रेट प्राप्त करते हैं और HTML कोड जेनरेट करने के लिए फ़ंक्शन को कॉल करते हैं।

अब चलिए ReadyLookupCommonMetadata मेटाडेटा प्रोसेसिंग फ़ंक्शन की ओर मुड़ते हैं।

  private static ModelMetadata PrepareLookupCommonMetadata(ModelMetadata fieldMetadata, ModelMetadata modelMetadata , Type modelType, String nameField) { LookupAttribute lookupMetadata; if (modelType != null && nameField != null) { lookupMetadata = new LookupAttribute { Model = modelType, NameField = nameField }; if (fieldMetadata.AdditionalValues.ContainsKey(LookupConsts.LookupMetadata)) fieldMetadata.AdditionalValues.Remove(LookupConsts.LookupMetadata); fieldMetadata.AdditionalValues.Add(LookupConsts.LookupMetadata, lookupMetadata); } 

सबसे पहले, देखें कि क्या उपयोगकर्ता ने दृश्य में प्रकार और मॉडल निर्दिष्ट किया है, यदि ऐसा है, तो अतिरिक्तवैल्यूस में डेटा को अपडेट करें। आगे बढ़ते हैं

  if (fieldMetadata.AdditionalValues != null && fieldMetadata.AdditionalValues.ContainsKey(LookupConsts.LookupMetadata)) { lookupMetadata = fieldMetadata.AdditionalValues[LookupConsts.LookupMetadata] as LookupAttribute; if (lookupMetadata != null) { var prop = lookupMetadata.Model.GetPropertyWithAttribute("KeyAttribute"); var releatedTableKey = prop != null ? prop.Name : String.Format("{0}Id", lookupMetadata.Model.Name); fieldMetadata.AdditionalValues.Add("idField", releatedTableKey); var releatedTableMetadata = modelMetadata.Properties.FirstOrDefault(proper => proper.PropertyName == lookupMetadata.Model.Name); if (releatedTableMetadata != null) { UpdateLookupColumnsInfo(releatedTableMetadata, fieldMetadata); UpdateNameFieldInfo(lookupMetadata.NameField, releatedTableMetadata, fieldMetadata); } else { throw new ModelValidationException(String.Format( "Couldn't find data from releated table. Lookup failed for model {0}", lookupMetadata.Model.Name)); } } } else { throw new ModelValidationException(String.Format("Couldn't find releated model type. Lookup field")); } return fieldMetadata; } 

जाँच करें कि अतिरिक्तवैल्यूज़ के पास जगह है, फिर उसे मेटाडेटा संग्रह से पुनर्प्राप्त करें। अगला, GetPropertyWithAttribute प्रकार एक्सटेंशन विधि का उपयोग करके, हम संबंधित मॉडल से कुंजी विशेषता के साथ क्षेत्र प्राप्त करते हैं। हम इस क्षेत्र का उपयोग अपने संबंधों की पहचान करने के लिए करेंगे, अर्थात यह फ़ील्ड लिंक्ड टेबल की प्राथमिक कुंजी है। यदि हमें यह नहीं मिलता है, तो हम नियम का उपयोग करके खुद को बनाने की कोशिश करते हैं- मॉडल का नाम + आईडी = प्राथमिक कुंजी। अतिरिक्त मान के लिए इस मान को idField के रूप में जोड़ें। इसके बाद, हम इसके नाम से लिंक की गई तालिका का मेटाडेटा प्राप्त करने का प्रयास करते हैं।
यदि प्राप्त होता है, तो हम कॉलम की जानकारी और लिंक किए गए तालिका की पाठ परिभाषा प्राप्त करते हैं।
अब कॉलम के बारे में जानकारी प्राप्त करने पर ध्यान केन्द्रित करते हैं। खेतों की इस सूची का उपयोग JqGrid में रिकॉर्ड प्रदर्शित करने के लिए किया जाएगा। इस सूची को कॉन्फ़िगर करने के लिए, एक और विशेषता बनाएं।

  [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] public class LookupGridColumnsAttribute : Attribute { public string[] LookupColumns { get; set; } public LookupGridColumnsAttribute(params string[] values) { LookupColumns = values; } } 

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

  [LookupGridColumns(new[] { "Description" })] public class UserGroup { [Key] public int UserGroupId { get; set; } [DisplayName("Group Name")] public string GroupName { get; set; } [DisplayName("Group Description")] public string Description { get; set; } public virtual ICollection<UserProfile> Users { get; set; } } 

कॉलम सूची में, पहले से मौजूद डिफ़ॉल्ट समूहनाम के अलावा, हम विवरण जोड़ते हैं। अब हम कॉलम द्वारा मेटाडेटा तैयार करने वाले फ़ंक्शन के विचार पर लौटते हैं।

  private static void UpdateLookupColumnsInfo(ModelMetadata releatedTableMetadata, ModelMetadata metadata) { IDictionary<string, string> columns = new Dictionary<string, string>(); var gridColumns = releatedTableMetadata.ModelType.GetCustomAttributeByType<LookupGridColumnsAttribute>(); if (gridColumns != null) { foreach (var column in gridColumns.LookupColumns) { var metadataField = releatedTableMetadata.Properties.FirstOrDefault( propt => propt.PropertyName == column); if (metadataField != null) { columns.Add(column, metadataField.DisplayName); } else { throw new ModelValidationException( String.Format("Couldn't find column in releated table {0}", releatedTableMetadata.GetDisplayName())); } } metadata.AdditionalValues.Add("lookupColumns", columns); } } 

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

तो अब हमारे तैयारीलुकअपमोनमेटडेटाटा फ़ंक्शन पर लौटने और अंतिम कॉल को अपडेट करने का समय है, अर्थात् UpdateNameFieldInfo।

 private static void UpdateNameFieldInfo(string nameField, ModelMetadata releatedTableMetadata, ModelMetadata commonMetadata) { var nameFieldMetedata = releatedTableMetadata.Properties.FirstOrDefault(propt => propt.PropertyName == nameField); if (nameFieldMetedata != null) { commonMetadata.AdditionalValues.Add("lookupFieldValue", nameFieldMetedata.SimpleDisplayText); commonMetadata.AdditionalValues.Add("lookupFieldDisplayValue", nameFieldMetedata.DisplayName); } else { throw new ModelValidationException(String.Format("Couldn't find name field in releated table {0}", releatedTableMetadata.GetDisplayName())); } } 

यह फ़ंक्शन हमारे कनेक्शन के शाब्दिक प्रतिनिधित्व के संबंध में सभी जानकारी प्राप्त करता है, अर्थात्, वही फ़ील्ड जिसे हमने लुकअप विशेषता में "NameField =" GroupName "के रूप में निर्दिष्ट किया है और इस जानकारी को हमारे फ़ील्ड के अतिरिक्तValues ​​मेटाडेटा में जोड़ता है। nameFieldMetedata.SimpleDisplayText - लिंक्ड टेबल से GroupName फ़ील्ड का मान। nameFieldMetedata.DisplayName - लिंक की गई तालिका से GroupName फ़ील्ड का नाम।

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

  private static MvcHtmlString LookupHtmlInternal(HtmlHelper htmlHelper, ModelMetadata metadata, LookupAttribute lookupMetadata, string name, string action, IDictionary<string, object> htmlAttributes) { if (string.IsNullOrEmpty(name)) { throw new ArgumentException("Error", "htmlHelper"); } var divBuilder = new TagBuilder("div"); divBuilder.MergeAttribute("id", String.Format("{0}_{1}", name, "div")); divBuilder.MergeAttribute("class", "form-wrapper cf"); divBuilder.MergeAttribute("type", lookupMetadata.Model.FullName); divBuilder.MergeAttribute("nameField", lookupMetadata.NameField); divBuilder.MergeAttribute("idField", metadata.AdditionalValues["idField"] as string); divBuilder.MergeAttribute("nameFieldDisplay", metadata.AdditionalValues["lookupFieldDisplayValue"] as string); divBuilder.MergeAttribute("action", action); 

हम निम्नलिखित तर्कों को स्वीकार करते हैं। 1. htmlHelper - हमें html कोड उत्पन्न करने की अनुमति देता है, 2. मेटाडेटा - वास्तव में, यह सभी ext वाले फ़ील्ड का मेटाडेटा है। मेटाडाटा सूचना संग्रह के चरणों में प्राप्त किया। 3. समर्पित लुकमैटडेटा अलग से। 4. नाम - हमारे क्षेत्र का नाम, जैसा कि दृश्य में है। 5 कार्रवाई - नियंत्रक और विधि निर्दिष्ट करें जिसका उपयोग डेटा का अनुरोध करने के लिए किया जाएगा। 5 htmlAttributes - ext। HTML विशेषताओं को प्रोग्रामर द्वारा परिभाषित किया गया है।
अगला, हम देखते हैं कि फ़ील्ड नाम शून्य नहीं है और हमारे क्षेत्र के मुख्य मापदंडों से युक्त एक div का निर्माण करता है। आइए हम मुख्य मापदंडों पर ध्यान केंद्रित करें: प्रकार - जिस मॉडल का हम उल्लेख कर रहे हैं, nameField - लिंक्ड टेबल से टेक्स्ट फ़ील्ड का नाम जो रिश्ते की पहचान करता है (हमारे मामले में समूह का नाम), idField - लिंक्ड टेबल की प्राथमिक कुंजी, nameFieldDisplay - लिंक किए गए तालिका से पाठ फ़ील्ड का मान। जो अच्छी तरह से कनेक्शन और कार्रवाई की पहचान करता है - जैसा कि मैंने कहा, यह नियंत्रक और विधि है जो डेटा का अनुरोध करने के लिए उपयोग किया जाएगा।

  var columnsDivBuilder = new TagBuilder("div"); columnsDivBuilder.MergeAttribute("id", String.Format("{0}_{1}", name, "columns")); columnsDivBuilder.MergeAttribute("style", "display:none"); if (metadata.AdditionalValues.ContainsKey("lookupColumns")) { var columns = ((IDictionary<string, string>)metadata.AdditionalValues["lookupColumns"]); var columnString = String.Empty; foreach (var column in columns.Keys) { var columnDiv = new TagBuilder("div"); columnDiv.MergeAttribute("colName", column); columnDiv.MergeAttribute("displayName", columns[column]); columnString += columnDiv.ToString(TagRenderMode.SelfClosing); } columnsDivBuilder.InnerHtml = columnString; } 

इसके अलावा, उसी योजना के अनुसार, हम एक टेबल को जोड़ते हैं जिसमें लिंक किए गए टेबल से सभी कॉलम हैं जो कि JGGrid के लिए व्यू बनाने के लिए उपयोग किए जाएंगे।

  var inputBuilder = new TagBuilder("input"); inputBuilder.MergeAttributes(htmlAttributes); inputBuilder.MergeAttribute("type", "text"); inputBuilder.MergeAttribute("class", "lookup", true); inputBuilder.MergeAttribute("id", String.Format("{0}_{1}", name, "lookup"), true); inputBuilder.MergeAttribute("value", metadata.AdditionalValues["lookupFieldValue"] as string, true); var hiddenInputBuilder = new TagBuilder("input"); hiddenInputBuilder.MergeAttribute("type", "hidden"); hiddenInputBuilder.MergeAttribute("name", name, true); hiddenInputBuilder.MergeAttribute("id", name, true); hiddenInputBuilder.MergeAttribute("value", metadata.SimpleDisplayText, true); var buttonBuilder = new TagBuilder("input"); buttonBuilder.MergeAttribute("type", "button"); buttonBuilder.MergeAttribute("value", "Lookup"); buttonBuilder.MergeAttribute("class", "lookupbutton"); buttonBuilder.MergeAttribute("id", String.Format("{0}_{1}", name, "lookupbtn"), true); 

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

  divBuilder.InnerHtml = String.Format(@"{0}{1}{2}{3}", inputBuilder.ToString(TagRenderMode.SelfClosing), hiddenInputBuilder.ToString(TagRenderMode.SelfClosing), buttonBuilder.ToString(TagRenderMode.SelfClosing), columnsDivBuilder.ToString(TagRenderMode.Normal) ); return new MvcHtmlString(divBuilder.ToString(TagRenderMode.Normal)); } 

हम वह सब कुछ पैक करते हैं जो हमने रूट div में जेनरेट किया था और प्रदर्शन के लिए ब्राउज़र में html स्ट्रिंग लौटाते हैं।

हमारे HTML सहायक का उपयोग करने के लिए सरल था, हम लुकअप विधि अधिभार को भी लागू करते हैं

  public static MvcHtmlString LookupFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression) { var urlHelper = new UrlHelper(htmlHelper.ViewContext.RequestContext); return LookupFor(htmlHelper, expression, urlHelper.Action("LookupData"), null, null, null); } public static MvcHtmlString LookupFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string filterAction) { return LookupFor(htmlHelper, expression, filterAction, null, null, null); } 

हमारे html सहायक का उपयोग करने के लिए, यह देखने में Html.LookupFor (model => model.UserGroupId) को कॉल करने के लिए पर्याप्त है।
दृश्य में काम करने के लिए अंतर्मुखी के लिए, आपको नामस्थान को जोड़ने की आवश्यकता है जिसमें आपके एचटीएमएल हेल्पर को लागू करने वाला वर्ग web.config में system.web -> पृष्ठों -> नामस्थान अनुभाग में स्थित है, या बस इस वर्ग को पहले से परिभाषित नामस्थानों में से एक में रखें। System.Web.Helpers में कहते हैं। या, सीधे दृश्य में, <@use your.namespace> निर्दिष्ट करें।

यह कहा जा सकता है कि हमारे HtmlHelper का विकास समाप्त हो गया है और हम दूसरे भाग की ओर बढ़ रहे हैं।

2. अभिव्यक्ति और गतिशील विधेय का गठन।

बुनियादी प्रश्नों का एक सेट बनाने के लिए जो डेवलपर को आसानी से "डिफ़ॉल्ट" मोड में हमारे घटक का उपयोग शुरू करने की अनुमति देगा, हमें उन विधेयकों को तैयार करने की आवश्यकता है जो हमें अपने आवेदन के निष्पादन के दौरान एक क्वेरी ट्री बनाने की अनुमति देते हैं। LinqExtension वर्ग पर विचार करें, जिसमें कई विधियां शामिल हैं जो अंततः गतिशील Linq के गठन को सक्षम करती हैं। चलिए शुरू करते हैं जहां विधि लागू करने से।

  public static IQueryable<T> Where<T>(this IQueryable<T> source, string fieldName, string searchString, string compareFunction) { if (searchString == null) searchString = String.Empty; var param = Expression.Parameter(typeof(T)); var prop = Expression.Property(param, fieldName); var methodcall = Expression.Call(prop, typeof(String).GetMethod(compareFunction, new[] { typeof(string) }), Expression.Constant(value: searchString)); var lambda = Expression.Lambda<Func<T, bool>>(methodcall, param); var request = source.Where(lambda); return request; } 

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

हम एक पूर्वनिर्धारित स्ट्रिंग तुलना फ़ंक्शन के साथ कई फ़ंक्शन लागू करते हैं

  public static IQueryable<T> WhereStartsWith<T>(this IQueryable<T> source, string fieldName, string searchString) { return Where(source, fieldName, searchString, "StartsWith"); } public static IQueryable<T> WhereContains<T>(this IQueryable<T> source, string fieldName, string searchString) { return Where(source, fieldName, searchString, "Contains"); } 

छवि और समानता में, हम समान और NotEqual विधियों को लागू करते हैं

  public static IQueryable<T> Equal<T>(this IQueryable<T> source, string fieldName, string searchString) { if (searchString == null) searchString = String.Empty; var param = Expression.Parameter(typeof(T)); var prop = Expression.Property(param, fieldName); var methodcall = Expression.Equal(prop, Expression.Constant(searchString)); var lambda = Expression.Lambda<Func<T, bool>>(methodcall, param); var request = source.Where(lambda); return request; } public static IQueryable<T> NotEqual<T>(this IQueryable<T> source, string fieldName, string searchString) { if (searchString == null) searchString = String.Empty; var param = Expression.Parameter(typeof(T)); var prop = Expression.Property(param, fieldName); var methodcall = Expression.NotEqual(prop, Expression.Constant(searchString)); var lambda = Expression.Lambda<Func<T, bool>>(methodcall, param); var request = source.Where(lambda); return request; } 

यहाँ, सादृश्य द्वारा, मैं विस्तार से नहीं रहूँगा।

हमें डायनामिक रूप से सक्षम होने की भी आवश्यकता है, इसलिए हम ApplyOrder विधि को लागू करते हैं

  static IOrderedQueryable<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName) { var type = typeof(T); var param = Expression.Parameter(type); var pr = type.GetProperty(prop); var expr = Expression.Property(param, type.GetProperty(prop)); var ptype = pr.PropertyType; var delegateType = typeof(Func<,>).MakeGenericType(type, ptype); var lambda = Expression.Lambda(delegateType, expr, param); var result = typeof(Queryable).GetMethods().Single( method => method.Name == methodName && method.IsGenericMethodDefinition && method.GetGenericArguments().Length == 2 && method.GetParameters().Length == 2) .MakeGenericMethod(type, ptype) .Invoke(null, new object[] { source, lambda }); return (IOrderedQueryable<T>)result; } 

तर्कों द्वारा: 1. संपत्ति - वह क्षेत्र जिसके द्वारा हम सॉर्ट करेंगे; 2.मेथोडनेम - वह विधि जिसका उपयोग हम छँटाई के लिए करेंगे। अगला, हम मापदंडों का एक सेट बनाते हैं। MakeGenericType हमारे मामले में एक प्रतिनिधि फंड <Tc, string> का निर्माण करेगा, फिर इसका उपयोग एक लैम्ब्डा बनाने के लिए करेंगे, जिसे हम मेथडनाम के रूप में परिभाषित विधि के तर्क के रूप में पास करते हैं और इसे सभी प्रतिबिंब के साथ कहते हैं।

इस प्रकार, अब हम Queryable से विधियों को छांटने के लिए गतिशील कॉल को परिभाषित करने में सक्षम हैं।

  public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, bool desc , string property) { return ApplyOrder(source, property, desc ? "OrderByDescending" : "OrderBy"); } public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string property) { return ApplyOrder(source, property, "OrderBy"); } public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> source, string property) { return ApplyOrder(source, property, "OrderByDescending"); } public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, string property) { return ApplyOrder(source, property, "ThenBy"); } public static IOrderedQueryable<T> ThenByDescending<T>(this IOrderedQueryable<T> source, string property) { return ApplyOrder(source, property, "ThenByDescending"); } 

यह लाइनक हेल्पर वर्ग के कार्यान्वयन को पूरा करता है और अगले चरण के लिए आगे बढ़ता है।

3. हमारे घटक के ModelBinder और कॉन्फ़िगरेशन।

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

  public enum SearchOperator { Equal, NotEqual, Contains } public class FilterSettings { public string SearchString; public string SearchField; public SearchOperator Operator; } public class GridSettings { public bool IsSearch { get; set; } public int PageSize { get; set; } public int PageIndex { get; set; } public string SortColumn { get; set; } public bool Asc { get; set; } } public class LookupSettings { public Type Model { get; set; } public FilterSettings Filter { get; set; } public GridSettings GridSettings { get; set; } public string IdField { get; set; } public string NameField { get; set; } } 

मैं कक्षाओं के विवरण पर ध्यान नहीं दूंगा। इसके बाद, उस कोड के एक टुकड़े पर विचार करें जो jqGrid से प्राप्त डेटा या वर्ग के संगत उदाहरण में परिवर्तित होने वाले लुकअप की अनुमति देता है।

  public class LookupModelBinder : IModelBinder { public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { HttpRequestBase request = controllerContext.HttpContext.Request; var lookupSettings = new LookupSettings { Model = Type.GetType(request["modelType"]), IdField = request["IdField"], NameField = request["NameField"], Filter = new FilterSettings { SearchString = request["searchString"] ?? String.Empty, SearchField = request["searchField"] } }; if(request["searchOper"] != null) { switch (request["searchOper"]) { case "eq": lookupSettings.Filter.Operator = SearchOperator.Equal; break; case "ne": lookupSettings.Filter.Operator = SearchOperator.NotEqual; break; case "cn": lookupSettings.Filter.Operator = SearchOperator.Contains; break; } } lookupSettings.GridSettings = new GridSettings {Asc = request["sord"] == "asc"}; if (request["_search"] != null) lookupSettings.GridSettings.IsSearch = Convert.ToBoolean(request["_search"]); if (request["page"] != null) lookupSettings.GridSettings.PageIndex = Convert.ToInt32(request["page"]); if (request["rows"] != null) lookupSettings.GridSettings.PageSize = Convert.ToInt32(request["rows"]); lookupSettings.GridSettings.SortColumn = request["sidx"]; if (lookupSettings.Filter.SearchField == null) { lookupSettings.Filter.SearchField = request["NameField"]; lookupSettings.Filter.Operator = SearchOperator.Contains; } return lookupSettings; } } 

बाध्यकारी को लागू करने के लिए, हमें IModelBinder वर्ग से विरासत में प्राप्त करने और BindModel फ़ंक्शन को लागू करने की आवश्यकता है, जहां कंट्रोलर कॉन्सेप्ट वह संदर्भ है जिसमें नियंत्रक संचालित होता है। संदर्भ जानकारी में नियंत्रक, HTTP सामग्री, अनुरोध संदर्भ और मार्ग डेटा के बारे में जानकारी शामिल है। बाइंडिंगटेक्स्ट - वह संदर्भ जिसमें मॉडल बाध्य है। संदर्भ में मॉडल ऑब्जेक्ट, मॉडल का नाम, मॉडल प्रकार, संपत्ति फ़िल्टर, और मूल्य प्रदाता जैसी जानकारी होती है। हम HttpRequestBase प्राप्त करते हैं और अनुरोध में दिए गए डेटा को प्राप्त करने के लिए इस ऑब्जेक्ट का उपयोग करते हैं। अगला, हम सेटिंग मॉडल की संरचना बनाते हैं और परिणामी वर्ग को वापस करते हैं। बाध्यकारी के लिए काम करना शुरू करने के लिए, आपको इसे पंजीकृत करने की आवश्यकता है, तो चलिए Global.asax.cs पर जाएं और संबंधित कॉल जोड़ें।

  ModelBinders.Binders.Add(typeof(LookupSettings), new LookupModelBinder()); 

परिणामस्वरूप, सभी पंजीकरणों के बाद, मेरा Global.asax.cs इस तरह दिखता है:

  protected void Application_Start() { AreaRegistration.RegisterAllAreas(); ModelMetadataProviders.Current = new LookupMetadataExtension(); ModelBinders.Binders.Add(typeof(LookupSettings), new LookupModelBinder()); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); AuthConfig.RegisterAuth(); } 

अब नियंत्रक में, हम लुकअप से प्राप्त तर्कों का उल्लेख करने के लिए निम्न प्रविष्टि का उपयोग कर सकते हैं।

 public virtual ActionResult LookupData([ModelBinder(typeof(LookupModelBinder))] LookupSettings settings) 

इस पर हम कॉन्फ़िगरेशन ऑब्जेक्ट के साथ काम खत्म करते हैं और अगले चरण पर जाते हैं:

4. लुकअप नियंत्रण के लिए एक सामान्य MVC नियंत्रक का कार्यान्वयन।

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

चूंकि प्रकार केवल रनटाइम में निर्धारित किया जाता है, हम एक फ़ंक्शन लागू करते हैं जो हमारे मॉडल को एक सामान्य तर्क के रूप में टाइप करेगा और फ़ंक्शन को अनुरोध के अनुरूप कॉल करेगा। तो हम निम्नलिखित कोड dbContext.Set () का उपयोग कर सकते हैं। AsQueryable (); एक बुनियादी अनुरोध बनाने के लिए।

लुकअपमेथोडकॉल फ़ंक्शन पर विचार करें।

  private static ActionResult LookupMethodCall(string methodName, LookupSettings settings, DbContext dbContext, OnAfterQueryPrepared onAfterQueryPrepared) { var methodLookupCall = typeof(LookupDataResolver). GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static); methodLookupCall = methodLookupCall.MakeGenericMethod(settings.Model); var lookupSettings = Expression.Parameter(typeof(LookupSettings), "settings"); var dbCtx = Expression.Parameter(typeof(DbContext), "dbContext"); var funct = Expression.Parameter(typeof(OnAfterQueryPrepared), "onAfterQueryPrepared"); var lookupSearch = Expression.Lambda( Expression.Call( null, methodLookupCall, lookupSettings, dbCtx, funct), lookupSettings, dbCtx, funct); var lookupSearchDelegate = (Func<LookupSettings, DbContext, OnAfterQueryPrepared, JsonResult>) lookupSearch.Compile(); return lookupSearchDelegate(settings, dbContext, onAfterQueryPrepared); } 

सबसे पहले, हम मेथडनाम विधि के लिए वर्तमान प्रकार में देखते हैं। उसके बाद, MakeGenericMethod फ़ंक्शन का उपयोग करके, हम अपने मॉडल को जेनेरिक तर्क के रूप में उपयोग के लिए तैयार करते हैं। हम पैरामीटर बनाते हैं: सेटिंग्स (लुकअप से प्राप्त सेटिंग्स का सार), dbContext (डेटाबेस तक पहुंचने के लिए संदर्भ), onAfterQueryPrepared (प्रतिनिधि जो डेटाबेस के लिए बुनियादी अनुरोध के गठन के तुरंत बाद बुलाया जाएगा। अतिरिक्त फिल्टर जोड़ने की आवश्यकता है, यदि आवश्यक हो तो)। इसके बाद, संबंधित लैम्बडा बनाएं जो हमारी विधि को कॉल करेगा, जिसके बाद हम इसे संकलित करते हैं और इसे कॉल करते हैं।

हम लुकअपमेथकॉडल फ़ंक्शन का उपयोग करके अनुरोध के अनुरूप विधि को कॉल करने वाले फ़ंक्शन को लागू करते हैं। BasicLookup, लुकअप में उपयोगकर्ता द्वारा दर्ज किए गए टेक्स्ट को हल करने के लिए, सामान्य लुकअप खोज फ़ंक्शन का उपयोग करेगा। BasicGrid ग्रिड में सॉर्टिंग और खोज प्रदान करेगा, इसे सामान्य फ़ंक्शन LookupDataForGrid कहते हैं।

  public static ActionResult BasicLookup(LookupSettings settings, DbContext dbContext, OnAfterQueryPrepared onAfterQueryPrepared) { return LookupMethodCall("LookupSearch", settings, dbContext, onAfterQueryPrepared); } public static ActionResult BasicGrid(LookupSettings settings, DbContext dbContext, OnAfterQueryPrepared onAfterQueryPrepared) { return LookupMethodCall("LookupDataForGrid", settings, dbContext, onAfterQueryPrepared); } 

हम उन कार्यों को महसूस करते हैं जो डेटाबेस के साथ संचालन करते हैं और परिणामी डेटा सेट बनाते हैं। ये दो सामान्य कार्य हैं जिनके कॉल ऊपर वर्णित हैं।

  private static JsonResult LookupSearch<T>(LookupSettings settings, DbContext dbContext, OnAfterQueryPrepared onAfterQueryPrepared) where T : class { var modelType = typeof(T); var request = dbContext.Set<T>().AsQueryable(); if (onAfterQueryPrepared != null) { var query = onAfterQueryPrepared(request, settings); if (query != null) request = query.Cast<T>(); } request = request.WhereStartsWith(settings.Filter.SearchField, settings.Filter.SearchString); return new JsonResult { Data = request.ToList().Select(t => new { label = modelType.GetProperty(settings.NameField).GetValue(t).ToString(), id = modelType.GetProperty(settings.IdField).GetValue(t).ToString() }).ToList(), ContentType = null, ContentEncoding = null, JsonRequestBehavior = JsonRequestBehavior.AllowGet }; } 

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

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

  private static JsonResult LookupDataForGrid<T>(LookupSettings settings, DbContext dbContext, OnAfterQueryPrepared onAfterQueryPrepared) where T : class { var modelType = typeof(T); var pageIndex = settings.GridSettings.PageIndex - 1; var pageSize = settings.GridSettings.PageSize; var request = dbContext.Set<T>().AsQueryable(); if (onAfterQueryPrepared != null) { var query = onAfterQueryPrepared(request, settings); if (query != null) request = query.Cast<T>(); } if (settings.GridSettings.IsSearch) { switch (settings.Filter.Operator) { case SearchOperator.Equal: request = request.Equal(settings.Filter.SearchField, settings.Filter.SearchString); break; case SearchOperator.NotEqual: request = request.NotEqual(settings.Filter.SearchField, settings.Filter.SearchString); break; case SearchOperator.Contains: request = request.WhereContains(settings.Filter.SearchField, settings.Filter.SearchString); break; } } var totalRecords = request.Count(); var totalPages = (int)Math.Ceiling(totalRecords / (float)pageSize); var userGroups = request .OrderBy(!settings.GridSettings.Asc, settings.GridSettings.SortColumn) .Skip(pageIndex * pageSize) .Take(pageSize); return new JsonResult { Data = new { total = totalPages, settings.GridSettings.PageIndex, records = totalRecords, rows = ( userGroups.AsEnumerable().Select(t => new { id = modelType.GetProperty(settings.IdField).GetValue(t).ToString(), cell = GetDataFromColumns(modelType, settings, t) }).ToList()) }, ContentType = null, ContentEncoding = null, JsonRequestBehavior = JsonRequestBehavior.AllowGet }; } 

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

  private static IEnumerable<string> GetDataFromColumns(Type model, LookupSettings settings, object instance) { var dataArray = new List<string> { model.GetProperty(settings.IdField).GetValue(instance).ToString(), model.GetProperty(settings.NameField).GetValue(instance).ToString() }; var gridColumns = model.GetCustomAttributeByType<LookupGridColumnsAttribute>(); if (gridColumns != null) { dataArray.AddRange(from column in gridColumns.LookupColumns select model.GetProperty(column).GetValue(instance) into val where val != null select val.ToString()); } return dataArray; } 

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

अब मूल नियंत्रक को लागू करने का समय है, जो "डिफ़ॉल्ट" मोड में फॉर्म पर सभी लुकअप नियंत्रणों के कामकाज को सुनिश्चित करेगा

  public class LookupBasicController : Controller { protected virtual DbContext GetDbContext { get { throw new NotImplementedException("You have to implement this method to return correct db context"); } } protected virtual IQueryable LookupBaseQuery(IQueryable query, LookupSettings settings) { return null; } public virtual ActionResult LookupData([ModelBinder(typeof(LookupModelBinder))] LookupSettings settings) { return LookupDataResolver.BasicLookup(settings, GetDbContext, LookupBaseQuery); } public virtual ActionResult LookupDataGrid([ModelBinder(typeof(LookupModelBinder))] LookupSettings settings) { return LookupDataResolver.BasicGrid(settings, GetDbContext, LookupBaseQuery); } 

उत्तराधिकारी वर्ग में सही ढंग से काम करने के लिए, आपको डेटाबेस संदर्भ को फिर से परिभाषित करना होगा, और यदि आप डिफ़ॉल्ट प्रश्नों का विस्तार करने की योजना बनाते हैं, तो लुकअपबेस फ़ंक्शन। इस फ़ंक्शन का उपयोग आधार क्वेरी बनाते समय LookupSearch और LookupDataForGrid से कॉल करने के लिए किया जाता है। मैं यह भी ध्यान देता हूं कि जेएस द्वारा डेटा प्राप्त करने के लिए नियंत्रक के कार्यों के नाम एचटीएमएल सहायक के विन्यास के दौरान निर्धारित किए जा सकते हैं। हालांकि, jqGrid के लिए डेटा अधिग्रहण करने वाले फ़ंक्शन का नाम निम्न पैटर्न के अनुसार बनता है: HTML हेल्पर + ग्रिड के कॉन्फ़िगरेशन के दौरान निर्दिष्ट नाम। डिफ़ॉल्ट रूप से, JS लुकअपडेटा और लुकअपडेटाग्रिड फ़ंक्शन का उपयोग करेगा।

इस पर हम कह सकते हैं कि घटक के मूल तत्वों का विकास पूरा हो गया है। स्रोत में आप फ़ाइल को देख सकते हैं। जेएस, जो हमारे घटक के काम के ग्राहक भाग के लिए जिम्मेदार है, मैंने इसे यहां नहीं माना है, क्योंकि यह बहुत रुचि का नहीं है।

5. उपयोग उदाहरण

उन मॉडलों पर विचार करें जो लेख की शुरुआत में वर्णित किए गए थे। आइए हमारे घटक को संचार पर लागू करें।

  [Table("UserProfile")] public class UserProfile { [Key] [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)] public int UserId { get; set; } public string UserName { get; set; } [Lookup(Model = typeof(UserGroup), NameField = "GroupName")] public int? UserGroupId { get; set; } public virtual UserGroup UserGroup { get; set; } } [LookupGridColumns(new[] { "Description" })] public class UserGroup { [Key] public int UserGroupId { get; set; } [DisplayName("Group Name")] public string GroupName { get; set; } [DisplayName("Group Description")] public string Description { get; set; } public virtual ICollection<UserProfile> Users { get; set; } } 

तो, हमारे पास एक UserProfile है जिसमें हम लुकअप लिंक को UserGroup में जोड़ते हैं और निर्धारित करते हैं कि हम इस रिकॉर्ड के पाठीय प्रतिनिधित्व के लिए किस क्षेत्र का उपयोग करेंगे। UserGroud तालिका में, LookupGridColumns विशेषता जोड़ें जिसमें हम अतिरिक्त निर्दिष्ट करते हैं। कॉलम जिसे आप दृश्य में देखना चाहेंगे। वास्तव में यह सब है, अब नियंत्रक पर जाएं।

  public class UserListController : LookupBasicController { private readonly DataBaseContext _db = new DataBaseContext(); protected override DbContext GetDbContext { get { return _db; } } 

हम LookupBasicController और वंशानुक्रम GetDbContext से db संदर्भ के लिए LookupBasicController पहुँच देने के लिए इनहेरिट करेंगे।

  public ActionResult Edit(int id = 0) { UserProfile userprofile = _db.UserProfiles.Include(c => c.UserGroup) .SingleOrDefault(x => x.UserId == id); if (userprofile == null) { return HttpNotFound(); } return View(userprofile); } 

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

 @using TestApp.Models @model UserProfile @{ ViewBag.Title = "Edit"; } @Styles.Render("~/Content/JqGrid") <h2>Edit</h2> @using (Html.BeginForm()) { @Html.ValidationSummary(true) <fieldset> <legend>UserProfile</legend> @Html.HiddenFor(model => model.UserId) <div class="editor-label"> @Html.LabelFor(model => model.UserName) </div> <div class="editor-field"> @Html.EditorFor(model => model.UserName) @Html.ValidationMessageFor(model => model.UserName) </div> <div class="editor-label"> @Html.LabelFor(model => model.UserGroupId) </div> <div class="editor-field"> @Html.LookupFor(model => model.UserGroupId) @Html.ValidationMessageFor(model => model.UserGroupId ) </div> <p> <input type="submit" value="Save" /> </p> </fieldset> } <div> @Html.ActionLink("Back to List", "Index") </div> @section Scripts { @Scripts.Render("~/bundles/lookup") @Scripts.Render("~/bundles/jqueryval") @Scripts.Render("~/bundles/jqueryui") @Scripts.Render("~/bundles/jqgrid") } 

यहां आपको अतिरिक्त जोड़ने के लिए याद रखने की आवश्यकता है। लिपिक, लुकअप आदि जैसी स्क्रिप्ट। आप लेख से जुड़े स्रोत कोड का उपयोग करके प्रस्तुति पर अधिक विस्तार से विचार कर सकते हैं।


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

यह सब इस तरह दिखता है:

6. निष्कर्ष

अंत में, मैं कहना चाहता हूं, हमने कुछ समय एक घटक की तलाश में बिताया, जो हमारी जरूरतों को पूरा करता है, और परिणामस्वरूप हम उत्पाद ASP.net MVC भयानक 3.5 पर बस गए। मैं ध्यान देता हूं कि MVC विस्मयकारी लुकअप घटक काफी लचीला है, और आपको विभिन्न प्रकार की सेटिंग्स करने की अनुमति देता है, लेकिन चूंकि यह खरोंच से सब कुछ विकसित करने का निर्णय लिया गया था, इसलिए मैं इसकी अनुशंसा नहीं कर सकता क्योंकि मैंने इसका उपयोग नहीं किया है। यहां एक उपयोग उदाहरण और कोड देखें: Awe लुकअप । उन्हें बहु-चयन समर्थन भी है।

घटक के स्रोत कोड और लेख में चर्चा किए गए परीक्षण एप्लिकेशन को यहां डाउनलोड किया जा सकता है: TestApp.zip ।

मुझे आशा है कि सामग्री आपके लिए दिलचस्प थी!