You can create a new `Layout` page and wrap the PartialView inside of a Full View that is responsible for rendering the contents and also any library sections.

For example, let's say I have the following code:

**`HomeController.cs`**



    [HttpGet]
    public ActionResult About()
    {
        var vm = new AboutViewModel();
        return View("About", vm);
    }

When the Full Page view is rendered, it's typically renderedby merging two files:

**`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`** <sup>(or whatever is specified in _ViewStart or overridden in the page)</sup>



    <!DOCTYPE html>
    
    <html>
    <head>
        @RenderSection("Styles", false)
        <title>@ViewBag.Title</title>
    </head>
    <body>
        @RenderBody()
    
        @RenderSection("scripts", false)
    </body>
    </html>

-----

**Now**, suppose you wanted to Render **`About.cshtml`** as a **Partial View**, perhaps as modal window in response to AJAX call. The goal here being to return only the content specified in the about page, scripts and all, without all the bloat included in the `_Layout.cshtml` master layout (like a full `<html>` document).

You might try it like this, but it won't come with any of the section blocks:



   

    return PartialView("About", vm);

Instead, add a simpler layout page like this:

**`_PartialLayout.cshtml`**

  

    <div>
        @RenderBody()
        @RenderSection("Styles", false)
        @RenderSection("scripts", false)
    </div>

Or to support a modal window like this: 

