एक आंशिक से एक उस्तरा अनुभाग आबाद


102

ऐसा करने की कोशिश करने के लिए मेरी मुख्य प्रेरणा जावास्क्रिप्ट है जो केवल पृष्ठ के निचले भाग में आंशिक रूप से जावास्क्रिप्ट के बाकी हिस्सों के साथ आवश्यक है और पृष्ठ के मध्य में नहीं है जहां आंशिक प्रदान की गई है।

यहाँ एक सरल उदाहरण है कि मैं क्या करने की कोशिश कर रहा हूँ:

यहां बॉडी से ठीक पहले स्क्रिप्स सेक्शन वाला लेआउट है।

<!DOCTYPE html>
<html>
<head>
    <title>@ViewBag.Title</title>
    <link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css" />    
</head>

<body>
    @RenderBody()
    <script src="@Url.Content("~/Scripts/jquery-1.4.4.min.js")" type="text/javascript"></script>
    @RenderSection("Scripts", false)
</body>
</html>

इस लेआउट का उपयोग करके एक उदाहरण देखें।

<h2>This is the view</h2>

@{Html.RenderPartial("_Partial");}

@section Scripts {
<script type="text/javascript">
        alert("I'm a view.");
</script>
}

और यहाँ आंशिक दृश्य से प्रदान किया जा रहा है।

<p>This is the partial.</p>

@* this never makes it into the rendered page *@
@section Scripts {
<script type="text/javascript">
    alert("I'm a partial."); 
</script>
}

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


हो सकता है कि यह एक समस्या है क्योंकि आपके पास आंशिक रूप से एक और स्क्रिप्ट अनुभाग है .. IDK .. आपका कोड थोड़ा भ्रमित है ..
गिदोन

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

जवाबों:


78

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

यहाँ सहायक विधि हैं:

public static string RequireScript(this HtmlHelper html, string path, int priority = 1)
{
    var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as List<ResourceInclude>;
    if (requiredScripts == null) HttpContext.Current.Items["RequiredScripts"] = requiredScripts = new List<ResourceInclude>();
    if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceInclude() { Path = path, Priority = priority });
    return null;
}

public static HtmlString EmitRequiredScripts(this HtmlHelper html)
{
    var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as List<ResourceInclude>;
    if (requiredScripts == null) return null;
    StringBuilder sb = new StringBuilder();
    foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
    {
        sb.AppendFormat("<script src=\"{0}\" type=\"text/javascript\"></script>\n", item.Path);
    }
    return new HtmlString(sb.ToString());
}
public class ResourceInclude
{
    public string Path { get; set; }
    public int Priority { get; set; }
}

एक बार जब आप अपने आंशिक दृश्य को कॉल करने की आवश्यकता होती है @Html.RequireScript("/Path/To/Script")

और लेआउट दृश्य के प्रमुख अनुभाग में आप कॉल करते हैं @Html.EmitRequiredScripts()

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


सुरुचिपूर्ण और साफ समाधान। +1
bevacqua

मेरे बालों में से अधिकांश को बाहर निकालने के बाद बस इस समाधान में आया - उत्कृष्ट समाधान ....
हिग्गी

मुझे यह समाधान काम करने के लिए नहीं मिल रहा है। ऐसा लगता है कि EmitRequiredScripts () किसी भी आंशिक विचारों को कॉल करने के लिए आवश्यकताएँ () से पहले कॉल किया जाता है। क्या मुझसे कुछ गलत हो रही है?
ब्रायन रोथ 19

कुछ सही नहीं लगता है, ब्रायन। मैंने पिछले एक साल में इस समाधान का बड़े पैमाने पर उपयोग किया है और इसका अच्छा काम कर रहा है। हो सकता है कि अपनी समस्या के विवरण के साथ एक नया प्रश्न पोस्ट करें और यहां url लिंक करें
Mr Bell

1
क्या ऐप के नए संस्करण को तैनात करते समय इसका कोई कैश बस्टिंग समर्थन है? आउट-ऑफ-द-बॉक्स @ script.Render () विधि अंत में एक URL पैरामीटर चिपकाती है जो बिल्ड टाइम पर उत्पन्न होती है ताकि ब्राउज़र को नए संस्करण को तैनात करने पर नवीनतम संस्करण लाने के लिए मजबूर किया जाए।
साइमन ग्रीन

28

