ASP.NET MVC पाठ सी। बहुभाषी वेबसाइट

पाठ का उद्देश्य। बहुभाषी साइट बनाना सीखें। DB संरचना साइट संसाधन। भाषा की परिभाषा। भाषाओं के बीच स्विच करें। व्यवस्थापक क्षेत्र में कार्य करें।

बहुभाषी वेबसाइट के मुद्दे

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

• चयनित स्थान के आधार पर दिनांक, राशियाँ लिखना। System.Globalization वर्ग इसे संभालता है।
• साइट के अंतर्निहित संसाधन - त्रुटि संदेश ("फ़ील्ड खाली नहीं हो सकता", "फ़ील्ड आवश्यक है") और अन्य संदेश।
• गैर-एम्बेडेड संसाधन, जैसे लोगो, चित्र, नियंत्रण के js- स्थानीयकरण। उनके बीच स्विच करने के लिए, आपको पृष्ठ पर वर्तमान भाषा मूल्य जानने की आवश्यकता है।
• कस्टम मूल्य।

इस समस्या को हल करने के लिए कई विकल्प हैं। उन पर विचार करें।

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

तीसरे विकल्प पर तुरंत विचार करें और निर्धारित करें कि हम इसे एप्लिकेशन में कैसे व्यवस्थित करते हैं:

• लैंग पैरामीटर अब साइट पते में दिखाई देता है
  
  • शायद पता ही लगेगा our-site.com{lang}/{controller}/{action}
  • शायद पता ही लगेगा our-site.com{controller}/{action}?lang=ru
  
  
• लैंग पैरामीटर एक आईएसओ दो अक्षर की भाषा परिभाषा है (आरयू - रूसी, ब्रिटेन - यूक्रेनी, सीएस - चेक)
• सबसे पहले, हम तारीखों को सही ढंग से प्रदर्शित करने के लिए System.Globalization का उपयोग करते हैं।
• हम दिए गए भाषाओं के संबंध में त्रुटियों को प्रदर्शित करने के लिए आंतरिक संसाधनों का आयोजन करते हैं
• हम डेटाबेस में तालिकाओं को व्यवस्थित करते हैं ताकि प्रत्येक रिकॉर्ड के लिए आवश्यक फ़ील्ड का अनुवाद हो।

हम 2 स्थानीयकरण बनाएंगे - रूसी और अंग्रेजी, और रूसी डिफ़ॉल्ट रूप से होगा।

रूटिंग

DefaultAreaRegademy में, लैंग प्रोसेसिंग (/Areas/Default/DefaultAreaRegistration.cs) जोड़ें:

 context.MapRoute( name: "lang", url: "{lang}/{controller}/{action}/{id}", defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }, constraints : new { lang = @"ru|en" }, namespaces: new[] { "LessonProject.Areas.Default.Controllers" } ); context.MapRoute( name : "default", url : "{controller}/{action}/{id}", defaults : new { controller = "Home", action = "Index", id = UrlParameter.Optional, lang = "ru" }, namespaces : new [] { "LessonProject.Areas.Default.Controllers" } ); 

इसलिए, यदि लाइन लैंग से शुरू होती है, तो हम "लैंग" मार्ग के प्रसंस्करण का उपयोग करते हैं। कंट्रास्टिन्स (प्रतिबंधों) पर ध्यान दें, यहां यह निर्दिष्ट किया गया है कि भाषा केवल आरयू या एन हो सकती है। यदि यह शर्त पूरी नहीं होती है, तो हम अगले मार्ग प्रसंस्करण के लिए आगे बढ़ते हैं - "डिफ़ॉल्ट", जहां डिफ़ॉल्ट रूप से lang = ru।
हम थ्रेड संस्कृति को बदलने के लिए DefaultController को इनिशियलाइज़ करने के लिए इसका उपयोग करते हैं (Thread.Current.CurrentCulture) (/Areas/Default/DefaultController.cs):

 public class DefaultController : BaseController { public string CurrentLangCode { get; protected set; } public Language CurrentLang { get; protected set; } protected override void Initialize(System.Web.Routing.RequestContext requestContext) { if (requestContext.HttpContext.Request.Url != null) { HostName = requestContext.HttpContext.Request.Url.Authority; } if (requestContext.RouteData.Values["lang"] != null && requestContext.RouteData.Values["lang"] as string != "null") { CurrentLangCode = requestContext.RouteData.Values["lang"] as string; CurrentLang = Repository.Languages.FirstOrDefault(p => p.Code == CurrentLangCode); var ci = new CultureInfo(CurrentLangCode); Thread.CurrentThread.CurrentUICulture = ci; Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(ci.Name); } base.Initialize(requestContext); } } 

