Compile Code: Code Behind and Inline Coding; The Common Language Runtime

📖 Theory

Two questions every page answers

Every FestConnect page has to answer two different questions: what does it look like (the layout: headings, text boxes, a Register button) and what does it do (the logic: save the registration, greet the user). ASP.NET lets you keep these two concerns in the right places.

The layout lives in an .aspx file, written in markup. The logic is C# code, and you have a choice of where to put that code: mixed into the same .aspx file (inline), or in a separate partner file (code-behind). This lesson compares the two and shows how the CLR turns either one into a running page.

📖 Theory

Inline coding

Inline coding places the C# directly inside the .aspx file, typically in a <script runat="server"> block alongside the markup.

Everything for the page sits in one file. That is convenient for a tiny demo, but it mixes layout and logic together, which quickly becomes hard to read and maintain as a page grows. Think of it like writing your styling, your HTML, and your program all in one long file: fine for five lines, painful for five hundred.

⌨️ Practical

Inline: C# inside the .aspx file

<%@ Page Language="C#" %>
<script runat="server">
    // Logic lives in the same file as the markup
    void Greet(object sender, EventArgs e) {
        lblMessage.Text = "Welcome to FestConnect";
    }
</script>

<html>
<body>
    <form runat="server">
        <asp:Label id="lblMessage" runat="server" />
        <asp:Button Text="Greet" OnClick="Greet" runat="server" />
    </form>
</body>
</html>

This example runs in Gri-Learn on the web, where you can edit it and see the output.

📖 Theory

Code-behind

Code-behind puts the C# in a separate file that partners the page. For a page named Default.aspx, the code lives in Default.aspx.cs. The .aspx keeps only markup; the .aspx.cs keeps only logic. A directive at the top of the .aspx links them.

This is the standard, recommended approach. It cleanly separates layout from logic, so designers can work on the markup and programmers on the code without colliding, and each file stays focused and readable. Every real FestConnect page uses code-behind.

⌨️ Practical

Code-behind: logic in Default.aspx.cs

using System;

// The .aspx page links here via its CodeFile and Inherits directive
public partial class Default : System.Web.UI.Page
{
    protected void Greet(object sender, EventArgs e)
    {
        lblMessage.Text = "Welcome to FestConnect";
    }
}
// The markup (labels, buttons) stays in Default.aspx, kept separate and clean.

✏️ Formula

The CLR still compiles it

Either way, your page code is compiled, not interpreted line by line. This is the same Common Language Runtime (CLR) from BCA404: your C# is compiled to MSIL (an intermediate language), then just-in-time compiled to native machine code and run.

ASP.NET compiles a page the first time it is requested and reuses that compiled version afterwards, so the first hit is slightly slower and the rest are fast. The takeaway: ASP.NET is compiled .NET, with all the type-checking and speed that brings.

🧩 Quiz

What is the main difference between code-behind and inline coding in ASP.NET?

1. Code-behind runs in the browser, while inline coding runs on the server
2. Code-behind puts the C# in a separate partner file from the .aspx markup, while inline coding mixes the C# into the .aspx itself
3. Inline coding is compiled by the CLR, while code-behind is not compiled at all
4. There is no real difference; the two names mean the same thing

📊 At a glance

💭 Think first

Why is separating layout from logic worth the extra file?

Code-behind means two files instead of one. Why is that separation considered better practice? Then tap.

✅ Summary

Key takeaways

• An ASP.NET page splits into markup (.aspx, the layout) and code (C#, the logic).
• Inline coding puts the C# inside the .aspx file, using a script runat=server block; fine for tiny demos only.
• Code-behind puts the C# in a separate partner file (Default.aspx.cs) linked by a page directive; this is the recommended approach.
• Code-behind separates layout from logic, keeping each file focused and maintainable.
• Either way, the CLR compiles the page: C# to MSIL, then just-in-time to native code (the same CLR as BCA404).
• ASP.NET compiles a page on its first request and reuses the compiled version after.
• Memory hook: code-behind = logic in its own file, next to the markup, not inside it.