ASP.NET MVC और इकाई फ्रेमवर्क पर डेटा फ़िल्टर

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

मैं तुरंत ध्यान देना चाहूंगा कि मेरा समाधान प्रतिभा और परिपूर्ण वास्तुकला का ढोंग नहीं करता है, इसके नुकसान हैं जो मैं अंत में ध्यान दूंगा, और मुझे वास्तव में उम्मीद है कि हब्र समुदाय मुझे उन नुकसानों की ओर संकेत करेगा जो मुझे नहीं दिखते हैं।

मुझे लगता है कि आपको तुरंत नीचे दिए गए वर्णन का एक उदाहरण देना चाहिए। विचार यह है: मान लें कि हमारे पास एक ऐसा डेटा मॉडल है

public class Student { [Key] public int Id { get; set; } //  public string Name { get; set; } //  public string Group { get; set; } //   public short DefYear { get; set; } //    public bool IsDefended { get; set; } } 

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

 public class StudentFilter : FilterModel<Student> { [FilterName("")] [InputType(InputTypeAttribute.InputTypies.TextBox)] public string Name { get; set; } [FilterName("")] [InputType(InputTypeAttribute.InputTypies.TextBox)] public string Group { get; set; } [FilterName(" ")] [InputType(InputTypeAttribute.InputTypies.DropDownList)] [SelectListProperty("DefYearList", "")] public short? DefYear { get; set; } [FilterName("  ")] [InputType(InputTypeAttribute.InputTypies.DropDownList)] [SelectListProperty("IsDefendedList", "")] public bool? IsDefended { get; set; } public SelectList DefYearList { get { return new SelectList(new List<short> { 2011, 2012 }, DefYear); } } public SelectList IsDefendedList { get { var list = new List<object> { {new {Id="true", Title=""}}, {new {Id="false", Title=" "}}, }; return new SelectList(list, "Id", "Title", IsDefended); } } public override Func<Student, bool> FilterExpression { get { return p => (String.IsNullOrEmpty(Name) || p.Name.IndexOf(Name) == 0) && (String.IsNullOrEmpty(Group) || p.Group.ToLower().IndexOf(Group.ToLower()) == 0) && (DefYear == null || p.DefYear == DefYear) && (IsDefended == null || (p.IsDefended == IsDefended)); } } public override void Reset() { Name = null; Group = null; DefYear = null; IsDefended = null; } } 

फ़िल्टर मॉडल होने पर, हम डेटाबेस से डेटा का चयन कर सकते हैं जो इस मॉडल में संग्रहीत मूल्यों को संतुष्ट करता है। आप इसे इस तरह से कर सकते हैं

 var filters = IocContainer.Resolve<IFilterFactory>(); var students = DbContext.Students .Where(Filter.FilterExpression) .OrderBy(s => s.Name) .ToList(); 

और निश्चित रूप से, दृश्य कोड, जो उस फॉर्म को प्रदर्शित करेगा जिसे उपयोगकर्ता को डेटा को फ़िल्टर करने के लिए भरना होगा।

 .................. <h2></h2> @Html.FilterForm(Filters.Find<UserFilter>()) .................. 

फिल्टर एक ही फिल्टर रिपॉजिटरी है जो डेटाबेस से लाते समय उपयोग किया गया था। व्यक्तिगत रूप से, मैं इसे एकता का उपयोग करके प्राप्त करता हूं।

बस, हमें कुछ और नहीं चाहिए। यूजर अपने सामने कुछ इस तरह से देखेगा

और एक डेटा सेट जो इस फॉर्म से मेल खाता है।

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

 public abstract class FilterModel { [Dependency] public IUnityContainer IocContainer { get; set; } public abstract void Reset(); } public abstract class FilterModel<ModelType> : FilterModel { public abstract Func<ModelType, bool> FilterExpression { get; } } 

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

अब जब हमारे पास मॉडल है, तो हमें इसे कहीं स्टोर करने की आवश्यकता है। अब भंडारण की आवश्यकता पर विचार करें।

