.ASAX

Task 037: .ASAX File Format

Task 037: .ASAX File Format

thinkmelt@protonmail.com

• 15 min read

Task Response: .ASAX File Format Specifications and Implementation

The .ASAX file format, primarily associated with ASP.NET as the "ASP.NET Server Application File," is used to handle application-level and session-level events in ASP.NET web applications. The most common .ASAX file is Global.asax, which resides in the root directory of an ASP.NET application. Below, I address each part of the task based on the available information and critical analysis of the .ASAX file format.

1. Properties of the .ASAX File Format Intrinsic to Its File System

The .ASAX file format is a plain text file used by ASP.NET applications, typically written in a scripting language like C# or VB.NET. Its intrinsic properties, based on its role and structure within the ASP.NET framework, include:

  • File Extension: .asax
  • File Type: Text-based, human-readable script file.
  • Location: Stored in the root directory of an ASP.NET application, typically named Global.asax.
  • Purpose: Contains code to handle application-level and session-level events raised by ASP.NET or HTTP modules (e.g., Application_Start, Session_End).
  • Structure:
  • Application Directives: Tags at the start of the file (e.g., <%@ Application Language="C#" %>) that define settings for the ASP.NET parser.
  • Code Declaration Blocks: Server-side code within <script runat="server"> tags, typically in C# or VB.NET, defining event handlers.
  • Optional Nature: The file is optional; an ASP.NET application can function without it.
  • Security: Web servers are configured to reject direct URL requests to .ASAX files, preventing external access to the source code.
  • Runtime Behavior: Parsed and compiled at runtime into a .NET Framework class derived from HttpApplication.
  • MIME Type: application/x-aspx (though primarily associated with ASP.NET processing).
  • Encoding: Typically UTF-8, as it is a plain text file.
  • Single Instance: Only one .ASAX file (usually Global.asax) is allowed per ASP.NET application.
  • Event Handlers: Supports predefined event handlers such as:
  • Application_Start: Triggered when the application starts.
  • Application_End: Triggered when the application shuts down.
  • Session_Start: Triggered when a new user session begins.
  • Session_End: Triggered when a session ends (only for InProc session mode).
  • Application_Error: Triggered for unhandled exceptions.
  • Application_BeginRequest, Application_EndRequest, etc., for request lifecycle events.

These properties are derived from the file’s role in the ASP.NET framework and its interaction with the server’s file system.

Challenges and Assumptions

  • Lack of Formal Specification: Unlike formats like PNG or JSON, .ASAX does not have a publicly available, detailed file format specification beyond its role in ASP.NET. It is a text-based format with a structure defined by ASP.NET conventions.
  • Implementation Focus: The task requires reading, writing, and printing properties. Since .ASAX is a text file with code, “decoding” implies parsing its directives and code blocks, while “properties” refer to the intrinsic attributes listed above (e.g., extension, encoding, event handlers).
  • Cross-Language Implementation: The task requests implementations in Python, Java, JavaScript, and C. Since .ASAX files are plain text, the classes will focus on reading the file, parsing its structure (directives and event handlers), and writing back to a file.
  • C Language Note: C does not have a native "class" construct, so a struct-based approach with functions will be used to emulate class-like behavior.

Below, I provide implementations for each language, focusing on:

  • Reading the .ASAX file to extract its directives and event handlers.
  • Printing the identified properties to the console.
  • Writing a new .ASAX file with sample content.

2. Python Class for .ASAX File Handling

import re
import os

