ASP.NET MVC - ADO.NET के माध्यम से MySQL के साथ काम कर रहा है

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

और अब मैं सबसे मानक कार्य के बारे में बात करूंगा - डेटा के साथ सामान्य कार्य: सारणीबद्ध रूप में रिकॉर्ड करना, डेटा जोड़ना (जोड़ना और बदलना) की सूची। हालांकि, लगभग सभी पुस्तकों और ASP.NET MVC के लिए कई इंटरनेट समाधानों में, किसी कारण से, विकल्प को विशेष रूप से ORM (ऑब्जेक्ट रिलेशन मैपिंग) के माध्यम से माना जाता है: SQL के लिए एंटिटी फ्रेमवर्क (EF) या LINQ। प्रौद्योगिकियां उत्कृष्ट हैं, इसमें कोई संदेह नहीं है, अंत में, प्रोग्रामर समझ नहीं सकता है - लेकिन यह कैसे संबंधपरक डीबीएमएस (जो वह सबसे अधिक उपयोग करता है) आमतौर पर काम करता है, और यहां तक ​​कि एसक्यूएल, सिद्धांत रूप में, अब आवश्यक नहीं है: ईएफ के रूप में बिछाने DBMS के लिए कनेक्टर एक दूसरे को समझेंगे। "यहाँ यह खुशी है - इसके लिए और अधिक सौंदर्य नहीं है।" लेकिन उन प्रोग्रामर के लिए जो ADO.NET तंत्र के माध्यम से सीधे डेटाबेस के साथ काम करने से डरते नहीं हैं, यह अक्सर स्पष्ट नहीं होता है - और सामान्य रूप से ASP.NET MVC के साथ कहां शुरू करना है और क्या यह आवश्यक है।

इसके अलावा, मेरे लिए, उदाहरण के लिए, शुरुआत में यह ग्रिड टेबल में डेटा प्रदर्शित करने के लिए एक सुविधाजनक घटक की कमी पर जंगली टूटने का कारण बना। यह समझा जाता है कि डेवलपर को स्वयं यह सब लागू करना चाहिए या पैकेज प्रबंधक से कुछ उपयुक्त लेना चाहिए। यदि आप, मेरी तरह, ASP.NET WebForms में GridView घटक से अधिक खुश थे, तो MVC के लिए, Grid.mvc को छोड़कर, कुछ अधिक या कम तुलनीय खोजना मुश्किल है। लेकिन ऐसे घटकों में मेरा विश्वास पर्याप्त रूप से बड़ी परियोजना के लिए उनका उपयोग करने के लिए पर्याप्त नहीं है। यदि उनका उपयोग किया जाता है, तो प्रोग्रामर किसी अन्य डेवलपर पर निर्भर होना शुरू होता है, जो सबसे पहले, यह नहीं जानता कि इस घटक को कैसे लिखना है (क्या यह गुणात्मक है?), और दूसरी बात, यह पता नहीं है कि इसे कब और कैसे अंतिम रूप दिया जाएगा। यह कभी-कभी घटक का विस्तार करने के लिए भी संभव लगता है और आगे देखा जाता है, लेकिन, अगर डेवलपर इसे पूरा करता है, तो हमें अपने कोड को फिर से खोदने या एक निश्चित संस्करण पर घटक अपडेट को फ्रीज करने के लिए मजबूर किया जाता है। और अगर डेवलपर एक भेद्यता को ठीक करता है, तो आपको अभी भी नए संस्करण में अपग्रेड करना होगा। यहां तक ​​कि MySQL कनेक्टर के नए संस्करणों के लिए संक्रमण कुछ समस्याओं का कारण बनता है, हालांकि यह अभी भी एक बड़ी कंपनी द्वारा विकसित किया जा रहा है, लेकिन नुगेट पैकेज मैनेजर में कई "बाइक" के बारे में क्या है?

इसलिए, MySQL DBMS द्वारा संसाधित किए गए डेटा के साथ काम करते हुए, ASP.NET MVC के तहत लिखने का तरीका जानने की कोशिश करें। इस पते पर सभी कोड यहां लिए जा सकते हैं, नीचे इस कोड को छोटे लिंक और स्पष्टीकरण के साथ आंशिक रूप से प्रस्तुत किया जाएगा। और यहां आप एप्लिकेशन देख सकते हैं।

MySQL में एक डेटाबेस बनाएँ

