We Keep Coding

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")

What to do with Javascript files needed when rendering an asp.net MVC ChildAction

I have a pretty intensive call to a Child Action, with a massive amount of c# code simply called in a few views by:
#Html.RenderPartial("mychildAction")
Now I need to load some javascript file whenever this action is called. I can not put the tags inline (inside the view) because Jquery (and other JS libraries) aren't loaded until the end of the html page.
The (master) _layout should be aware that this ChildAction was called. But it isn't because a Child Action gets a new HttpContext.
The only solution I came up with, is to switch to a partial (including a big chunk of c# code into the partial and add a few strings to some custom object kept in the HttpContext.Current.Items and make my _Layout act appropriatly). But doing so would mean I have no output caching on this ChildAction and I throw in bad practices like code in partials.
What is the best way to handle this scenario?

You can access the HttpContext from the calling action using
Html.ViewContext.ParentActionViewContext
So one could add something to the "Items" collection there, this approach could solve this particuliar issue, but I still wonder if it's the best approach.

The View is responsible for rendering scripts and since the view knows when to render the partial view, it knows when to render the scripts for it.
In your layout you might find this:
#RenderSection("scripts", required: false)
The view can load scripts there like this:
#section Scripts
{
#Scripts.Render("~/bundles/SomeBundle")
}
This allows the calling view to render scripts.
What is not possible is to render scripts from a partial view or a sub-view.
You might find some workarounds on how to render scripts from a partial view, but in general is the responsibility of the view to know which scripts to load.
edit
Some of the workarounds I've seen are here.

I agree with #Odys
_Layout.cshtml
#RenderSection("scripts", required: false)
ChildView
#{
Layout = "~/Views/Share/_Layout.cshtml"
}
#section scripts
{
<script></script>
}

Is it possible to make Razor sections optional?

If I have a page with:
<body>
#section SomeStuff {
<span>This is a section I just addered</span>
}
</body>
Is it possible for the layout to not render this section, or is that contrary to how this should work conceptually. Seems like it would be useful to be able to not render certain sections on a page (unless I'm thinking about this incorrectly).
Edit:
Including the error message may be helpful, when I put a section into the main page, the layout page fails with: The following sections have been defined but have not been rendered for the layout page "/Views/Layouts/_Layout1.cshtml": "SomeStuff". As if it's forcing me to render every section on the page or something.
In otherwords, in Layout.cshtml, I don't call #RenderSection, but in Index.html I have a section called SomeStuff defined. Is that legal? Seems like it's forcing me to render all sections in the page, but that seems like sections should be optional, no?

you can specify if a section is required.
#RenderSection("SomeStuff", required: false)
if you don't render it out in a view, it shouldn't error then, noted here
http://weblogs.asp.net/scottgu/archive/2010/12/30/asp-net-mvc-3-layouts-and-sections-with-razor.aspx

You can set a section to be optional by setting the required parameter to false. If you'd like to include some optional wrapper HTML around your section then you can also use the IsSectionDefined method.
#if(IsSectionDefined("SideBar"))
{
<div class="sidebar">
#RenderSection("SideBar", required: false)
</div>
}

For a certain layout not to render certain section you need to have something like this is your layout.cshtml
#RenderSection("Somestuff", required:false)

You could do:
#if (condition) {
#RenderSection("SomeStuff")
}
Or just use a conditional statement directly rather than #RenderSection:
#if (yourCondition) {
<span>This is a section I just addered</span>
}

I encountered a similar issue when I was trying to dynamically inject code into an inline script, I solved it via:
#if (someCondition)
{
#Html.Raw(#"
Your stuff here
");
}

in _ViewStart,cshtml, how come the Javascript part does not get executed every time when I goto another page?

In the code below which is located in _ViewStart.cshtml, for some reason,
only what is inside #{ } gets executed everytime when i goto another page, but the javascript part does not, why is this and how do I fix it?
<script>
alert("in side viewstate");
</script>
#{
Layout = "~/Views/Shared/myLayout.cshtml";
}

This JavaScript code has to be put in the myLayout.cshtml, not _ViewStart. _ViewStart.cshtml is a special view that sets up the Razor variables, not contain the HTML code.

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.