class ASAXFile:
    def __init__(self, filepath):
        self.filepath = filepath
        self.properties = {
            "extension": ".asax",
            "file_type": "text",
            "location": "root directory (Global.asax)",
            "encoding": "UTF-8",
            "directives": [],
            "event_handlers": [],
            "is_optional": True,
            "single_instance": True,
            "mime_type": "application/x-aspx"
        }

    def read(self):
        """Read and parse the .ASAX file."""
        try:
            with open(self.filepath, 'r', encoding='utf-8') as file:
                content = file.read()
                
                # Extract directives (e.g., <%@ Application Language="C#" %>)
                directive_pattern = r'<%@\s*(\w+)\s+([^%>]+)%>'
                directives = re.findall(directive_pattern, content)
                self.properties["directives"] = [(d[0], dict(re.findall(r'(\w+)="([^"]+)"', d[1]))) for d in directives]

                # Extract event handlers (e.g., Application_Start, Session_End)
                event_pattern = r'void\s+(\w+)\s*\([^)]*\)\s*{'
                self.properties["event_handlers"] = re.findall(event_pattern, content)
                
                return content
        except FileNotFoundError:
            print(f"Error: File {self.filepath} not found.")
            return None
        except Exception as e:
            print(f"Error reading file: {str(e)}")
            return None

    def write(self, content=None):
        """Write a sample .ASAX file."""
        try:
            sample_content = content or (
                '<%@ Application Language="C#" %>\n'
                '<script runat="server">\n'
                'void Application_Start(object sender, EventArgs e) {\n'
                '    // Code for application startup\n'
                '}\n'
                'void Application_Error(object sender, EventArgs e) {\n'
                '    // Code for error handling\n'
                '}\n'
                '</script>'
            )
            with open(self.filepath, 'w', encoding='utf-8') as file:
                file.write(sample_content)
            print(f"Successfully wrote to {self.filepath}")
        except Exception as e:
            print(f"Error writing file: {str(e)}")

    def print_properties(self):
        """Print all properties of the .ASAX file."""
        print("ASAX File Properties:")
        for key, value in self.properties.items():
            print(f"{key}: {value}")

# Example usage
if __name__ == "__main__":
    asax = ASAXFile("Global.asax")
    asax.write()  # Create a sample file
    asax.read()   # Read and parse the file
    asax.print_properties()  # Print properties

Explanation:

  • Reading: Uses regex to parse directives and event handlers from the text file.
  • Writing: Creates a sample Global.asax file with basic directives and event handlers if no content is provided.
  • Properties: Stores and prints intrinsic properties like extension, encoding, and parsed directives/event handlers.
  • Error Handling: Handles file not found and encoding errors.

3. Java Class for .ASAX File Handling

import java.io.*;
import java.util.*;
import java.util.regex.*;

public class ASAXFile {
    private String filepath;
    private Map<String, Object> properties;

    public ASAXFile(String filepath) {
        this.filepath = filepath;
        this.properties = new HashMap<>();
        properties.put("extension", ".asax");
        properties.put("file_type", "text");
        properties.put("location", "root directory (Global.asax)");
        properties.put("encoding", "UTF-8");
        properties.put("directives", new ArrayList<String[]>());
        properties.put("event_handlers", new ArrayList<String>());
        properties.put("is_optional", true);
        properties.put("single_instance", true);
        properties.put("mime_type", "application/x-aspx");
    }

