दिलचस्प पोस्ट
मूल_ओआईएस पर झंडे की शब्दावली ग्रहण के बाद मैं हमेशा एपीपी फाइल को फिर से स्थापित कर सकता हूं आप SEHException त्रुटि का निदान कैसे करें – बाहरी घटक ने एक अपवाद डाला है सी / सी ++ में एक DLL संकलित करें, फिर उसे किसी अन्य प्रोग्राम से कॉल करें मापा संकेत का पीक पहचान एक एसएमके क्लाइंट के साथ ओपनफायर कस्टम प्लगइन को मैप करना नरम कीबोर्ड से रोकें बटन सी # संकलक में बतख टाइपिंग डिवाइस पर आईओएस ऐप को अनइंस्टॉल करने के बाद IOS में पहचानकर्ताफ़ोरेवेंडर को कैसे संरक्षित करें? मेरे पायथन कोड को पहली बार चलाने के लिए अच्छे तरीके क्या हैं? मैं ईक्लिप्स थीम कैसे बदल सकता हूँ? एक बड़ा या बराबर चिन्ह प्रदर्शित करना ASP.NET MVC दृश्य में पुनरावर्ती मार्कडाउन फ़ाइल में गीथहब रिश्तेदार लिंक प्रक्रिया लॉन्च लॉन्च नहीं किया जा सका: ऐप्लिकेशन लॉन्च करने के लिए समय-समय पर प्रतीक्षा

आंशिक दृश्य ASP.NET MVC 3 से रेजर व्यू इंजन के साथ विशिष्ट अनुभागों में सामग्री इंजेक्शन

मेरे पास यह अनुभाग मेरी _Layout.cshtml में परिभाषित है

 @RenderSection("Scripts", false) 

मैं इसे आसानी से एक दृश्य से उपयोग कर सकते हैं:

 @section Scripts { @*Stuff comes here*@ } 

मैं किसके साथ संघर्ष कर रहा हूं यह है कि इस अनुभाग के अंदर आंशिक दृश्य से इंजेक्ट कुछ सामग्री कैसे प्राप्त करें

