ASP.Net Fundamentals

Introduction to ASP.NET

• ASP.NET (Active Server Pages .NET) is a web development platform provided by Microsoft, which is a part of the .NET framework.
• It allows developers to build dynamic websites, web applications, and web services.
• ASP.NET extends the .NET platform with tools and libraries specifically designed for building interactive, data-driven websites.
• ASP.NET operates on the server-side, meaning that the code runs on the server and dynamically generates the HTML content that is sent to the user’s browser.
• This approach enables the creation of more dynamic and interactive web pages as compared to static HTML.
• The platform supports multiple programming languages such as C#, VB.NET, and J#.
• One of its core features is its seamless integration with the .NET framework, which gives developers access to a wide array of libraries and APIs.
• ASP.NET provides a robust and secure environment for building web applications of all sizes, ranging from small personal websites to large enterprise applications.
• ASP.NET is widely used due to its compatibility with other Microsoft products and technologies, making it an attractive choice for businesses and developers already invested in the Microsoft ecosystem.

Advantages of ASP.NET

• Rich Toolbox and Features
• ASP.NET comes with an extensive set of tools and features, including Visual Studio, which makes web development faster and easier. 
• The platform provides features like drag-and-drop server controls, automatic state management, and easy deployment, reducing the amount of code developers need to write.
• Separation of Concerns (MVC Architecture)
• ASP.NET MVC (Model-View-Controller) architecture separates the application’s concerns into three main components: the Model (data), View (UI), and Controller (logic). 
• This separation improves code manageability and allows developers to work on different aspects of an application in parallel.
• Cross-Platform and Open Source
• With the introduction of ASP.NET Core, applications can now be built and run on different platforms such as Windows, macOS, and Linux. 
• ASP.NET Core is also open-source, meaning developers can access and contribute to the source code, making it more flexible and community-driven.
• High Performance
• ASP.NET is known for its high performance, especially with ASP.NET Core. 
•  The platform uses efficient memory management and just-in-time compilation, resulting in faster request processing and higher throughput. 
• It also includes asynchronous programming models that help boost application performance by handling multiple requests simultaneously.
• Built-in Security Features
• Security is a major concern in web development, and ASP.NET addresses this with built-in security features like authentication, authorization, and secure communication. 
• It supports various authentication methods (e.g., Windows Authentication, Forms Authentication) and provides tools to prevent common vulnerabilities like cross-site scripting (XSS) and SQL injection attacks.
• Scalability and Flexibility
• ASP.NET is designed to be highly scalable, allowing applications to handle growing user demands. 
• It can support everything from small websites to large, enterprise-level applications. 
• Additionally, the platform’s modularity means developers can add or remove functionalities as needed, making it flexible for various project requirements.
• Easy Integration with Databases
• ASP.NET seamlessly integrates with databases such as SQL Server, MySQL, and others. 
• Entity Framework (EF) is an Object-Relational Mapper (ORM) available in ASP.NET that simplifies database access by allowing developers to interact with the database using .NET objects instead of writing raw SQL queries.
• Support for Web APIs
• ASP.NET makes it easy to build Web APIs (Application Programming Interfaces) that can be consumed by various clients, such as mobile applications, desktop apps, and IoT devices. 
• These APIs can be used to expose data and functionality to external applications, allowing for increased interoperability.
• Consistent and Reliable
• As a Microsoft-supported platform, ASP.NET is continuously updated and maintained, ensuring that developers can rely on its stability, security, and performance over time. 
• Microsoft provides extensive documentation and support for ASP.NET, making it a trusted choice for many organizations.
• Developer Community and Ecosystem
• ASP.NET has a large and active developer community, offering a wealth of resources, libraries, and third-party tools that simplify development. 
• The strong ecosystem ensures that developers can find solutions to problems, contribute to discussions, and use established best practices.

v ASP.Net application life cycle:

• Application Start
• The webserver executes the application start when a user requests an application for access. In this method, it sets all global variables to default.

• Object Creation
• Object creation holds all the HTTP Context, HTTP Request, and HTTP Response by the webserver. 
• It also contains information about the request, cookies, and browsing information.

• HTTP Application
• HTTP Application is an object created by the webserver. It helps to process all the subsequent information that is sent to the user.

• Dispose
• Dispose is an event that is called before the application is destroyed. It also helps to release manually unmanaged resources when the objects are no longer needed.

• Application End
• Application End is the last stage of the application life cycle. It helps to unload the memory.

v ASP.Net Page life cycle:

• Page Request
• Page Request is the first step of the page life cycle. 
• When a user request is made, the server checks the request and compiles the pages. 
• Once the compilation is done, the request is sent back to the user.

• Page Start
• Page Start helps in creating two objects: request and response. 
• The request holds all the information which the user sent, while the response contains all the information that is sent back to the user.

• Page Initialization
• Page Initialization helps to set all the controls on the pages. 
• It has a separate ID, and it applies themes to the pages in this step.

• Page Load
• Page Load helps to load all the control properties of an application. 
• It also helps to provide information using view state and control state.