आंशिक विचार उनके माता-पिता के विचारों में भाग नहीं ले सकते।


1
यह मुझे संदेह है। धन्यवाद।
क्रेग एम

@JohnBubriski रेज़र 2 में है। प्रचलित के बारे में नहीं जानते। संस्करणों।
शिम्मी वेइटहैंडलर

@SLaks, यह डिज़ाइन द्वारा क्यों है? मेरे परिदृश्य में मेरे पास एक आंशिक हिस्सा है जो एक बैनर रोटेटर है, मैं चाहता हूं कि इसकी स्क्रिप्ट / शैली केवल तभी लोड हो जब यह चालू हो, इसे इनलाइन लोड करना क्यों बुरा है?
शिम्मी वेइटहैंडलर

2
@ शमी: आपको एक संसाधन प्रबंधन प्रणाली का उपयोग करना चाहिए, जैसे कि कैसेट।
SLACs 14

धन्यवाद। मैं इस पर गौर करूंगा।
शिम्मी वेइटहैंडलर

14

आपके पास एक दूसरा आंशिक हिस्सा हो सकता है जो केवल आवश्यक जावास्क्रिप्ट को इंजेक्ट करने के प्रभारी है। @ifयदि आप चाहें तो कई स्क्रिप्ट्स को ब्लॉक के आसपास रखें।

@model string
@if(Model == "bla") {
    <script type="text/javascript">...</script>
}

@else if(Model == "bli") {
    <script type="text/javascript">...</script>
}

यह स्पष्ट रूप से थोड़ा साफ किया जा सकता है, लेकिन फिर, Scriptsआपके विचार के अनुभाग में:

@section Scripts
{
    @Html.Partial("_Scripts", "ScriptName_For_Partial1")
}

फिर, यह एक सौंदर्य पुरस्कार नहीं जीत सकता है लेकिन यह काम करेगा।


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

@ क्रेगम वह है जहाँ मैं भी जा रहा हूँ। MVC वैध है, लेकिन यह टेम्पलेट क्लाइंट-साइड का उपयोग करने के लिए (मुझे) बहुत अधिक समझ में आता है (मैं Backbone.js में देख रहा हूं) और फिर एक एपीआई से पुश / पुल।
one.beat.consumer

@ one.beat.customer - मैं अंडरस्कोर के टेम्प्लेट का उपयोग कर रहा हूं क्योंकि मैं भी बैकबोन का उपयोग करता हूं, लेकिन मैं ट्विटर से होगन लाइब्रेरी या नॉडजित्सु से प्लेट्स पर स्विच करने के बारे में सोच रहा हूं। दोनों में बहुत अच्छी विशेषताएं हैं।
क्रेग एम

10

ऐसा करने का अधिक सुरुचिपूर्ण तरीका आंशिक दृश्य स्क्रिप्ट को अलग फ़ाइल में स्थानांतरित करना है और फिर इसे स्क्रिप्ट के दृश्य अनुभाग में प्रस्तुत करना है:

<h2>This is the view</h2>

@Html.RenderPartial("_Partial")

@section Scripts
{
    @Html.RenderPartial("_PartialScripts")

    <script type="text/javascript">
        alert("I'm a view script.");
    </script>
}

आंशिक दृश्य _ Partial.cshtml :

<p>This is the partial.</p>

आंशिक दृश्य _ PartialScripts.cshtml केवल लिपियों के साथ:

<script type="text/javascript">
    alert("I'm a partial script!");
</script>

यह अन्य उत्तरों में सुझाए गए कुछ विस्तार विधियों या प्लग-इन के रूप में स्वचालित नहीं है, लेकिन इसमें सरलता और स्पष्टता का लाभ है। यह इसे पसंद है।
मार्क मेउर

7

Forloop.HtmlHelpers nuget पैकेज स्थापित करें - यह आंशिक विचारों और संपादक टेम्प्लेट में स्क्रिप्ट प्रबंधित करने के लिए कुछ सहायक जोड़ता है।

कहीं आपके लेआउट में, आपको कॉल करने की आवश्यकता है

@Html.RenderScripts()

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

यदि आप बंडल के साथ वेब ऑप्टिमाइज़ेशन फ़्रेमवर्क का उपयोग कर रहे हैं, तो आप अधिभार का उपयोग कर सकते हैं

@Html.RenderScripts(Scripts.Render)

ताकि इस पद्धति का उपयोग स्क्रिप्ट फ़ाइलों को लिखने के लिए किया जाए।

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