मान लीजिए कि यह मेरा दृश्य पृष्ठ है:

 @section Scripts { <script> //code comes here </script> } <div> poo bar poo </div> <div> @Html.Partial("_myPartial") </div> 

मुझे कुछ सामग्री को _myPartial आंशिक दृश्य से Scripts अनुभाग के अंदर इंजेक्ट करने की आवश्यकता है I

मैं यह कैसे कर सकता हूँ?

Solutions Collecting From Web of "आंशिक दृश्य ASP.NET MVC 3 से रेजर व्यू इंजन के साथ विशिष्ट अनुभागों में सामग्री इंजेक्शन"

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

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

मेरे _layout मेरे पास है:

 @RenderSection("body_scripts", false) 

मेरे index दृश्य में मेरे पास है:

 @Html.Partial("Clients") @section body_scripts { @Html.Partial("Clients_Scripts") } 

अपने clients दृश्य में मेरे पास (सभी मानचित्र और एशॉक। Html):

 @section body_scripts { @Html.Partial("Clients_Scripts") } 

मेरे Clients_Scripts व्यू में पृष्ठ पर गाया जाने वाला जावास्क्रिप्ट है

इस तरह से मेरी स्क्रिप्ट अलग है और आवश्यक है कि पृष्ठ में गाया जा सकता है, body_scripts टैग के साथ ही पहली उपस्थिति पर body_scripts व्यू इंजिन को पाता है।

यह मुझे सब कुछ अलग करने देता है – यह एक समाधान है जो मेरे लिए काफी अच्छी तरह से काम करता है, दूसरों को इसके साथ समस्या हो सकती है, लेकिन यह "डिज़ाइन द्वारा" छेद पैच करता है

इस धागे में दिए गए समाधानों से, मैं निम्न संभावित समाधान के साथ आया हूं जो आपको किसी भी ब्लॉक के भीतर किसी भी HTML (स्क्रिप्ट भी) में देरी करने देता है

उपयोग

"अनुभाग" बनाएं

  1. विशिष्ट परिदृश्य: आंशिक दृश्य में, केवल एक बार ब्लॉक को शामिल करें, चाहे कितनी बार पेज में आंशिक दृश्य दोहराया जाए:

     @using (Html.Delayed(isOnlyOne: "some unique name for this section")) { <script> someInlineScript(); </script> } 
  2. आंशिक दृष्टि से, आंशिक उपयोग किए जाने वाले प्रत्येक समय के लिए ब्लॉक शामिल करें:

     @using (Html.Delayed()) { <b>show me multiple times, @Model.Whatever</b> } 
  3. आंशिक दृश्य में, केवल एक बार ब्लॉक शामिल होता है चाहे कितनी बार आंशिक बार दोहराया जाए, लेकिन बाद में इसे विशेष रूप से जब- when-i-call-you नाम से प्रस्तुत करना होगा:

     @using (Html.Delayed("when-i-call-you", isOnlyOne: "different unique name")) { <b>show me once by name</b> <span>@Model.First().Value</span> } 

"अनुभाग" प्रस्तुत करें

(यानी माता पिता के दृश्य में देरी वाले अनुभाग को प्रदर्शित करें)

 @Html.RenderDelayed(); // writes unnamed sections (#1 and #2, excluding #3) @Html.RenderDelayed("when-i-call-you", false); // writes the specified block, and ignore the `isOnlyOne` setting so we can dump it again @Html.RenderDelayed("when-i-call-you"); // render the specified block by name @Html.RenderDelayed("when-i-call-you"); // since it was "popped" in the last call, won't render anything due to `isOnlyOne` provided in `Html.Delayed` 

कोड

 public static class HtmlRenderExtensions { /// <summary> /// Delegate script/resource/etc injection until the end of the page /// <para>@via https://stackoverflow.com/a/14127332/1037948 and http://jadnb.wordpress.com/2011/02/16/rendering-scripts-from-partial-views-at-the-end-in-mvc/ </para> /// </summary> private class DelayedInjectionBlock : IDisposable { /// <summary> /// Unique internal storage key /// </summary> private const string CACHE_KEY = "DCCF8C78-2E36-4567-B0CF-FE052ACCE309"; // "DelayedInjectionBlocks"; /// <summary> /// Internal storage identifier for remembering unique/isOnlyOne items /// </summary> private const string UNIQUE_IDENTIFIER_KEY = CACHE_KEY; /// <summary> /// What to use as internal storage identifier if no identifier provided (since we can't use null as key) /// </summary> private const string EMPTY_IDENTIFIER = ""; /// <summary> /// Retrieve a context-aware list of cached output delegates from the given helper; uses the helper's context rather than singleton HttpContext.Current.Items /// </summary> /// <param name="helper">the helper from which we use the context</param> /// <param name="identifier">optional unique sub-identifier for a given injection block</param> /// <returns>list of delayed-execution callbacks to render internal content</returns> public static Queue<string> GetQueue(HtmlHelper helper, string identifier = null) { return _GetOrSet(helper, new Queue<string>(), identifier ?? EMPTY_IDENTIFIER); } /// <summary> /// Retrieve a context-aware list of cached output delegates from the given helper; uses the helper's context rather than singleton HttpContext.Current.Items /// </summary> /// <param name="helper">the helper from which we use the context</param> /// <param name="defaultValue">the default value to return if the cached item isn't found or isn't the expected type; can also be used to set with an arbitrary value</param> /// <param name="identifier">optional unique sub-identifier for a given injection block</param> /// <returns>list of delayed-execution callbacks to render internal content</returns> private static T _GetOrSet<T>(HtmlHelper helper, T defaultValue, string identifier = EMPTY_IDENTIFIER) where T : class { var storage = GetStorage(helper); // return the stored item, or set it if it does not exist return (T) (storage.ContainsKey(identifier) ? storage[identifier] : (storage[identifier] = defaultValue)); } /// <summary> /// Get the storage, but if it doesn't exist or isn't the expected type, then create a new "bucket" /// </summary> /// <param name="helper"></param> /// <returns></returns> public static Dictionary<string, object> GetStorage(HtmlHelper helper) { var storage = helper.ViewContext.HttpContext.Items[CACHE_KEY] as Dictionary<string, object>; if (storage == null) helper.ViewContext.HttpContext.Items[CACHE_KEY] = (storage = new Dictionary<string, object>()); return storage; } private readonly HtmlHelper helper; private readonly string identifier; private readonly string isOnlyOne; /// <summary> /// Create a new using block from the given helper (used for trapping appropriate context) /// </summary> /// <param name="helper">the helper from which we use the context</param> /// <param name="identifier">optional unique identifier to specify one or many injection blocks</param> /// <param name="isOnlyOne">extra identifier used to ensure that this item is only added once; if provided, content should only appear once in the page (ie only the first block called for this identifier is used)</param> public DelayedInjectionBlock(HtmlHelper helper, string identifier = null, string isOnlyOne = null) { this.helper = helper; // start a new writing context ((WebViewPage)this.helper.ViewDataContainer).OutputStack.Push(new StringWriter()); this.identifier = identifier ?? EMPTY_IDENTIFIER; this.isOnlyOne = isOnlyOne; } /// <summary> /// Append the internal content to the context's cached list of output delegates /// </summary> public void Dispose() { // render the internal content of the injection block helper // make sure to pop from the stack rather than just render from the Writer // so it will remove it from regular rendering var content = ((WebViewPage)this.helper.ViewDataContainer).OutputStack; var renderedContent = content.Count == 0 ? string.Empty : content.Pop().ToString(); // if we only want one, remove the existing var queue = GetQueue(this.helper, this.identifier); // get the index of the existing item from the alternate storage var existingIdentifiers = _GetOrSet(this.helper, new Dictionary<string, int>(), UNIQUE_IDENTIFIER_KEY); // only save the result if this isn't meant to be unique, or // if it's supposed to be unique and we haven't encountered this identifier before if( null == this.isOnlyOne || !existingIdentifiers.ContainsKey(this.isOnlyOne) ) { // remove the new writing context we created for this block // and save the output to the queue for later queue.Enqueue(renderedContent); // only remember this if supposed to if(null != this.isOnlyOne) existingIdentifiers[this.isOnlyOne] = queue.Count; // save the index, so we could remove it directly (if we want to use the last instance of the block rather than the first) } } } /// <summary> /// <para>Start a delayed-execution block of output -- this will be rendered/printed on the next call to <see cref="RenderDelayed"/>.</para> /// <para> /// <example> /// Print once in "default block" (usually rendered at end via <code>@Html.RenderDelayed()</code>). Code: /// <code> /// @using (Html.Delayed()) { /// <b>show at later</b> /// <span>@Model.Name</span> /// etc /// } /// </code> /// </example> /// </para> /// <para> /// <example> /// Print once (ie if within a looped partial), using identified block via <code>@Html.RenderDelayed("one-time")</code>. Code: /// <code> /// @using (Html.Delayed("one-time", isOnlyOne: "one-time")) { /// <b>show me once</b> /// <span>@Model.First().Value</span> /// } /// </code> /// </example> /// </para> /// </summary> /// <param name="helper">the helper from which we use the context</param> /// <param name="injectionBlockId">optional unique identifier to specify one or many injection blocks</param> /// <param name="isOnlyOne">extra identifier used to ensure that this item is only added once; if provided, content should only appear once in the page (ie only the first block called for this identifier is used)</param> /// <returns>using block to wrap delayed output</returns> public static IDisposable Delayed(this HtmlHelper helper, string injectionBlockId = null, string isOnlyOne = null) { return new DelayedInjectionBlock(helper, injectionBlockId, isOnlyOne); } /// <summary> /// Render all queued output blocks injected via <see cref="Delayed"/>. /// <para> /// <example> /// Print all delayed blocks using default identifier (ie not provided) /// <code> /// @using (Html.Delayed()) { /// <b>show me later</b> /// <span>@Model.Name</span> /// etc /// } /// </code> /// -- then later -- /// <code> /// @using (Html.Delayed()) { /// <b>more for later</b> /// etc /// } /// </code> /// -- then later -- /// <code> /// @Html.RenderDelayed() // will print both delayed blocks /// </code> /// </example> /// </para> /// <para> /// <example> /// Allow multiple repetitions of rendered blocks, using same <code>@Html.Delayed()...</code> as before. Code: /// <code> /// @Html.RenderDelayed(removeAfterRendering: false); /* will print */ /// @Html.RenderDelayed() /* will print again because not removed before */ /// </code> /// </example> /// </para> /// </summary> /// <param name="helper">the helper from which we use the context</param> /// <param name="injectionBlockId">optional unique identifier to specify one or many injection blocks</param> /// <param name="removeAfterRendering">only render this once</param> /// <returns>rendered output content</returns> public static MvcHtmlString RenderDelayed(this HtmlHelper helper, string injectionBlockId = null, bool removeAfterRendering = true) { var stack = DelayedInjectionBlock.GetQueue(helper, injectionBlockId); if( removeAfterRendering ) { var sb = new StringBuilder( #if DEBUG string.Format("<!-- delayed-block: {0} -->", injectionBlockId) #endif ); // .count faster than .any while (stack.Count > 0) { sb.AppendLine(stack.Dequeue()); } return MvcHtmlString.Create(sb.ToString()); } return MvcHtmlString.Create( #if DEBUG string.Format("<!-- delayed-block: {0} -->", injectionBlockId) + #endif string.Join(Environment.NewLine, stack)); } } 

मुझे इस समस्या थी और इस तकनीक का इस्तेमाल किया था

इसका सबसे अच्छा समाधान मैंने पाया जो बहुत लचीला है।

इसके अलावा कृपया संचयी अनुभाग घोषणापत्र के लिए समर्थन जोड़ने के लिए यहां वोट दें

विरोधाभासी सिद्धांत के बाद, सामग्री को सीधे स्क्रिप्ट अनुभाग में डालने के लिए "_mypartital" के लिए काफी आवश्यक नहीं है आप उन आंशिक दृश्य स्क्रिप्ट को अलग .js फ़ाइल में जोड़ सकते हैं और उन्हें माता-पिता के दृश्य से @ स्क्रिप्ट अनुभाग में संदर्भित कर सकते हैं।

अगर आपको कुछ js को partial से चलाने की वैध आवश्यकता है, तो यहां आप यह कैसे कर सकते हैं, jQuery की आवश्यकता है:

 <script type="text/javascript"> function scriptToExecute() { //The script you want to execute when page is ready. } function runWhenReady() { if (window.$) scriptToExecute(); else setTimeout(runWhenReady, 100); } runWhenReady(); </script> 

जिस तरह से हम वेब के बारे में सोचते हैं, विशेष रूप से MVC का उपयोग करते समय एक बुनियादी दोष है दोष यह है कि जावास्क्रिप्ट किसी तरह देखने की ज़िम्मेदारी है। एक दृश्य एक दृश्य है, जावास्क्रिप्ट (व्यवहार या अन्यथा) जावास्क्रिप्ट है सिल्वरलाइट और WPF के एमवीवीएम पैटर्न में हम "पहले देखें" या "मॉडल पहले" के साथ सामना कर रहे हैं। एमवीसी में हम हमेशा मॉडल के दृष्टिकोण से तर्क करने की कोशिश करते हैं और जावास्क्रिप्ट इस मॉडल का एक हिस्सा कई मायनों में है।

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

पहला समाधान जिसके बारे में मैं सोच सकता हूं, वह दृश्यों को संग्रहीत करने के लिए व्यूबैग का उपयोग करना है जो प्रदान किए जाने चाहिए।

अगर मैंने यह काम आंशिक नज़र से किया, तो मैंने कभी कोशिश नहीं की, लेकिन इसे इमो करना चाहिए।

आपको आंशिक दृश्य में वर्गों का उपयोग करने की आवश्यकता नहीं है।

अपने आंशिक दृश्य में शामिल करें यह jQuery लोड किए जाने के बाद फ़ंक्शन निष्पादित करता है। आप अपने कोड के लिए हालत खंड को बदल सकते हैं

 <script type="text/javascript"> var time = setInterval(function () { if (window.jQuery != undefined) { window.clearInterval(time); //Begin $(document).ready(function () { //.... }); //End }; }, 10); </script> 

जूलियो स्पडर

आंशिक दृश्यों में वर्गों को सम्मिलित करने का एक तरीका है, हालांकि यह सुंदर नहीं है आपको मूल दृश्य से दो चर तक पहुंच की आवश्यकता है। आपके आंशिक दृश्य के बहुत ही उद्देश्य के हिस्से से उस अनुभाग को बनाने के लिए, यह इन चर की आवश्यकता के लिए समझ में आता है

आंशिक दृश्य में एक अनुभाग सम्मिलित करना ऐसा दिखता है:

 @model KeyValuePair<WebPageBase, HtmlHelper> @{ Model.Key.DefineSection("SectionNameGoesHere", () => { Model.Value.ViewContext.Writer.Write("Test"); }); } 

और पृष्ठ में आंशिक दृश्य डालने में …

 @Html.Partial(new KeyValuePair<WebPageBase, HtmlHelper>(this, Html)) 

आप किसी भी वर्ग में किसी प्रोग्राम की सामग्री को परिभाषित करने के लिए इस तकनीक का उपयोग भी कर सकते हैं।

का आनंद लें!

आप इन विस्तार विधियों का उपयोग कर सकते हैं : (आंशिक WithScript.cs के रूप में सहेजें)

 namespace System.Web.Mvc.Html { public static class PartialWithScript { public static void RenderPartialWithScript(this HtmlHelper htmlHelper, string partialViewName) { if (htmlHelper.ViewBag.ScriptPartials == null) { htmlHelper.ViewBag.ScriptPartials = new List<string>(); } if (!htmlHelper.ViewBag.ScriptPartials.Contains(partialViewName)) { htmlHelper.ViewBag.ScriptPartials.Add(partialViewName); } htmlHelper.ViewBag.ScriptPartialHtml = true; htmlHelper.RenderPartial(partialViewName); } public static void RenderPartialScripts(this HtmlHelper htmlHelper) { if (htmlHelper.ViewBag.ScriptPartials != null) { htmlHelper.ViewBag.ScriptPartialHtml = false; foreach (string partial in htmlHelper.ViewBag.ScriptPartials) { htmlHelper.RenderPartial(partial); } } } } } 

इस तरह प्रयोग करें:

उदाहरण आंशिक: (_MyPartial.cshtml) यदि में एचटीएमएल रखो, और दूसरे में जे एस

 @if (ViewBag.ScriptPartialHtml ?? true) <p>I has htmls</p> } else { <script type="text/javascript"> alert('I has javascripts'); </script> } 

अपने _Layout.cshtml में, या जहाँ आप आंशिक रूप से लिपियों को प्रस्तुत करना चाहते हैं, उनमें से एक को निम्नलिखित (एक बार) रखें: यह इस स्थान पर वर्तमान पृष्ठ पर केवल सभी आंशिक जावास्क्रिप्ट प्रस्तुत करेगा।

 @{ Html.RenderPartialScripts(); } 

फिर अपने आंशिक उपयोग के लिए, बस ऐसा करें: यह इस स्थान पर केवल html को प्रस्तुत करेगा।

 @{Html.RenderPartialWithScript("~/Views/MyController/_MyPartial.cshtml");} 

यह मुझे एक ही फ़ाइल में आंशिक दृश्य के लिए जावास्क्रिप्ट और html को सह-पता लगाने की अनुमति देने के लिए काम करता है। समान आंशिक दृश्य फ़ाइल में html और संबंधित भाग को देखने के लिए सोचा प्रक्रिया के साथ मदद करता है।


देखें में जो आंशिक दृश्य का उपयोग करता है "_MyPartialView.cshtml"

 <div> @Html.Partial("_MyPartialView",< model for partial view>, new ViewDataDictionary { { "Region", "HTMLSection" } } }) </div> @section scripts{ @Html.Partial("_MyPartialView",<model for partial view>, new ViewDataDictionary { { "Region", "ScriptSection" } }) } 

आंशिक दृश्य फ़ाइल में

 @model SomeType @{ var region = ViewData["Region"] as string; } @if (region == "HTMLSection") { } @if (region == "ScriptSection") { <script type="text/javascript"> </script"> } 

मैंने इसे एक पूरी तरह से अलग मार्ग का हल किया है (क्योंकि मैं जल्दी में था और एक नया एचटीएमएल हेल्पर को लागू नहीं करना चाहता था):

मैंने अपने आंशिक दृश्य को एक बड़ा अगर- या बयान में लपेट लिया है:

 @if ((bool)ViewData["ShouldRenderScripts"] == true){ // Scripts }else{ // Html } 

फिर, मैंने एक कस्टम व्यूडेटा के साथ दो बार आंशिक कहा:

 @Html.Partial("MyPartialView", Model, new ViewDataDictionary { { "ShouldRenderScripts", false } }) @section scripts{ @Html.Partial("MyPartialView", Model, new ViewDataDictionary { { "ShouldRenderScripts", true } }) } 

मुझे एक ऐसी ही समस्या थी, जहां मेरे पास एक मास्टर पेज था:

 @section Scripts { <script> $(document).ready(function () { ... }); </script> } ... @Html.Partial("_Charts", Model) 

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

 @{ var partial = Html.Raw(Json.Encode(new { html = Html.Partial("_Charts", Model).ToString() })); } @section Scripts { <script> $(document).ready(function () { ... var partial = @partial; $('#partial').html(partial.html); }); </script> } <div id="partial"></div> 

खैर, मुझे लगता है कि अन्य पोस्टर ने आपको अपने आंशिक (सीधे 3 पार्टी एचटीएमएल हेल्पर्स का इस्तेमाल करके) एक सीडे को सीधे शामिल करने के साधन प्रदान किए हैं।

लेकिन, मुझे लगता है कि, अगर आपकी लिपि अपने आंशिक रूप से कसकर मिलती है, तो बस अपनी जावास्क्रिप्ट सीधे एक इनलाइन <script> टैग के अंदर अपने आंशिक रूप में डाल दीजिए और इसके साथ किया जाये (सिर्फ स्क्रिप्ट दोहराव का सावधान रहें, यदि आप आंशिक उपयोग करने का इरादा रखते हैं एकल दृश्य में एक से अधिक बार);

चुने हुए, आप अपने फ़ोल्डर / index.cshtml को एक मास्टरपेप के रूप में इस्तेमाल कर सकते हैं, फिर अनुभाग स्क्रिप्ट जोड़ सकते हैं। उसके बाद, आपके लेआउट में आपके पास:

 @RenderSection("scripts", required: false) 

और आपकी index.cshtml:

 @section scripts{ @Scripts.Render("~/Scripts/file.js") } 

और यह आपके सभी आंशिक दृश्यों पर कार्य करेगा। यह मेरे लिए काम करता है

प्लूटो का विचार अच्छे तरीके से है:

CustomWebViewPage.cs:

  public abstract class CustomWebViewPage<TModel> : WebViewPage<TModel> { public IHtmlString PartialWithScripts(string partialViewName, object model) { return Html.Partial(partialViewName: partialViewName, model: model, viewData: new ViewDataDictionary { ["view"] = this, ["html"] = Html }); } public void RenderScriptsInBasePage(HelperResult scripts) { var parentView = ViewBag.view as WebPageBase; var parentHtml = ViewBag.html as HtmlHelper; parentView.DefineSection("scripts", () => { parentHtml.ViewContext.Writer.Write(scripts.ToHtmlString()); }); } } 

दृश्य \ web.config:

 <pages pageBaseType="Web.Helpers.CustomWebViewPage"> 

राय:

 @PartialWithScripts("_BackendSearchForm") 

आंशिक (_BackendSearchForm.cshtml):

 @{ RenderScriptsInBasePage(scripts()); } @helper scripts() { <script> //code will be rendered in a "scripts" section of the Layout page </script> } 

लेआउट पृष्ठ:

 @RenderSection("scripts", required: false) 

मान लें कि आपके पास _contact.cshtml नाम का एक आंशिक दृश्य है, आपका संपर्क एक कानूनी (नाम) या भौतिक विषय (प्रथम नाम, अंतिम नाम) हो सकता है। आपके विचार को ध्यान में रखना चाहिए कि क्या प्रदान किया गया है और यह जावास्क्रिप्ट के साथ हासिल किया जा सकता है। इसलिए विलंबित रेंडरिंग और जे एस अंदर देखने की आवश्यकता हो सकती है।

एकमात्र तरीका मुझे लगता है, इसे कैसे खत्म किया जा सकता है, जब हम ऐसी UI चिंताओं को नियंत्रित करने का एक विनोदी तरीका बनाते हैं

यह भी ध्यान रखें कि एमवीसी 6 के पास एक तथाकथित दृश्य घटक होगा, यहां तक ​​कि एमवीसी वायदा के पास कुछ समान सामान था और टेलरिक भी ऐसी चीज़ों का समर्थन करता है …

मुझे इसके साथ इस समस्या का समाधान हुआ था:

 @section ***{ @RenderSection("****", required: false) } 

मुझे लगता है इंजेक्षन करने का एक बहुत ही अच्छा तरीका है