    public String read() {
        try (BufferedReader reader = new BufferedReader(new FileReader(filepath))) {
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }

            // Parse directives
            Pattern directivePattern = Pattern.compile("<%@\\s*(\\w+)\\s+([^%>]+)%>");
            Matcher directiveMatcher = directivePattern.matcher(content);
            List<String[]> directives = new ArrayList<>();
            while (directiveMatcher.find()) {
                directives.add(new String[]{directiveMatcher.group(1), directiveMatcher.group(2)});
            }
            properties.put("directives", directives);

            // Parse event handlers
            Pattern eventPattern = Pattern.compile("void\\s+(\\w+)\\s*\\([^)]*\\)\\s*\\{");
            Matcher eventMatcher = eventPattern.matcher(content);
            List<String> events = new ArrayList<>();
            while (eventMatcher.find()) {
                events.add(eventMatcher.group(1));
            }
            properties.put("event_handlers", events);

            return content.toString();
        } catch (FileNotFoundException e) {
            System.out.println("Error: File " + filepath + " not found.");
            return null;
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
            return null;
        }
    }

    public void write(String content) {
        String defaultContent = content != null ? content :
                "<%@ Application Language=\"C#\" %>\n" +
                "<script runat=\"server\">\n" +
                "void Application_Start(object sender, EventArgs e) {\n" +
                "    // Code for application startup\n" +
                "}\n" +
                "void Application_Error(object sender, EventArgs e) {\n" +
                "    // Code for error handling\n" +
                "}\n" +
                "</script>";
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filepath))) {
            writer.write(defaultContent);
            System.out.println("Successfully wrote to " + filepath);
        } catch (IOException e) {
            System.out.println("Error writing file: " + e.getMessage());
        }
    }

    public void printProperties() {
        System.out.println("ASAX File Properties:");
        for (Map.Entry<String, Object> entry : properties.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static void main(String[] args) {
        ASAXFile asax = new ASAXFile("Global.asax");
        asax.write(null); // Create a sample file
        asax.read();      // Read and parse
        asax.printProperties(); // Print properties
    }
}

Explanation:

  • Reading: Uses BufferedReader to read the file and regex to parse directives and event handlers.
  • Writing: Writes a sample Global.asax file with default content if none is provided.
  • Properties: Stores properties in a HashMap and prints them.
  • Error Handling: Manages file I/O exceptions.

4. JavaScript Class for .ASAX File Handling

const fs = require('fs').promises;

class ASAXFile {
    constructor(filepath) {
        this.filepath = filepath;
        this.properties = {
            extension: '.asax',
            file_type: 'text',
            location: 'root directory (Global.asax)',
            encoding: 'utf-8',
            directives: [],
            event_handlers: [],
            is_optional: true,
            single_instance: true,
            mime_type: 'application/x-aspx'
        };
    }

    async read() {
        try {
            const content = await fs.readFile(this.filepath, 'utf-8');

            // Parse directives
            const directivePattern = /<%@\s*(\w+)\s+([^%>]+)%>/g;
            const directives = [];
            let match;
            while ((match = directivePattern.exec(content)) !== null) {
                directives.push([match[1], match[2]]);
            }
            this.properties.directives = directives;

            // Parse event handlers
            const eventPattern = /void\s+(\w+)\s*\([^)]*\)\s*{/g;
            const events = [];
            while ((match = eventPattern.exec(content)) !== null) {
                events.push(match[1]);
            }
            this.properties.event_handlers = events;

            return content;
        } catch (error) {
            if (error.code === 'ENOENT') {
                console.error(`Error: File ${this.filepath} not found.`);
            } else {
                console.error(`Error reading file: ${error.message}`);
            }
            return null;
        }
    }

    async write(content) {
        const defaultContent = content || (
            '<%@ Application Language="C#" %>\n' +
            '<script runat="server">\n' +
            'void Application_Start(object sender, EventArgs e) {\n' +
            '    // Code for application startup\n' +
            '}\n' +
            'void Application_Error(object sender, EventArgs e) {\n' +
            '    // Code for error handling\n' +
            '}\n' +
            '</script>'
        );
        try {
            await fs.writeFile(this.filepath, defaultContent, 'utf-8');
            console.log(`Successfully wrote to ${this.filepath}`);
        } catch (error) {
            console.error(`Error writing file: ${error.message}`);
        }
    }

    printProperties() {
        console.log('ASAX File Properties:');
        for (const [key, value] of Object.entries(this.properties)) {
            console.log(`${key}: ${JSON.stringify(value, null, 2)}`);
        }
    }
}

// Example usage
(async () => {
    const asax = new ASAXFile('Global.asax');
    await asax.write(); // Create a sample file
    await asax.read();  // Read and parse
    asax.printProperties(); // Print properties
})();

Explanation:

  • Reading: Uses Node.js fs.promises for asynchronous file reading and regex to parse directives and event handlers.
  • Writing: Writes a sample Global.asax file using async I/O.
  • Properties: Stores properties in an object and prints them with proper formatting.
  • Error Handling: Handles file not found and I/O errors.

5. C Implementation for .ASAX File Handling

Since C does not support classes, I use a struct and functions to emulate class-like behavior.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE 1024
#define MAX_EVENTS 10
#define MAX_DIRECTIVES 10

typedef struct {
    const char *filepath;
    char *extension;
    char *file_type;
    char *location;
    char *encoding;
    char *directives[MAX_DIRECTIVES][2]; // [name, attributes]
    char *event_handlers[MAX_EVENTS];
    int directive_count;
    int event_count;
    int is_optional;
    int single_instance;
    char *mime_type;
} ASAXFile;

ASAXFile* create_asax_file(const char *filepath) {
    ASAXFile *asax = (ASAXFile*)malloc(sizeof(ASAXFile));
    asax->filepath = filepath;
    asax->extension = ".asax";
    asax->file_type = "text";
    asax->location = "root directory (Global.asax)";
    asax->encoding = "UTF-8";
    asax->directive_count = 0;
    asax->event_count = 0;
    asax->is_optional = 1;
    asax->single_instance = 1;
    asax->mime_type = "application/x-aspx";
    for (int i = 0; i < MAX_DIRECTIVES; i++) {
        asax->directives[i][0] = NULL;
        asax->directives[i][1] = NULL;
    }
    for (int i = 0; i < MAX_EVENTS; i++) {
        asax->event_handlers[i] = NULL;
    }
    return asax;
}

void free_asax_file(ASAXFile *asax) {
    for (int i = 0; i < asax->directive_count; i++) {
        free(asax->directives[i][0]);
        free(asax->directives[i][1]);
    }
    for (int i = 0; i < asax->event_count; i++) {
        free(asax->event_handlers[i]);
    }
    free(asax);
}

char* read_asax(ASAXFile *asax) {
    FILE *file = fopen(asax->filepath, "r");
    if (!file) {
        printf("Error: File %s not found.\n", asax->filepath);
        return NULL;
    }

    char *content = NULL;
    size_t size = 0;
    char line[MAX_LINE];
    while (fgets(line, MAX_LINE, file)) {
        size_t len = strlen(line);
        content = realloc(content, size + len + 1);
        strcpy(content + size, line);
        size += len;

        // Parse directives
        if (strstr(line, "<%@") && strstr(line, "%>")) {
            if (asax->directive_count < MAX_DIRECTIVES) {
                char *name = strtok(line + 3, " \t");
                char *attrs = strtok(NULL, "%>");
                asax->directives[asax->directive_count][0] = strdup(name);
                asax->directives[asax->directive_count][1] = strdup(attrs ? attrs : "");
                asax->directive_count++;
            }
        }

        // Parse event handlers
        if (strstr(line, "void ") && strstr(line, "(")) {
            if (asax->event_count < MAX_EVENTS) {
                char *name = strtok(line + 5, " \t(");
                asax->event_handlers[asax->event_count] = strdup(name);
                asax->event_count++;
            }
        }
    }

    fclose(file);
    return content;
}

void write_asax(ASAXFile *asax, const char *content) {
    const char *default_content = content ? content :
        "<%@ Application Language=\"C#\" %>\n"
        "<script runat=\"server\">\n"
        "void Application_Start(object sender, EventArgs e) {\n"
        "    // Code for application startup\n"
        "}\n"
        "void Application_Error(object sender, EventArgs e) {\n"
        "    // Code for error handling\n"
        "}\n"
        "</script>";

    FILE *file = fopen(asax->filepath, "w");
    if (!file) {
        printf("Error writing file: %s\n", asax->filepath);
        return;
    }

    fputs(default_content, file);
    fclose(file);
    printf("Successfully wrote to %s\n", asax->filepath);
}

void print_properties(ASAXFile *asax) {
    printf("ASAX File Properties:\n");
    printf("extension: %s\n", asax->extension);
    printf("file_type: %s\n", asax->file_type);
    printf("location: %s\n", asax->location);
    printf("encoding: %s\n", asax->encoding);
    printf("is_optional: %d\n", asax->is_optional);
    printf("single_instance: %d\n", asax->single_instance);
    printf("mime_type: %s\n", asax->mime_type);
    printf("directives:\n");
    for (int i = 0; i < asax->directive_count; i++) {
        printf("  %s: %s\n", asax->directives[i][0], asax->directives[i][1]);
    }
    printf("event_handlers:\n");
    for (int i = 0; i < asax->event_count; i++) {
        printf("  %s\n", asax->event_handlers[i]);
    }
}

int main() {
    ASAXFile *asax = create_asax_file("Global.asax");
    write_asax(asax, NULL); // Create a sample file
    char *content = read_asax(asax); // Read and parse
    print_properties(asax); // Print properties
    if (content) free(content);
    free_asax_file(asax);
    return 0;
}

Explanation:

  • Reading: Reads the file line by line, parsing directives and event handlers using string matching.
  • Writing: Writes a sample Global.asax file with default content.
  • Properties: Stores properties in a struct and prints them.
  • Memory Management: Properly allocates and frees memory for dynamic strings.
  • Error Handling: Checks for file opening failures.

Notes and Limitations

  • Parsing Simplicity: The parsing of directives and event handlers is basic (using regex in Python/Java/JavaScript and string matching in C) and assumes well-formed .ASAX files. Real-world parsing may require more robust handling for complex code.
  • File Access: The implementations assume local file system access. In a real ASP.NET environment, .ASAX files are server-side and may require additional permissions.
  • C Implementation: Lacks native regex support, so parsing is simplified. A library like PCRE could enhance it but was avoided for simplicity.
  • Cross-Platform: The JavaScript implementation requires Node.js for file system access. Browser-based JavaScript would need adjustments (e.g., File API).

If you need further refinements or have a specific .ASAX file to test, please provide it, and I can tailor the code further!

File Format Specifications for .ASAX

The .ASAX file format is used for ASP.NET Server Application Files, most commonly as Global.asax in the root directory of an ASP.NET web application. It is a plain text file (not binary), human-readable, and contains code to handle application-level events raised by ASP.NET or HTTP modules. The file is parsed and compiled at runtime by ASP.NET into a class derived from HttpApplication. Direct access to the file via URL is restricted, and it is optional for ASP.NET applications.

The structure typically includes:

  • An optional <%@ Application %> directive at the beginning, specifying attributes like Language, Inherits, CodeBehind, and Description.
  • directive at the beginning, specifying attributes like Language, Inherits, CodeBehind, and Description.
  • An optional <script runat="server"> block containing event handler methods in C# or another .NET language.
  • The code responds to global events during the application's lifecycle, such as startup, shutdown, requests, sessions, and errors.

No binary headers, magic numbers, or encoded sections exist; it is purely text-based with ASP.NET-specific syntax.

  1. List of all the properties of this file format intrinsic to its file system: Since .ASAX is a text-based format without binary properties or file-system-specific intrinsics beyond standard file metadata (e.g., size, timestamps, permissions—which apply to any file), the "properties" here refer to the key event handlers defined in the specifications for Global.asax. These are the standard application and session events that can be implemented as methods in the file:
  • Application_Start
  • Application_End
  • Application_BeginRequest
  • Application_EndRequest
  • Application_Error
  • Session_Start
  • Session_End

These properties represent the code blocks for each event, which can be read (extracted) and written (modified or added) in the file.

  1. Python class:
import re

class ASAXFile:
    def __init__(self, filename):
        self.filename = filename
        self.directive = ''
        self.events = {}
        self.event_list = [
            'Application_Start', 'Application_End', 'Application_BeginRequest',
            'Application_EndRequest', 'Application_Error', 'Session_Start', 'Session_End'
        ]

    def load(self):
        with open(self.filename, 'r', encoding='utf-8') as f:
            content = f.read().strip()

        # Extract directive
        directive_match = re.match(r'(<%.+?%>)\s*', content, re.DOTALL)
        if directive_match:
            self.directive = directive_match.group(1)
            content = content[directive_match.end():].strip()

        # Extract script block if present
        script_match = re.match(r'<script runat="server">(.*?)</script>', content, re.DOTALL)
        if script_match:
            script = script_match.group(1).strip()
        else:
            script = content  # Assume raw code if no script tag

        # Extract each event's code
        for event in self.event_list:
            code = self._extract_method_code(script, event)
            if code is not None:
                self.events[event] = code.strip()

    def _extract_method_code(self, script, event):
        pattern = r'void\s+' + re.escape(event) + r'\s*\(\s*object\s+sender\s*,\s*EventArgs\s+e\s*\)\s*\{'
        match = re.search(pattern, script)
        if not match:
            return None
        pos = match.end()
        brace_count = 1
        code = ''
        while pos < len(script):
            char = script[pos]
            code += char
            if char == '{':
                brace_count += 1
            elif char == '}':
                brace_count -= 1
                if brace_count == 0:
                    return code[:-1]  # Exclude closing }
            pos += 1
        return None

    def get_event_code(self, event):
        if event not in self.event_list:
            raise ValueError("Invalid event")
        return self.events.get(event, '')

    def set_event_code(self, event, code):
        if event not in self.event_list:
            raise ValueError("Invalid event")
        self.events[event] = code

    def save(self):
        script_content = ''
        for event in self.event_list:
            if event in self.events:
                script_content += f'void {event}(object sender, EventArgs e) {{\n{self.events[event]}\n}}\n\n'

        content = f'{self.directive}\n<script runat="server">\n{script_content}</script>' if self.directive else f'<script runat="server">\n{script_content}</script>'
        with open(self.filename, 'w', encoding='utf-8') as f:
            f.write(content)

Usage example: asax = ASAXFile('Global.asax'); asax.load(); print(asax.get_event_code('Application_Start')); asax.set_event_code('Application_Start', '// New code'); asax.save()

This class assumes C# syntax and simplified parsing (handles nested braces via counting).

  1. Java class:
import java.io.*;
import java.util.*;
import java.util.regex.*;

public class ASAXFile {
    private String filename;
    private String directive = "";
    private Map<String, String> events = new HashMap<>();
    private List<String> eventList = Arrays.asList(
        "Application_Start", "Application_End", "Application_BeginRequest",
        "Application_EndRequest", "Application_Error", "Session_Start", "Session_End"
    );

    public ASAXFile(String filename) {
        this.filename = filename;
    }

    public void load() throws IOException {
        StringBuilder contentBuilder = new StringBuilder();
        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = br.readLine()) != null) {
                contentBuilder.append(line).append("\n");
            }
        }
        String content = contentBuilder.toString().trim();

        // Extract directive
        Pattern directivePattern = Pattern.compile("(<%.+?%>)\\s*", Pattern.DOTALL);
        Matcher directiveMatcher = directivePattern.matcher(content);
        if (directiveMatcher.find()) {
            directive = directiveMatcher.group(1);
            content = content.substring(directiveMatcher.end()).trim();
        }

        // Extract script block if present
        Pattern scriptPattern = Pattern.compile("<script runat=\"server\">(.*?)</script>", Pattern.DOTALL);
        Matcher scriptMatcher = scriptPattern.matcher(content);
        String script;
        if (scriptMatcher.find()) {
            script = scriptMatcher.group(1).trim();
        } else {
            script = content;  // Assume raw code if no script tag
        }

        // Extract each event's code
        for (String event : eventList) {
            String code = extractMethodCode(script, event);
            if (code != null) {
                events.put(event, code.trim());
            }
        }
    }

    private String extractMethodCode(String script, String event) {
        Pattern pattern = Pattern.compile("void\\s+" + Pattern.quote(event) + "\\s*\\(\\s*object\\s+sender\\s*,\\s*EventArgs\\s+e\\s*\\)\\s*\\{");
        Matcher match = pattern.matcher(script);
        if (!match.find()) {
            return null;
        }
        int pos = match.end();
        int braceCount = 1;
        StringBuilder code = new StringBuilder();
        while (pos < script.length()) {
            char ch = script.charAt(pos);
            code.append(ch);
            if (ch == '{') {
                braceCount++;
            } else if (ch == '}') {
                braceCount--;
                if (braceCount == 0) {
                    return code.substring(0, code.length() - 1);  // Exclude closing }
                }
            }
            pos++;
        }
        return null;
    }

    public String getEventCode(String event) {
        if (!eventList.contains(event)) {
            throw new IllegalArgumentException("Invalid event");
        }
        return events.getOrDefault(event, "");
    }

    public void setEventCode(String event, String code) {
        if (!eventList.contains(event)) {
            throw new IllegalArgumentException("Invalid event");
        }
        events.put(event, code);
    }

    public void save() throws IOException {
        StringBuilder scriptContent = new StringBuilder();
        for (String event : eventList) {
            if (events.containsKey(event)) {
                scriptContent.append("void ").append(event).append("(object sender, EventArgs e) {\n")
                             .append(events.get(event)).append("\n}\n\n");
            }
        }

        String content = (directive.isEmpty() ? "" : directive + "\n") + "<script runat=\"server\">\n" + scriptContent + "</script>";
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(filename))) {
            bw.write(content);
        }
    }
}

Usage example: ASAXFile asax = new ASAXFile("Global.asax"); asax.load(); System.out.println(asax.getEventCode("Application_Start")); asax.setEventCode("Application_Start", "// New code"); asax.save();

4. JavaScript class (Node.js):

const fs = require('fs');

class ASAXFile {
    constructor(filename) {
        this.filename = filename;
        this.directive = '';
        this.events = {};
        this.eventList = [
            'Application_Start', 'Application_End', 'Application_BeginRequest',
            'Application_EndRequest', 'Application_Error', 'Session_Start', 'Session_End'
        ];
    }

    load() {
        let content = fs.readFileSync(this.filename, 'utf-8').trim();

        // Extract directive
        const directiveMatch = content.match(/^(<%.+?%>)\s*/s);
        if (directiveMatch) {
            this.directive = directiveMatch[1];
            content = content.slice(directiveMatch[0].length).trim();
        }

        // Extract script block if present
        const scriptMatch = content.match(/<script runat="server">(.*?)<\/script>/s);
        let script = scriptMatch ? scriptMatch[1].trim() : content;  // Assume raw code if no script tag

        // Extract each event's code
        for (const event of this.eventList) {
            const code = this._extractMethodCode(script, event);
            if (code !== null) {
                this.events[event] = code.trim();
            }
        }
    }

    _extractMethodCode(script, event) {
        const pattern = new RegExp(`void\\s+${event.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\s*\\(\\s*object\\s+sender\\s*,\\s*EventArgs\\s+e\\s*\\)\\s*\\{`);
        const match = script.match(pattern);
        if (!match) {
            return null;
        }
        let pos = match.index + match[0].length;
        let braceCount = 1;
        let code = '';
        while (pos < script.length) {
            const ch = script[pos];
            code += ch;
            if (ch === '{') {
                braceCount++;
            } else if (ch === '}') {
                braceCount--;
                if (braceCount === 0) {
                    return code.slice(0, -1);  // Exclude closing }
                }
            }
            pos++;
        }
        return null;
    }

    getEventCode(event) {
        if (!this.eventList.includes(event)) {
            throw new Error('Invalid event');
        }
        return this.events[event] || '';
    }

    setEventCode(event, code) {
        if (!this.eventList.includes(event)) {
            throw new Error('Invalid event');
        }
        this.events[event] = code;
    }

    save() {
        let scriptContent = '';
        for (const event of this.eventList) {
            if (this.events[event]) {
                scriptContent += `void ${event}(object sender, EventArgs e) {\n${this.events[event]}\n}\n\n`;
            }
        }

        const content = (this.directive ? `${this.directive}\n` : '') + `<script runat="server">\n${scriptContent}</script>`;
        fs.writeFileSync(this.filename, content, 'utf-8');
    }
}

Usage example: const asax = new ASAXFile('Global.asax'); asax.load(); console.log(asax.getEventCode('Application_Start')); asax.setEventCode('Application_Start', '// New code'); asax.save();

5. C++ class (using std::regex and fstreams; compile with C++11 or later):

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <regex>

class ASAXFile {
private:
    std::string filename;
    std::string directive;
    std::map<std::string, std::string> events;
    std::vector<std::string> eventList = {
        "Application_Start", "Application_End", "Application_BeginRequest",
        "Application_EndRequest", "Application_Error", "Session_Start", "Session_End"
    };

public:
    ASAXFile(const std::string& fn) : filename(fn) {}

    void load() {
        std::ifstream file(filename);
        if (!file) {
            throw std::runtime_error("Cannot open file");
        }
        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        file.close();
        // Trim content (simple trim)
        content.erase(0, content.find_first_not_of(" \n\r\t"));
        content.erase(content.find_last_not_of(" \n\r\t") + 1);

        // Extract directive
        std::regex directiveRegex(R"((<%.+?%>)\s*)", std::regex::ECMAScript);
        std::smatch directiveMatch;
        if (std::regex_search(content, directiveMatch, directiveRegex)) {
            directive = directiveMatch[1].str();
            content = directiveMatch.suffix().str();
            // Trim again
            content.erase(0, content.find_first_not_of(" \n\r\t"));
        }

        // Extract script block if present
        std::regex scriptRegex(R"(<script runat="server">(.*?)</script>)", std::regex::ECMAScript | std::regex::dotall);
        std::smatch scriptMatch;
        std::string script;
        if (std::regex_search(content, scriptMatch, scriptRegex)) {
            script = scriptMatch[1].str();
        } else {
            script = content;  // Assume raw code if no script tag
        }
        // Trim script
        script.erase(0, script.find_first_not_of(" \n\r\t"));
        script.erase(script.find_last_not_of(" \n\r\t") + 1);

        // Extract each event's code
        for (const auto& event : eventList) {
            auto code = extractMethodCode(script, event);
            if (!code.empty()) {
                events[event] = code;
            }
        }
    }

    std::string extractMethodCode(const std::string& script, const std::string& event) {
        std::regex pattern("void\\s+" + std::regex_replace(event, std::regex("[-/\\\\^$*+?.()|\\[\\]{}]"), "\\\\$&") + "\\s*\\(\\s*object\\s+sender\\s*,\\s*EventArgs\\s+e\\s*\\)\\s*\\{");
        std::smatch match;
        if (!std::regex_search(script, match, pattern)) {
            return "";
        }
        size_t pos = match.position(0) + match.length(0);
        int braceCount = 1;
        std::string code;
        while (pos < script.length()) {
            char ch = script[pos];
            code += ch;
            if (ch == '{') {
                ++braceCount;
            } else if (ch == '}') {
                --braceCount;
                if (braceCount == 0) {
                    return code.substr(0, code.length() - 1);  // Exclude closing }
                }
            }
            ++pos;
        }
        return "";
    }

    std::string getEventCode(const std::string& event) {
        if (std::find(eventList.begin(), eventList.end(), event) == eventList.end()) {
            throw std::invalid_argument("Invalid event");
        }
        auto it = events.find(event);
        return it != events.end() ? it->second : "";
    }

    void setEventCode(const std::string& event, const std::string& code) {
        if (std::find(eventList.begin(), eventList.end(), event) == eventList.end()) {
            throw std::invalid_argument("Invalid event");
        }
        events[event] = code;
    }

    void save() {
        std::string scriptContent;
        for (const auto& event : eventList) {
            auto it = events.find(event);
            if (it != events.end()) {
                scriptContent += "void " + event + "(object sender, EventArgs e) {\n" + it->second + "\n}\n\n";
            }
        }

        std::string content = (directive.empty() ? "" : directive + "\n") + "<script runat=\"server\">\n" + scriptContent + "</script>";
        std::ofstream file(filename);
        if (!file) {
            throw std::runtime_error("Cannot write file");
        }
        file << content;
        file.close();
    }
};