 public interface IFilterFactory { /// <summary> ///     /// </summary> /// <typeparam name="TFilter"></typeparam> /// <returns></returns> TFilter Find<TFilter>() where TFilter : FilterModel; /// <summary> ///    GUID  /// </summary> /// <param name="guidString"></param> /// <returns></returns> FilterModel Find(String guidString); /// <summary> ///    /// </summary> /// <param name="filter"></param> void Replace(FilterModel filter); /// <summary> ///       /// </summary> /// <param name="guidString">guid  </param> void Reset(String guidString); } 

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

यहाँ IFilterFactory इंटरफ़ेस का एक बुनियादी कार्यान्वयन है।

 public class DefaultFilterFactory : IFilterFactory { protected List<object> Collection { get; private set; } [InjectionConstructor] public DefaultFilterFactory() { Collection = new List<object>(); } [Dependency] public IUnityContainer IocContainer { get; set; } /// <summary> ///    /// </summary> /// <typeparam name="TFilter"> </typeparam> /// <returns></returns> public TFilter Find<TFilter>() where TFilter : FilterModel { try { return (TFilter)Collection.Single(f => f.GetType().FullName == typeof(TFilter).FullName); } catch { AddNew<TFilter>(); return Find<TFilter>(); } } /// <summary> ///    GUID   /// </summary> /// <param name="guidString">  GUID</param> /// <returns></returns> public FilterModel Find(String guidString) { return (FilterModel)Collection.Single(f => f.GetType().GUID.ToString() == guidString); } public void Replace(FilterModel filter) { try { var old = Collection.SingleOrDefault(f => f.GetType().FullName == filter.GetType().FullName); if (old != null) { if (!Collection.Remove(old)) throw new InvalidOperationException("    "); } } catch (InvalidOperationException) { throw; } catch { //    } Collection.Add(filter); } /// <summary> ///    /// </summary> /// <typeparam name="TFilter"> </typeparam> protected void AddNew<TFilter>() where TFilter : FilterModel { var filter = IocContainer.Resolve<TFilter>(); filter.Reset(); Collection.Add(filter); } /// <summary> ///    GUID   /// </summary> /// <param name="guidString">  GUID</param> /// <returns></returns> public void Reset(String guidString) { try { var filter = Find(guidString); filter.Reset(); } catch { //    } } } 

उपयोगकर्ता द्वारा चुने गए मूल्यों को बचाने के लिए सत्र के भीतर डिफ़ॉल्ट ऑब्जेक्ट में क्लास ऑब्जेक्ट को संग्रहीत करना आवश्यक है। इसके लिए, मैं ASP.NET MVC सत्रों के लिए एक अतिरिक्त आजीवन के साथ यूनिटी का उपयोग करता हूं, आप किसी अन्य DI फ्रेमवर्क का उपयोग कर सकते हैं या ऑब्जेक्ट के साथ स्वयं काम कर सकते हैं। आप IFilterFactory इंटरफ़ेस का एक और कार्यान्वयन भी लिख सकते हैं, जिसका उपयोग xml को संग्रहीत करने के लिए किया जाएगा, उदाहरण के लिए, या डेटाबेस, यहाँ कल्पना असीम हो सकती है ...

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

