ASP.NET Online Training | ASP.NET Online Course | Free demo on ASP.NET
India:+91 (0)8885575549, 040-42627705 | USA: +1 973-619-0109 | UK: +44 207-993-2319








Download [PDF]

  • Overview of the ASPNET Framework
      ASPNET and the NET Framework
      Understanding the Framework Class Library
      Understanding the Common Language Runtime
      Understanding ASPNET Controls, HTML Controls and Control Events
      Understanding View State, ASPNET Pages, Dynamic Compilation, Control Trees
      Using Code-Behind Pages and Handling Page Events
      Using the PageIsPostBack Property
      Debugging and Tracing ASPNET Pages
      Tracing Page Execution
  • Installing the ASPNET Framework Using the Standard Controls
      Displaying Information
      Using the Label Control, Literal Control
      Accepting User Input, Using the TextBox Control, CheckBox Control, RadioButton Control
      Submitting Form Data, Using the Button Control, LinkButton Control, ImageButton Control
      Using Client Scripts with Button Controls, Performing Cross-Page Posts
      Specifying a Default Button, Handling the Command Event
      Displaying Images, Using the Image Control, Using the ImageMap Control, Panel Control, HyperLink Control
  • Using the Validation Controls
      Overview of the Validation Controls
      Validation Controls and JavaScript
      Using PageIsValid
      Setting the Display Property
      Highlighting Validation Errors
      Using Validation Groups
      Disabling Validation
      Creating Custom Validation Controls
  • Using the Rich Controls
      Accepting File Uploads, Saving Files to the File System, Saving Files to a Database, Uploading Large Files
      Displaying a Calendar, Creating a Pop-up Date Picker, Rendering a Calendar from a Database Table
      Displaying Advertisements, Storing Advertisements in an XML File and Database Table
      Tracking Impressions and Transfers
      Displaying Different Page Views, Displaying a Tabbed Page View, Displaying a Multi-Part Form
      Displaying a Wizard
  • Designing Websites with Master Pages
      Creating Master Pages
      Creating Default Content
      Nesting Master Pages
      Using Images and Hyperlinks in Master Pages
      Registering Master Pages in Web Configuration
      Modifying Master Page Content
      Using the Title Attribute, Page Header Property
      Exposing Master Page Properties
      Using FindControl with Master Pages
      Loading Master Pages Dynamically and the same for Multiple Content Pages
  • Designing Websites with Themes
      Creating Themes, Adding Skins to Themes
      Creating Named Skins
      Themes Versus StyleSheet Themes
      Disabling Themes
      Registering Themes in the Web Configuration File
      Adding Cascading Style Sheets to Themes
      Adding Multiple Cascading Style Sheets to a Theme
      Changing Page Layouts with Cascading Style Sheets
      Creating Global Themes
      Applying Themes and Skins Dynamically
  • Using List Controls
      Overview of the List Controls
      Declaring List Items
      Binding to a Data Source
      Determining the Selected List Item
      Appending Data Items
      Enabling Automatic PostBacks
      Using the Items Collection
      Working with the DropDownList Control, RadioButtonList Control, ListBox Control, CheckBoxList Control, BulletedList Control and Custom List Control
  • Using the GridView Control
      GridView Control Fundamentals
      Displaying Data, Selecting Data, Using Data Keys, Sorting Data, Paging Through Data, Editing Data and Displaying Empty Data
      Formatting the GridView Control
      Using ViewState with the GridView Control
      Using Fields with the GridView Control
      Using BoundFields, CheckBoxFields, CommandFields, ButtonFields, HyperLinkFields, ImageFields and TemplateFields
  • Using the DetailsView and FormView Controls
      Using the DetailsView Control
      Displaying Data with the DetailsView Control
      Using Fields with the DetailsView Control
      Displaying Data, Paging Through Data,Editing Data, Inserting and Deleting data with the DetailsView Control
      Working with DetailsView Control Events
      Formatting the DetailsView Control
      Using the FormView Control
      Displaying Data, Paging Through Data,Editing Data, Inserting and Deleting data with the FormView Control
  • Using the Repeater and DataList Controls
      Using the Repeater Control
      Displaying Data with the Repeater Control
      Using Templates with the Repeater Control
      Handling Repeater Control Events
      Using the DataList Control
      Displaying Data with the DataList Control
      Displaying Data in Multiple Columns
      Using Templates with the DataList Control
      Selecting Data with the DataList Control
      Editing Data with the DataList Control
      Formatting the DataList Control
  • Creating Custom Controls with User Controls
      Creating User Controls
      Registering User Controls in the Web Configuration File
      Exposing Properties from a User Control
      Exposing Events from a User Control
      Creating an AddressForm Control
      AJAX and User Controls
      Dynamically Loading User Controls
      Using the Reference Directive
      Creating a Multi-Page Wizard
  • Using the ListView and DataPager Controls
      Using the ListView Control
      Using the LayoutTemplate and ItemTemplate
      Using the GroupTemplate
      Selecting a Row
      Sorting Database Data
      Editing Database Data
      Using the DataPager Control
      Creating a Custom User Interface for Paging
      Data Source Paging with the DataPager Control
  • Using the ListView and DataPager Controls
      Using the ListView Control
      Using the LayoutTemplate and ItemTemplate
      Using the GroupTemplate
      Selecting a Row
      Sorting Database Data
      Editing Database Data
      Using the DataPager Control
      Creating a Custom User Interface for Paging
      Data Source Paging with the DataPager Control
  • Building Components
      Building Basic Components
      Components and Dynamic Compilation
      Mixing Different Language Components in the
      App_Code Folder
      Declaring Methods
      Declaring Fields and Properties
      Declaring Constructors
      Overloading Methods and Constructors
      Declaring Namespaces
      Creating Partial Classes
      Inheritance and Abstract Classes
      Declaring Interfaces
      Using Access Modifiers
      Intellisense and Components
      Using ASPNET Intrinsics in a Component
      Building Component Libraries
      Compiling Component Libraries
      Adding a Reference to a Class Library
      Architectural Considerations
      Building Multi-Tier Applications
      Creating the User Interface Layer, Business Logic Layer and Data Access Layer
  • Building Data Access Components with ADONET
      Connected Data Access Using the Connection Object, Command Object, DataReader Object
      Disconnected Data Access Using the DataAdapter Object
      Using the DataTable and DataView Object and DataSet Object
      Executing Asynchronous Database Commands
      Using Asynchronous ADONET Methods
      Using Asynchronous ASPNET Pages
      Building Database Objects with the NET Framework
      Enabling CLR Integration
      Creating User-Defined Types with the NET Framework
      Building a Data Access Layer with a User-Defined Type
      Creating Stored Procedures with the NET Framework
      Creating the Stored Procedure Assembly
  • Using the Login Controls
      Overview of the Login Controls
      Using the Login Control
      Automatically Redirecting a User to the Referring Page
      Automatically Hiding the Login Control from
      Authenticated Users
      Using a Template with the Login Control
      Performing Custom Authentication with the Login Control
      Using the CreateUserWizard Control
      Configuring Create User Form Fields
      Sending a Create User Email Message
      Automatically Redirecting a User to the Referring Page
      Automatically Generating a Password
      Using Templates with the CreateUserWizard Control
      Adding Steps to the CreateUserWizard Control
      Using the LoginStatus Control
      Using the LoginName Control
      Using the ChangePassword Control
      Sending a Change Password Email
      Using Templates with the ChangePassword Control
      Using the PasswordRecovery Control
      Sending the Original Password
      Requiring a Security Question and Answer
      Using Templates with the PasswordRecovery Control
      Using the LoginView Control
      Using Roles with the LoginView Control
  • Maintaining Application State
      Using Browser Cookies
      Cookie Security Restrictions
      Creating Cookies
      Reading Cookies
      Setting Cookie Properties
      Deleting Cookies
      Working with Multivalued Cookies
      Using Session State
      Storing Database Data in Session State
      Using the Session Object
      Handling Session Events
      Controlling When a Session Times Out
      Using Cookieless Session State
      Configuring a Session State Store
      Configuring SQL Server Session State
      Using Profiles
      Creating Profile Groups
      Supporting Anonymous Users
      Migrating Anonymous Profiles
      Inheriting a Profile from a Custom Class
      Creating Complex Profile Properties
      Saving Profiles Automatically
      Accessing Profiles from Components
      Using the Profile Manager
      Configuring the Profile Provider
      Creating a Custom Profile Provider
  • Working with the HTTP Runtime
      Creating a Custom BuildProvider
      Creating a Simple BuildProvider
      Creating a Data Access Component BuildProvider
      Creating a Custom ExpressionBuilder
      Creating a Lookup ExpressionBuilder
      Creating HTTP Handlers
      Creating a Generic Handler
      Implementing the IHttpHandler Interface
      Registering Extensions with Internet Information Server
      Creating an Asynchronous HTTP Handler
      Working with HTTP Applications and HTTP Modules
      Creating a Globalasax File
      Creating Custom HTTP Modules
  • Caching Application Pages and Data
      Overview of Caching
      Using Page Output Caching
      Varying the Output Cache by Parameter / Control / Header / Browser / Custom Function
      Specifying the Cache Location
      Creating a Page Output Cache File Dependency
      Expiring the Page Output Cache Programmatically
      Manipulating the Page Output Cache Programmatically
      Creating Page Output Cache Profiles
      Using Partial Page Caching
      Using Post-Cache Substitution
      Caching with a User Control
      Sharing a User Control Output Cache
      Manipulating a User Control Cache Programmatically
      Creating a User Control Cache File Dependency
      Caching Dynamically Loaded User Controls
      Using DataSource Caching
      Using an Absolute Cache Expiration Policy
      Using a Sliding Cache Expiration Policy
      Caching with the ObjectDataSource Control
      Caching with the XmlDataSource Control
      Creating a DataSource Control Key Dependency
      Using Data Caching
      Using the Cache Application Programming Interface
      Adding Items to the Cache
      Adding Items with an Absolute Expiration Policy
      Adding Items with a Sliding Expiration Policy
      Adding Items with Dependencies
      Specifying Cache Item Priorities
      Configuring the Cache
      Using SQL Cache Dependencies
      Using Polling SQL Cache Dependencies
      Configuring Polling SQL Cache Dependencies
      Using Polling SQL Cache Dependencies with Page
      Output Caching
      Using Polling SQL Cache Dependencies with
      DataSource Caching
      Using Polling SQL Cache Dependencies with Data Caching
      Using Push SQL Cache Dependencies
      Configuring Push SQL Cache Dependencies
      Using Push SQL Cache Dependencies with Page
      Output Caching
      Using Push SQL Cache Dependencies with Data
      Source Caching
      Using Push SQL Cache Dependencies with Data Caching
  • Localizing Applications for Multiple Languages
      Setting the Current Culture
      Setting a Culture Manually
      Automatically Detecting a Culture
      Setting the Culture in the Web Configuration File
      Culture and ASPNET Controls
      Using the CultureInfo Class
      Using the CultureInfo Class to Format String Values
      Comparing and Sorting String Values
      Creating Local Resources
      Explicit Localization Expressions
      Implicit Localization Expressions
      Using Local Resources with Page Properties
      Retrieving Local Resources Programmatically
      Creating Global Resources
      Retrieving Global Resources Programmatically
      Using Strongly Typed Localization Expressions
      Using the Localize Control
  • Using ASPNET Membership
      Configuring Authentication
      Configuring Forms Authentication
      Using Cookieless Forms Authentication
      Using Sliding Expiration with Forms Authentication
      Using Forms Authentication Across Applications
      Using Forms Authentication Across Domains
      Using the FormsAuthentication Class
      Using the User Class
      Configuring Authorization
      Authorizing by Role
      Authorizing Files by Location
      Using Authorization with Images and Other File Types
      Using Authorization with ASP Classic Pages
      Using ASPNET Membership
      Using the Membership Application Programming Interface
      Encrypting and Hashing User Passwords
      Modifying User Password Requirements
      Locking Out Bad Users
      Configuring the SQLMembershipProvider
      Configuring the ActiveDirectoryMembershipProvider
      Creating a Custom Membership Provider
      Using the Role Manager
      Configuring the SqlRoleProvider
      Configuring the WindowsTokenRoleProvider
      Configuring the AuthorizationStoreRoleProvider
      Caching Roles in a Browser Cookie
      Using the Roles Application Programming Interface
  • Configuring Applications
      Overview of Website Configuration
      Using the Web Site Administration Tool
      Using the ASPNET Microsoft Management Console Snap-In
      ASPNET Configuration Sections
      Contents xix
      Applying Configuration Settings to a Particular Path
      Locking Configuration Settings
      Adding Custom Application Settings
      Placing Configuration Settings in an External File
      Using the Configuration API
      Reading Configuration Sections from the Current Apps
      Opening a Configuration File
      Opening a Configuration File on a Remote Server
      Using the Configuration Class
      Modifying Configuration Sections
      Provisioning a New Website
      Creating Custom Configuration Sections
      Creating a Configuration Element Collection
      Creating Encrypted Configuration Sections
      Encrypting Sections with the aspnet_regiis tool
      Encrypting Sections Programmatically
      Deploying Encrypted Web Configuration Files


