We Keep Coding

Asp.net Space being auto-generated into html Divs

I am new to Asp.Net and I am having a problem using a layout. I have a div and inside is a p tag, depending on if the embedded c# flip is true or false I would like it to be an empty p tag or a p tag with content.
Problem: This occurs when there is nothing being placed inside the div tag. It will generate a lot of space which is stopping me from using the :empty css tag because there is technically content inside it.
My code is as such:
<div>
#if (flip = true){
<p>text</p>
}
else{}
</div>

Try using one of Razor's 'literal' tags (as described here: How to use Razor like asp:Literal?):
<div>#Html.Raw(flip ? "<p>text</p>" : "")</div>
and be sure to keep the <div> on one line.
There might be a better way to do it with syntax similar to #:, but I can't recall that syntax off hand.
Update: If you're adding substantial content within the div and you're concern is only about the css :empty selector, you might be better off just adding a specialized class to the div (as described here: How to use ? : if statements with Razor and inline code blocks):
<div class="col-md-12 game #(flip ? "" : "empty")">
Then you can just use the syntax you've already been using (#if(flip){})

Determine what View is going to be rendered in #RenderBody()

In _Layout.cshtml is it possible to determine what View is going to be rendered in #RenderBody() ?

You can get the View (i.e. Index.cshtml) through ((RazorView)ViewContext.View).ViewPath
Example for your needs:
<script type="text/javascript" src="~/Content/Scripts/#(Path.GetFileNameWithoutExtension(Server.MapPath(((RazorView)ViewContext.View).ViewPath))).js"></script>
If you need your actual View (i.e. _Layout.cshtml), you can use VirtualPath instead.
Old answer
Reading your comments, you want to add a
<script ...>...</script>
depending on the view but outside of #RenderBody()?
Then put
#RenderSection("Scripts", required:false)
and in your view define the section like
#section Scripts {
<script ...>...</script>
}
So you don't need to maintain your _Layout.cshtml since every View defines their own scripts.
Here is an easy explanation: http://weblogs.asp.net/scottgu/asp-net-mvc-3-layouts-and-sections-with-razor

What you can do is check Html.ViewContext.RouteData.Values. That's a dictionary with controller, action, and id (as necessary).

Read this article and it will solve your problem.
Edit
RenderBody
What is RenderBody?
In layout pages, renders the portion of a content page that is not
within a named section. [MSDN]
How RenderBody works (graphical presentation)?

The #RenderBody() renders the view controlled by the controller. so if your controller is like this.
public class HomeController : Controller
{
public ActionResult Index() // Renders File /Views/Home/Index.cshtml
{
return View();
}
}
Then the public ActionResult Index() Index.cshtml will be the view it will render located int the /Views/Home folder.
You can add to the Index.cshtml or _Layout.cshtml view to render other Views or partialViews By adding #Html.Partial("_MyView") as shown below.
#Html.Partial("_LayoutHeaderHeader")
#Html.Partial("_LayoutHeaderNavbar")
Sometimes it is easy to setup a few layout pages to call from different Views.
If you want to call scripts to you View you should always create a _PartialView and place your scripts in the partial view and call that View at the bottom of your View like this #Html.Partial("_MyView") and the scripts will set properly.
Here is a good tutorial. http://www.codeproject.com/Articles/698246/ASP-NET-MVC-Special-Views-Partial-View-and-Layout

If you derive all your models from a base model then you could add a property to you base model that returns the controller name, which you can get using
this.RouteData.Values["controller"].ToString();
It would be even better if you had a BaseController class because you could put this in the constructor and never have to touch it again.
Since you would be returning a descendant of the base Model to your index page which has the controller name, now you could use some scheme base on #Model.ControllerName. If your controller services multiple views the property could be updated to indicate a certain view name.
I don't think you can get the name of a Partial inside the index unless you use jquery and by that point the page resources have already been loaded.
Edit: One other trick would be to create your own version of #Html.Partial() HtmlHelper class. So you have #Html.MyPartial("ViewName") and inside that method call the internal function that generates Html.Partial and then inject your dependencies.

EDIT: I just read your comments about the issue and think that the better way is using the code snipplet provided by #Matt in another answer.
You can use the #section razor statement inside your view to inform wich script should be loaded.
Layout template placeholder
#RenderSection("scripts", required: false)
View Code
#section scripts {
<script src="~/Scripts/custom-imgedit.js"></script>
}
The example above inform that the custom-imgedit.js will be loaded in the render section placeholder. Note: You can even use bundles like #Scripts.Render("~/bundles/myCustomScripts")