@using (Html.BeginScriptContext())
{
  Html.AddScriptFile("~/Scripts/jquery.validate.js");
  Html.AddScriptBlock(
    @<script type="text/javascript">
       $(function() { $('#someField').datepicker(); });
     </script>
  );
}

मददगार सुनिश्चित करते हैं कि केवल एक स्क्रिप्ट फ़ाइल संदर्भ प्रदान किया जाता है अगर कई बार जोड़ा जाता है और यह भी सुनिश्चित करता है कि स्क्रिप्ट फ़ाइलों को एक अपेक्षित क्रम में प्रदान किया गया है अर्थात

  1. ख़ाका
  2. विभाजन और टेम्पलेट (जिस क्रम में वे दृश्य में दिखाई देते हैं, ऊपर से नीचे)

5

[अपडेट किया गया संस्करण] इनलाइन स्क्रिप्ट शामिल करने के लिए @Necrocubus प्रश्न के बाद अपडेट किया गया संस्करण।

public static class ScriptsExtensions
{
    const string REQ_SCRIPT = "RequiredScript";
    const string REQ_INLINESCRIPT = "RequiredInlineScript";
    const string REQ_STYLE = "RequiredStyle";

    #region Scripts
    /// <summary>
    /// Adds a script 
    /// </summary>
    /// <param name="html"></param>
    /// <param name="path"></param>
    /// <param name="priority">Ordered by decreasing priority </param>
    /// <param name="bottom"></param>
    /// <param name="options"></param>
    /// <returns></returns>
    public static string RequireScript(this IHtmlHelper html, string path, int priority = 1, bool bottom=false, params string[] options)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_SCRIPT] as List<ResourceToInclude>;
        if (requiredScripts == null) ctxt.Items[REQ_SCRIPT] = requiredScripts = new List<ResourceToInclude>();
        if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceToInclude() { Path = path, Priority = priority, Options = options, Type=ResourceType.Script, Bottom=bottom});
        return null;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="html"></param>
    /// <param name="script"></param>
    /// <param name="priority">Ordered by decreasing priority </param>
    /// <param name="bottom"></param>
    /// <returns></returns>
    public static string RequireInlineScript(this IHtmlHelper html, string script, int priority = 1, bool bottom = false)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_INLINESCRIPT] as List<InlineResource>;
        if (requiredScripts == null) ctxt.Items[REQ_INLINESCRIPT] = requiredScripts = new List<InlineResource>();
        requiredScripts.Add(new InlineResource() { Content=script, Priority = priority, Bottom=bottom, Type=ResourceType.Script});
        return null;
    }

    /// <summary>
    /// Just call @Html.EmitRequiredScripts(false)
    /// at the end of your head tag and 
    /// @Html.EmitRequiredScripts(true) at the end of the body if some scripts are set to be at the bottom.
    /// </summary>
    public static HtmlString EmitRequiredScripts(this IHtmlHelper html, bool bottom)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_SCRIPT] as List<ResourceToInclude>;
        var requiredInlineScripts = ctxt.Items[REQ_INLINESCRIPT] as List<InlineResource>;
        var scripts = new List<Resource>();
        scripts.AddRange(requiredScripts ?? new List<ResourceToInclude>());
        scripts.AddRange(requiredInlineScripts ?? new List<InlineResource>());
        if (scripts.Count==0) return null;
        StringBuilder sb = new StringBuilder();
        foreach (var item in scripts.Where(s=>s.Bottom==bottom).OrderByDescending(i => i.Priority))
        {
            sb.Append(item.ToString());
        }
        return new HtmlString(sb.ToString());
    }
    #endregion Scripts

    #region Styles
    /// <summary>
    /// 
    /// </summary>
    /// <param name="html"></param>
    /// <param name="path"></param>
    /// <param name="priority">Ordered by decreasing priority </param>
    /// <param name="options"></param>
    /// <returns></returns>
    public static string RequireStyle(this IHtmlHelper html, string path, int priority = 1, params string[] options)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_STYLE] as List<ResourceToInclude>;
        if (requiredScripts == null) ctxt.Items[REQ_STYLE] = requiredScripts = new List<ResourceToInclude>();
        if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceToInclude() { Path = path, Priority = priority, Options = options });
        return null;
    }

    /// <summary>
    /// Just call @Html.EmitRequiredStyles()
    /// at the end of your head tag
    /// </summary>
    public static HtmlString EmitRequiredStyles(this IHtmlHelper html)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_STYLE] as List<ResourceToInclude>;
        if (requiredScripts == null) return null;
        StringBuilder sb = new StringBuilder();
        foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
        {
            sb.Append(item.ToString());
        }
        return new HtmlString(sb.ToString());
    }
    #endregion Styles

    #region Models
    public class InlineResource : Resource
    {
        public string Content { get; set; }
        public override string ToString()
        {
            return "<script>"+Content+"</script>";
        }
    }

    public class ResourceToInclude : Resource
    {
        public string Path { get; set; }
        public string[] Options { get; set; }
        public override string ToString()
        {
            switch(Type)
            {
                case ResourceType.CSS:
                    if (Options == null || Options.Length == 0)
                        return String.Format("<link rel=\"stylesheet\" href=\"{0}\" type=\"text/css\" />\n", Path);
                    else
                        return String.Format("<link rel=\"stylesheet\" href=\"{0}\" type=\"text/css\" {1} />\n", Path, String.Join(" ", Options));
                default:
                case ResourceType.Script:
                    if (Options == null || Options.Length == 0)
                        return String.Format("<script src=\"{0}\" type=\"text/javascript\"></script>\n", Path);
                    else
                        return String.Format("<script src=\"{0}\" type=\"text/javascript\" {1}></script>\n", Path, String.Join(" ", Options));
            }
        }
    }
    public class Resource
    {
        public ResourceType Type { get; set; }
        public int Priority { get; set; }
        public bool Bottom { get; set; }
    }
    public enum ResourceType
    {
        Script,
        CSS
    }
    #endregion Models
}