The .NET Framework is a development and execution environment that allows different programming languages and libraries to work together seamlessly to create Windows-based applications that are easier to build, manage, deploy, and integrate with other networked systems. Built on Web service standards, .NET enables both new and existing personal and business applications to connect with software and services across platforms, applications, and programming languages. These connections give users access to key information, whenever and wherever you need it.

Microsoft .NET connected software makes the “real-time” enterprise real by enabling information to flow freely throughout the organization, accessible to business partners, and delivering value to customers. With .NET-connected software, users can increase the value of existing systems and seamlessly extend those systems to partners, suppliers, and customers.

  • Connected.
  • Compelling
  • Ubiquitous and Productive


.NET Framework empowers developers to build applications that require robust messaging systems or flexible workflows.


With the .NET Framework, developers and designers can collaborate to create rich user experiences.

Ubiquitous and Productive

The .NET Framework, including improvements like LINQ, provides a single platform to quickly build mobile desktop and server-based applications.

ASP.NET Overview

ASP.NET is a unified Web development model that includes the services necessary for you to build enterprise-class Web applications with a minimum of coding. ASP.NET is part of the .NET Framework, and when coding ASP.NET applications you have access to classes in the .NET Framework. You can code your applications in any language compatible with the common language runtime (CLR), including Microsoft Visual Basic and C#. These languages enable you to develop ASP.NET applications that benefit from the common language runtime, type safety, and inheritance.