 public class FilterBinder { /// <summary> ///   ,      guid  /// </summary> public static string TypeKey { get { return "_filter_type"; } } /// <summary> ///    ,       ///    ,         InputTypeAttribute /// </summary> public static Func<PropertyInfo, bool> IsFilterProperty { get { return p => p.GetCustomAttributes(true).Count(a => a.GetType() == typeof(InputTypeAttribute)) > 0; } } /// <summary> ///   /// </summary> public HttpRequest Request { get; protected set; } /// <summary> /// Unity  /// </summary> [Dependency] public IUnityContainer IocContainer { get; set; } /// <summary> ///   /// </summary> public Type FilterType { get { return IocContainer.Resolve<IFilterFactory>().Find(Request[TypeKey]).GetType(); } } public FilterBinder() { Request = HttpContext.Current.Request; } /// <summary> ///   /// </summary> /// <returns></returns> public FilterModel BindFilter() { var filter = (FilterModel)IocContainer.Resolve(FilterType); //    ,  InputTypeAttribute foreach (var property in FilterType.GetProperties().Where(FilterBinder.IsFilterProperty)) { object value = null; //   ,        ,     if (property.PropertyType == typeof(String)) { value = Request[property.Name]; } //  ,    else { try { var parse = property.PropertyType.GetMethod("Parse", new Type[] { typeof(String) }) ?? property.PropertyType.GetProperty("Value").PropertyType.GetMethod("Parse", new Type[] { typeof(String) }); if (parse != null) value = parse.Invoke(null, new object[] { Request[property.Name] }); } catch { value = null; } } //     property.SetValue(filter, value, null); } return filter; } } 

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

 public class _FilterController : ExpandController { public ActionResult SetFilter(string backUrl) { try { var filter = IocContainer.Resolve<FilterBinder>().BindFilter(); if (filter == null) { FlashMessanger.ErrorMessage = "  "; return Redirect(backUrl); } Filters.Replace(filter); } catch { FlashMessanger.ErrorMessage = "  :   . ,  "; } return Redirect(backUrl); } public ActionResult Reset(string backUrl, string filter) { Filters.Reset(filter); return Redirect(backUrl); } } 

(विस्तारकंट्रोलर - उन्नत बुनियादी नियंत्रक, फ्लैशमेन्सर - टेंपडाटा के लिए ऐड-ऑन, मैं इस विषय पर स्पष्टीकरण नहीं देता, क्योंकि यह पूरी तरह से अलग कहानी है)

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

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

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

 /// <summary> ///   ,   SelectList    /// </summary> public class SelectListPropertyAttribute : Attribute { /// <summary> ///   /// </summary> public string Property { get; set; } /// <summary> ///   null /// </summary> public string OptionLabel { get; set; } public SelectListPropertyAttribute(string property) { Property = property; OptionLabel = String.Empty; } public SelectListPropertyAttribute(string property, string optionLabel) : this(property) { OptionLabel = optionLabel; } } /// <summary> ///               ///          /// </summary> public class InputTypeAttribute : Attribute { public enum InputTypies { TextBox, CheckBox, DropDownList } public InputTypies Type { get; set; } public InputTypeAttribute(InputTypies type) { Type = type; } } /// <summary> ///       /// </summary> public class FilterNameAttribute : Attribute { public string Name { get; set; } public FilterNameAttribute(string name) { Name = name; } } 

और सहायक कोड