• Validation
• Validation happens when the execution of an application is successful. 
• It returns two conditions: true and false. If execution is successful, it returns true, otherwise false.

• Event Handling
• Event Handling takes place when the same pages are loaded. 
• It is a response for the validation. 
• When the same page is loaded, a Post back event is called, which checks the page’s credentials.

• Rendering
• Rendering happens before it sends all the information back to the user. 
• And all this information is stored before being sent back.

• Unload
• Unload is a process that helps in deleting all unwanted information from the memory once the output is sent to the user.

ASP.NET Page Life Cycle Events

• ASP.NET page life cycle consists of a series of events that are triggered sequentially when a page is requested and processed by the server. Here is an explanation of all 12 key events that occur during this process:

Event	Description
1. PreInit	This is the first stage of the page life cycle. It is triggered after the page object is created but before any initialization happens. This event is primarily used to set dynamic properties such as themes, master pages, or to create dynamic controls. The IsPostBack property is checked here to determine if the request is a postback (i.e., a form submission). This is also where you can set the page's dynamic controls, layout, and state.
2. Init	In this stage, all controls on the page are initialized. The control's properties are set to their default values. This event is triggered for each control on the page, and it’s used for setting up control-level properties. At this point, controls are initialized but not yet populated with data (e.g., ViewState). It is the perfect time to initialize settings that apply to all controls, such as skin and themes.
3. InitComplete	This event is fired once all the initialization for the controls is complete. It signals the end of the initialization phase. At this point, the page’s state has not been restored yet, and the controls' properties can still be manipulated before the page state is restored. This event is rarely used but may be helpful when you need to make changes after the Init phase.
4. PreLoad	This event occurs before the Load event, but after the page’s postback data has been loaded. During this phase, you can make changes to the page that need to occur before data is loaded into controls. This can be useful for custom handling of posted data before it gets loaded into server-side controls.
5. Load	This is one of the most commonly used events in the page life cycle. In this event, the page and its controls are fully initialized, and data from ViewState is restored. This is the point where you should set properties for the controls, bind data, or read the values of user input. It is a crucial event for populating controls like GridViews, DropDownLists, and others.
6. Control Events	During this stage, ASP.NET processes control-specific events triggered by user interaction, such as a button click, text change, or any event that causes postback. Event handlers (like Button_Click or TextBox_TextChanged) are executed in this phase. If the request is a postback, this is where the server-side events are fired.
7. LoadComplete	This event signals that the Load phase is complete, meaning all data and controls have been fully loaded. It is triggered after the Load event and all controls have been loaded. This is a good place to perform actions that require all the data and controls to be fully initialized and loaded, such as finalizing data operations.
8. PreRender	This event occurs just before the page is rendered into HTML and sent to the client. At this point, any last-minute changes to the page or its controls can be made. This is the final stage where changes to the UI are made, such as setting control properties or modifying the output. For example, you could dynamically change control properties here.
9. PreRenderComplete	This event is raised immediately after the PreRender event. It marks the completion of all changes to the page and its controls before rendering. This is the last chance to make any modifications before the page is actually rendered. After this point, no changes to the control tree or its properties can be made.
10. SaveStateComplete	This event is raised after the page's ViewState has been saved to the persistent medium (like the hidden field in the HTML form). At this point, all changes to ViewState and control state have been saved, and further changes to these states will not be persisted. The content is now ready to be rendered to the client.
11. Render	During this phase, ASP.NET renders the page and its controls into HTML, which is sent to the client browser. The Render method for each control generates the HTML output that will be rendered. Developers can override this method to customize the rendering of the page. The Render event allows developers to manipulate the final HTML output if needed.
12. Unload	This is the last event in the life cycle, triggered after the page has been fully rendered and sent to the client. It is used to perform cleanup activities, such as closing database connections, releasing resources, or disposing of objects. It is important to release any resources that were used during the page processing to prevent memory leaks.

ASP.NET Application Structure

• ASP.NET applications are organized into a structured format to ensure that all components, resources, and settings work cohesively.

Resources in ASP.NET

• Resources in ASP.NET are any files or data that are used by the application to support its operation. 
• These resources can include images, stylesheets, scripts, configuration files, localization data, and any other auxiliary data that the web application needs to run efficiently. 
• Managing these resources correctly is crucial for maintaining the performance, scalability, and ease of deployment of ASP.NET applications.
• Types of Resources in ASP.NET:
• Static Resources: Static resources are files that do not change frequently and are served directly to the client. These include:

• Images (e.g., .png, .jpg, .gif)
• CSS files (stylesheets)
• JavaScript files (client-side scripting)
• Fonts (e.g., .woff, .ttf)