ASP.NET provides services to allow the creation, deployment, and execution of Web Applications and Web Services Like ASP, ASP.NET is a server-side technology Web Applications are built using Web Forms. ASP.NET comes with built-in Web Forms controls, which are responsible for generating the user interface. They mirror typical HTML widgets like text boxes or buttons. If these controls do not fit your needs, you are free to create your own user controls.

Web Forms are designed to make building web-based applications as easy as building Visual Basic applications

Introducing ASP.NET

ASP.NET was developed in direct response to the problems that developers had with classic ASP. Since ASP is in such wide use, however, Microsoft ensured that ASP scripts execute without modification on a machine with the .NET Framework (the ASP engine, ASP.DLL, is not modified when installing the .NET Framework). Thus, IIS can house both ASP and ASP.NET scripts on the same machine.

Advantages of ASP.NET

1. Separation of Code from HTML

To make a clean sweep, with ASP.NET you have the ability to completely separate layout and business logic. This makes it much easier for teams of programmers and designers to collaborate efficiently. This makes it much easier for teams of programmers and designers to collaborate efficiently.

2. Support for compiled languages

developer can use VB.NET and access features such as strong typing and object-oriented programming. Using compiled languages also means that ASP.NET pages do not suffer the performance penalties associated with interpreted code. ASP.NET pages are precompiled to byte-code and Just In Time (JIT) compiled when first requested. Subsequent requests are directed to the fully compiled code, which is cached until the source changes.