स्वाभाविक रूप से, BaseController में हम कॉन्फ़िगरेशन फ़ाइल (/Controllers/BaseController.cs) के माध्यम से स्ट्रीम संस्कृति के आरंभ को हटा देते हैं:

 protected override void Initialize(System.Web.Routing.RequestContext requestContext) { if (requestContext.HttpContext.Request.Url != null) { HostName = requestContext.HttpContext.Request.Url.Authority; } base.Initialize(requestContext); } 

हम इसे शुरू करते हैं और जाँचते हैं कि दिनांक आउटपुट कैसे बदलता है:


पहला चरण पूरा हो गया है। हम साइट संसाधनों के प्रबंधन की ओर मुड़ते हैं।

साइट संसाधन

साइट संसाधन सभी स्थिर लाइनें हैं जिनका अनुवाद करने की आवश्यकता है:

• मेनू नाम
• युक्तियाँ
• त्रुटि निष्कर्ष

मुख्य पृष्ठ पर चार ऐसी लाइनें हैं: भूमिकाएं, उपयोगकर्ता, लॉगिन और पंजीकरण। संसाधन फ़ाइलें बनाएँ:

• Asp.net फ़ोल्डर को App_LocalResources फ़ोल्डर में जोड़ें:
  
  
• इसमें GlobalRes.resx और GlobalRes.en.resx फाइलें बनाएँ:
  
  
• हम उन पर अपनी लाइनें जोड़ते हैं, GlobalRes में - रूसी अनुवाद, GlobalRes.en में - अंग्रेजी:
  
  

  दर्ज	प्रविष्टि
  रजिस्टर	पंजीकरण
  भूमिकाएँ	भूमिका
  उपयोगकर्ता	उपयोगकर्ताओं

  
  
  
• GlobalRes के लिए गुण खोलें और फ़ील्ड के लिए निम्न मान सेट करें
  
  • बिल्ड एक्शन: एंबेडेड संसाधन
  • कस्टम टूल: PublicResXFileCodeGenerator
  
  
  
• अब System.web.webPages.razor (Web.config) में Web.cofig के लिए Namepace LessonProject.App_LocalResources जोड़ें।
  

   <system.web.webPages.razor> <pages pageBaseType="System.Web.Mvc.WebViewPage"> <namespaces> <add namespace="LessonProject.Helper" /> <add namespace="LessonProject.Tools" /> <add namespace="LessonProject.App_LocalResources" /> </namespaces> </pages> </system.web.webPages.razor> 

  
  