मेरा 2 सेंट, यह एक पुरानी पोस्ट है, लेकिन अभी भी प्रासंगिक है, इसलिए यहां श्री बेल के समाधान का एक उन्नत अद्यतन है जो एएसपी .नेट कोर के साथ काम करता है।

यह आयातित आंशिक दृश्यों और साक्षात्कारों से मुख्य लेआउट में स्क्रिप्ट और शैलियों को जोड़ने की अनुमति देता है, और स्क्रिप्ट / शैली आयात (जैसे async defer आदि) के विकल्प जोड़ने की संभावना है:

public static class ScriptsExtensions
{
    const string REQ_SCRIPT = "RequiredScript";
    const string REQ_STYLE = "RequiredStyle";

    public static string RequireScript(this IHtmlHelper html, string path, int priority = 1, params string[] options)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_SCRIPT] as List<ResourceInclude>;
        if (requiredScripts == null) ctxt.Items[REQ_SCRIPT] = requiredScripts = new List<ResourceInclude>();
        if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceInclude() { Path = path, Priority = priority, Options = options });
        return null;
    }


    public static HtmlString EmitRequiredScripts(this IHtmlHelper html)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_SCRIPT] as List<ResourceInclude>;
        if (requiredScripts == null) return null;
        StringBuilder sb = new StringBuilder();
        foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
        {
            if (item.Options == null || item.Options.Length == 0)
                sb.AppendFormat("<script src=\"{0}\" type=\"text/javascript\"></script>\n", item.Path);
            else
                sb.AppendFormat("<script src=\"{0}\" type=\"text/javascript\" {1}></script>\n", item.Path, String.Join(" ", item.Options));

        }
        return new HtmlString(sb.ToString());
    }


    public static string RequireStyle(this IHtmlHelper html, string path, int priority = 1, params string[] options)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_STYLE] as List<ResourceInclude>;
        if (requiredScripts == null) ctxt.Items[REQ_STYLE] = requiredScripts = new List<ResourceInclude>();
        if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceInclude() { Path = path, Priority = priority, Options = options });
        return null;
    }


    public static HtmlString EmitRequiredStyles(this IHtmlHelper html)
    {
        var ctxt = html.ViewContext.HttpContext;

        var requiredScripts = ctxt.Items[REQ_STYLE] as List<ResourceInclude>;
        if (requiredScripts == null) return null;
        StringBuilder sb = new StringBuilder();
        foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
        {
            if (item.Options == null || item.Options.Length == 0)
                sb.AppendFormat("<link rel=\"stylesheet\" href=\"{0}\" type=\"text/css\" />\n", item.Path);
            else
                sb.AppendFormat("<link rel=\"stylesheet\" href=\"{0}\" type=\"text/css\" {1} />\n", item.Path, String.Join(" ", item.Options));
        }
        return new HtmlString(sb.ToString());
    }


    public class ResourceInclude
    {
        public string Path { get; set; }
        public int Priority { get; set; }
        public string[] Options { get; set; }
    }
}