 public static class Helpers { /// <summary> ///  ,    /// </summary> private const string CONTROLLER_NAME = "_Filter"; /// <summary> ///      /// </summary> private const string SET_ACTION_NAME = "SetFilter"; /// <summary> ///      /// </summary> private const string RESET_ACTION_NAME = "Reset"; /// <summary> ///    /// </summary> /// <returns></returns> public static IHtmlString FilterForm(this HtmlHelper helper, FilterModel filter, string controllerName = CONTROLLER_NAME, string setActionName = SET_ACTION_NAME, string resetActionName = RESET_ACTION_NAME) { var url = new UrlHelper(HttpContext.Current.Request.RequestContext, helper.RouteCollection); // url      var hrefSet = url.Action(setActionName, controllerName, new { area = "", backUrl = HttpContext.Current.Request.Url }); var result = String.Format("<form action=\"{0}\" method=\"post\">\n\t<div class=\"filters\">", hrefSet); result += helper.Hidden(FilterBinder.TypeKey, filter.GetType().GUID.ToString()).ToString(); result += "<h3></h3>"; //  ,    //    Func<PropertyInfo, string> getFilterName = p => p.GetCustomAttributes(typeof(FilterNameAttribute), true).Any() ? ((FilterNameAttribute)p.GetCustomAttributes(typeof(FilterNameAttribute), true).Single()).Name : p.Name; //  ,  SelectList   Func<PropertyInfo, PropertyInfo> getSelectListProperty = p => !p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Any() ? null : p.DeclaringType.GetProperty( ((SelectListPropertyAttribute)p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Single()).Property, typeof(SelectList) ); //      Func<PropertyInfo, string> getSelectListOptionLabel = p => !p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Any() ? null : ((SelectListPropertyAttribute)p.GetCustomAttributes(typeof(SelectListPropertyAttribute), true).Single()).OptionLabel; //    ,  InputTypeAttribute foreach (var property in filter.GetType().GetProperties().Where(FilterBinder.IsFilterProperty)) { result += "\n\t\t<div class=\"filter_item\">"; result += "\n\t\t\t<span>" + getFilterName(property) + "</span>"; //   ,       var type = (InputTypeAttribute)property.GetCustomAttributes(typeof(InputTypeAttribute), true).Single(); //  html  switch (type.Type) { case InputTypeAttribute.InputTypies.TextBox: result += helper.TextBox(property.Name, property.GetValue(filter, null)).ToString(); break; case InputTypeAttribute.InputTypies.CheckBox: result += helper.CheckBox(property.Name, property.GetValue(filter, null)).ToString(); break; case InputTypeAttribute.InputTypies.DropDownList: var selectList = getSelectListProperty(property) != null ? (SelectList)getSelectListProperty(property).GetValue(filter, null) : new SelectList(new List<object>()); result += String.IsNullOrEmpty(getSelectListOptionLabel(property)) ? helper.DropDownList(property.Name, selectList) : helper.DropDownList(property.Name, selectList, getSelectListOptionLabel(property)); break; } result += "\n\t\t</div>"; } result += "\n\t\t<div class=\"clear\"></div>"; result += String.Format( @"<input type='image' src='{0}' /><a href='{1}'><img src='{2}' alt='' /></a>", url.Content("~/Content/images/button_apply.png"), url.Action(resetActionName, controllerName, new { area = "", backUrl = HttpContext.Current.Request.Url, filter = filter.GetType().GUID }), url.Content("~/Content/images/button_cancel.png") ); return helper.Raw(result + "\n\t</div>\n</form>"); } } 

शायद बस इतना ही। अब शुरू में मैंने जिन मंत्रियों के बारे में बात की थी:

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

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

3) फ़िल्टरमॉडल वर्ग की रीसेट विधि के लिए, आप एक डिफ़ॉल्ट कार्यान्वयन लिख सकते हैं जिसमें InputTypeAttribute के साथ चिह्नित सभी गुण शून्य पर सेट हैं।

4) मुझे इस सब की वास्तुकला की पूर्ण शुद्धता के बारे में निश्चित नहीं है।

मेरे लेख को अंत तक पढ़ने के लिए बहुत-बहुत धन्यवाद! मैं उन सभी का बहुत आभारी रहूंगा जो अपनी राय और टिप्पणी छोड़ते हैं।

अद्यतन
जैसा कि टिप्पणियों में सही ढंग से उल्लेख किया गया है

 public abstract class FilterModel<ModelType> : FilterModel { public abstract Func<ModelType, bool> FilterExpression { get; } } 

द्वारा प्रतिस्थापित बेहतर है

 public abstract class FilterModel<ModelType> : FilterModel { public abstract Expression<Func<ModelType, bool>> FilterExpression { get; } } 

इस स्थिति में, फ़िल्टर अभिव्यक्ति SQL क्वेरी में बदल जाएगी।