3. Use services provided by the .NET Framework

The .NET Framework provides class libraries that can be used by your application. Some of the key classes help you with input/output, access to operating system services, data access, or even debugging. We will go into more detail on some of them in this module.

4. Graphical Development Environment

Visual Studio .NET provides a very rich development environment for Web developers. You can drag and drop controls and set properties the way you do in Visual Basic 6. And you have full IntelliSense support, not only for your code, but also for HTML and XML.

5. State management

To refer to the problems mentioned before, ASP.NET provides solutions for session and application state management. State information can, for example, be kept in memory or stored in a database. It can be shared across Web farms, and state information can be recovered, even if the server fails or the connection breaks down.

6. Update files while the server is running!

Components of your application can be updated while the server is online and clients are connected. The Framework will use the new files as soon as they are copied to the application. Removed or old files that are still in use are kept in memory until the clients have finished.

7. XML-Based Configuration Files

Configuration settings in ASP.NET are stored in XML files that you can easily read and edit. You can also easily copy these to another server, along with the other files that comprise your application.
Drawbacks of with Traditional ASP

There are many problems with ASP if you think of needs for Today’s powerful Web applications.

  • Interpreted and Loosely-Typed Code
  • Mixes layout (HTML) and logic (scripting code)
  • Limited Development and Debugging Tools
  • No real state management
  • Update files only when server is down
  • Obscure Configuration Settings