श्रीमान धन्यवाद! इसे और अधिक अपग्रेड किया जाना चाहिए क्योंकि यह उत्तर की तुलना में अधिक प्रासंगिक है जो 6 साल पुराना है।
नेक्रोक्यूबस

इसके अलावा, क्या इन एक्सटेंशन को स्क्रिप्ट के अनुभागों को इनपुट करने की अनुमति देने के लिए संशोधित किया जा सकता है? @ <पाठ> </ पाठ> या कुछ अनुभागों की तरह? अन्यथा मुझे अभी भी सर्वर साइड मॉडल चर के साथ अन्य स्क्रिप्ट को आरंभीकृत करने के लिए एक छोटी सी जेएस स्क्रिप्ट की आवश्यकता है: /
नेक्रोकैबस

@Necroqubus आप अपडेट किए गए संस्करण की जांच कर सकते हैं, हालाँकि मैंने अभी तक इसका परीक्षण नहीं किया है :)
जीन

ठीक है, मैं कोशिश करूँगा और आपके लिए इसका परीक्षण करूँगा। मुझे आशा है कि यह ASP.NET Core 1.0 MVC के साथ काम करता है। संदर्भ के लिए मेरे पास नेस्टेड भाग के कई स्तर हैं और चाहते हैं कि उनकी स्क्रिप्ट पाद लेख पर प्रस्तुत की जाए।
नेक्रोक्युबस