**`_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>

Then you can [specify a custom Master View][1] in this controller or any other handler that you want to render the contents and scripts of a view simultaneously

    

    [HttpGet]
    public ActionResult About()
    {
        var vm = new AboutViewModel();
        return !Request.IsAjaxRequest()
                  ? View("About", vm)
                  : View("About", "~/Views/Shared/_ModalLayout.cshtml", vm);
    }




[1]: https://stackoverflow.com/a/5161384/1366033

My main motivation for trying to do this is to get Javascript that is only required by a partial at the bottom of the page with the rest of the Javascript and not in the middle of the page where the partial is rendered. 

Here's a simplified example of what I'm trying to do:

Here is the layout with a Scripts section right before the body.

    <!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>

Here's an example view using this layout. 

    <h2>This is the view</h2>
    
    @{Html.RenderPartial("_Partial");}
    
    @section Scripts {
    <script type="text/javascript">
            alert("I'm a view.");
    </script>
    }

And here's the partial being rendered from the view.

    <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>
    }

In this example, the markup specified in the view is placed into the section, but the markup from the partial is not. Is it possible to populate a section from a partial view with Razor? If not, what are some other methods of getting Javascript that's only needed by partials at the bottom of the page without including it globally?

Populate a Razor Section From a Partial

This is exactly what the `NullDisplayText` property on [`[DisplayFormat]` attribute][1] is for.

Add this directly on your model:



    [DisplayFormat(NullDisplayText="", ApplyFormatInEditMode=true)]
    public string EMail { get; set; }

[1]:https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.displayformatattribute.aspx "System.ComponentModel.DataAnnotations.DisplayFormatAttribute"

I have a razor template like below. I want to check if the value in the input field is null, put a empty string, if the `@UIManager.Member.EMail` has a value, put its value. How can I do that?

Normal Input:



    <input name="EMail" id="SignUpEMail" type="text" class="Input" 
           value="@UIManager.Member.EMail" validate="RequiredField" />


Razor Syntax Attempt:



    <input name="EMail" id="SignUpEMail" type="text" class="Input" validate="RequiredField"
           value="@(UIManager.Member == null) ? string.Empty : UIManager.Member.EMail" />


The value is shown in the input field is:

    True ? string.Empty : UIBusinessManager.MemberCandidate.EMail

If value is null put an empty string on razor template?

For **multi-line support**, as pointed out in [Using in Razor VB.net MVC not work as expected](https://stackoverflow.com/q/16414271/1366033), you can use `@<text>...</text>` to switch back to "text mode" and output html like this:



    @Using Html.BeginForm("Action", "Controller")
        @<text>
          <fieldset>
            * Other form code and values *
          </fieldset>
        </text>
    End Using

related: https://stackoverflow.com/questions/4990717/mvc3-razor-using-html-beginform-problem

When I make an HTML form for MVC 3/VB with the Razor engine, I would expect to be able to do it like this:

    @Using Html.BeginForm("Action", "Controller")
        <fieldset>
            @* Other form code and values *@
        </fieldset>
    End Using

But if I do that I get "BC32035: Attribute specifier is not a complete statement. Use a line continuation to apply the attribute to the following statement."  I need to add an @ character before the opening <fieldset> tag to avoid this error.  Can someone explain why?

Why does normal markup inside an @Using Html.BeginForm need an @?

Just to clarify the solution for other people hitting this question. The ajax helper fires `OnSuccess` vs `OnFailure` based on the returned HTTP Code per the [`AjaxOptions` docs][1]:

> [`OnSuccess`][2]: This function is called if the response status **is** in the 200 range.  
> [`OnFailure`][3]: This function is called if the response status **is not** in the 200 range.

In other words, you have to manually specify that there was a failure when returning your ActionResult by changing the `Response.StatusCode` and then returning whatever values you're expecting in your `OnFailure` js method.  You can drive that based on any business logic you want (i.e. `catch Exception ex)` or `!ModelState.IsValid` ...)

    [HttpPost]
    public ActionResult Search(Person model) 
    {
      if (ModelState.IsValid) {
        // if valid, return a HTML view inserted by AJAX helper
        var results = PersonRepository.Get(model)
        return PartialView("Resulsts", vm);
        
      } else {
      	// if invalid, return a JSON object and handle with OnFailure method
        Response.StatusCode = (int)HttpStatusCode.BadRequest;
        return Json(new { errors = ModelState.Values.SelectMany(v => v.Errors) });
    
      }
    }


**Further Reading**: 

* [MVC 4 Ajax.BeginForm and ModelState.AddModelError][4]
* [ASP.NET MVC “Ajax.BeginForm” executes OnSuccess even though model is not valid][5]


[1]: https://msdn.microsoft.com/en-us/library/system.web.mvc.ajax.ajaxoptions.aspx
[2]: https://msdn.microsoft.com/en-us/library/system.web.mvc.ajax.ajaxoptions.onsuccess.aspx
[3]: https://msdn.microsoft.com/en-us/library/system.web.mvc.ajax.ajaxoptions.onfailure.aspx
[4]: https://stackoverflow.com/q/21311026/1366033
[5]: https://stackoverflow.com/q/7328977/1366033

I'm trying to get errors to show up after an ajax submit has returned an error. I'm not sure what I'm missing, but I can't get it to work. This question is basically the same thing - https://stackoverflow.com/questions/10406998/modelstate-addmodelerror-is-not-being-displayed-inside-my-view but I'm still not having any luck. My experience with Ajax and MVC (any version) is still a bit limited. Here is a very simple example, most of which I took from the previous link. 

View: test.cshtml

    @model TestProject.VisitLabResult

    @Scripts.Render("~/Scripts/jquery.unobtrusive-ajax.min.js")
    @Scripts.Render("~/Scripts/ckeditor/ckeditor.js")

    @{
        AjaxOptions ajaxOpts = new AjaxOptions
        {
            Url = Url.Action("test"),
            HttpMethod = "Post",
            LoadingElementId = "loading",
            LoadingElementDuration = 500,
            OnSuccess = "processData"
        };
    }
    @Html.ValidationMessage("CustomError")


    <div id="loading" class="load" style="display:none">
        <p>Saving...</p>
    </div>

    <table>
    @for (int item = 0; item < 10; item++)
    {
        <tr id = @item>
        @using (Ajax.BeginForm(ajaxOpts))
        {  
            @Html.ValidationSummary(true)

            @Html.AntiForgeryToken()
        
            <td>
                <input type="submit" value="Create" />
            </td>

            <td id = @(item.ToString() + "td")>
            </td>
        }
        </tr>
        }
    </table>

Controller: HomeController.cs

    public ActionResult test()
    {
        return View();
    }
    [HttpPost]
    [ValidateAntiForgeryToken]
    public ActionResult test(VisitLabResult vlr, int visitid = 28)
    {
        try
        {
            if (ModelState.IsValid)
            {
                if (Request.IsAjaxRequest())
                {
                    throw new Exception("error");
                }
                else
                    return View(vlr);
            }
            else
                return View(vlr);
        }
        catch (Exception ex)
        {
            ModelState.AddModelError("CustomError", "The Same test Type might have been already created, go back to the Visit page to see the available Lab Tests");
            return View(vlr);
        }
    }

Model 

    public class VisitLabResult
    {
        public int visitid { get; set; }
    }


If it is an Ajax request I throw an error and it's caught and an error is added to ModelState. That error never shows up on the page though. Am I approaching this the right way at all? Or do I need to take a different route? I appreciate any help.

MVC 4 Ajax.BeginForm and ModelState.AddModelError

If you look at the Description for the [`ShortName` property][1] on the [`Display` Attribute][2] you'll see that it has a pretty limited scope out of the box:

![Short Name Description][3]

Of course, that doesn't limit you from leveraging that value on your Model Metadata, but there aren't any native helpers that do so.

[Starting with MVC 2][4], [`ModelMetadata`][5] provides two methods to access the underlying data: `FromStringExpression` and `FromLambdaExpression`, so you don't really need to start from scratch in writing your own helper or extension method.

If you *hate* writing HTML helper methods, you can do this all inline:



    @ModelMetadata.FromLambdaExpression<RegisterModel, string>( 
                model => model.TransferDate, ViewData).ShortDisplayName} )  

But it's also perfectly valid to add an extension method for consistency of access, deduplication of code, and improved error handling


    
    public static class MvcHtmlHelpers
    {
       public static MvcHtmlString ShortNameFor<TModel, TValue>(this HtmlHelper<TModel> self, 
               Expression<Func<TModel, TValue>> expression)
       {
           var metadata = ModelMetadata.FromLambdaExpression(expression, self.ViewData);
           var name = metadata.ShortDisplayName ?? metadata.DisplayName ?? metadata.PropertyName;
    
           return MvcHtmlString.Create(string.Format(@"<span>{0}</span>", name));
       }
    }

And then use like any other helper method:



    @Html.ShortNameFor(model => model.TransferDate)




**Further Reading**:

* [How do I display the DisplayAttribute.Description attribute value?][9]
* MVC has long subsisted on custom extension methods, like [needing DisplayNameFor before it was added in MVC 4][6]  
* See this question for a quick [breakdown of the differences between `[Display(name="")]` vs. `[DisplayName("")]` attributes][7]  
* See this answer for [working with ASP.NET MVC 6 / Core 1][8]

[1]: https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.displayattribute.shortname.aspx
[2]:https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.displayattribute.aspx "System.ComponentModel.DataAnnotations.DisplayAttribute"
[3]: http://i.stack.imgur.com/PwPkI.png
[4]: http://bradwilson.typepad.com/blog/2009/10/aspnet-mvc-2-templates-part-2-modelmetadata.html
[5]: https://msdn.microsoft.com/en-us/library/system.web.mvc.modelmetadata.aspx "System.Web.Mvc.ModelMetadata"
[6]: https://stackoverflow.com/q/3885796/1366033
[7]: https://stackoverflow.com/q/5243665/1366033
[8]: https://stackoverflow.com/a/35294035/1366033
[9]: https://stackoverflow.com/a/6578828/1366033

Name attribute works proper, but ShortName doesn't work. 

    [Display(Name = "Date of the transfer the task", ShortName = "Trans date")]
    public DateTime TransferDate { get; set; }

Even when I delete Name attribute, ShortName is ignored ("TransferDate" displays in the column header).

In the view I do this:

    @Html.DisplayNameFor(model => model.TransferDate)



ShortName in the Display attribute (DataAnnotations)

All unobtrusive validation (the kind used by ASP.NET MVC) is predicated on finding and parsing `data` attributes on each object.  Those carry all the information that the validation engine needs to run and only elements that have `data-val="true"` are included.  

Any HTML attributes you pass will override any of the default attributes, so the easiest way is to just force `data-val="false"` and the form element won't be included in the validation engine and none of the other dependent tags will be parsed.

Here's an example from [ASP .NET MVC Disable Client Side Validation at Per-Field Level][1]:



    @Html.TextBoxFor(m => m.BatchId, new { data_val = "false" })

[1]: https://stackoverflow.com/a/24264780/1366033

I've read around that the given way of doing this seems to be having different view models (which is a bit overkill imo) for different actions/controllers.

I thought 

    @Html.EditorFor(model => model.Ingredient.Name, new { htmlAttributes = new { @class = "form-control", disabled = "disabled", data_val = "false"} })

 might work but unfortunately not.

Does anyone have any ideas?

Disable Validation on a single (disabled) @Html.EditorFor

You can use the `GetUnobtrusiveValidationAttributes()` method of `HtmlHelper` to get the validation attributes associated with a specific property.

For example in the view

    @{ var attributes = Html.GetUnobtrusiveValidationAttributes("QuestionTwo"); }

    <input 
        type="textbox"
        @foreach(var attr in attributes)
        {
            @:@attr.Key="@attr.Value"
        }
        id="@Html.IdFor(m => m.QuestionTwo)"
        ....
    />

Note the `@:@attr.Key="@attr.Value"` line will give a warning (_Missing attribute name_) but will run correctly

Alternatively, you could use javaScript/jQuery to add the attributes

	<script type="text/javascript">
		var attributes = @Html.Raw(Json.Encode(attributes));
		var input = $('#QuestionTwo');
		for(var i in attributes) {
        	input.attr(i, attributes[i]);
    	}
	</script>

I have forked the [DotNetFiddle here](https://dotnetfiddle.net/e2WnPl) to show the working code for both options.

While the above code shows how it can be done, you should not be doing that. The `HtmlHelper` methods execute a lot of code your ignoring to ensure correct 2-way model binding, for example, the `value` attribute is determined by first checking for a value in `ModelState`, then in the `ViewDataDictionary`, and only if the previous values do not exist, does it use the value of the property (the second part of [TextBoxFor displaying initial value, not the value updated from code](https://stackoverflow.com/questions/26654862/textboxfor-displaying-initial-value-not-the-value-updated-from-code/26664111#26664111) explains the behavior).

Except for the incorrect `value` attribute, the code you have shown for the `<input>` is the same as will be generated by simply using `@Html.TextBoxFor(m => m.Question2)`. I assume your real case is different, but if you cannot make use of `TextBoxFor()` and using an overload that accepts `htmlAttributes` to generate the html you need, then the correct approach is to create your own `HtmlHelper` method (and making use of existing methods in the `HtmlHelper` class and `System.Web.Mvc.Html` namespace)



When using any of the [Input Extension Helper Methods][1], like [`@Html.TextboxFor`][2], any [Validation Attributes][3] from your model are automatically generated by the Razor engine (via [`ClientValidationEnabled`][4]/[`UnobtrusiveJavaScriptEnabled`][5]).

For example, take the following case which works fine

**Model**:



    [Required]
    public string QuestionOne { get; set; }

**View**:



    @Html.TextBoxFor(model => model.QuestionOne) 
    @Html.ValidationMessageFor(model => model.QuestionOne)

**Generated Markup**:



	<input type="text" id="QuestionOne" name="QuestionOne" value=""
           data-val="true" data-val-required="The QuestionOne field is required." > 
	<span class="field-validation-valid" data-valmsg-for="QuestionOne" data-valmsg-replace="true"></span>

In this case the attributes `data-val="true"` & `data-val-required="The QuestionOne field is required."` are picked up by Unobtrusive validation and the form element is successfully validated.


---

**However**, for extensibility reasons, I want to be able to generate the `<input>` element myself instead of using `TextBoxFor`.  So my view would now look like this:



    <input type="textbox" 
		   id="@Html.IdFor(m => m.QuestionTwo)"
		   name="@Html.NameFor(m => m.QuestionTwo)" 
		   value="@Model.QuestionTwo"
		   data-val="true" data-val-required="Selection is Required" />
	
	@Html.ValidationMessageFor(model => model.QuestionTwo)

In this case, I'm faking the validation attribute output by just re-writing `data-val="true" (etc)` by hand, but this would have to be expanded to cover every single case.

### [Here's a running Demo in .NET Fiddle][6]


**Q: Can I build /return a list of `data-val-*` attributes for a given element?**

[1]: https://msdn.microsoft.com/en-us/library/system.web.mvc.html.inputextensions "System.Web.MVC.Html.InputExtensions"
[2]: https://msdn.microsoft.com/en-us/library/system.web.mvc.html.inputextensions.textboxfor "System.Web.MVC.Html.InputExtensions.TextboxFor"
[3]: https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.validationattribute "System.ComponentModel.DataAnnotations.ValidationAttribute"
[4]:https://msdn.microsoft.com/en-us/library/system.web.mvc.viewcontext.clientvalidationenabled "System.Web.MVC.ViewContext.ClientValidationEnabled"
[5]: https://msdn.microsoft.com/en-us/library/system.web.mvc.viewcontext.unobtrusivejavascriptenabled "System.Web.MVC.CiewContext.UnobtrusiveJavaScriptEnabled"
[6]: https://dotnetfiddle.net/4U6pIO

Build list of data validation attributes for a given element

The `Selected` property **is** being set by the `SelectList` constructor. The image you have shown is for the `items` argument (i.e the collection of `SelectListItem` that you passing to the method), not the result of calling the method.

The constructor does not modify the collection passed to it, it creates a new `IEnumerable<SelectListItem>`, and if you inspect the value of `var x`, then you will see that the 2nd `SelectListItem` (the one with `Value = "2"`) will have its `Selected` property set to `true`.

However, the purpose of the `SelectListItem` class is for use in one of the `HtmlHelper` methods that generates a `<select>` (`DropDownList()`, `DropDownListFor()`, `ListBox()` and `ListBoxFor()` methods) which accept an `IEnumerable<SelectListItem>` as either the 1st or 2nd argument.

Unless you specifically not binding to a model property (e.g. `@Html.DropDownList("NotAModelProperty", Model.YourSelectList)`), then setting the `Selected` property is ignored because the method sets the selected option based on the value of the property your binding to (refer [How to set “selectedValue” in DropDownListFor Html helper](https://stackoverflow.com/questions/41719293/mvc5-how-to-set-selectedvalue-in-dropdownlistfor-html-helper/41731685#41731685) for more detail), therefore creating a new `IEnumerable<SelectListItem>` from the first one by using `new SelectList(...)` is pointless extra overhead.

The reason for using the `SelectList` constructor is to create an `IEnumerable<SelectListItem>` from an existing collection of objects, for example

    IEnumerable<SelectListItem> options = new SelectList(db.Flavors, "ID", "Name")

which would get the records from the `Flavors` table, and set the `Value` based on its `ID` property, and the `Text` based on its `Name` property. It just provides an alternative to using (say)

    IEnumerable<SelectListItem> options = db.Flavors.Select(x => new SelectListItem
    {
        Value = x.ID.ToString(),
        Text = x.Name
    });



I'm creating a `SelectList` to pass to a `Html.DropDownList`, but the correct value doesn't seem to be populating

    var x = new SelectList(new[] { 
        new SelectListItem() { Value="1", Text="Vanilla"}, 
        new SelectListItem() { Value="2", Text="Chocolate"},
        new SelectListItem() { Value="3", Text="Strawberry"}
    }, "Value", "Text", "2");


[`SelectList`][2] should take a constructor that takes in the `selectedValue`:

    public SelectList(
    	IEnumerable items,
    	string dataValueField,
    	string dataTextField,
    	object selectedValue
    )

But this only sets the SelectedValue on the entire collection.  The individual `SelectListItems` haven't been set as `Selected`

![Inspector][1]


Do I need to iterate over them individually and set selected for each as in [this question][3]?

[1]: https://i.stack.imgur.com/I6zt3.png
[2]: https://msdn.microsoft.com/en-us/library/system.web.mvc.selectlist.selectlist#M:System.Web.Mvc.SelectList.#ctor(System.Collections.IEnumerable,System.String,System.String,System.Object)
[3]: https://stackoverflow.com/a/1390874/1366033