• These resources are typically stored in dedicated folders like /Images, /Scripts, and /Styles.
• Embedded Resources: 
• Embedded resources are files that are included directly within a compiled assembly (DLL). 
• These files are packaged as part of the application's code, making them easy to distribute but harder to change after deployment. 
• Embedded resources are often used for items like images or localized strings.
• Global Resources: 
• Global resources are files used for internationalization and localization, stored in the App_GlobalResources folder. 
• These resource files (.resx) contain data for different languages, allowing you to provide multi-language support within your application.
• Local Resources: 
• Local resources are similar to global resources but are specific to individual web pages or controls. 
• These are stored in the App_LocalResources folder and are used to localize content for a specific page.
• Database Resources: 
• Resources stored in databases are often used for dynamic data, such as product images or user-uploaded files. 
• These resources are not part of the file system but are fetched from the database during application runtime.
• Configuration Files: 
• Configuration files like Web.config are a vital resource for managing the settings of the application, including security, session state, connection strings, and more.

---

Resource Management in ASP.NET

• Resource management in ASP.NET is essential for optimizing application performance, security, and maintainability. 
• ASP.NET provides various ways to manage resources effectively:
• Resource Bundling and Minification:
• ASP.NET includes features for bundling and minification, which combine multiple CSS or JavaScript files into a single file to reduce HTTP requests and file size. 
• This improves page load times and application performance.

• Bundling: Combines multiple files into one.
• Minification: Removes unnecessary characters from CSS or JS files, reducing their size.
• Caching:
• Resources like images, scripts, and stylesheets can be cached on the client or server-side to improve load times. 
• ASP.NET offers caching strategies like output caching, which stores the processed page output and serves it to users, reducing the need for repeated processing.
• Localization and Globalization:
• ASP.NET supports localization (adapting content to specific locales) by using resource files (.resx). Global resource files are used across the application, while local resources are specific to a particular page or control. 
• Using resource files for localization ensures the application can support multiple languages with minimal code changes.
• CDN (Content Delivery Network):
• External resources like JavaScript libraries (e.g., jQuery) can be loaded from a CDN, reducing server load and improving response times. 
• CDNs store copies of resources in multiple geographical locations to ensure faster delivery to users worldwide.
• File Compression:
• ASP.NET supports file compression techniques like GZIP compression, which compresses static and dynamic resources before they are sent to the client, reducing file sizes and improving response times.

---

Code Management in ASP.NET

• ASP.NET allows developers to manage code effectively by separating it into different layers and modules. The key principles of code management in ASP.NET include:
• Separation of Concerns:
• ASP.NET follows the principle of separating the presentation logic (UI) from the business logic and data access. 
• This separation is typically achieved using the MVC (Model-View-Controller) architecture or the Web Forms model.
• Model: Manages data and business logic.
• View: Handles the presentation and user interface.
• Controller: Acts as an intermediary between the model and the view.
• Code-Behind Files:
• In Web Forms, code-behind files (e.g., .aspx.cs or .aspx.vb) separate the markup (HTML) from the server-side logic (C# or VB.NET). 
• This makes the code easier to manage, update, and maintain.
• App_Code Directory:
• The App_Code folder in an ASP.NET application is used to store classes, components, and helper methods that can be shared across the entire application. 
• Files in this folder are automatically compiled by ASP.NET at runtime.
• User Controls:
• User controls (.ascx) allow the reuse of UI components across multiple pages, improving code modularity. 
• These controls are similar to server controls but can be customized and reused within the application.

---

Page Directives in ASP.NET

• Page directives provide instructions to the ASP.NET compiler on how to process the page. 
• They appear at the top of .aspx or .ascx files and control various aspects of the page's behavior. Some common page directives include:
• @Page: Defines page-specific attributes like the language, code-behind class, and inheritance.
• @Master: Links the page to a master page for consistent layout across multiple pages.
• @Control: Used in user controls to define control-specific settings.
• @Import: Imports namespaces into the page to simplify code.
• @Register: Registers user controls or custom server controls to be used within the page.

---

Page Class in ASP.NET

• Each web page in ASP.NET is an instance of the Page class, which provides methods and properties to manage the page's lifecycle, server controls, events, and state. 
• The Page class is a core component that enables the server-side processing of web forms. 
• It handles events such as Load, PreRender, and Unload, and provides access to controls, query strings, and server variables.

---

Internet Information Services (IIS)

• IIS (Internet Information Services) is the web server used to host ASP.NET applications. 
• It handles HTTP requests, manages application pools, and provides a platform for deploying and running ASP.NET applications. IIS manages tasks like:
• Handling Requests: IIS receives incoming HTTP requests and directs them to the correct ASP.NET application.
• Application Pools: IIS uses application pools to isolate web applications, improving security and reliability.
• Authentication and Authorization: IIS provides various authentication methods (Windows, Forms, etc.) to secure web applications.

---

Web.Config File

• The Web.config file is a central configuration file for ASP.NET applications. 
• It stores settings related to security, database connections, session state, error handling, and more. 
• ASP.NET applications can have multiple Web.config files (one per folder), but there is typically one main configuration file at the root of the application.
• Key Sections in Web.config:

• Connection Strings: Stores database connection details.
• AppSettings: Contains key-value pairs for custom application settings.
• Authentication/Authorization: Configures security settings, such as login methods and access control.
• Session State: Manages session settings, such as the timeout duration and storage mode.
• Custom Errors: Configures error pages and handling mechanisms for the application.

Material Link :