Razor Section Definition

I am looking at some razor layout code. I have found the following snippet:
#section Foo
{
#if (#IsSectionDefined("Foo"))
{
#RenderSection("Foo", required: false)
}
}
Wouldn't #section Foo define Foo, meaning that the if (#IsSectionDefined("Foo")) condition would always be true? Also, if that section is defined in another view page, wouldn't this cause a redefinition?
Basically, I don't understand why this condition is wrapped in an #section clause.

I have figured out what this pattern is for: this is used in the situation where there are several layers of layouts. A section definition is scoped to the direct parent layout of a page. Therefore, to define a section that will be rendered in a higher level layout, one must pass it up the hierarchy using this construct.

You define the Sections in a Layout file with RenderSection("Foo");

So here is what I figured out:
The snipped of code doesn't hurt anything by itself.
What it says is this:
If you want to define a #section Foo, you have to define it in some other pages that has the current Layout page. And if you define it, you have to render it by adding #RenderSection("ExtraContent") in Layout page.
In Layout Page:
#section ExtraContent{
#if (#IsSectionDefined("ExtraContent")){
#RenderSection("ExtraContent", required: false)
}
}
#RenderSection("ExtraContent")
In About page:
#section ExtraContent{
<p>Some extra content</p>
}

Razor: Render does not work inside code block

This seems very strange to me, if I do
#RenderSection("scripts", required: false)
then it works perfectly fine, but if I do
#{
RenderSection("scripts", required: false);
}
then the scripts section will not get rendered and I would get "The following sections have been defined but have not been rendered for the layout page "~/Views/Shared/_Layout.cshtml": "scripts"." error
Any idea why RenderSection/Script.Render cannot be inside a code block?
Edit:
I have tried to put a break point inside the code block and the break point is getting hit when the page loads, and the RenderSection method executes without any exception

RenderSection does not write anything. Instead this methods returns an HelperResult which implements IHtmlString and can be render to the page by using its WriteTo method.
#{
HelperResult renderSection = RenderSection("scripts", required: false);
renderSection.WriteTo(Output);
}
When using #RenderSection it automatically render it to the page

Why does my .cshtml page need to define content?

Let's say I have the following structure in my ASP.NET MVC 3 application.
Items
Index.cshtml
Categories
Shared
_Index.cshtml
_Site.cshtml
Index.cshtml
Both Index.cshtml files use _Index.cshtml as the layout page and _Index is nested within the _Site layout.
Items/Index implements the optional sections defined in _Index. Shared/Index is empty.
The Items/Index view works fine. Since Categories doesn't have an Index, it uses the one in the Shared folder. This does not work.
It throws the error
The "RenderBody" method has not been called for layout page "~/Views/Shared/_Index.cshtml".
If _Site calls RenderBody, and _Index inherits from _Site, doesn't the content in _Index satisfy the required RenderBody call and Shared/Index.cshtml can be blank?
The reason I ask is because I have an ASP.NET MVC 1 application that implemented this structure using Master pages and it worked fine, but converting it to MVC 3 with Razor is causing this issue.
Here is the basic outline of what I'm describing:
_Site.cshtml
<!DOCTYPE html>
// head
<body>
#RenderBody()
</body>
_Index.cshtml
#{
Layout = "~/Views/Shared/_Site.cshtml";
}
<div id="sub-menu">
// Markup
</div>
// More markup
#RenderSection("SectionOne", required: false)
#RenderSection("SectionTwo", required: false)
Items/Index.cshtml (Working)
#{
Layout = "~/Views/Shared/_Index.cshtml";
}
#section SectionOne {
// Markup
}
Shared/Index.cshtml (RenderBody error)
#{
Layout = "~/Views/Shared/_Index.cshtml";
}
// Rest of this file is empty

I'm not sure i follow you completely, but ALL layout pages have to have a RenderBody(), even if they're nested. RenderBody() renders the content for the "child". When you have nested layout pages the nested layout is the child of the parent, and it's output must be rendered in the RenderBody. Likewise, the child of the child has to render it's body into the middle page.
To put it another way, anything that's not in a #section is considered the "body". So, _Index.cshtml needs to render it's body (Index.cshtml) and _Site.html has to render it's body (_Index.cshtml). It goes up the chain.
EDIT:
It appears that a layout has to render at least one section, be it with a RenderBody() or a RenderSection(). While it may be true that the sections are optional, rendering at least one section is not. Either add an empty section to your Index.cshtml or add a RenderBody() to your _Index.cshtml.