जरूरत नहीं है <text>, बस इसे एक स्ट्रिंग के रूप में जोड़ें (यदि आप चाहें तो मल्टी लाइन के लिए आप अभी भी @ "के साथ उपसर्ग कर सकते हैं), और <script>टैग के बिना
जीन

1

आप एक नया Layoutपृष्ठ बना सकते हैं और पूर्ण दृश्य के अंदर आंशिक दृश्य लपेट सकते हैं जो सामग्री और किसी भी पुस्तकालय अनुभागों के प्रतिपादन के लिए जिम्मेदार है।

उदाहरण के लिए, मान लें कि मेरे पास निम्नलिखित कोड हैं:

HomeController.cs

[HttpGet]
public ActionResult About()
{
    var vm = new AboutViewModel();
    return View("About", vm);
}

जब पूर्ण पृष्ठ दृश्य प्रदान किया जाता है, तो यह आम तौर पर दो फ़ाइलों को मर्ज कर रहा है:

About.cshtml

@model AboutViewModel

@{
    ViewBag.Title = "About CSHN";
}

<h3>@ViewBag.Title</h3>

@section Styles {
    <style> /* style info here */ </style>
}

@section Scripts {
    <script> /* script info here */ </script>
}

_Layout.cshtml (या जो कुछ भी _ViewStart में निर्दिष्ट है या पृष्ठ में ओवरराइड है)

<!DOCTYPE html>

<html>
<head>
    @RenderSection("Styles", false)
    <title>@ViewBag.Title</title>
</head>
<body>
    @RenderBody()

    @RenderSection("scripts", false)
</body>
</html>

अब , मान लें कि आप आंशिक दृश्य केAbout.cshtml रूप में रेंडर करना चाहते थे , शायद AJAX कॉल के जवाब में मोडल विंडो के रूप में। यहाँ लक्ष्य केवल पृष्ठ, स्क्रिप्ट और सभी में निर्दिष्ट सामग्री को वापस करने के लिए है, मास्टर लेआउट में शामिल सभी ब्लोट के बिना (पूर्ण दस्तावेज़ की तरह )।_Layout.cshtml<html>

आप इसे इस तरह आज़मा सकते हैं, लेकिन यह किसी खंड खंड के साथ नहीं आएगा:

return PartialView("About", vm);

इसके बजाय, इस तरह एक सरल लेआउट पेज जोड़ें:

_PartialLayout.cshtml

<div>
    @RenderBody()
    @RenderSection("Styles", false)
    @RenderSection("scripts", false)
</div>

या इस तरह एक मोडल विंडो का समर्थन करने के लिए:

_ModalLayout.cshtml

<div class="modal modal-page fade" tabindex="-1" role="dialog" >
    <div class="modal-dialog modal-lg" role="document">
        <div class="modal-content">

            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
                <h4 class="modal-title">@ViewBag.Title</h4>
            </div>

            <div class="modal-body">

                @RenderBody()
                @RenderSection("Styles", false)
                @RenderSection("scripts", false)

            </div>
            <div class="modal-footer">
                <button type="button" class="btn btn-inverse" data-dismiss="modal">Dismiss</button>
            </div>
        </div>
    </div>
</div>

फिर आप इस नियंत्रक या किसी अन्य हैंडलर में एक कस्टम मास्टर दृश्य निर्दिष्ट कर सकते हैं जिसे आप एक साथ एक दृश्य की सामग्री और स्क्रिप्ट को प्रस्तुत करना चाहते हैं

[HttpGet]
public ActionResult About()
{
    var vm = new AboutViewModel();
    return !Request.IsAjaxRequest()
              ? View("About", vm)
              : View("About", "~/Views/Shared/_ModalLayout.cshtml", vm);
}

1

एस्पनेट कोर 2.0 संस्करण की तलाश करने वालों के लिए:

    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.AspNetCore.Html;
    using Microsoft.AspNetCore.Http;

    public static class HttpContextAccessorExtensions
    {
        public static string RequireScript(this IHttpContextAccessor htmlContextAccessor, string path, int priority = 1)
        {
            var requiredScripts = htmlContextAccessor.HttpContext.Items["RequiredScripts"] as List<ResourceInclude>;
            if (requiredScripts == null) htmlContextAccessor.HttpContext.Items["RequiredScripts"] = requiredScripts = new List<ResourceInclude>();
            if (requiredScripts.All(i => i.Path != path)) requiredScripts.Add(new ResourceInclude() { Path = path, Priority = priority });
            return null;
        }

        public static HtmlString EmitRequiredScripts(this IHttpContextAccessor htmlContextAccessor)
        {
            var requiredScripts = htmlContextAccessor.HttpContext.Items["RequiredScripts"] as List<ResourceInclude>;
            if (requiredScripts == null) return null;
            StringBuilder sb = new StringBuilder();
            foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
            {
                sb.AppendFormat("<script src=\"{0}\" type=\"text/javascript\"></script>\n", item.Path);
            }
            return new HtmlString(sb.ToString());
        }
        public class ResourceInclude
        {
            public string Path { get; set; }
            public int Priority { get; set; }
        }
    }

स्क्रिप्ट को सेक्शन कॉल रेंडर करने के बाद अपने लेआउट में जोड़ें:

@HttpContextAccessor.EmitRequiredScripts()

और आपके आंशिक दृश्य में:

@inject IHttpContextAccessor HttpContextAccessor

...

@HttpContextAccessor.RequireScript("/scripts/moment.min.js")

0

ऊपर श्री बेल और शिम्मी के जवाब के आधार पर, मैं बंडल स्क्रिप्ट के लिए अतिरिक्त फ़ंक्शन पर जोड़ता हूं।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.Web.Mvc;
namespace ABC.Utility
{
public static  class PartialViewHelper
{
    public static string RequireScript(this HtmlHelper html, string path, int priority = 1)
    {
        var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as List<ResourceInclude>;
        if (requiredScripts == null) HttpContext.Current.Items["RequiredScripts"] = requiredScripts = new List<ResourceInclude>();
        if (!requiredScripts.Any(i => i.Path == path)) requiredScripts.Add(new ResourceInclude() { Path = path, Priority = priority });
        return null;
    }

    public static string RequireBundleStyles(this HtmlHelper html, string bundleName)
    {
        var a = System.Web.Optimization.Styles.Render(bundleName);
        var requiredStyles = HttpContext.Current.Items["RequiredStyles"] as IHtmlString;
        if (requiredStyles == null) HttpContext.Current.Items["RequiredStyles"] = requiredStyles = a;
        return null;
    }

    public static string RequireBundleScripts(this HtmlHelper html, string bundleName)
    {
        var a=System.Web.Optimization.Scripts.Render(bundleName);
        var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as IHtmlString;
        if (requiredScripts == null) HttpContext.Current.Items["RequiredScripts"] = requiredScripts = a;
        return null;
    }

    public static HtmlString EmitRequiredBundleStyles(this HtmlHelper html)
    {
        var requiredStyles = HttpContext.Current.Items["RequiredStyles"] as IHtmlString;
        if (requiredStyles == null) return null;
        return MvcHtmlString.Create(requiredStyles.ToHtmlString()) ;
    }

    public static HtmlString EmitRequiredBundleScripts(this HtmlHelper html)
    {
        var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as IHtmlString;
        if (requiredScripts == null) return null;
        return MvcHtmlString.Create(requiredScripts.ToHtmlString());
    }

    public static HtmlString EmitRequiredScripts(this HtmlHelper html)
    {
        var requiredScripts = HttpContext.Current.Items["RequiredScripts"] as List<ResourceInclude>;
        if (requiredScripts == null) return null;
        StringBuilder sb = new StringBuilder();
        foreach (var item in requiredScripts.OrderByDescending(i => i.Priority))
        {
            sb.AppendFormat("<script src=\"{0}\" type=\"text/javascript\"></script>\n", item.Path);
        }
        return new HtmlString(sb.ToString());
    }
    public class ResourceInclude
    {
        public string Path { get; set; }
        public int Priority { get; set; }
    }
}//end class
}// end namespace  

आंशिक दृश्य पर नमूना: - @ Html.RequireBundleStyles ("~ / बंडल / फाइलअपलोड / बूटस्ट्रैप / BasicPlusUI / css"); @ Html.RequireBundleScripts ( "~ / बंडलों / fileupload / बूटस्ट्रैप / BasicPlusUI / js");

मास्टरपेज पर नमूना: - @ Html.EmitRequiredBundleStyles ()


0

पृष्ठ में बाद में किसी भी सामग्री (स्क्रिप्ट या सिर्फ HTML) को प्रस्तुत करने के लिए @using(Html.Delayed()){ ...your content... }उत्तर https://stackoverflow.com/a/18790222/1037948 से एक्सटेंशन का उपयोग करें । आंतरिक Queueको सही क्रम सुनिश्चित करना चाहिए।


0

यह कार्यक्षमता क्लाइंटडिपेंडेंसी में भी लागू होती है। Core.Mvc.dll। यह html हेल्पर्स प्रदान करता है: @ Html.RequiresJs और @ Html.RenderJsHere ()। Nuget पैकेज: ClientD dependency-Mvc


0

यहाँ अक्सर पूछे जाने वाले प्रश्नों के लिए मेरा समाधान "कैसे आंशिक विचारों से मुख्य विचारों या asp.net mvc के लिए मुख्य लेआउट दृश्य को इंजेक्ट करें?"। यदि आप "अनुभाग + आंशिक" कीवर्ड द्वारा स्टैकओवरफ़्लो पर खोज करते हैं, तो आपको संबंधित प्रश्नों की एक बड़ी सूची मिलेगी, और दिए गए उत्तर भी मिलेंगे, लेकिन उनमें से कोई भी रेजर इंजन व्याकरण के माध्यम से मेरे लिए सुरुचिपूर्ण नहीं लगता है। इसलिए मैं सिर्फ रेजर इंजन को देखता हूं कि क्या इस सवाल का कोई बेहतर समाधान हो सकता है।

सौभाग्य से, मैंने पाया कि यह मेरे लिए दिलचस्प है कि रेज़र इंजन व्यू टेम्प्लेट फ़ाइल (* .cshtml, * .vbhtml) के लिए संकलन कैसे करता है। (मैं बाद में समझाऊंगा), नीचे दिए गए समाधान का मेरा कोड है जो मुझे लगता है कि उपयोग में काफी सरल और सुरुचिपूर्ण है।

namespace System.Web.Mvc.Html
{
    public static class HtmlHelperExtensions
    {
        /// <summary>
        /// 确保所有视图,包括分部视图(PartialView)中的节(Section)定义被按照先后顺序追加到最终文档输出流中
        /// </summary>
        public static MvcHtmlString EnsureSection(this HtmlHelper helper)
        {
            var wp = (WebViewPage)helper.ViewDataContainer;
            Dictionary<string, WebPages.SectionWriter> sw = (Dictionary<string, WebPages.SectionWriter>)typeof(WebPages.WebPageBase).GetProperty("SectionWriters", Reflection.BindingFlags.NonPublic | Reflection.BindingFlags.Instance).GetValue(wp);
            if (!helper.ViewContext.HttpContext.Items.Contains("SectionWriter"))
            {
                Dictionary<string, Stack<WebPages.SectionWriter>> qss = new Dictionary<string, Stack<WebPages.SectionWriter>>();
                helper.ViewContext.HttpContext.Items["SectionWriter"] = qss;
            }
            var eqs = (Dictionary<string, Stack<WebPages.SectionWriter>>)helper.ViewContext.HttpContext.Items["SectionWriter"];
            foreach (var kp in sw)
            {
                if (!eqs.ContainsKey(kp.Key)) eqs[kp.Key] = new Stack<WebPages.SectionWriter>();
                eqs[kp.Key].Push(kp.Value);
            }
            return MvcHtmlString.Create("");
        }

        /// <summary>
        /// 在文档流中渲染指定的节(Section)
        /// </summary>
        public static MvcHtmlString RenderSectionEx(this HtmlHelper helper, string section, bool required = false)
        {
            if (helper.ViewContext.HttpContext.Items.Contains("SectionWriter"))
            {
                Dictionary<string, Stack<WebPages.SectionWriter>> qss = (Dictionary<string, Stack<WebPages.SectionWriter>>)helper.ViewContext.HttpContext.Items["SectionWriter"];
                if (qss.ContainsKey(section))
                {
                    var wp = (WebViewPage)helper.ViewDataContainer;
                    var qs = qss[section];
                    while (qs.Count > 0)
                    {
                        var sw = qs.Pop();
                        var os = ((WebViewPage)sw.Target).OutputStack;
                        if (os.Count == 0) os.Push(wp.Output);
                        sw.Invoke();
                    }
                }
                else if (!qss.ContainsKey(section) && required)
                {
                    throw new Exception(string.Format("'{0}' section is not defined.", section));
                }
            }
            return MvcHtmlString.Create("");
        }
    }
}

उपयोग : कोड का उपयोग करने के लिए भी काफी सरल है, और यह हमेशा की तरह एक ही शैली दिखता है। यह नेस्टेड आंशिक विचारों के लिए किसी भी स्तर का समर्थन करता है। अर्थात। मेरे पास एक दृश्य टेम्पलेट श्रृंखला है: _ViewStart.cshtml-> Layout.cshtml-> index.cshtml -> [head.cshtml, foot.cshtml] -> ad.cshtml।

Layout.cshtml में, हमारे पास:

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>@ViewBag.Title - @ViewBag.WebSetting.Site.WebName</title>
    <base href="@ViewBag.Template/" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta http-equiv="Cache-Control" content="no-siteapp" />
    <meta name="viewport" content="width=device-width, initial-scale=1,maximum-scale=1.0, user-scalable=0,user-scalable=no">
    <meta name="format-detection" content="telephone=no">
    <meta name="renderer" content="webkit">
    <meta name="author" content="Taro Technology Co.,LTD" />
    <meta name="robots" content="index,follow" />
    <meta name="description" content="" />
    <meta name="keywords" content="" />
    <link rel="alternate icon" type="@ViewBag.WebSetting.Site.WebFavIcon" href="@ViewBag.WebSetting.Site.WebFavIcon">
    @Html.RenderSectionEx("Head")
</head>
<body>
    @RenderBody()
    @Html.RenderSectionEx("Foot")
</body>
</html>

और index.cshtml में, हमारे पास:

@{
    ViewBag.Title = "首页";
}

@Html.Partial("head")
<div class="am-container-1">
    .......
</div>
@Html.Partial("foot")

और सिर में .shtml, हम कोड होगा:

@section Head{
    <link rel="stylesheet" href="assets/css/amazeui.css" />
    <link rel="stylesheet" href="assets/css/style.css" />
}

<header class="header">
   ......
</header>
@Html.EnsureSection()

यह foot.cshtml या ad.cshtml में समान है, आप अभी भी उनमें हेड या फुट सेक्शन को परिभाषित कर सकते हैं, आंशिक व्यू फ़ाइल के अंत में एक बार @ Html.EnsureSection () कॉल करना सुनिश्चित करें। यह सब तुम एस्प mvc में विषय के मुद्दे से छुटकारा पाने की जरूरत है।

मैं सिर्फ अपना कोड स्निपेट साझा करता हूं ताकि अन्य लोग इसका उपयोग कर सकें। यदि आपको लगता है कि यह उपयोगी है, तो कृपया मेरी पोस्ट को रेट करने में संकोच न करें। :)

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.