Elanat

CodeBehind

CodeBehind is a back-end framework under ASP.NET Core, in which the design pattern is MVC and allows the creation of dynamic aspx files.

Why use CodeBehind?

Using CodeBehind allows you to create dynamic applications with plugin support and not experience the default programming limitations of ASP.NET Core.

CodeBehind is a stable and reliable framework; Elanat is the most powerful .NET system implemented using the CodeBehind framework.

Figure 1 Elanat is based on CodeBehind

Projects based on CodeBehind will have a great logic and a modern architecture; CodeBehind supports aspx pages as views. Each view must introduce a Controller class at the top of the page, the model class is also added at the top of the page, but if the user does not want to use the MVC architecture, CodeBehind gives the user the option.

Unlike the default model of developing web applications in ASP.NET Core, new CodeBehind aspx pages are distributed in the root path of the application; The presence of the aspx physical file in the root path makes the program more structured.

By using CodeBehind, you can call aspx pages in each part of your codes and display them in different sections.

Figure 2 aspx file in ASP.NET Core

Note: Note that after running the program and compiling the aspx pages by CodeBehind, your program will no longer refer to any of the aspx files.

Web Parts in CodeBehind

Figure 3 a project created under CodeBehind

How to add web part?

First, copy your compiled project files to the desired path in wwwroot; then copy the main dll file to wwwroot/bin path. You can do the copy while the process is running in the method and then call the code below to compile without restarting the program.

Getting started with CodeBehind

View File: Default.aspx

<%@ Page Controller="YourProjectName.wwwroot.DefaultController" Model="YourProjectName.wwwroot.DefaultModel" %><!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title><%=model.PageTitle%></title>
</head>
<body>
    <%=model.BodyValue%>
</body>
</html>

Model File: Default.aspx.Model.cs

using CodeBehind;
namespace YourProjectName.wwwroot
{
    public partial class DefaultModel : CodeBehindModel
    {
        public string PageTitle { get; set; }
        public string BodyValue { get; set; }
    }
}

Controler File: Default.aspx.Controller.cs

using CodeBehind;
namespace YourProjectName.wwwroot
{
    public partial class DefaultController : CodeBehindController
    {
        public DefaultModel model = new DefaultModel();
        public void PageLoad(HttpContext context)
        {
            model.PageTitle = "My Title";
            model.BodyValue = "HTML Body";
            View(model);
        }
    }
}

Program File: Program.cs

using CodeBehind;
using SetCodeBehind;
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}
+ CodeBehindCompiler.Initialization();
app.Run(async context =>
{
+    CodeBehindExecute execute = new CodeBehindExecute();
+    await context.Response.WriteAsync(execute.Run(context));
+    await context.Response.CompleteAsync();
});
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.Run();

You can use the Write method in the model and controller classes; the Write method adds a string value to the ResponseText attribute; you can also change the values of the ResponseText attribute by accessing them directly.

In the controller class, there is an attribute named IgnoreViewAndModel attribute, and if you activate the IgnoreViewAndModel attribute, it will ignore the values of model and view and you will only see a blank page; this feature allows you to display the values you need to the user and avoid multiple redirects and transfers.

Note: If you have set the name of a model in the aspx file, You must make sure to call View(ModelName) in the controller class at the end of the method or set the value of IgnoreViewAndModel to true.

To receive the information sent through the form, you can follow the instructions below:

public DefaultModel model = new DefaultModel();
public void PageLoad(HttpContext context)
{
    if (!string.IsNullOrEmpty(context.Request.Form["btn_Add"]))
        btn_Add_Click();
    View(model);
}
private void btn_Add_Click()
{
    model.PageTitle = "btn_Add Button Clicked";
}

The following example shows the power of CodeBehind:

aspx page

<%@ Page Controller="YourProjectName.wwwroot.DefaultController" Model="YourProjectName.wwwroot.DefaultModel" %><!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title><%=model.PageTitle%></title>
</head>
<body>
    <%=model.LeftMenuValue%>
    <div class="main_content">
        <%=model.MainContentValue%>
    </div>
    <%=model.RightMenuValue%>
</body>
</html>

Controller class

using CodeBehind;
namespace YourProjectName.wwwroot
{
    public partial class DefaultController : CodeBehindController
    {
        public DefaultModel model = new DefaultModel();
        public void PageLoad(HttpContext context)
        {
            model.PageTitle = "My Title";
            CodeBehindExecute execute = new CodeBehindExecute();
            // Add Left Menu Page
            model.LeftMenuValue = execute.Run(context, "/menu/left.aspx");
            // Add Right Menu Page
            model.RightMenuValue = execute.Run(context, "/menu/right.aspx");
            // Add Main Content Page
            model.MainContentValue = execute.Run(context, "/pages/main.aspx");
            View(model);
        }
    }
}

Each of the pages left.aspx, right.aspx and main.aspx can also call several other aspx files; these calls can definitely be dynamic and an add-on can be executed that the kernel programmers don't even know about.

Enjoy CodeBehind, but be careful not to loop the program! (Don't call pages that call the current page)

CodeBehind in NuGet:
https://www.nuget.org/packages/CodeBehind
CodeBehind repository in GitHub:
https://github.com/elanatframework/Code_behind

Elanat is add-on oriented framework. Elanat is free and open-source ASP.NET Core CMS under license GPL V3. The Elanat kernel is designed to create an add-on for it as easily as possible; the Elanat kernel contains a variety of add-ons; the structure of Elanat allows the programmer to create a new web system containing different types of add-ons.
Download

About

- License
- About
- Contact
- Gallery
- Privacy policy
- Terms of service

Support

Development

Guidelines

#Component

#Module

#Patch

#Plugin

#Page

#Fetch

#Extra helper

#Editor template

JavaScript is disabled in your browser, you may not be able to properly viewing the content on this site. You may have disabled run JavaScript in your browser or your browser does not support JavaScript. In order to better view the content of the website, please use a browser that is able to run JavaScript.

elanat.net supported by your servers

free and open-source

CodeBehind

Why use CodeBehind?

Web Parts in CodeBehind

Getting started with CodeBehind

The following example shows the power of CodeBehind: