A

Project Report
On

E-learning

Submitted in partial fulfillment of the requirement

For the award of Degree of

BACHELOR OF TECHNOLOGY
(Computer Science and Engineering)
Submitted by

Nikhil Goel
(1491482708)

DEPARTMENT OF COMPUTER ENGINEERING

MAHARAJA AGRASEN INSTITUTE OF TECHNOLOGY
PSP AREA, SECTOR – 22, ROHINI, NEW DELHI – 110085
(AFFILIATED TO GURU GOBIND SINGH INDRAPRASTHA
UNIVERSITY, KASHMERE GATE, NEW DELHI)

1
 CERTIFICATE

This is to certify that this project titled “E-Learning” embodies the original work done by Nikhil goel
at Milestone softech.

This report has not been submitted for any other examination & does not form part of any other course
undergoing by the candidates.

DELHI (SIGNATURE)
DATE: Nikhil Goel

(Name and Seal of Institute)

2
 ACKNOWLEDGEMENT
We are extremely grateful and highly indebted to our advisor Ms. Garima Gupta for supporting us all
along and always being there for consultation. She has been a guide in the true sense of the word and
has directed the project in a very efficient and organized manner.

Finally we thank Mr. Amit Khilnaney, for his continued drive for better quality in everything that
happens at Milestone Softech. This report is a small contribution towards the greater goal.

Nikhil Goel

3
 INDEX
FEATURES OF THE COMMON LANGUAGE RUNTIME.............................................................................................21
.NET FRAMEWORK CLASS LIBRARY............................................................................................................................22
CLIENT APPLICATION DEVELOPMENT.......................................................................................................................23
SERVER APPLICATION DEVELOPMENT......................................................................................................................23

ABSTRACT
The project on ‘E-learning’ is aimed at helping people to gather, analyze and increase their knowledge
about computer related topics (hardware, software) in their leisure time being at their home. It provides
extensive knowledge for the topic selected, the site being a virtual teacher for the member enrolled. It
provides information regarding the courses offered courses fees and allowable discount for each
enrolling member. The project will also try to reflect the growth of the computer education on the basis
of e-learning. Main emphasis is made on e-learning of computer topics i.e. hardware & software. This

4
project tries to sell different online courses and provides online material & test related to the topic
concerned. According to members who want enroll for the courses may apply for this. The
administrator of the site uploads the related data (books, questions, online tutorial) relevant to the
course. He himself updates, deletes & insert the data relevant to the course. The members now have the
full control over the courses data and they can now study them but total control is with the
administrator.

LIST OF FIGURES

S.NO FIGURE NAME PAGE

1 Question 13
2 Member_Details 14
3 Score_Details 14
4 Login 14
5 Payment_Details 15
5
6 Course_members_Details 15
7 Course 15
8 Books 15
9 Login Form 28
10 Create Member 29
11 Select Course 30
12 User Page 31
13 Course Type Selection 32
14 Tutorial 33
15 FAQ 34

SOFTWARE REQUIREMENT SPECIFICATION

1. INTRODUCTION

The document aims at defining the overall software requirements for ”E-LEARNING”. Efforts are been
made to define the requirement exhaustively and accurately. The final product will be having
only features/functionalities mentioned in this document and assumption for any additional
functionality/feature should not make by any of the parties involved in

6
developing/testing/implementing the products. In case it is required to have some additional
features, a formal change request will need to be raised and subsequently a new release of this
document and/or product will be produced.

1.1 PURPOSE

This specification document describes the capabilities that will be provided by the software application
“E-LEARNING”. It also states the various required constraints by which the system will abide. The
intended audience for this document is the development team, testing team and the users of the product.

1.2 SCOPE

The main objective of this project is to provide e-learning to the people on computer related topics. This
project will offer different courses on computer based topic. A member has to enroll for particular
courses to gather information on the related topic selected by him while enrolling.

1.3 DEFINITIONS, ACRONYMS AND ABBREVATIONS

The following abbreviations have been used throughout:

DBA – Database Administrator

1.4 REFERENCES

(a) IEEE recommended practice for software requirements specifications-IEEE standard 1830-
1993.

1.5 OVERVIEW

The rest of this SRS document describes the various system requirements, interfaces and
functionalities in details.

2. OVERALL DESCRIPTION

2.1 PRODUCT PERSPECTIVE

The application will be a Web based, self-contained and independent software product.

2.1.1 SYSTEM INTERFACES

None

2.1.2 USER INTERFACES

The application will have a user friendly and menu based interface.
Following screens can be found:

7
 • This E-Learning website provides the user with a very easy to use interface. The administrator
and the members who join us both log on to our website through the same login page. Both are
presented with different home pages after they have logged on providing their proper user-ids
and passwords.

• The Administrator after logging in can change the delete, update and add the questions in the
questions database. The administrator can also delete or add the books for the courses offered by
the website.

• The Member after logging in can enroll for courses, download books and give tests for the
enrolled subjects. The users can view there scores after giving the test or any time until the
course period expires. The rank relative to the number of members appearing for the test is also
shown to the user.

• Any visitor can browse through the website and look around the information about the courses
offered and the benefits of pursuing the course with our website.

2.1.3 HARDWARE INTERFACES

(a) Screen resolution of at least 800 X 600 is required for complete and proper viewing of screens.
Higher resolution will not be any problem.
(b) Network based as it will be installed on the server.

SOFTWARE INTERFACES

(i) Any windows based operating system.

(ii) SQL Server 2005 as the DBMS for database future release of the application will aim at
upgrading to SQL server 2008.
(iii) Visual Studio 2008 for coding and developing the software.
(iv) ASP.net 3.5 framework for website development.

2.1.4 COMMUNICATION INTERFACES

None

2.1.5 MEMORY CONSTRAINTS

At least 512 MB of RAM and 40 GB on hard disk on server will be required for development and
deployment of the application.

2.1.6 OPERATIONS

This product release will not cover any automated housekeeping aspects of the data base. The DBA at
the client site will be responsible for manually deleting old or non-required data. Data base backup and
recovery will also be handled by the DBA.

8
2.1.7 SITE ADAPTATION REQUIREMENTS

The terminals at client site will have to support just the minimum requirements of a 256 Kbps internet
connection.

2.2 PRODUCT PERSPECTIVE

The system will allow access to only authorized personnel. Depending on user’s role, he/she will
be able to excess only specific modules of the system. A summary of the major functions that the
software will perform are:

(i) A login facility for enabling only authorized person to the system.
(ii) User (with role of DBA) will be able to add/modify/delete information about different
courses available.
(iii) User (with role of a site Viewer) will be able to access the study material and can also
download books and give tests.

2.3 USER CHARACTERISTICS

(i) Educational Level: Should be comfortable with English Language.

(ii) Technical Expertise: Should be comfortable using internet on the computer.

2.4 CONSTRAINTS

(i) A MS Windows based system is a necessity for the website development.

2.5 APPORTIONING OF REQUIREMENTS

None

3. SPECIFIC REQUIREMENTS
This section contains the software requirement to a level of detail sufficient to enable designers to
design the system and testers to test the system.

3.1 EXTERNAL INTERFACES

3.1.1 USER INTERFACES

The following screens will be provided:

(i) LOGIN SCREEN

9
 This will be the first screen to be displayed. It will allow user to access different screen
based upon the user’s role. Various fields available on this screen will be :

(a) User ID : Alphanumeric upto 10 characters

(b) Password : Alphanumeric of length upto 10 characters.
(c) Sign in as:Member, Aministrator

(ii) COURSE INFORMATION SCREEN

This screen is accessible to the members. It allows the user with the option of courses
out of user can select as per his/her choice. The operator can access these details. The
screen will display the list of courses..

(iii) COURSES SCREEN

This screen is accessible to the user which allows him to access the information about
various courses.

(iv) USER SCREEN

This form tells the user about his course enrolled, his test score and rank if he has given
any online test.
(v) MEMBER REGISTRATION
This screen gives various fields of information regarding getting registered to the E-
Learning website as a New User.

3.1.2 HARDWARE INTERFACES

(i) Seen resolution of at least 800X600 is required for complete and proper viewing of
screens. Higher resolution will not be any problem.
(ii) Network based as it will be installed on the server and accessed through the Internet.

3.1.3 SOFTWARE INTERFACES

1. Any windows based operating system.

2. SQL Server 2005 as the DBMS for database future release of the application will aim at
upgrading to SQL server 2008.
3. Visual Studio 2008 for coding and developing the software.
4. ASP.net 3.5 framework for website development.

3.1.4 COMMUNICATION INTERCACES

10
 None

3.2 SYSTEM FEATURES

3.2.1 COURSE INFORMATION MANAGEMENT

DESCRIPTION

This project will provide the facility of learning a computer related subject through
Internet. It will manage which course is selected by a user and also the information
Available on various courses.

SEQUENCING INFORMATION

Course for a particular user will have to be entered before any details, download or view any
tutorials.

ERROR HANDLING/RESPONSE TO ABNORMAL SITUATIONS

If any of the above validations/sequencing flow does not hold true, appropriate error messages
will be prompted to the user for doing the needful.

VALIDITY CHECKS

(i) Only user with authenticated UserName and password will be allowed to access his
course and test details.
(ii) Only Adminisrator will have the right to access and modify user and course information.

3.2.2 USER INFORMATION MANAGEMENT

DESCRIPTION

The system will maintain information about the Users on the Website. It will provide the user
with the facility like enrolling for a course, download tutorial, appear for tests and access the
FAQ.

VALIDITY CHECKS

1. Only user with authenticated UserName and password will be allowed to access his
course and test details.
2. Only Adminisrator will have the right to access and modify user and course information.

SEQUENCE INFORMATION

Course Information will be present in the system before it can be accessed.

11
 ERROR HANDLING/RESPNOSE TO ABNORMAL SITUATIONS

If any of the above validations/sequencing flow does not hold true, appropriate error messages
will be prompted to the user for doing the needful.

3.2.3 TESTS AND TEST SCORE MANAGEMENT

The system will maintain information about the various tests available for the users on the
website. Any user can select the desired course and appear for the tests.This will also manage
the user’s score in the test.

VALIDITY CHECKS

1. Only user with authenticated UserName and password will be allowed to access his
course and test details.
2. Only Adminisrator will have the right to access and modify user and course
information.

SEQUENCE INFORMATION

A valid user login must be done. And a course be selected for the test to appear.

ERROR HANDLING/RESPONSE TO ABNORMAL SITUATIONS

If any of the above validations/sequencing flow does not hold true, appropriate error messages
will be prompted to the user for doing the needful.

3.3 OTHER REQUIREMENTS

3.3.1 PERFORMANCE REQUIREMENTS

None

3.4 DESIGN CONSTRAINTS

None

SOFTWARE SYSTEM ATTRIBUTES

3.4.1 SECURITY

The application will be password protected. Users will have to enter correct username, password
and role to access the application.

3.4.2 MAINTAINABILITY

12
 The application will be designed in a maintainable manner. It will be easy to in corporate new
requirements in the individual modules .

3.4.3 PORTABILITY

The application will be easily portable on any WINDOW based system that has SQL SERVER
installed for the Development and Deployment purpose. Else for client side, it is totally
portable.

3.5 LOGICAL DATABASE REQUIREMENTS

The following information will be placed in a database.

Figure 1:Question

13
Figure 2:Members_Details

Figure 3:Score_Details

Figure 4:Login

14
Figure 5:Payment_Details

Figure 6:Course_Member_Details

Figure 7:Course

Figure 8:Books

3.7 Other Requirements

None

15
DATA FLOW DIAGRAM LEVEL 0 & LEVEL 1

16
ER DIAGRAMS

17
USE CASE DIAGRAM

18
 INTRODUCTION

This E-Learning website provides the user with a very easy to use interface. The administrator and the
members who join us both log on to our website through the same login page. Both are presented with
different home pages after they have logged on providing their proper user-ids and passwords.

The Administrator after logging in can change the delete, update and add the questions in the
questions database. The administrator can also delete or add the books for the courses offered by the
website.

The Member after logging in can enroll for courses, download books and give tests for the enrolled
subjects. The users can view there scores after giving the test or any time until the course period
expires. The rank relative to the number of members appearing for the test is also shown to the user.

Any visitor can browse through the website and look around the information about the courses offered
and the benefits of pursuing the course with our website. The courses are offered in two categories:

1) Long Term Course: Here the members enrolled for the course can download books on the topic
and study them before giving the evaluation test. The duration for the Long Term courses is 45 days.

2) Short Term Course: Here the members enrolled can appear only for the evaluation test. The
duration for the Short Term courses is 15 days.

19
 .NET Framework Conceptual Overview

The .NET Framework is an integral Windows component that supports building and running the next
generation of applications and XML Web services. The .NET Framework is designed to fulfill the
following objectives:
• To provide a consistent object-oriented programming environment whether object code is stored
and executed locally, executed locally but Internet-distributed, or executed remotely.
• To provide a code-execution environment that minimizes software deployment and versioning
conflicts.
• To provide a code-execution environment that promotes safe execution of code, including code
created by an unknown or semi-trusted third party.
• To provide a code-execution environment that eliminates the performance problems of scripted
or interpreted environments.
• To make the developer experience consistent across widely varying types of applications, such
as Windows-based applications and Web-based applications.
• To build all communication on industry standards to ensure that code based on the .NET
Framework can integrate with any other code.
The .NET Framework has two main components: the common language runtime and the .NET
Framework class library. The common language runtime is the foundation of the .NET Framework.
You can think of the runtime as an agent that manages code at execution time, providing core services
such as memory management, thread management, and remoting, while also enforcing strict type safety
and other forms of code accuracy that promote security and robustness. In fact, the concept of code
management is a fundamental principle of the runtime. Code that targets the runtime is known as
managed code, while code that does not target the runtime is known as unmanaged code. The class
library, the other main component of the .NET Framework, is a comprehensive, object-oriented
collection of reusable types that you can use to develop applications ranging from traditional command-
line or graphical user interface (GUI) applications to applications based on the latest innovations
provided by ASP.NET, such as Web Forms and XML Web services.
The .NET Framework can be hosted by unmanaged components that load the common language
runtime into their processes and initiate the execution of managed code, thereby creating a software
environment that can exploit both managed and unmanaged features. The .NET Framework not only
provides several runtime hosts, but also supports the development of third-party runtime hosts.
For example, ASP.NET hosts the runtime to provide a scalable, server-side environment for managed
code. ASP.NET works directly with the runtime to enable ASP.NET applications and XML Web
services, both of which are discussed later in this topic.
Internet Explorer is an example of an unmanaged application that hosts the runtime (in the form of a
MIME type extension). Using Internet Explorer to host the runtime enables you to embed managed
components or Windows Forms controls in HTML documents. Hosting the runtime in this way makes
managed mobile code (similar to Microsoft® ActiveX® controls) possible, but with significant
improvements that only managed code can offer, such as semi-trusted execution and isolated file
storage.
The following illustration shows the relationship of the common language runtime and the class library
to your applications and to the overall system. The illustration also shows how managed code operates
within a larger architecture.

20
.NET Framework in context

The following sections describe the main components and features of the .NET Framework in greater
detail.

Features of the Common Language Runtime

The common language runtime manages memory, thread execution, code execution, code safety
verification, compilation, and other system services. These features are intrinsic to the managed code
that runs on the common language runtime.
With regards to security, managed components are awarded varying degrees of trust, depending on a
number of factors that include their origin (such as the Internet, enterprise network, or local computer).
This means that a managed component might or might not be able to perform file-access operations,
registry-access operations, or other sensitive functions, even if it is being used in the same active
application.
The runtime enforces code access security. For example, users can trust that an executable embedded in
a Web page can play an animation on screen or sing a song, but cannot access their personal data, file
system, or network. The security features of the runtime thus enable legitimate Internet-deployed
software to be exceptionally feature rich.
The runtime also enforces code robustness by implementing a strict type-and-code-verification
infrastructure called the common type system (CTS). The CTS ensures that all managed code is self-
describing. The various Microsoft and third-party language compilers generate managed code that
21
conforms to the CTS. This means that managed code can consume other managed types and instances,
while strictly enforcing type fidelity and type safety.
In addition, the managed environment of the runtime eliminates many common software issues. For
example, the runtime automatically handles object layout and manages references to objects, releasing
them when they are no longer being used. This automatic memory management resolves the two most
common application errors, memory leaks and invalid memory references.
The runtime also accelerates developer productivity. For example, programmers can write applications
in their development language of choice, yet take full advantage of the runtime, the class library, and
components written in other languages by other developers. Any compiler vendor who chooses to target
the runtime can do so. Language compilers that target the .NET Framework make the features of the
.NET Framework available to existing code written in that language, greatly easing the migration
process for existing applications.
While the runtime is designed for the software of the future, it also supports software of today and
yesterday. Interoperability between managed and unmanaged code enables developers to continue to
use necessary COM components and DLLs.
The runtime is designed to enhance performance. Although the common language runtime provides
many standard runtime services, managed code is never interpreted. A feature called just-in-time (JIT)
compiling enables all managed code to run in the native machine language of the system on which it is
executing. Meanwhile, the memory manager removes the possibilities of fragmented memory and
increases memory locality-of-reference to further increase performance.
Finally, the runtime can be hosted by high-performance, server-side applications, such as Microsoft®
SQL Server™ and Internet Information Services (IIS). This infrastructure enables you to use managed
code to write your business logic, while still enjoying the superior performance of the industry's best
enterprise servers that support runtime hosting.

.NET Framework Class Library

The .NET Framework class library is a collection of reusable types that tightly integrate with the
common language runtime. The class library is object oriented, providing types from which your own
managed code can derive functionality. This not only makes the .NET Framework types easy to use,
but also reduces the time associated with learning new features of the .NET Framework. In addition,
third-party components can integrate seamlessly with classes in the .NET Framework.
For example, the .NET Framework collection classes implement a set of interfaces that you can use to
develop your own collection classes. Your collection classes will blend seamlessly with the classes in
the .NET Framework.
As you would expect from an object-oriented class library, the .NET Framework types enable you to
accomplish a range of common programming tasks, including tasks such as string management, data
collection, database connectivity, and file access. In addition to these common tasks, the class library
includes types that support a variety of specialized development scenarios. For example, you can use
the .NET Framework to develop the following types of applications and services:
• Console applications.
• Windows GUI applications (Windows Forms).
• ASP.NET applications.
• XML Web services.
• Windows services.

22
For example, the Windows Forms classes are a comprehensive set of reusable types that vastly simplify
Windows GUI development. If you write an ASP.NET Web Form application, you can use the Web
Forms classes.

Client Application Development

Client applications are the closest to a traditional style of application in Windows-based programming.
These are the types of applications that display windows or forms on the desktop, enabling a user to
perform a task. Client applications include applications such as word processors and spreadsheets, as
well as custom business applications such as data-entry tools, reporting tools, and so on. Client
applications usually employ windows, menus, buttons, and other GUI elements, and they likely access
local resources such as the file system and peripherals such as printers.
Another kind of client application is the traditional ActiveX control (now replaced by the managed
Windows Forms control) deployed over the Internet as a Web page. This application is much like other
client applications: it is executed natively, has access to local resources, and includes graphical
elements.
In the past, developers created such applications using C/C++ in conjunction with the Microsoft
Foundation Classes (MFC) or with a rapid application development (RAD) environment such as
Microsoft® Visual Basic®. The .NET Framework incorporates aspects of these existing products into a
single, consistent development environment that drastically simplifies the development of client
applications.
The Windows Forms classes contained in the .NET Framework are designed to be used for GUI
development. You can easily create command windows, buttons, menus, toolbars, and other screen
elements with the flexibility necessary to accommodate shifting business needs.
For example, the .NET Framework provides simple properties to adjust visual attributes associated with
forms. In some cases the underlying operating system does not support changing these attributes
directly, and in these cases the .NET Framework automatically recreates the forms. This is one of many
ways in which the .NET Framework integrates the developer interface, making coding simpler and
more consistent.
Unlike ActiveX controls, Windows Forms controls have semi-trusted access to a user's computer. This
means that binary or natively executing code can access some of the resources on the user's system
(such as GUI elements and limited file access) without being able to access or compromise other
resources. Because of code access security, many applications that once needed to be installed on a
user's system can now be deployed through the Web. Your applications can implement the features of a
local application while being deployed like a Web page.

Server Application Development

Server-side applications in the managed world are implemented through runtime hosts. Unmanaged
applications host the common language runtime, which allows your custom managed code to control
the behavior of the server. This model provides you with all the features of the common language
runtime and class library while gaining the performance and scalability of the host server.
The following illustration shows a basic network schema with managed code running in different server
environments. Servers such as IIS and SQL Server can perform standard operations while your
application logic executes through the managed code.

23
Server-side managed code

ASP.NET is the hosting environment that enables developers to use the .NET Framework to target
Web-based applications. However, ASP.NET is more than just a runtime host; it is a complete
architecture for developing Web sites and Internet-distributed objects using managed code. Both Web
Forms and XML Web services use IIS and ASP.NET as the publishing mechanism for applications, and
both have a collection of supporting classes in the .NET Framework.
XML Web services, an important evolution in Web-based technology, are distributed, server-side
application components similar to common Web sites. However, unlike Web-based applications, XML
Web services components have no UI and are not targeted for browsers such as Internet Explorer and
Netscape Navigator. Instead, XML Web services consist of reusable software components designed to
be consumed by other applications, such as traditional client applications, Web-based applications, or
even other XML Web services. As a result, XML Web services technology is rapidly moving
application development and deployment into the highly distributed environment of the Internet.
If you have used earlier versions of ASP technology, you will immediately notice the improvements
that ASP.NET and Web Forms offer. For example, you can develop Web Forms pages in any language
that supports the .NET Framework. In addition, your code no longer needs to share the same file with
your HTTP text (although it can continue to do so if you prefer). Web Forms pages execute in native
machine language because, like any other managed application, they take full advantage of the runtime.
In contrast, unmanaged ASP pages are always scripted and interpreted. ASP.NET pages are faster,
more functional, and easier to develop than unmanaged ASP pages because they interact with the
runtime like any managed application.
The .NET Framework also provides a collection of classes and tools to aid in development and
consumption of XML Web services applications. XML Web services are built on standards such as
SOAP (a remote procedure-call protocol), XML (an extensible data format), and WSDL ( the Web
Services Description Language). The .NET Framework is built on these standards to promote
interoperability with non-Microsoft solutions.
For example, the Web Services Description Language tool included with the .NET Framework SDK
can query an XML Web service published on the Web, parse its WSDL description, and produce C# or
Visual Basic source code that your application can use to become a client of the XML Web service.
The source code can create classes derived from classes in the class library that handle all the
underlying communication using SOAP and XML parsing. Although you can use the class library to
consume XML Web services directly, the Web Services Description Language tool and the other tools
contained in the SDK facilitate your development efforts with the .NET Framework.
If you develop and publish your own XML Web service, the .NET Framework provides a set of classes
that conform to all the underlying communication standards, such as SOAP, WSDL, and XML. Using
those classes enables you to focus on the logic of your service, without concerning yourself with the
communications infrastructure required by distributed software development.
24
Finally, like Web Forms pages in the managed environment, your XML Web service will run with the
speed of native machine language using the scalable communication of IIS.

Compiling to MSIL
When compiling to managed code, the compiler translates your source code into Microsoft intermediate
language (MSIL), which is a CPU-independent set of instructions that can be efficiently converted to
native code. MSIL includes instructions for loading, storing, initializing, and calling methods on
objects, as well as instructions for arithmetic and logical operations, control flow, direct memory
access, exception handling, and other operations. Before code can be run, MSIL must be converted to
CPU-specific code, usually by a just-in-time (JIT) compiler. Because the common language runtime
supplies one or more JIT compilers for each computer architecture it supports, the same set of MSIL
can be JIT-compiled and run on any supported architecture.
When a compiler produces MSIL, it also produces metadata. Metadata describes the types in your code,
including the definition of each type, the signatures of each type's members, the members that your
code references, and other data that the runtime uses at execution time. The MSIL and metadata are
contained in a portable executable (PE) file that is based on and extends the published Microsoft PE
and common object file format (COFF) used historically for executable content. This file format, which
accommodates MSIL or native code as well as metadata, enables the operating system to recognize
common language runtime images. The presence of metadata in the file along with the MSIL enables
your code to describe itself, which means that there is no need for type libraries or Interface Definition
Language (IDL). The runtime locates and extracts the metadata from the file as needed during
execution.
For detailed descriptions of MSIL instructions, see the Tool Developers Guide directory of the .NET
Framework SDK.
Common Language Runtime Overview
To enable the runtime to provide services to managed code, language compilers must emit metadata
that describes the types, members, and references in your code. Metadata is stored with the code; every
loadable common language runtime portable executable (PE) file contains metadata. The runtime uses
metadata to locate and load classes, lay out instances in memory, resolve method invocations, generate
native code, enforce security, and set run-time context boundaries.
The runtime automatically handles object layout and manages references to objects, releasing them
when they are no longer being used. Objects whose lifetimes are managed in this way are called
managed data. Garbage collection eliminates memory leaks as well as some other common
programming errors. If your code is managed, you can use managed data, unmanaged data, or both
managed and unmanaged data in your .NET Framework application. Because language compilers
supply their own types, such as primitive types, you might not always know (or need to know) whether
your data is being managed.
The common language runtime makes it easy to design components and applications whose objects
interact across languages. Objects written in different languages can communicate with each other, and
their behaviors can be tightly integrated. For example, you can define a class and then use a different
language to derive a class from your original class or call a method on the original class. You can also
pass an instance of a class to a method of a class written in a different language. This cross-language
integration is possible because language compilers and tools that target the runtime use a common type
system defined by the runtime, and they follow the runtime's rules for defining new types, as well as for
creating, using, persisting, and binding to types.
25
As part of their metadata, all managed components carry information about the components and
resources they were built against. The runtime uses this information to ensure that your component or
application has the specified versions of everything it needs, which makes your code less likely to break
because of some unmet dependency. Registration information and state data are no longer stored in the
registry where they can be difficult to establish and maintain. Rather, information about the types you
define (and their dependencies) is stored with the code as metadata, making the tasks of component
replication and removal much less complicated.
Language compilers and tools expose the runtime's functionality in ways that are intended to be useful
and intuitive to developers. This means that some features of the runtime might be more noticeable in
one environment than in another. How you experience the runtime depends on which language
compilers or tools you use. For example, if you are a Visual Basic developer, you might notice that
with the common language runtime, the Visual Basic language has more object-oriented features than
before. Following are some benefits of the runtime:
• Performance improvements.
• The ability to easily use components developed in other languages.
• Extensible types provided by a class library.
• New language features such as inheritance, interfaces, and overloading for object-oriented
programming; support for explicit free threading that allows creation of multithreaded, scalable
applications; support for structured exception handling and custom attributes.
If you use Microsoft® Visual C++® .NET, you can write managed code using the Managed Extensions
for C++, which provide the benefits of a managed execution environment as well as access to powerful
capabilities and expressive data types that you are familiar with. Additional runtime features include:
• Cross-language integration, especially cross-language inheritance.
• Garbage collection, which manages object lifetime so that reference counting is unnecessary.
• Self-describing objects, which make using Interface Definition Language (IDL) unnecessary.
• The ability to compile once and run on any CPU and operating system that supports the runtime.
You can also write managed code using the C# language, which provides the following benefits:
• Complete object-oriented design.
• Very strong type safety.
• A good blend of Visual Basic simplicity and C++ power.
• Garbage collection.
• Syntax and keywords similar to C and C++.
• Use of delegates rather than function pointers for increased type safety and security. Function
pointers are available through the use of the unsafe C# keyword and the /unsafe option of the C#
compiler (Csc.exe) for unmanaged code and data.

Compiling MSIL to Native Code

Before you can run Microsoft intermediate language (MSIL), it must be converted by a .NET
Framework just-in-time (JIT) compiler to native code, which is CPU-specific code that runs on the
same computer architecture as the JIT compiler. Because the common language runtime supplies a JIT
compiler for each supported CPU architecture, developers can write a set of MSIL that can be JIT-
compiled and run on computers with different architectures. However, your managed code will run only
on a specific operating system if it calls platform-specific native APIs, or a platform-specific class
library.

26
JIT compilation takes into account the fact that some code might never get called during execution.
Rather than using time and memory to convert all the MSIL in a portable executable (PE) file to native
code, it converts the MSIL as needed during execution and stores the resulting native code so that it is
accessible for subsequent calls. The loader creates and attaches a stub to each of a type's methods when
the type is loaded. On the initial call to the method, the stub passes control to the JIT compiler, which
converts the MSIL for that method into native code and modifies the stub to direct execution to the
location of the native code. Subsequent calls of the JIT-compiled method proceed directly to the native
code that was previously generated, reducing the time it takes to JIT-compile and run the code.
The runtime supplies another mode of compilation called install-time code generation. The install-time
code generation mode converts MSIL to native code just as the regular JIT compiler does, but it
converts larger units of code at a time, storing the resulting native code for use when the assembly is
subsequently loaded and run. When using install-time code generation, the entire assembly that is being
installed is converted into native code, taking into account what is known about other assemblies that
are already installed. The resulting file loads and starts more quickly than it would have if it were being
converted to native code by the standard JIT option.
As part of compiling MSIL to native code, code must pass a verification process unless an
administrator has established a security policy that allows code to bypass verification. Verification
examines MSIL and metadata to find out whether the code is type safe, which means that it only
accesses the memory locations it is authorized to access. Type safety helps isolate objects from each
other and therefore helps protect them from inadvertent or malicious corruption. It also provides
assurance that security restrictions on code can be reliably enforced.
The runtime relies on the fact that the following statements are true for code that is verifiably type safe:
• A reference to a type is strictly compatible with the type being referenced.
• Only appropriately defined operations are invoked on an object.
• Identities are what they claim to be.
During the verification process, MSIL code is examined in an attempt to confirm that the code can
access memory locations and call methods only through properly defined types. For example, code
cannot allow an object's fields to be accessed in a manner that allows memory locations to be overrun.
Additionally, verification inspects code to determine whether the MSIL has been correctly generated,
because incorrect MSIL can lead to a violation of the type safety rules. The verification process passes
a well-defined set of type-safe code, and it passes only code that is type safe. However, some type-safe
code might not pass verification because of limitations of the verification process, and some languages,
by design, do not produce verifiably type-safe code. If type-safe code is required by security policy and
the code does not pass verification, an exception is thrown when the code is run.

27
 OUTPUT

F-1:LOGIN_FORM
This is the main form where a member or an administrator logins and can access other links.

28
F-2:CREATE_MEMBER
This form creates new member who enrolls for a particular course.

29
F-3[SELECT_COURSE

This form is used by a member to enroll for more than one course.

30
F-4:USER_PAGE

This form tells the user about his course enrolled, his test score and rank if he has given any
online test.

31
F-5: Course Selection

This page gived the user option to select a particular course and course type.

32
F-6: Tutorial

This page gives the information available to the user on a given course subject.

33
F-7: FAQ

This page gives the information regarding the frequently asked questions.

34
 CONCLUSION

This website not only helps the students but also helps the teachers and professionals who want to
enhance their technical skills. This project is fully user friendly and the users can’t find any difficulties
while using it. We have tried our best to make this website as useful and as easy to use as possible. We
have tried to incorporate as much information as possible but still nothing is perfect, so we welcome
your views and suggestions to make this website more competent. You can post your views and
suggestions on the feedback section at our homepage.

35
 REFERENCE

1) Ahmed,Garrett “ASP.NET Web Developers Guide”, Syngress.

2) Anders,Howard “ASP.Net: Tips & Tutorials”, SAMS.
3) Paul Kimmel “Advanced C# Programming”, McGarw Hill.

4) “Programming in C#”, O’RELLY.

5) www.programmingblog .com

6) www.yahoo/programming_asp/blog.com

7) MSDN Library for Visual Studio 2008

36