• हम UserLogin.cshtml (/Areas/Default/Views/Home/UserLogin.cshtml) और Index.cshtml ((/Areas/Default/Views/Hearome-Index.cshtml) में उपयोग करते हैं:
  

   @model LessonProject.Model.User @if (Model != null) { <li>@Model.Email</li> <li>@Html.ActionLink("", "Logout", "Login")</li> } else { <li><span class="btn btn-link" id="LoginPopup">@GlobalRes.Enter</span></li> <li>@Html.ActionLink(GlobalRes.Register, "Register", "User")</li> } … @{ ViewBag.Title = "LessonProject"; Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml"; } <h2>LessonProject </h2> <p> @DateTime.Now.ToString("D") <div class="menu"> <a href="@Url.Action("Index", "Role", new { id = "1" })">@GlobalRes.Roles</a> @Html.ActionLink(GlobalRes.Users, "Index", "User") </div> </p> 

  
  

चलाएं, जांचें:



चलिए LoginView उदाहरण का उपयोग करके सत्यापन संदेश सेट करने के लिए आगे बढ़ते हैं:

• फ़ील्ड फ़ाइलों के लिए ErrorMessage चुनें (/App_LocalResources/GlobalRes.resx):
  

  EnterEmail	ईमेल दर्ज करें
  EnterPassword	पासवर्ड डालें

  
  
• हम LoginView.cs (/Models/ViewModel/LoginView.cs) में सत्यापन नियम निर्धारित करते हैं:
  

   public class LoginView { [Required(ErrorMessageResourceType=typeof(GlobalRes), ErrorMessageResourceName="EnterEmail")] public string Email { get; set; } [Required(ErrorMessageResourceType = typeof(GlobalRes), ErrorMessageResourceName = "EnterPassword")] public string Password { get; set; } public bool IsPersistent { get; set; } } 

  
  

स्थानीयहोस्ट / en / लॉगिन पृष्ठ संस्करण में जाँच करें:


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

• संसाधनों में जोड़ें (/App_LocalResources/GlobalRes(.en).resx)CurrentLang = ru और CurrentLang = en
• इसे छिपे हुए फ़ील्ड में _Layout.cshtml (/Areas/Default/Views/Saring/_Layout.cshtml) में सूचीबद्ध करें:
  

   <body> @Html.Hidden("CurrentLang", GlobalRes.CurrentLang) <div class="navbar navbar-fixed-top"> •    ajax- (/Scripts/common.js): _this = this; this.loginAjax = "/Login/Ajax"; this.init = function () { _this.loginAjax = "/" + $("#CurrentLang").val() + _this.loginAjax; $("#LoginPopup").click(function () { _this.showPopup(_this.loginAjax, initLoginPopup); }); } function initLoginPopup(modal) { $("#LoginButton").click(function () { $.ajax({ type: "POST", url: _this.loginAjax, data : $("#LoginForm").serialize(), 

  
  

हम जाँच करते हैं:

डेटाबेस

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

आईडी	अद्वितीय रिकॉर्ड संख्या
UserID	द्वारा पोस्ट किया गया
हैडर	हैडर	अनुवाद की आवश्यकता है
यूआरएल	उरल रिकॉर्ड
सामग्री	सामग्री पोस्ट करें	अनुवाद की आवश्यकता है
AddedDate	तिथि जोड़ी गई

तो, यह सब कैसे आयोजित किया जाएगा:

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

ठीक है, अब इसे LessonProject.Model (LessonProject.Model / IRepository.cs) में जोड़ें:

 #region Language IQueryable<Language> Languages { get; } bool CreateLanguage(Language instance); bool UpdateLanguage(Language instance); bool RemoveLanguage(int idLanguage); #endregion #region Post IQueryable<Post> Posts { get; } bool CreatePost(Post instance); bool UpdatePost(Post instance); bool RemovePost(int idPost); #endregion 

हम पहले से बनाए गए स्निपेट / प्रॉक्सि / लैंग्वेजेज का उपयोग करके मॉडल बनाते हैं:

 namespace LessonProject.Model { public partial class Language { } } 

/Proxy/Post.cs:

 namespace LessonProject.Model { public partial class Post { } } 

/SqlRepository/Language.cs:

 public partial class SqlRepository { public IQueryable<Language> Languages { get { return Db.Languages; } } public bool CreateLanguage(Language instance) { if (instance.ID == 0) { Db.Languages.InsertOnSubmit(instance); Db.Languages.Context.SubmitChanges(); return true; } return false; } public bool UpdateLanguage(Language instance) { Language cache = Db.Languages.Where(p => p.ID == instance.ID).FirstOrDefault(); if (cache != null) { cache.Code = instance.Code; cache.Name = instance.Name; Db.Languages.Context.SubmitChanges(); return true; } return false; } public bool RemoveLanguage(int idLanguage) { Language instance = Db.Languages.Where(p => p.ID == idLanguage).FirstOrDefault(); if (instance != null) { Db.Languages.DeleteOnSubmit(instance); Db.Languages.Context.SubmitChanges(); return true; } return false; } } 

/SqlRepository/Post.cs:

 public partial class SqlRepository { public IQueryable<Post> Posts { get { return Db.Posts; } } public bool CreatePost(Post instance) { if (instance.ID == 0) { Db.Posts.InsertOnSubmit(instance); Db.Posts.Context.SubmitChanges(); return true; } return false; } public bool UpdatePost(Post instance) { Post cache = Db.Posts.Where(p => p.ID == instance.ID).FirstOrDefault(); if (cache != null) { //TODO : Update fields for Post Db.Posts.Context.SubmitChanges(); return true; } return false; } public bool RemovePost(int idPost) { Post instance = Db.Posts.Where(p => p.ID == idPost).FirstOrDefault(); if (instance != null) { Db.Posts.DeleteOnSubmit(instance); Db.Posts.Context.SubmitChanges(); return true; } return false; } } 

तो, हमारे पास पोस्ट क्लास के ऑब्जेक्ट में PostLangs का एक सेट है, जहां विभिन्न अनुवाद संग्रहीत हैं। इसके अलावा, अंग्रेजी या रूसी में अनुवाद हो भी सकता है और नहीं भी। लेकिन कम से कम एक भाषा तो होनी ही चाहिए। इसके लिए क्या करना होगा:

• Post (Header, Content) के लिए भाषा क्षेत्र जोड़ें
• करेंटलैंग प्रॉपर्टी का निर्माण करते हैं, जब बदला जाता है, तो भाषा क्षेत्र आरंभ किया जाएगा।
• जब आप पोस्ट डेटाबेस में एक प्रविष्टि बनाते हैं, तो PostLang डेटाबेस में एक प्रविष्टि स्वचालित रूप से बनाई जाती है।
• डेटाबेस में कोई रिकॉर्ड बदलते समय, यह जांचा जाता है कि कौन सी भाषा बदल रही है, और यदि ऐसी कोई भाषा (अनुवाद) अभी तक नहीं है, तो डेटाबेस में एक नया पोस्टलैंग रिकॉर्ड बनाया जाता है:

आइए कार्यान्वयन के लिए आगे बढ़ें (/Proxy/Post.cs):

 public partial class Post { private int _currentLang; public int CurrentLang { get { return _currentLang; } set { _currentLang = value; var currentLang = PostLangs.FirstOrDefault(p => p.LanguageID == value); if (currentLang == null) { IsCorrectLang = false; var anyLang = PostLangs.FirstOrDefault(); if (anyLang != null) { SetLang(anyLang); } } else { IsCorrectLang = true; SetLang(currentLang); } } } private void SetLang(PostLang postLang) { Header = postLang.Header; Content = postLang.Content; } public bool IsCorrectLang { get; protected set; } public string Header { get; set; } public string Content { get; set; } } 

यहां यह ध्यान रखना महत्वपूर्ण है कि अगर कोई आवश्यक अनुवाद नहीं है, तो पहले एक लिया जाता है, और IsCorrectLang = false सेट किया जाता है। यह इतना है कि उपयोगकर्ता को कम से कम कुछ जानकारी दिखाने से बेहतर है कि कुछ भी न दिखाएं।
पोस्ट ऑब्जेक्ट बनाना / संशोधित करना (/SqlRepository/Post.cs):

 public bool CreatePost(Post instance) { if (instance.ID == 0) { instance.AddedDate = DateTime.Now; Db.Posts.InsertOnSubmit(instance); Db.Posts.Context.SubmitChanges(); var lang = Db.Languages.FirstOrDefault(p => p.ID == instance.CurrentLang); if (lang != null) { CreateOrChangePostLang(instance, null, lang); return true; } } return false; } public bool UpdatePost(Post instance) { Post cache = Db.Posts.Where(p => p.ID == instance.ID).FirstOrDefault(); if (cache != null) { cache.Url = instance.Url; Db.Posts.Context.SubmitChanges(); var lang = Db.Languages.FirstOrDefault(p => p.ID == instance.CurrentLang); if (lang != null) { CreateOrChangePostLang(instance, cache, lang); return true; } return true; } return false; } private void CreateOrChangePostLang(Post instance, Post cache, Language lang) { PostLang postLang = null; if (cache != null) { postLang = Db.PostLangs.FirstOrDefault(p => p.PostID == cache.ID && p.LanguageID == lang.ID); } if (postLang == null) { var newPostLang = new PostLang() { PostID = instance.ID, LanguageID = lang.ID, Header = instance.Header, Content = instance.Content, }; Db.PostLangs.InsertOnSubmit(newPostLang); } else { postLang.Header = instance.Header; postLang.Content = instance.Content; } Db.PostLangs.Context.SubmitChanges(); } 

विचार करें कि CreateOrChangePostLang फ़ंक्शन कैसे काम करता है:

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

पोस्ट प्रविष्टि को हटाते समय, सभी PostLang को OnDelete = कैस्केड लिंक द्वारा हटा दिया जाता है (इसका अनुसरण करें)
आवश्यक भाषाओं के लिए प्रविष्टियाँ पहले ही डेटाबेस में जोड़ दी जानी चाहिए:

1	आरयू	रूसी
2	एन	अंग्रेजी

व्यवस्थापक
अब, यह सब प्रदर्शित करने के लिए, हम एक व्यवस्थापक पैनल बनाएंगे। कार्य योजना इस प्रकार है (हम इसे बाद में परिष्कृत करेंगे और इसे आवाज देंगे):

• मॉडल बनाएं
• इनपुट भाषा और उपयोगकर्ता को संबद्ध करें (यह स्पष्ट करने के लिए कि व्यवस्थापक या संपादक किस भाषा में काम करता है)
• भाषा स्विचिंग बनाएं
• व्यवस्थापक होमपेज बनाएँ
• पोस्ट कंट्रोलर बनाएं
• डिफ़ॉल्ट / पोस्टकंट्रोलर भाग में सूची पोस्ट करें

तालिका में जोड़ें उपयोगकर्ता भाषा:


IRepository.cs में जोड़ें:

 bool ChangeLanguage(User instance, string LangCode); 

हम /SqlRepository/User.cs में लागू करते हैं:

  public bool ChangeLanguage(User instance, string LangCode) { var cache = Db.Users.FirstOrDefault(p => p.ID == instance.ID); var newLang = Db.Languages.FirstOrDefault(p => p.Code == LangCode); if (cache != null && newLang != null) { cache.Language = newLang; Db.Users.Context.SubmitChanges(); return true; } return false; } 

मॉडल बनाएँ / मॉडल / दृश्य / मॉडल / पोस्ट दृश्य:

 public class PostView { public int ID { get; set; } public int UserID { get; set; } public bool IsCorrectLang { get; set; } public int CurrentLang { get; set; } [Required(ErrorMessage = " ")] public string Header { get; set; } [Required] public string Url { get; set; } [Required(ErrorMessage = " ")] public string Content { get; set; } } 

मान्यता लाइनों को GlobalRes में डालने की आवश्यकता नहीं है, क्योंकि यहां हम केवल व्यवस्थापक पैनल में काम करते हैं और यह हमारे लिए कोई फायदा नहीं है (क्योंकि प्रशासक मामूली लोग हैं)। लेकिन अगर अन्य आवश्यकताएं हैं, तो हमें पता है कि क्या करना है।
/Areas/Admin/Controller/AdminController.cs बनाएँ:

 public abstract class AdminController : BaseController { public Language CurrentLang { get { return CurrentUser != null ? CurrentUser.Language : null; } } protected override void Initialize(RequestContext requestContext) { CultureInfo ci = new CultureInfo("ru"); Thread.CurrentThread.CurrentCulture = ci; base.Initialize(requestContext); } } 

और /Areas/Admin/Controller/HomeController.cs:

 [Authorize(Roles="admin")] public class HomeController : AdminController { public ActionResult Index() { return View(); } public ActionResult AdminMenu() { return View(); } public ActionResult LangMenu() { if (CurrentLang == null) { var lang = repository.Languages.FirstOrDefault(); repository.ChangeLanguage(currentUser, lang.Code); } var langProxy = new LangAdminView(repository, CurrentLang.Code); return View(langProxy); } [HttpPost] public ActionResult ChangeLanguage(string SelectedLang) { repository.ChangeLanguage(currentUser, SelectedLang); return Redirect("~/admin"); } } 

इसलिए, AdminController चयन और सेट करता है कि हम वर्तमान में किस भाषा में काम कर रहे हैं। यदि यह भाषा स्थापित नहीं है, तो पहले वाला चुना जाता है, और HomeController.cs में: LangMenu उपयोगकर्ता के लिए स्थापित किया जाता है। LangAdminView.cs (/Models/ViewModel/LangAdminView.cs) बनाएं:

 public class LangAdminView { private IRepository Repository { get { return DependencyResolver.Current.GetService<IRepository>(); } } public string SelectedLang {get; set; } public List<SelectListItem> Langs { get; set; } public LangAdminView(string currentLang) { currentLang = currentLang ?? ""; Langs = new List<SelectListItem>(); foreach (var lang in Repository.Languages) { Langs.Add(new SelectListItem() { Selected = (string.Compare(currentLang, lang.Code, true) == 0), Value = lang.Code, Text = lang.Name }); } } } 

आइए देखें सभी विवरण (+ js फाइलें):
/Areas/Admin/Views/Shared/_Layout.cshtml:

 @{ var currentUser = ((LessonProject.Controllers.BaseController)ViewContext.Controller).CurrentUser; } <!DOCTYPE html> <html> <head> <title>@ViewBag.Title</title> <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" /> @Styles.Render("~/Content/css/jqueryui") @Styles.Render("~/Content/css") @RenderSection("styles", required: false) @Scripts.Render("~/bundles/modernizr") </head> <body> <div class="navbar navbar-fixed-top"> <div class="navbar-inner"> <div class="container-fluid"> <div class="btn-group pull-right"> <a class="btn dropdown-toggle" data-toggle="dropdown" href="#"><i class="icon-user"> </i> @currentUser.Email<span class="caret"></span> </a> <ul class="dropdown-menu"> <li><a href="/"> </a></li> <li class="divider"></li> <li><a href="@Url.Action("Logout", "Login", new { area = "Default" })"></a> </li> </ul> </div> <a class="brand" href="@Url.Action("Index", "Home")">LessonProject</a> </div> </div> </div> <div class="container-fluid"> <div class="row-fluid"> <div class="span3"> <div class="well sidebar-nav"> <ul class="nav nav-list"> @Html.Action("LangMenu", "Home") @Html.Action("AdminMenu", "Home") </ul> </div> </div> <div class="span9"> @RenderBody() </div> </div> </div> @Scripts.Render("~/bundles/jquery") @Scripts.Render("~/bundles/jqueryui") @Scripts.Render("~/bundles/bootstrap") @Scripts.Render("~/bundles/common") @Scripts.Render("/Scripts/admin/common.js") @RenderSection("scripts", required: false) </body> </html> 

Index.cshtml (/Areas/Admin/Views/Home/Index.cshtml):

 @{ ViewBag.Title = "Index"; Layout = "~/Areas/Admin/Views/Shared/_Layout.cshtml"; } <h2></h2> AdminMenu.cshtml (/Areas/Admin/Views/Home/AdminMenu.cshtml): <li> @Html.ActionLink("", "Index", "Home") </li> <li> @Html.ActionLink("", "Index", "Post") </li> 

LangMenu.cshtml (/Areas/Admin/Views/Home/LangMenu.cshtml:

 @model LessonProject.Models.ViewModels.LangAdminView <li> @using (Html.BeginForm("ChangeLanguage", "Home", FormMethod.Post, new { id = "SelectLangForm" })) { @Html.DropDownList("SelectedLang", Model.Langs) } </li> 

और सेलेन्गलैंग हैंडलर (/ स्क्रिप्ट्स / एडमिन / एब्नॉर्मल):

 function AdminCommon() { _this = this; this.init = function () { $("#SelectedLang").change(function () { $("#SelectLangForm").submit(); }); } } var adminCommon = null; $().ready(function () { adminCommon = new AdminCommon(); adminCommon.init(); }); 

हम प्रशासक के पास जाते हैं (मेरे पास chernikov@gmail.com है) और लोकलहोस्ट / एडमिन पेज पर जाएँ:



यदि इसे लॉग इन करना / लॉगिन करना संभव नहीं था, तो डेटाबेस में UserRole कनेक्शन की जांच करें, ताकि वर्तमान उपयोगकर्ता की "व्यवस्थापक" कोड के साथ एक भूमिका हो।

भाषाओं की ड्रॉप-डाउन सूची खोलें। यह दिखाता है कि वर्तमान में हम किस भाषा में काम कर रहे हैं।
PostController.cs कंट्रोलर जोड़ें (/Areas/Admin/Controllers/PostController.cs):

 public class PostController : AdminController { public ActionResult Index(int page = 1) { var list = Repository.Posts.OrderByDescending(p => p.AddedDate); var data = new PageableData<Post>(list, page); data.List.ForEach(p => p.CurrentLang = CurrentLang.ID); return View(data); } [HttpGet] public ActionResult Create() { var postView = new PostView { CurrentLang = CurrentLang.ID }; return View("Edit", postView); } [HttpGet] public ActionResult Edit(int id) { var post = Repository.Posts.FirstOrDefault(p => p.ID == id); if (post != null) { post.CurrentLang = CurrentLang.ID; var postView = (PostView)ModelMapper.Map(post, typeof(Post), typeof(PostView)); return View(postView); } return RedirectToNotFoundPage; } [HttpPost] [ValidateInput(false)] public ActionResult Edit(PostView postView) { if (ModelState.IsValid) { var post = (Post)ModelMapper.Map(postView, typeof(PostView), typeof(Post)); post.CurrentLang = CurrentLang.ID; if (post.ID == 0) { post.UserID = CurrentUser.ID; Repository.CreatePost(post); } else { Repository.UpdatePost(post); } TempData["Message"] = "!"; return RedirectToAction("Index"); } return View(postView); } public ActionResult Delete(int id) { Repository.RemovePost(id); TempData["Message"] = " "; return RedirectToAction("Index"); } } 

PageableData को बदलें ताकि आप Foreach (/Models/Info/PageableData.cs) बना सकें:

  public class PageableData<T> where T : class { protected static int ItemPerPageDefault = 20; public List<T> List { get; set; } … public PageableData(IQueryable<T> queryableSet, int page, int itemPerPage = 0) { … List = queryableSet.Skip((PageNo - 1) * itemPerPage).Take(itemPerPage).ToList(); } } 

Index.cshtml (/Areas/Admin/Views/Post/Index.cshtml):

 @model LessonProject.Models.Info.PageableData<LessonProject.Model.Post> @{ ViewBag.Title = ""; Layout = "~/Areas/Admin/Views/Shared/_Layout.cshtml"; } <h2>  </h2> @Html.ActionLink("", "Create", "Post", null, new { @class = "btn" }) <table class="table"> <thead> <tr> <th> # </th> <th>  </th> <th>  </th> <th> </th> </tr> </thead> @foreach (var item in Model.List) { <tr> <td> @item.ID </td> <td> @(item.IsCorrectLang ? "" : " ") </td> <td> @item.Header </td> <td> @Html.ActionLink("", "Edit", "Post", new { id = item.ID }, new { @class = "btn btn-mini" }) @Html.ActionLink("", "Delete", "Post", new { id = item.ID }, new { @class = "btn btn-mini btn-danger" }) </td> </tr> } </table> 

ForEach में इनिशियलाइज़ करते समय, भाषा क्षेत्र पहले से ही प्रत्येक ऑब्जेक्ट में इनिशियलाइज़ हो जाते हैं। भाषा - वह जिसके साथ हम वर्तमान में व्यवस्थापक पैनल में काम कर रहे हैं।
संपादन के लिए दृश्य तुच्छ है, क्योंकि हम नियंत्रक में सभी काम करते हैं, और हमारा पोस्ट व्यू पहले ही भाषा सेटिंग्स का उपयोग करता है। (/Areas/Admin/Views/Post/Edit.cshtml):

 @model LessonProject.Models.ViewModels.PostView @{ ViewBag.Title = Model.ID == 0 ? " " : " "; Layout = "~/Areas/Admin/Views/Shared/_Layout.cshtml"; } <h2>@(Model.ID == 0 ? " " : " ")</h2> <p> </p> @using (Html.BeginForm("Edit", "Post", FormMethod.Post)) { @Html.Hidden("ID", Model.ID) <fieldset> <div class="control-group"> <label class="control-label"> @(!Model.IsCorrectLang && Model.ID != 0 ? " " : "") </label> </div> <div class="control-group"> <label class="control-label"> </label> <div class="controls"> @Html.TextBox("Header", Model.Header, new { @class = "input-xlarge" }) @Html.ValidationMessage("Header") </div> </div> <div class="control-group"> <label class="control-label"> Url</label> <div class="controls"> @Html.TextBox("Url", Model.Url, new { @class = "input-xlarge" }) @Html.ValidationMessage("Url") </div> </div> <div class="control-group"> <label class="control-label"> </label> <div class="controls"> @Html.TextArea("Content", Model.Content, new { @class = "input-xlarge" }) @Html.ValidationMessage("Content") </div> </div> <div class="form-actions"> <button type="submit" class="btn btn-primary"> </button> @Html.ActionLink("", "Index", null, null, new { @class = "btn" }) </div> </fieldset> } 

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


ठीक है, पोस्ट बनाए गए
डिफ़ॉल्ट क्षेत्र में एक पोस्टकंट्रोलर बनाएँ और पदों (/Areas/Default/Controller/PostController.cs) प्रदर्शित करें:

 public class PostController : DefaultController { public ActionResult Index(int page = 1) { var list = Repository.Posts.OrderByDescending(p => p.AddedDate); var data = new PageableData<Post>(list, page); data.List.ForEach(p => p.CurrentLang = CurrentLang.ID); return View(data); } } 

Index.cshtml (/Areas/Default/Views/Post/Index.cshtml):

 @model LessonProject.Models.Info.PageableData<LessonProject.Model.Post> @{ ViewBag.Title = "Index"; Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml"; } <div class="item"> @foreach (var post in Model.List) { <h3>@post.Header</h3> <p> @post.Content.NlToBr() </p> <span>@post.AddedDate.ToString("d")</span> } </div> <div class="pagination"> @Html.PageLinks(Model.PageNo, Model.CountPage, x => Url.Action("Index", new {page = x})) </div> 

और जांचें:



सुपर!

भाषाओं के बीच स्विच करें

चलो ग्राहक भाग में आरयू / एन स्विच बनाते हैं। LangHelper.cs वर्ग (/Helper/LangHelper.cs) जोड़ें:

 public static class LangHelper { public static MvcHtmlString LangSwitcher(this UrlHelper url, string Name, RouteData routeData, string lang) { var liTagBuilder = new TagBuilder("li"); var aTagBuilder = new TagBuilder("a"); var routeValueDictionary = new RouteValueDictionary(routeData.Values); if (routeValueDictionary.ContainsKey("lang")) { if (routeData.Values["lang"] as string == lang) { liTagBuilder.AddCssClass("active"); } else { routeValueDictionary["lang"] = lang; } } aTagBuilder.MergeAttribute("href", url.RouteUrl(routeValueDictionary)); aTagBuilder.SetInnerText(Name); liTagBuilder.InnerHtml = aTagBuilder.ToString(); return new MvcHtmlString(liTagBuilder.ToString()); } } 

आंशिक रूप से _Layout.cshtml (/Areas/Default/Views/Saring/_Layout.cshtml) में जोड़ें:
<

 div class="container"> <ul class="nav nav-pills pull-right"> @Html.Partial("LangMenu") </ul> 

+ LangMenu.cshtml:

 @Url.LangSwitcher("en", ViewContext.RouteData, "en") @Url.LangSwitcher("ru", ViewContext.RouteData, "ru") 

हम शुरू करते हैं। देखा! सौंदर्य।



गलत प्रारूप, रूसी में अनुवाद
कभी-कभी, जब हम अपेक्षित संख्या क्षेत्र में एक पाठ मान दर्ज करते हैं, तो हम निम्नलिखित संदेश प्राप्त कर सकते हैं:

 The value 'one hundred dollars' is not valid for Price. 

लेकिन इस संदेश को रूसी में कैसे प्रदर्शित किया जाए। निम्नलिखित कदम आपको ऐसा करने में मदद करेंगे:

• App_GlobalResources फ़ोल्डर जोड़ें
• Message.resx संसाधन जोड़ें
• पंक्ति जोड़ें "PropertyValueInvalid: मान {0} फ़ील्ड {1} के लिए मान्य नहीं है "
• App_Start में, Application_Start () (/Global.asax.cs) पर एक पंक्ति जोड़ें
• DefaultModelBinder.ResourceClassKey = "संदेश";
• फ़ील्ड नाम निर्दिष्ट करने के लिए आप प्रदर्शन [नाम = "मूल्य"] विशेषता का उपयोग कर सकते हैं।
• हमें इसका परिणाम मिलता है:
  

परिणाम

एक बहुभाषी साइट में काम इस प्रकार है:

• संसाधनों में अनुवाद के तार अलग
• डेटाबेस तालिकाओं में भाषा क्षेत्रों को परिभाषित करें और उन्हें भाषा तालिका के माध्यम से लिंक करें
• भाषा समर्थन के आधार पर ajax अनुरोधों का उपयोग करें

अंत में, मैं यह कहूंगा कि यह बहुभाषी साइट शुरू करने के लायक नहीं है, अगर ग्राहक स्पष्ट रूप से ऐसा नहीं कहता है, लेकिन अगर इस तरह के अवसर का उपयोग भविष्य में किया जा सकता है, तो बहुभाषावाद का उपयोग करके साइट का निर्माण शुरू करना आवश्यक है, कम से कम डेटाबेस स्तर पर।

सभी स्रोत https://bitbucket.org/chernikov/lessons पर स्थित हैं