CREATE SCHEMA `example`; USE `example`; CREATE TABLE `users` ( `UserID` int(4) unsigned NOT NULL AUTO_INCREMENT, `SupporterTier` enum('None','Silver','Gold','Platinum') NOT NULL DEFAULT 'None', `Loginname` varchar(255) NOT NULL, `LanguageID` int(4) unsigned NOT NULL DEFAULT '2', `Email` varchar(255) DEFAULT NULL, `LastLoginDate` datetime DEFAULT NULL, PRIMARY KEY (`UserID`), KEY `i_Loginname` (`Loginname`), KEY `i_Language_idx` (`LanguageID`), CONSTRAINT `i_Language` FOREIGN KEY (`LanguageID`) REFERENCES `languages` (`LanguageID`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; CREATE TABLE `languages` ( `LanguageID` int(4) unsigned NOT NULL AUTO_INCREMENT, `LanguageName` varchar(50) NOT NULL DEFAULT '', `Culture` varchar(10) DEFAULT NULL, PRIMARY KEY (`LanguageID`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; 

डेटाबेस (DB) सरल और केवल दो तालिकाओं द्वारा दर्शाया जाएगा, जिनके साथ LanguageID क्षेत्र में उनके बीच एक-से-कई संबंध होंगे। इस तरह मैं उपयोगकर्ता के लिए भाषाओं में से एक को चुनने के लिए ड्रॉप-डाउन सूची का उपयोग करने की आवश्यकता के लिए स्थिति को जटिल करने जा रहा हूं। इसके अलावा, जटिलता के लिए, उपयोगकर्ता के लिए, हम SupporterTier क्षेत्र भी पेश करेंगे, जो एनम के माध्यम से उपयोगकर्ता समर्थन के स्तर को निर्धारित करेगा। और हमारी परियोजना में लगभग सभी डेटा प्रकारों का उपयोग करने के लिए, हम “दिनांक / समय” प्रकार के LastLoginDate फ़ील्ड को जोड़ते हैं, जो उपयोगकर्ता द्वारा इस परियोजना में लॉग इन नहीं किए जाने पर एप्लिकेशन द्वारा ही भरा जाएगा।

एक प्रोजेक्ट बनाएं

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



हमें पहले से ही भरे हुए कंटेंट , फोंट , लिपियों के फोल्डर, साथ ही साथ ASP.NET MVC बंडलों और फिल्टर पंजीकरणों के साथ App_Start निर्देशिका में FilesConfig.cs और FilterConfig.cs फाइलें भरी हुई हैं । किसी रिक्त प्रोजेक्ट में, रूटकॉन्फ़िग.एक्स फ़ाइल में केवल मार्गों का पंजीकरण होता है। Global.asax.cs में, इन फ़ाइलों में वर्णित विधि कॉल को भी जोड़ा जाएगा:

 FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); 

हमने बुनियादी ढांचे और पूरे बंडल की स्थापना की

MySQL DBMS के साथ काम करने के लिए, MySql.Data लाइब्रेरी जोड़ें: या तो मैन्युअल रूप से, अगर mysql-कनेक्टर-net-8.0.18 कनेक्टर पहले से ही कंप्यूटर पर स्थापित है, या Nuget पैकेज मैनेजर से:



कनेक्शन स्ट्रिंग के कॉन्फ़िगरेशन को Web.config फ़ाइल में MySQL DBMS में जोड़ें:

 <connectionStrings> <add name="example" providerName="MySql.Data.MySqlClient" connectionString="server=localhost;Port=3306;user id=develop;Password=develop;persistsecurityinfo=True;database=example;CharSet=utf8;SslMode=none" /> </connectionStrings> 

जोड़े गए कनेक्शन स्ट्रिंग के लिंक के साथ <appSettings> अनुभाग में एक पंक्ति जोड़ें: <add key="ConnectionString" value="example" />
हम एप्लिकेशन में एक नई डोमेन निर्देशिका जोड़ते हैं, इसमें हम एक नया स्टैटिक Base क्लास ( बेस.एससी फ़ाइल में) बनाते हैं , जिसमें हम इन मापदंडों को एक्सेस करते हैं:

 public static class Base { private static string ConnectionString { get { return System.Configuration.ConfigurationManager.AppSettings["ConnectionString"]; } } public static string strConnect { get { return System.Configuration.ConfigurationManager.ConnectionStrings[ConnectionString].ConnectionString; } } } 

मैं आवेदन मापदंडों और कुछ मानक कार्यों के लिंक के साथ आवेदन में एक निश्चित आधार वर्ग होना पसंद करता हूं जिसे पूरे आवेदन से बुलाया जा सकता है।
कनेक्शन स्ट्रिंग का नाम एप्लिकेशन सेटिंग्स में परिभाषित किया गया है, ताकि भविष्य में DBMS के कनेक्शन स्ट्रिंग के साथ काम करना आसान हो जाए: जल्दी से अलग-अलग डेटाबेस के बीच स्विच करें और कनेक्शन सेटिंग्स को बदलें। इसके अलावा, Microsoft Azure में एप्लिकेशन को प्रकाशित करने के लिए एप्लिकेशन पैरामीटर में कनेक्शन स्ट्रिंग नाम का उपयोग करना सुविधाजनक है - वहां आप उस एप्लिकेशन सेवा के लिए पैरामीटर सेट कर सकते हैं जो प्रकाशन के लिए उपयोग किया जाता है, और इसमें वांछित कनेक्शन स्ट्रिंग निर्धारित करते हैं, जो <connectionStrings> में पूर्वनिर्धारित है। फिर, जब प्रकाशन, आप web.config फ़ाइल के परिवर्तन का उपयोग नहीं कर सकते।

मुझे पाठ में वैश्विक संसाधन फ़ाइल से मानों का उपयोग करना पसंद है, इसलिए यदि आवश्यक हो, तो उन्हें कई स्थानों पर अधिलेखित नहीं करना चाहिए। उदाहरण के लिए:



पृष्ठ लेआउट फ़ाइल में _Layout.cshtml (यह मानक रूप से दृश्य \ साझा निर्देशिका में स्थित है और बाद में इस परियोजना के सभी पृष्ठों के लिए उपयोग किया जाता है), अब आप इन चर का उपयोग कर सकते हैं (उदाहरण के लिए, उदाहरण के लिए, Example_Users.Properties.Resources.Title देखें। Example_Users.Properties.Resources.Title ):

 <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/> <meta charset="utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>@ViewBag.Title – @Example_Users.Properties.Resources.Title</title> @Styles.Render("~/Content/css") @Scripts.Render("~/bundles/modernizr") </head> <body> <div class="container body-content"> <h1 class="page-header"><a href="/">@Example_Users.Properties.Resources.Title</a></h1> @RenderBody() <hr /> <footer> <p> @DateTime.Now.Year – @Example_Users.Properties.Resources.Author</p> </footer> </div> @Scripts.Render("~/bundles/jquery") @Scripts.Render("~/bundles/bootstrap") @RenderSection("scripts", required: false) </body> </html> 

इसके अलावा इस फाइल में हमें कनेक्टेड बूटस्ट्रैप और JQuery स्क्रिप्ट लाइब्रेरी की कैस्केडिंग स्टाइल शीट का लगाव दिखाई देता है। कॉल RenderBody() फ़ंक्शन के स्थान पर सभी दृश्यों की सामग्री उत्पन्न की जाएगी।

एम का मतलब मॉडल है

डोमेन निर्देशिका में फ़ाइल UserClass.cs जोड़ें:

 [DisplayName("User")] public class UserClass { [Key] [HiddenInput(DisplayValue=false)] public int UserID { get; set; } [Required(ErrorMessage="Please enter a login name")] [Display(Name = "Login")] public string Loginname { get; set; } public virtual LanguageClass Language { get; set; } [EmailAddress(ErrorMessage = "Please enter a valid email")] public string Email { get; set; } [UIHint("Enum")] [EnumDataType(typeof(Supporter))] [Required(ErrorMessage = "Please select supporter tier")] [Display(Name = "Supporter")] public Supporter SupporterTier { get; set; } [HiddenInput(DisplayValue = true)] [ScaffoldColumn(false)] [Display(Name = "Last login")] public DateTime? LastLoginDate { get; set; } [HiddenInput(DisplayValue = false)] public bool IsLastLogin { get { return LastLoginDate != null && LastLoginDate > DateTime.MinValue; } } public UserClass() {} public UserClass(int UserID, string Loginname, LanguageClass Language, string Email, DateTime? LastLoginDate, Supporter SupporterTier) { this.UserID = UserID; this.Loginname = Loginname; this.Language = Language; this.Email = Email; this.LastLoginDate = LastLoginDate; this.SupporterTier = SupporterTier; } } public enum Supporter { [Display(Name="")] None = 1, Silver = 2, Gold = 3, Platinum = 4 } 

और उसी निर्देशिका में LanguageClass.cs फ़ाइल भी:

 [DisplayName("Language")] public class LanguageClass { [Key] [HiddenInput(DisplayValue = false)] [Required(ErrorMessage = "Please select a language")] [Range(1, int.MaxValue, ErrorMessage = "Please select a language")] public int LanguageID { get; set; } [Display(Name = "Language")] public string LanguageName { get; set; } public LanguageClass() {} public LanguageClass(int LanguageID, string LanguageName) { this.LanguageID = LanguageID; this.LanguageName = LanguageName; } } 

यहां आप देख सकते हैं कि कक्षाओं के गुण DBMS में Users और Languages तालिका की संरचना को दोहराते हैं। गणन प्रकार के लिए एक enum Supporter बनाया enum Supporter ताकि इसका उपयोग डेटाबेस टेबल में एक समान क्षेत्र के SupporterTier वर्ग की संपत्ति के लिए किया जा सके। UserID , LanguageID फ़ील्ड के लिए, आप देख सकते हैं कि वे डेटाबेस की तरह ही प्राथमिक कुंजी के रूप में निर्दिष्ट हैं। [Key] विशेषता का उपयोग इसके लिए किया जाता है।

अन्य सभी विशेषताएँ इस वर्ग का उपयोग करने वाले विचारों से संबंधित हैं। और अगर हम इन गुणों के लिए HTML टैग बनाने के लिए सहायकों का उपयोग करने जा रहे हैं (जो मैं व्यक्तिगत रूप से निश्चित रूप से सुझाऊंगा), तो हमें उन विशेषताओं को बहुत सावधानी से सेट करना होगा जो हमें चाहिए। विशेष रूप से, यहाँ इस परियोजना के लिए क्या आवश्यक था:

• [DisplayName] - कक्षा के लिए प्रदर्शन नाम के रूप में उपयोग किया जाता है। कभी-कभी यह उपयोगी हो सकता है, इस परियोजना में मैंने विशेष रूप से प्रदर्शन के लिए Html.DisplayNameForModel सहायक का उपयोग जोड़ा।
• Name संपत्ति के साथ [Display] - स्क्रीन पर प्रदर्शित वर्ग संपत्ति के नाम के रूप में उपयोग किया जाता है। एक उपयोगी ऑर्डर प्रॉपर्टी भी है जो आपको सहायक के रूप में (डिफ़ॉल्ट रूप से, जिस क्रम में क्लास प्रॉपर्टीज़ को परिभाषित किया गया है, इसलिए ऑर्डर प्रॉपर्टी का इस प्रोजेक्ट में उपयोग नहीं किया गया था) का उपयोग करके, क्लास गुणों को प्रदर्शित करने के लिए ऑर्डर करने की अनुमति देता है।
• [HiddenInput] DisplayValue संपत्ति के साथ। इसका उपयोग उन संपत्तियों के लिए किया जाता है, जिन्हें या तो सभी रूपों और सूचियों में प्रदर्शित करने की आवश्यकता नहीं होती है ( DisplayValue=false , hidden प्रकार के साथ input टैग के रूप में तैयार की जाती हैं), या उन गुणों के लिए जिन्हें अभी भी प्रदर्शित करने की आवश्यकता है, लेकिन अपरिवर्तनीय पाठ ( DisplayValue=true , तैयार की गई है। स्वच्छ पाठ की तरह, टैग के बिना)
• [ScaffoldColumn] - इंगित करता है कि संपादन Html.EditorForModel में फ़ील्ड प्रदर्शित करना है (उदाहरण के लिए, Html.EditorForModel )। यदि false , तो न तो वर्ग संपत्ति का विवरण और न ही इसके मूल्य को फॉर्म में प्रदर्शित किया जाएगा। [HiddenInput(DisplayValue = false)] उपयोग [HiddenInput(DisplayValue = false)] नहीं किया जा सकता [HiddenInput(DisplayValue = false)] , क्योंकि इस मामले में इस वर्ग की संपत्ति के मूल्यों को न केवल सूचना इनपुट रूपों में, बल्कि टेबल डिस्प्ले में भी प्रदर्शित किया जाएगा। इस स्थिति में, LastLoginDate संपत्ति के लिए यह आवश्यक था, जिसे मैन्युअल रूप से दर्ज नहीं किया जाता है, लेकिन स्वचालित रूप से कहीं न कहीं भरा जाता है, लेकिन हमें अभी भी इसे देखने की आवश्यकता है।
• [Required] - यह जांचने के लिए कि क्या कोई क्लास प्रॉपर्टी के लिए कोई मूल्य दर्ज किया गया है, जिसमें एरर AllowEmptyStrings प्रॉपर्टी में एरर मैसेज टेक्स्ट और AllowEmptyStrings प्रॉपर्टी AllowEmptyStrings आपको रिक्त लाइनों में प्रवेश करने की अनुमति देता है।
• [EmailAddress] - डाक पते की शुद्धता की जांच के लिए अनिवार्य रूप से एक ही विशेषता है।

डेटाबेस मॉडल की कक्षाएं तैयार हैं, हम अभ्यावेदन की ओर रुख करते हैं (अभ्यावेदन के लिए मॉडलों के वर्ग नीचे वर्णित किए जाएंगे)।

वी - का अर्थ है प्रतिशोध प्रदर्शन

दृश्य निर्देशिका में, हमारे विचारों के लिए उपयोगकर्ता निर्देशिका बनाएं। हमारे सभी दृश्य मानक ( दृश्य निर्देशिका में _ViewStart.cshtml फ़ाइल में परिभाषित) का उपयोग करते हैं, दृश्य \ साझा निर्देशिका में स्थित _Layout.cshtml लेआउट। एक Index दृश्य ( उपयोगकर्ता निर्देशिका में Index.cshtml फ़ाइल) बनाएँ:



और कोड लिखें:

 @model Example_Users.Models.UsersGrid @{ ViewBag.Title = "Users page"; } @using (@Html.BeginForm()) { <div> <h3>Users list:</h3> @if (TempData["message"] != null) {<div class="text-success">@TempData["message"]</div>} @if (TempData["error"] != null) {<div class="text-warning"><span class="alert">ERROR:</span> @TempData["error"]</div>} @Html.Partial("List") <p> <input type="submit" name="onNewUser" value="New user" /> @*@Html.ActionLink("New user", "New", "Users")*@ </p> </div> } 

यदि हम चाहते हैं कि यह दृश्य डिफ़ॉल्ट रूप से प्रारंभ हो, तो मार्ग में Default से एक बदलाव करें ।Config.cs फ़ाइल:

 routes.MapRoute(name: "Default", url: "{controller}/{action}/{id}", defaults: new { controller = "Users", action = "Index", id = UrlParameter.Optional }); 

दृश्य में ही, आपको Html.Partial("List") साथ लाइन पर ध्यान देने की आवश्यकता है। इस जगह को दर्शाने के लिए आवश्यक है कि एक विशेष अलग सामान्य आंशिक दृश्य व्यू.शर्ड डायरेक्टरी में लिस्ट.सी.टीटीएमएल फाइल में स्थित हो। वास्तव में, यह हमारे users डेटाबेस तालिका से डेटा प्रदर्शित करने के लिए एक ग्रिड तालिका है:

 @model Example_Users.Models.UsersGrid @using Example_Users.Domain <div class="table-responsive"> <table class="table table-bordered table-hover"> <thead> <tr> <th>@Html.ActionLink(Html.DisplayNameFor(m => Model.Users.First().Loginname).ToString(), "Index", Request.QueryString.ToRouteValueDictionary("sortOrder", Model.SortingInfo.NewOrder(Html.NameFor(m => Model.Users.First().Loginname).ToString()))) @Html.SortIdentifier(Model.SortingInfo.currentSort, Html.NameFor(m => Model.Users.First().Loginname).ToString()) </th> <th>@Html.ActionLink(Html.DisplayNameFor(m => Model.Users.First().Language.LanguageName).ToString(), "Index", Request.QueryString.ToRouteValueDictionary("sortOrder", Model.SortingInfo.NewOrder(Html.NameFor(m => Model.Users.First().Language).ToString()))) @Html.SortIdentifier(Model.SortingInfo.currentSort, Html.NameFor(m => Model.Users.First().Language).ToString()) </th> <th>@Html.ActionLink(Html.DisplayNameFor(m => Model.Users.First().Email).ToString(), "Index", Request.QueryString.ToRouteValueDictionary("sortOrder", Model.SortingInfo.NewOrder(Html.NameFor(m => Model.Users.First().Email).ToString()))) @Html.SortIdentifier(Model.SortingInfo.currentSort, Html.NameFor(m => Model.Users.First().Email).ToString()) </th> <th>@Html.ActionLink(Html.DisplayNameFor(m => Model.Users.First().SupporterTier).ToString(), "Index", Request.QueryString.ToRouteValueDictionary("sortOrder", Model.SortingInfo.NewOrder(Html.NameFor(m => Model.Users.First().SupporterTier).ToString()))) @Html.SortIdentifier(Model.SortingInfo.currentSort, Html.NameFor(m => Model.Users.First().SupporterTier).ToString()) </th> <th>@Html.ActionLink(Html.DisplayNameFor(m => Model.Users.First().LastLoginDate).ToString(), "Index", Request.QueryString.ToRouteValueDictionary("sortOrder", Model.SortingInfo.NewOrder(Html.NameFor(m => Model.Users.First().LastLoginDate).ToString()))) @Html.SortIdentifier(Model.SortingInfo.currentSort, Html.NameFor(m => Model.Users.First().LastLoginDate).ToString()) </th> </tr> </thead> <tbody> @foreach (var item in Model.Users) { <tr> <td>@Html.ActionLink(item.Loginname, "Edit", "Users", new { UserID = item.UserID }, null)</td> <td>@Html.DisplayFor(modelitem => item.Language.LanguageName)</td> <td>@Html.DisplayFor(modelitem => item.Email)</td> <td class="@Html.DisplayFor(modelitem => item.SupporterTier)">@if (item.SupporterTier != Supporter.None) {@Html.DisplayFor(modelitem => item.SupporterTier);}</td> <td>@if (item.IsLastLogin) {@Html.DisplayFor(modelitem => item.LastLoginDate)}</td> </tr> } </tbody> </table> </div> @if (Model.PagingInfo.totalPages > 1) { <ul class="pagination"> @Html.PageLinks(Model.PagingInfo, x => Url.Action("Index", new { page = x, sortOrder = Model.SortingInfo.currentSort })) </ul> } 

यह देखा जा सकता है कि डेटा टेबल के हेडर में, स्तंभों के नाम प्रदर्शित करने के लिए Html.DisplayNameFor का Html.DisplayNameFor है और इसके लिए आपको क्लास ऑब्जेक्ट की संपत्ति का संदर्भ निर्दिष्ट करना होगा। चूंकि टेबल टाइटल बनाते समय हमारे पास केवल एक Model.Users ऑब्जेक्ट होता है, जो कि UserClass के प्रकारों की सूची है, हमें निम्नलिखित विधि का उपयोग करना होगा: UserClass वर्ग के ऑब्जेक्ट के रूप में इस सूची की पहली पंक्ति का चयन करें। उदाहरण के लिए, उपयोगकर्ता नाम के लिए: Model.Users.First().Loginname । चूंकि Users वर्ग की Loginname विशेषता में [Display(Name = "Login")] विशेषता है, यह कॉलम नाम में "लॉगिन" प्रदर्शित किया जाएगा:



List दृश्य में और क्या दिलचस्प है? UserClass ब्लॉक, ज़ाहिर है, Users वर्ग की वस्तुओं को प्रदान करता है जो नियंत्रक से प्राप्त Users सूची में हैं। और हमारे UsersGrid मॉडल में SortingInfo और PagingInfo यहां दिलचस्प हैं। और हमें इन वस्तुओं को डेटा सॉर्टिंग (तालिका शीर्षक में प्रयुक्त <th> टैग्स) में व्यवस्थित करने और सूचना के पृष्ठांकन (पेज के नीचे, तालिका के नीचे उपयोग किया जाता है) को व्यवस्थित करने की आवश्यकता है। इसीलिए हम मॉडल के रूप में IEnumerable<UserClass> प्रकार की वस्तुओं की शुद्ध सूची का उपयोग नहीं करते हैं। और एक मॉडल के रूप में, हम UsersGrid वर्ग का उपयोग करते हैं, जो ModelGrid.cs फ़ाइल में मॉडल निर्देशिका में स्थित है।

 public class UsersGrid { public IEnumerable<UserClass> Users { get; set; } public PagingInfo PagingInfo { get; set; } public SortingInfo SortingInfo { get; set; } } 

और PagingInfo और SortingInfo खुद को उसी स्थान पर GridInfo.cs फ़ाइल में GridInfo.cs करता है।

 public class PagingInfo { //     public int totalItems { get; set; } //     public int itemsPerPage { get; set; } //   public int currentPage { get; set; } //         public int showPages { get; set; } //   public int totalPages { get { return (int)Math.Ceiling((decimal)totalItems / itemsPerPage); } } //           public int pagesSide { get { return (int)Math.Truncate((decimal)showPages / 2); } } } public class SortingInfo { //  ,     public string currentOrder { get; set; } //   public SortDirection currentDirection { get; set; } //      public string currentSort { get { return currentDirection != SortDirection.Descending ? currentOrder : currentOrder + "_desc"; } } //       (      -   ) public string NewOrder(string columnName) { return columnName == currentOrder && currentDirection != SortDirection.Descending ? columnName + "_desc" : columnName; } } 

और विचारों में उपयोग के लिए, विशेष सहायकों को GridHelpers.cs फ़ाइल ( HtmlHelpers निर्देशिका) में जोड़ा गया है:

 public static class GridHelpers { //     1 ... 3 4 5 ... Last public static MvcHtmlString PageLinks(this HtmlHelper html, PagingInfo pagingInfo, Func<int, string> pageUrl) { StringBuilder result = new StringBuilder(); if (pagingInfo.currentPage > pagingInfo.pagesSide + 1) {//   TagBuilder li = new TagBuilder("li"); li.AddCssClass("page-item"); TagBuilder tag = new TagBuilder("a"); tag.MergeAttribute("href", pageUrl(1)); tag.InnerHtml = "1"; li.InnerHtml = tag.ToString(); result.Append(li.ToString()); } int page1 = pagingInfo.currentPage - pagingInfo.pagesSide; int page2 = pagingInfo.currentPage + pagingInfo.pagesSide; if (page1 < 1) { page2 = page2 - page1 + 1; page1 = 1; } if (page2 > pagingInfo.totalPages) page2 = pagingInfo.totalPages; if (page1 > 2) {// ... TagBuilder li = new TagBuilder("li"); li.AddCssClass("page-item"); TagBuilder tag = new TagBuilder("span"); tag.InnerHtml = "..."; tag.AddCssClass("page-item"); tag.AddCssClass("disabled"); li.InnerHtml = tag.ToString(); result.Append(li.ToString()); } for (int i = page1; i <= page2; i++) {//  TagBuilder li = new TagBuilder("li"); li.AddCssClass("page-item"); if (i == pagingInfo.currentPage) li.AddCssClass("active"); TagBuilder tag = new TagBuilder("a"); tag.AddCssClass("page-link"); tag.MergeAttribute("href", pageUrl(i)); tag.InnerHtml = i.ToString(); li.InnerHtml = tag.ToString(); result.Append(li.ToString()); } if (page2 < pagingInfo.totalPages) {// ...    TagBuilder li = new TagBuilder("li"); li.AddCssClass("page-item"); TagBuilder tag = new TagBuilder("span"); tag.InnerHtml = "..."; tag.AddCssClass("page-item"); tag.AddCssClass("disabled"); li.InnerHtml = tag.ToString(); result.Append(li.ToString()); li = new TagBuilder("li"); li.AddCssClass("page-item"); tag = new TagBuilder("a"); tag.MergeAttribute("href", pageUrl(pagingInfo.totalPages)); tag.InnerHtml = pagingInfo.totalPages.ToString(); li.InnerHtml = tag.ToString(); result.Append(li.ToString()); } return MvcHtmlString.Create(result.ToString()); } public static IHtmlString SortIdentifier(this HtmlHelper htmlHelper, string sortOrder, string field) { if (string.IsNullOrEmpty(sortOrder) || (sortOrder.Trim() != field && sortOrder.Replace("_desc", "").Trim() != field)) return null; string glyph = "glyphicon glyphicon-chevron-up"; if (sortOrder.ToLower().Contains("desc")) { glyph = "glyphicon glyphicon-chevron-down"; } var span = new TagBuilder("span"); span.Attributes["class"] = glyph; return MvcHtmlString.Create(span.ToString()); } public static RouteValueDictionary ToRouteValueDictionary(this NameValueCollection collection, string newKey, string newValue) { var routeValueDictionary = new RouteValueDictionary(); foreach (var key in collection.AllKeys) { if (key == null) continue; if (routeValueDictionary.ContainsKey(key)) routeValueDictionary.Remove(key); routeValueDictionary.Add(key, collection[key]); } if (string.IsNullOrEmpty(newValue)) { routeValueDictionary.Remove(newKey); } else { if (routeValueDictionary.ContainsKey(newKey)) routeValueDictionary.Remove(newKey); routeValueDictionary.Add(newKey, newValue); } return routeValueDictionary; } } 

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



हमें डेटा बनाने और संशोधित करने के लिए भी विचारों की आवश्यकता है। उपयोगकर्ता का प्रकार बनाने के लिए देखें



और व्यू कोड इस तरह दिखेगा:

 @model Example_Users.Models.UserModel @{ ViewBag.Title = "New " + Html.DisplayNameForModel().ToString().ToLower(); } <h2>@ViewBag.Title</h2> @using (@Html.BeginForm("New", "Users", FormMethod.Post)) { @Html.EditorFor(m => m.User); @Html.LabelFor(m => Model.User.Language)<br /> @Html.DropDownListFor(m => Model.User.Language.LanguageID, Model.SelectLanguages()) <span/>@Html.ValidationMessageFor(m => Model.User.Language.LanguageID)<br /> <br /> <p><input type="submit" name="action" value="Add" /> <input type="button" onclick="history.go(-1)" value="Cancel" /></p> @*<p>@Html.ActionLink("Back to list", "Index")</p>*@ } 

यह दृश्य दिखाता है, उदाहरण के लिए, UserClass वर्ग में वस्तुओं के सभी गुणों के संपादन के लिए टैग उत्पन्न करने के लिए एक साधन के रूप में Html.EditorFor सहायक का उपयोग। इसे निम्नानुसार प्रदर्शित किया जाता है:



यह दृश्य उपयोगकर्ता मॉडल के रूप में UserModel वर्ग का उपयोग करता है, ना कि सीधे UserClass । UserModel वर्ग स्वयं उपयोगकर्ता निर्देशिका में UserModel.cs फ़ाइल में स्थित है:

 public class UserModel { public UserClass User { get; set; } private IList<LanguageClass> Languages { get; set; } public UserModel() {} public UserModel(UserClass user, IList<LanguageClass> languages) { this.User = user; this.Languages = languages; } public IEnumerable<SelectListItem> SelectLanguages() { if (Languages != null) { return new SelectList(Languages, "LanguageID", "LanguageName"); } return null; } } 

UserClass ऑब्जेक्ट ही और UserClass ऑब्जेक्ट्स की एक अतिरिक्त सूची इस वर्ग में शामिल LanguageClass । हमें भाषाओं की एक ड्रॉप-डाउन सूची बनाने के लिए इस सूची की आवश्यकता थी, जिसमें वर्तमान उपयोगकर्ता भाषा का चयन किया गया था: @Html.DropDownListFor(m => Model.User.Language.LanguageID, Model.SelectLanguages(), "")

यह सहायक कॉल को SelectLanguages() फ़ंक्शन के लिए उपयोग करता है, जो भाषा की सूची को पहले से सेट किए गए पहचानकर्ता और लाइन नाम मापदंडों के साथ SelectList ऑब्जेक्ट में SelectList । इस ऑब्जेक्ट की पीढ़ी को दृश्य में रखना गलत होगा, क्योंकि इन नामों के बारे में क्षेत्र के नामों के बारे में पता नहीं था। SelectList , नियंत्रक में सीधे तैयार SelectList उत्पन्न करना संभव होगा, लेकिन मुझे डोमेन वर्ग ऑब्जेक्ट की एक निजी सूची और अधिक फ़ंक्शन के साथ विकल्प पसंद है।

ड्रॉप-डाउन सूची जेनरेट करने के लिए, हमें अलग-अलग Html.EditorFor(m => m.User) का उपयोग करना होगा, क्योंकि Html.EditorFor(m => m.User) हेल्पर टाइप LanguageClass की एम्बेडेड ऑब्जेक्ट के लिए एडिटिंग मार्कअप नहीं Html.EditorFor(m => m.User) (यह ड्रॉप-डाउन लिस्ट के लिए एक सामान्य टेम्पलेट लिखकर बायपास किया जा सकता है, लेकिन यहां हम हैं। हम ऐसा नहीं करेंगे ...)।

और जब से हम अपने दृष्टिकोण में UserModel वर्ग की एक वस्तु का उपयोग कर रहे हैं, जिसमें UserClass वर्ग का एक अन्य ऑब्जेक्ट शामिल है, तो हम Html.EditorForModel() सहायक का उपयोग करने में सक्षम नहीं होंगे, क्योंकि सहायक पुनरावर्ती नहीं हैं और इस स्थिति में काम नहीं करेंगे, इसलिए Html.EditorFor() सहायक का उपयोग किया जाता है। Html.EditorFor() User ऑब्जेक्ट के लिए।

मैं टिप्पणी किए गए टैग Html.ActionLink("Back to list", "Index")

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

और एक प्रकार की वस्तु को संपादित करने का दृष्टिकोण UserClass:



और उसका कोड:

 @model Example_Users.Models.UserModel @{ ViewBag.Title = "Edit " + Html.DisplayNameForModel().ToString().ToLower(); } <h2>@ViewBag.Title @Model.User.Loginname</h2> @using (@Html.BeginForm("Edit", "Users", FormMethod.Post)) { @Html.HiddenFor(m => Model.User.UserID) <div> @Html.LabelFor(m => Model.User.Loginname) @Html.EditorFor(m => Model.User.Loginname) @Html.ValidationMessageFor(m => Model.User.Loginname) </div> <div> @Html.LabelFor(m => Model.User.Language) @Html.DropDownListFor(m => Model.User.Language.LanguageID, Model.SelectLanguages()) @Html.ValidationMessageFor(m => Model.User.Language.LanguageID) </div> <div> @Html.LabelFor(m => Model.User.Email) @Html.EditorFor(m => Model.User.Email) @Html.ValidationMessageFor(m => Model.User.Email) </div> <div> @Html.LabelFor(m => Model.User.SupporterTier) @Html.EditorFor(m => Model.User.SupporterTier) @*@Html.EnumDropDownListFor(m => Model.User.SupporterTier)*@ @*@Html.DropDownListFor(m => m.Model.User.SupporterTier, new SelectList(Enum.GetNames(typeof(Example_Users.Domain.Supporter))))*@ @Html.ValidationMessageFor(m => Model.User.SupporterTier) </div> <br /> <p><input type="submit" name="action" value="Save" /> <input type="submit" name="action" value="Remove" onclick="javascript:return confirm('Are you sure?');" /> <input type="submit" name="action" value="Cancel" /></p> } 

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



और इस दृश्य में, सूची में वापस आने के लिए एक और तरीका उपयोग किया जाता है। एक बटन का उपयोग करने के बजाय जैसे: />उसी बटन का उपयोग अन्य क्रिया बटन ( सहेजें , निकालें ) के रूप />में किया जाता है : और रिटर्न नियंत्रक विधि के अंदर किया जाता है जो इन बटन के कार्यों को संसाधित करता है (नीचे विधि का कार्यान्वयन देखें)।

enum

और तब एक वर्ग संपत्ति के प्रकार के उपयोग से जुड़ी एक बारीकियों की गणना की गई थी । तथ्य यह है कि यदि हम केवल सहायक का उपयोग करते हैं Html.EditorFor(), तो पाठ सूचना इनपुट फ़ील्ड (टाइप टैग <input type=”text”/>) को फॉर्म पर प्रदर्शित किया जाएगा , लेकिन हमें वास्तव में मानों के एक सेट से विकल्प के साथ एक फ़ील्ड की आवश्यकता होती है (यानी <select>विकल्पों के सेट के साथ एक टैग <option>)।

1. rectilinearly सहायक प्रकार का उपयोग कर हल किया जाता है Html.DropDownListFor()या Html.ListBoxFor(), हमारे मामले में, उदाहरण के लिए @Html.DropDownListFor(m => m.Model.User.SupporterTier, new SelectList(Enum.GetNames(typeof(Example_Users.Domain.Supporter))))। दो मीनू हैं - प्रत्येक बार इसे सहायक के लिए व्यक्तिगत रूप से निर्धारित करना होगा Html.EditorForModel()या Html.EditorFor()यह काम नहीं करेगा।

2. आप एक कस्टम टाइप टेम्पलेट बना सकते हैं Editor। Views \ Shared \ EditorTemplates फ़ोल्डर में Supporter.cshtml फ़ाइल बनाएँ :

 @model Example_Users.Domain.Supporter @Html.DropDownListFor(m => m, new SelectList(Enum.GetNames(Model.GetType()), Model.ToString())) 

फ़ाइल का नाम टाइप नाम से मेल खाना चाहिए, या आपको लिखना नहीं होगा Html.EditorFor(m => Model.SupporterTier), लेकिन Html.EditorFor(m => Model.SupporterTier, "Supporter")। यदि आप फ़ाइल को अलग नाम देते हैं, तो आपको कक्षा में संपत्ति का वर्णन करने से पहले एक संकेत जोड़ना होगा [UIHint("Supporter")]। और यह भी करना होगा यदि इसका उपयोग करने की योजना है Html.EditorForModel()- इसके लिए फॉर्म का समाधान Html.EditorFor(m => Model.SupporterTier, "Supporter")काम नहीं करेगा।

मैं इस विकल्प की तरह तथ्य यह है कि, जब आप एक उपयोगकर्ता बनाने का प्रयास करें (शुरू प्रस्तुति से नहीं आया था Newसहायकों के लिए) कार्यक्रम Html.EditorFor()और Html.EditorForModel()त्रुटि के साथ बाहर गिर गई: " तत्व मॉडल शब्दकोश में पारित कर दिया, शून्य है, लेकिन इस शब्दावली की आवश्यकता है तत्व प्रकार« Example_Users मॉडल। Domain.Supporter ", अशक्त नहीं।»कारण स्पष्ट है - लिस्टिंग के लिए मान रिक्त नहीं हो सकता है, लेकिन समस्या को हल करना संभव नहीं था। इसलिए, वह आगे समझने लगा।

3. आप Html.EnumDropDownListFor()स्थानांतरण के लिए विशेष रूप से बनाए गए सहायक का उपयोग कर सकते हैं । यहां सब कुछ ठीक है, कुछ भी अतिरिक्त लिखने की आवश्यकता नहीं है, सब कुछ सही ढंग से प्रदर्शित किया गया है, यह संपादन करते समय और ऑब्जेक्ट बनाते समय काम करता है। एक "लेकिन" को छोड़कर: सहायक Html.EditorForModel()सभी गुणों को प्रदर्शित करने के लिए सहायकों का उपयोग करता है Html.EditorFor()और तदनुसार, इसका उपयोग नहीं करता है Html.EnumDropDownListFor()। और, जैसा कि मैं इसे समझते हैं, यह गुण के वर्ग के लिए गुण की मदद से बचा नहीं जा सकता है - [UIHint], [DataType]और [EnumDataType]उसके बाद काम नहीं करते। इसके अलावा, गणना मूल्यों की विशेषताएं काम नहीं करेंगी, अर्थात्, इसके बजाय यह काम नहीं करेगा, उदाहरण के लिए, एक रिक्त स्ट्रिंग प्रदर्शित करना, जैसा कि गणना के विवरण में परिभाषित किया गया हैSupporter।

4. परिणामस्वरूप, मैं इंटरनेट पर पाए जाने वाले एक समाधान विकल्प के साथ आया : स्थानान्तरण के लिए एक सामान्य टेम्पलेट बनाना। दृश्य \ साझा \ EditorTemplates फ़ोल्डर में Enum.cshtml फ़ाइल बनाएँ :

 @using System.ComponentModel.DataAnnotations @model Enum @{ Func<object, string> GetDisplayName = o => { var result = null as string; var display = o.GetType() .GetMember(o.ToString()).First() .GetCustomAttributes(false) .OfType<DisplayAttribute>() .LastOrDefault(); if (display != null) result = display.GetName(); return result ?? o.ToString(); }; var values = Enum.GetValues(ViewData.ModelMetadata.ModelType).Cast<object>() .Select(v => new SelectListItem { Selected = v.Equals(Model), Text = GetDisplayName(v), // v.ToString(), Value = v.ToString() }); } @Html.DropDownList("", values) 

यहां, सामान्य तौर पर, सब कुछ अच्छी तरह से निकला: टेम्पलेट जहां भी संभव हो महान काम करता है। आप [UIHint("Enum")]जोड़ भी नहीं सकते। इसके अलावा, यह सामान्य टेम्पलेट [Display(Name)]एक विशेष फ़ंक्शन का उपयोग करते हुए गणना मूल्यों के लिए विशेषता पढ़ता है ।

C का अर्थ है नियंत्रक

नियंत्रकों निर्देशिका में UsersController.cs फ़ाइल जोड़ें ।

 public class UsersController : Controller { public int pageSize = 10; public int showPages = 15; public int count = 0; //    public ViewResult Index(string sortOrder, int page = 1) { string sortName = null; System.Web.Helpers.SortDirection sortDir = System.Web.Helpers.SortDirection.Ascending; sortOrder = Base.parseSortForDB(sortOrder, out sortName, out sortDir); UsersRepository rep = new UsersRepository(); UsersGrid users = new UsersGrid { Users = rep.List(sortName, sortDir, page, pageSize, out count), PagingInfo = new PagingInfo { currentPage = page, itemsPerPage = pageSize, totalItems = count, showPages = showPages }, SortingInfo = new SortingInfo { currentOrder = sortName, currentDirection = sortDir } }; return View(users); } [ReferrerHold] [HttpPost] public ActionResult Index(string onNewUser) { if (onNewUser != null) { TempData["referrer"] = ControllerContext.RouteData.Values["referrer"]; return View("New", new UserModel(new UserClass(), Languages())); } return View(); } [ReferrerHold] public ActionResult New() { TempData["referrer"] = ControllerContext.RouteData.Values["referrer"]; return View("New", new UserModel(new UserClass(), Languages())); } [HttpPost] public ActionResult New(UserModel model) { if (ModelState.IsValid) { if (model.User == null || model.User.Language == null || model.User.Language.LanguageID == 0) RedirectToAction("Index"); UsersRepository rep = new UsersRepository(); if (rep.AddUser(model.User)) TempData["message"] = string.Format("{0} has been added", model.User.Loginname); else TempData["error"] = string.Format("{0} has not been added!", model.User.Loginname); if (TempData["referrer"] != null) return Redirect(TempData["referrer"].ToString()); return RedirectToAction("Index"); } else { model = new UserModel(model.User, Languages()); // -          model.Languages,   return View(model); } } [ReferrerHold] public ActionResult Edit(int UserID) { UsersRepository rep = new UsersRepository(); UserClass user = rep.FetchByID(UserID); if (user == null) return HttpNotFound(); TempData["referrer"] = ControllerContext.RouteData.Values["referrer"]; return View(new UserModel(user, Languages())); } [HttpPost] public ActionResult Edit(UserModel model, string action) { if (action == "Cancel") { if (TempData["referrer"] != null) return Redirect(TempData["referrer"].ToString()); return RedirectToAction("Index"); } if (ModelState.IsValid) { if (model.User == null || model.User.Language == null || model.User.Language.LanguageID == 0) RedirectToAction("Index"); UsersRepository rep = new UsersRepository(); if (action == "Save") { if (rep.ChangeUser(model.User)) TempData["message"] = string.Format("{0} has been saved", model.User.Loginname); else TempData["error"] = string.Format("{0} has not been saved!", model.User.Loginname); } if (action == "Remove") { if (rep.RemoveUser(model.User)) TempData["message"] = string.Format("{0} has been removed", model.User.Loginname); else TempData["error"] = string.Format("{0} has not been removed!", model.User.Loginname); } if (TempData["referrer"] != null) return Redirect(TempData["referrer"].ToString()); return RedirectToAction("Index"); } else { model = new UserModel(model.User, Languages()); return View(model); } } public IList<LanguageClass> Languages() { IList<LanguageClass> languages = new List<LanguageClass>(); LanguagesRepository rep = new LanguagesRepository(); languages = rep.List(); return languages; } } 

आइए नियंत्रक विधियों का विश्लेषण करें:

1) Index

उपयोगकर्ता की सूची के साथ एक पृष्ठ प्रदर्शित करने के तरीके : public ViewResult Index(string sortOrder, int page = 1)

दो इनपुट पैरामीटर हैं sortOrderऔर page। साथ pageसभी कम या ज्यादा स्पष्ट है, लेकिन के माध्यम से sortOrderपता पट्टी से, आप एक मनमाना स्ट्रिंग है, जो हम तो एसक्यूएल क्वेरी में रटना है और यह सीधे नहीं कर सकते पारित कर सकते हैं। इसलिए, हम फ़ंक्शन की सहायता से इस लाइन को पार्स करते हैं (मैं फ़ंक्शन को स्वयं यहां नहीं दूंगा, आप इसे बेस.केएस फ़ाइल में देख सकते हैं ): sortOrder = Base.parseSortForDB(sortOrder, out sortName, out sortDir);

फिर सब कुछ तुच्छ है, एक रिपॉजिटरी ऑब्जेक्ट बनाएं UsersRepository(डीबीएमएस के साथ काम करने के लिए, अगले अध्याय में चर्चा की गई), Listउपयोगकर्ताओं और सूची की सूची प्राप्त करने के लिए विधि को कॉल करें। क्लास ऑब्जेक्ट बनाएँUsersGridउपयोगकर्ताओं की वास्तविक सूची और सूचनाओं की छँटाई के आयोजन और छँटाई के लिए आवश्यक जानकारी से। इसके अलावा, TotalItem का मान तब प्राप्त होता है जब विधि को बुलाया जाता है List, साथ ही साथ क्लास ऑब्जेक्ट के निर्माण के साथ UsersGrid। इसके अलावा इस ऑब्जेक्ट को प्रदर्शन के लिए प्रतिनिधित्व के लिए स्थानांतरित किया जाता है।

उस विशेषता के साथ एक और अनुक्रमणिका विधि भी है जिसे देखने के [HttpPost]लिए हमें बटन क्लिक पर काम करना होगा : इनपुट पैरामीटर में दृश्य में तत्व के साथ कुछ सामान्य है और जब हम इस बटन पर क्लिक करते हैं तो यह उस फ़ंक्शन के मान को पास करता है जिसकी हम null के साथ तुलना करते हैं । यदि टाइप बटन दृश्य में होगाNewIndexpublic ActionResult Index(string onNewUser)

onNewUser/>IndexsubmitIndexकई, आपको स्वयं मूल्य की जांच करनी होगी (इस मामले में, मूल्य "नया उपयोगकर्ता" होगा)।

जाँच करने के बाद, हम एक क्लास ऑब्जेक्ट बनाते हैं UserModel, जिसमें एक नई ऑब्जेक्ट UserClassऔर भाषाओं की एक सूची होती है, जो उन्हें ड्रॉप-डाउन सूची से चुनकर प्रस्तुतिकरण के लिए भेजती है New। भाषाओं की सूची LanguageRepositoryविधि से कॉल करके Listइस प्रकार से प्राप्त की जाती है:

 public IList<LanguageClass> Languages() { LanguagesRepository rep = new LanguagesRepository(); return rep.List(); } 

2) तरीके एक पैरामीटर के बिना एक New

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

NewUserModelpublic ActionResult New(UserModel model)

UserModelUserClassLanguageClassUsersRepositoryAddUser(model.User)। फिर यह पिछले पृष्ठ पर लौटता है (जहां से दृश्य को कॉल किया गया था New) और वहां एक संदेश प्रदर्शित होता है जो ऑपरेशन की सफलता या विफलता को दर्शाता है।

3) Edit

विधि Editइनपुट पैरामीटर UserID(उपयोगकर्ता आईडी) के साथ एक विधि उपयोगकर्ता डेटा के संपादित दृश्य को खोलने के लिए सूची में उपयोगकर्ता नाम पर क्लिक करती है: public ActionResult Edit(int UserID)

विधि में, एक रिपॉजिटरी फिर से बनाई जाती है UsersRepositoryऔर इसे FetchByID(UserID)प्रकार के ऑब्जेक्ट प्राप्त करने के लिए एक फ़ंक्शन कहा जाता है UserClass। सफलता के मामले में, एक मॉडल बनाया जाता है - UserModelप्राप्त वस्तु और भाषाओं की एक सूची से एक वर्ग वस्तु और Editप्रदर्शन के लिए दृश्य में पारित किया गया ।

प्रकार UserModelऔर पंक्ति मॉडल के इनपुट पैरामीटर के साथ विधि action:public ActionResult Edit(UserModel model, string action)

एक प्रकार का ऑब्जेक्ट इस विधि को पारित किया जाता है UserModelऔर यह कार्रवाई तब करता है जब बटन पर क्लिक किया जाता है (दृश्य के डेटा भेजने के लिए प्रसंस्करण घटनाएँ) Edit। यह समझने के लिए कि कौन सा बटन दबाया गया है, इनपुट पैरामीटर का उपयोग किया जाता है action, जिसे HTML प्रकार टैग के नाम से इंगित किया गया है input। इसलिए, विधि valueइन बटन के पैरामीटर मूल्यों के साथ इस पैरामीटर के मूल्यों की तुलना करती है । वैधता के लिए मॉडल की जांच करने से पहले, Cancelउपयोगकर्ता संपादन को रद्द करने के लिए कार्रवाई करने के लिए मूल्य की जांच की जाती है । इस विकल्प का उपयोग ब्राउज़र इतिहास में वापस लौटने के बजाय किया जाता है, जिसका Newउपयोग दृश्य में किया जाता है और उस पृष्ठ के पते को संग्रहीत करने का उपयोग करता है जहां से दृश्य पुनर्निर्देशित किया गया था।Edit। ऐसा करने के लिए, नियंत्रक ने अपनी विशेषता का उपयोग करने के लिए तकनीक का प्रदर्शन किया ActionFilter: ReferrerHoldAttribute.csReferrerHoldAttribute फ़ाइल में वर्ग ( HtmlAttribute निर्देशिका ):

 public class ReferrerHoldAttribute : ActionFilterAttribute { public override void OnActionExecuting(ActionExecutingContext filterContext) { var referrer = filterContext.RequestContext.HttpContext.Request.UrlReferrer; if (referrer != null) filterContext.RouteData.Values.Add("referrer", referrer); base.OnActionExecuting(filterContext); } } 

इसका उपयोग उस पृष्ठ के बारे में जानकारी संग्रहीत करने के लिए किया जाता है जहां आपको " नया उपयोगकर्ता " बटन पर क्लिक करके या उपयोगकर्ता को बदलने के लिए एक लिंक पर लौटने की आवश्यकता होती है : TempData["referrer"] = ControllerContext.RouteData.Values["referrer"];

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

इसके बाद, उस पद्धति के मुख्य भाग में, जो विचारों की क्रियाओं को संसाधित करती है Newऔर Editसंग्रहीत जानकारी को निकाला जाता है और उस पृष्ठ पर वापस भेज दिया जाता है, जहाँ से इन विचारों को बुलाया गया था: if (TempData["referrer"] != null) return Redirect(TempData["referrer"].ToString());

यह निर्धारित करने के लिए कि क्या उपयोगकर्ता को सहेजने या हटाने की आवश्यकता है, पैरामीटर की तुलना सेव और के actionसाथ की जाती हैनिकालें, क्रमशः, और UsersRepositoryफ़ंक्शन ChangeUser(model.User)और रिपॉजिटरी से बुलाए जाते हैं RemoveUser(model.User)। फिर पिछले पृष्ठ (जहां से दृश्य कॉल आया था Edit) पर वापसी होती है और वहां एक संदेश प्रदर्शित होता है जो ऑपरेशन की सफलता या विफलता को दर्शाता है।

ADO.NET और MySQL - रिपॉजिटरी

यहां हमें आखिरकार डीबीएमएस के साथ काम करना पड़ा। हमें एक उपयोगकर्ता को एक तालिका में जोड़ने Users, उपयोगकर्ता डेटा में परिवर्तन करने, तालिका से एक उपयोगकर्ता को हटाने, उपयोगकर्ता को आईडी द्वारा प्राप्त करने, उपयोगकर्ताओं की सूची प्राप्त करने और तालिका से भाषाओं की सूची प्राप्त करने के कार्यों को लागू करने की आवश्यकता है Languages।

मानक वर्ग के लिए मुख्य रूप से इस्तेमाल किया डिजाइन में MySQL.Data का उपयोग कर MySqlCommand:

 using (MySqlConnection connect = new MySqlConnection( )) { string sql = " "; using (MySqlCommand cmd = new MySqlCommand(sql, connect)) { cmd.Parameters.Add(" ",  ).Value =  ; connect.Open(); result = cmd.ExecuteNonQuery() >= 0; //        (INSERT, UPDATE, DELETE)   cmd.ExecuteScalar()         SELECT } } 

या MySqlDataReaderक्वेरी के परिणामस्वरूप तालिका पंक्तियों को पढ़ने के लिए:

 using (MySqlConnection connect = new MySqlConnection( )) { string sql = " "; using (MySqlDataReader dr = cmd.ExecuteReader()) { cmd.Parameters.Add(" ",  ).Value =  ; objConnect.Open(); while (dr.Read()) {//       } } } 

मॉडल निर्देशिका में UserRepository.cs फ़ाइल बनाएँ :

 public class UsersRepository { public bool AddUser(UserClass user) { user.UserID = AddUser(Name: user.Loginname, LanguageID: user.Language.LanguageID, Email: user.Email, SupporterTier: user.SupporterTier); return user.UserID > 0; } public int AddUser(string Name, int LanguageID, string Email, Supporter SupporterTier) { int ID = 0; using (MySqlConnection connect = new MySqlConnection(Base.strConnect)) { string sql = "INSERT INTO `Users` (`Loginname`, `LanguageID`, `Email`, `SupporterTier`) VALUES (@Loginname, @LanguageID, @Email, @SupporterTier)"; using (MySqlCommand cmd = new MySqlCommand(sql, connect)) { cmd.Parameters.Add("Loginname", MySqlDbType.String).Value = Name; cmd.Parameters.Add("LanguageID", MySqlDbType.Int32).Value = LanguageID; cmd.Parameters.Add("Email", MySqlDbType.String).Value = Email; cmd.Parameters.Add("SupporterTier", MySqlDbType.Int32).Value = SupporterTier; connect.Open(); if (cmd.ExecuteNonQuery() >= 0) { sql = "SELECT LAST_INSERT_ID() AS ID"; cmd.CommandText = sql; int.TryParse(cmd.ExecuteScalar().ToString(), out ID); } } } return ID; } public bool ChangeUser(UserClass user) { return ChangeUser(ID: user.UserID, Name: user.Loginname, LanguageID: user.Language.LanguageID, Email: user.Email, SupporterTier: user.SupporterTier); } public bool ChangeUser(int ID, string Name, int LanguageID, string Email, Supporter SupporterTier) { bool result = false; if (ID > 0) { using (MySqlConnection connect = new MySqlConnection(Base.strConnect)) { string sql = "UPDATE `Users` SET `Loginname`=@Loginname, `LanguageID`=@LanguageID, `Email`=@Email, `SupporterTier`=@SupporterTier WHERE UserID=@UserID"; using (MySqlCommand cmd = new MySqlCommand(sql, connect)) { cmd.Parameters.Add("UserID", MySqlDbType.Int32).Value = ID; cmd.Parameters.Add("Loginname", MySqlDbType.String).Value = Name; cmd.Parameters.Add("LanguageID", MySqlDbType.Int32).Value = LanguageID; cmd.Parameters.Add("Email", MySqlDbType.String).Value = Email; cmd.Parameters.Add("SupporterTier", MySqlDbType.Int32).Value = SupporterTier; connect.Open(); result = cmd.ExecuteNonQuery() >= 0; } } } return result; } public bool RemoveUser(UserClass user) { return RemoveUser(user.UserID); } public bool RemoveUser(int ID) { using (MySqlConnection connect = new MySqlConnection(Base.strConnect)) { string sql = "DELETE FROM `Users` WHERE `UserID`=@UserID"; using (MySqlCommand cmd = new MySqlCommand(sql, connect)) { cmd.Parameters.Add("UserID", MySqlDbType.Int32).Value = ID; connect.Open(); return cmd.ExecuteNonQuery() >= 0; } } } public UserClass FetchByID(int ID) { UserClass user = null; using (MySqlConnection objConnect = new MySqlConnection(Base.strConnect)) { string strSQL = "SELECT u.`UserID`, u.`Loginname`, l.`LanguageID`, l.`LanguageName`, u.`Email`, u.`LastLoginDate`, CAST(u.`SupporterTier` AS UNSIGNED) as `SupporterTier` FROM `Users` u LEFT JOIN `Languages` l ON l.LanguageID=u.LanguageID WHERE `UserID`=@UserID"; using (MySqlCommand cmd = new MySqlCommand(strSQL, objConnect)) { objConnect.Open(); int UserID = 0, LanguageID = 0; string Loginname = null, LanguageName= null, Email = String.Empty; Supporter SupporterTier = Supporter.None; DateTime? LastLoginDate = null; cmd.Parameters.Add("UserID", MySqlDbType.Int32).Value = ID; using (MySqlDataReader dr = cmd.ExecuteReader()) { if (dr.Read()) { UserID = dr.GetInt32("UserID"); Loginname = dr.GetString("Loginname").ToString(); LanguageID = dr.GetInt32("LanguageID"); LanguageName = dr.GetString("LanguageName").ToString(); if (!dr.IsDBNull(dr.GetOrdinal("Email"))) Email = dr.GetString("Email").ToString(); if (!dr.IsDBNull(dr.GetOrdinal("LastLoginDate"))) LastLoginDate = dr.GetDateTime("LastLoginDate"); if (!dr.IsDBNull(dr.GetOrdinal("SupporterTier"))) SupporterTier = (Supporter)dr.GetInt32("SupporterTier"); } LanguageClass language = null; if (LanguageID > 0) language = new LanguageClass(LanguageID: LanguageID, LanguageName: LanguageName); if (UserID > 0 && language != null && language.LanguageID > 0) user = new UserClass(UserID: UserID, Loginname: Loginname, Language: language, Email: Email, LastLoginDate: LastLoginDate, SupporterTier: (Supporter)SupporterTier); } } } return user; } //       ASP.NET WebForms,             ObjectDataSource      //     ,         " "         //public IEnumerable<DataRow> List() //{ // using (MySqlConnection objConnect = new MySqlConnection(Base.strConnect)) // { // string strSQL = "select * from users"; // using (MySqlCommand objCommand = new MySqlCommand(strSQL, objConnect)) // { // objConnect.Open(); // using (MySqlDataAdapter da = new MySqlDataAdapter(objCommand)) // { // DataTable dt = new DataTable(); // da.Fill(dt); // return dt.AsEnumerable(); // } // } // } //} public IList<UserClass> List(string sortOrder, System.Web.Helpers.SortDirection sortDir, int page, int pagesize, out int count) { List<UserClass> users = new List<UserClass>(); using (MySqlConnection objConnect = new MySqlConnection(Base.strConnect)) { //     string sort = " ORDER BY "; //   ,               (inject) // ,  , MySQL        //    ,         (       ) //        ,    if (sortOrder != null && sortOrder != String.Empty) { sort += "`" + sortOrder + "`"; if (sortDir == System.Web.Helpers.SortDirection.Descending) sort += " DESC"; sort += ","; } sort += "`UserID`"; //   //        ( ) string limit = ""; if (pagesize > 0) { int start = (page - 1) * pagesize; limit = string.Concat(" LIMIT ", start.ToString(), ", ", pagesize.ToString()); } string strSQL = "SELECT SQL_CALC_FOUND_ROWS u.`UserID`, u.`Loginname`, l.`LanguageID`, l.`LanguageName` as `Language`, u.`Email`, u.`LastLoginDate`, CAST(u.`SupporterTier` AS UNSIGNED) as `SupporterTier` FROM `Users` u LEFT JOIN `Languages` l ON l.LanguageID=u.LanguageID" + sort + limit; using (MySqlCommand cmd = new MySqlCommand(strSQL, objConnect)) { objConnect.Open(); cmd.Parameters.Add("page", MySqlDbType.Int32).Value = page; cmd.Parameters.Add("pagesize", MySqlDbType.Int32).Value = pagesize; using (MySqlDataReader dr = cmd.ExecuteReader()) { while (dr.Read()) { LanguageClass language = new LanguageClass(LanguageID: dr.GetInt32("LanguageID"), LanguageName: dr.GetString("Language").ToString()); users.Add(new UserClass( UserID: dr.GetInt32("UserID"), Loginname: dr.GetString("Loginname"), Language: language, Email: dr.IsDBNull(dr.GetOrdinal("Email")) ? String.Empty : dr.GetString("Email"), LastLoginDate: dr.IsDBNull(dr.GetOrdinal("LastLoginDate")) ? (DateTime?) null : dr.GetDateTime("LastLoginDate"), SupporterTier: dr.IsDBNull(dr.GetOrdinal("SupporterTier")) ? (Supporter) Supporter.None : (Supporter)dr.GetInt32("SupporterTier"))); } } } using (MySqlCommand cmdrows = new MySqlCommand("SELECT FOUND_ROWS()", objConnect)) { int.TryParse(cmdrows.ExecuteScalar().ToString(), out count); } } return users; } } 

इसमें AddUserउपयोगकर्ता को जोड़ने के लिए एक विधि है , उपयोगकर्ता डेटा को अपडेट करना ( ChangeUser), हटाना ( RemoveUser), उपयोगकर्ता की खोज ( FetchByID) पहचानकर्ता द्वारा और Listछँटाई के साथ उपयोगकर्ताओं की पृष्ठांकित सूची प्रदर्शित करने के लिए सबसे दिलचस्प तरीका है । मैं फ़ंक्शन पर अतिरिक्त टिप्पणी करना चाहूंगा List:

1. यह तालिका को वापस करने के लायक नहीं है ( DataTable) इस तरह - इस मामले में, हम दृश्य में वर्ग के तत्वों तक पहुंचने की क्षमता खो देंगे और तालिका पंक्ति में मानों को संदर्भित करने के लिए स्ट्रिंग स्थिरांक का उपयोग करने के लिए मजबूर होंगे। यानी SQL-. UserClass .
2. LIMIT SQL- SELECT . , MySQL , LIMIT . , , ORDER BY . , SQL-, SQL , , . , , : .
3. SQL SELECT FOUND_ROWS() , , SELECT SQL_CALC_FOUND_ROWS LIMIT .

अन्य सभी विधियां पूरी तरह से सामान्य हैं, ऊपर के कैनन के अनुरूप हैं।

और LanguageRepository.cs मॉडल निर्देशिका में फ़ाइल :

 public class LanguagesRepository { public IList<LanguageClass> List() { List<LanguageClass> languages = new List<LanguageClass>(); using (MySqlConnection objConnect = new MySqlConnection(Base.strConnect)) { string strSQL = "SELECT `LanguageID`, `LanguageName` as `Language` FROM `Languages` ORDER BY `LanguageName`"; using (MySqlCommand cmd = new MySqlCommand(strSQL, objConnect)) { objConnect.Open(); using (MySqlDataReader dr = cmd.ExecuteReader()) { while (dr.Read()) { LanguageClass language = new LanguageClass(LanguageID: dr.GetInt32("LanguageID"), LanguageName: dr.GetString("Language").ToString()); languages.Add(language); } } } } return languages; } } 

डेटाबेस से भाषाओं की सूची प्राप्त करने के लिए केवल एक ही कार्य है, वर्ग तत्वों की सूची बनाना LanguageClass।

कुल मिलाकर

वह सब - कार्य हल है। यह स्पष्ट है कि कई मुद्दों को संबोधित नहीं किया गया था: निर्भरता इंजेक्शन कंटेनर, यूनिट परीक्षण, मोकिंग के लिए उपकरण, स्थानीयकरण, आदि। आदिकुछ चीजें अलग या बेहतर तरीके से की जा सकती हैं। लेकिन जो "ईंट" निकला, वह यह समझने के लिए पर्याप्त था कि ASP.NET MVC कैसे काम करता है और यह ADO.NET और DBMS के साथ काम करने के लिए इतना डरावना नहीं है जो MS SQL नहीं हैं।

PS और अंत में: आप देख सकते हैं कि यह प्रोजेक्ट इस पते पर कैसे काम करता है । और यहां आप पूरे प्रोजेक्ट को डाउनलोड कर सकते हैं। खैर, ढेर करने के लिए - मेरे ब्लॉग के लिए एक कड़ी ।