Você está na página 1de 97




School Management System is a large database system which can be used for managing
your school's day to day business. School Management System allows users to store almost
all of their school's information electronically, including information on students,
properties, teaching meteorites etc. Most importantly, this information can be easily shared
with authorized users, records can be easily searched, and reports can be easily generated.

School Management System is software which is helpful for students as well as the
school authorities. In the current system all the activities are done manually. It is very time
consuming and costly. Our School Management System deals with the various activities
related to the students.
There are mainly 3 modules in this software
 User module
 Student Module
 Mark management
In the Software we can register as a user and user has of two types, student and
administrator. Administrator has the power to add new user and can edit and delete a user.
A student can register as user and can add edit and delete his profile. The administrator can
add edit and delete marks for the student. All the users can see the marks.



School management system that provides following facilities search for student with
register number and name, add student, edit student details, delete student details, marks
and remarks. Language used is C# and db is SQL server 2000 and SQL Client has been
used in code.
One Student Master is already there once db is installed with user name and register
Its very good project where in all the events of all forms have been handled in Globals.cs
that acts as business and data access layer. All DB interactions are in this file only.. The
authentication and authorization was crosschecked at all the relevant stages. The user level
accessibility has been restricted into two zones namely. The student master zone and the
normal student zone.
About the Organization
School Management System will deal in all the requirements needed for managing School.
It will deal with the process of maintaining data about the students and many other things as
well as admissions, extracurricular, Family, marks and remark for school students .

Manual Process

Visit The
Student master school Search for student with name
management or register number

student Get the marks and results for
Add/edit/delete student details
manage students



System Analysis is a detailed study of the various operations performed by a system

and their relationships within and outside of the system. Here the key question is- what all
problems exist in the present system? What must be done to solve the problem? Analysis
begins when a user or manager begins a study of the program using existing system.

During analysis, data collected on the various files, decision points and transactions
handled by the present system. The commonly used tools in the system are Data Flow
Diagram, interviews, etc. Training, experience and common sense are required for collection
of relevant information needed to develop the system. The success of the system depends
largely on how clearly the problem is defined, thoroughly investigated and properly carried
out through the choice of solution. A good analysis model should provide not only the
mechanisms of problem understanding but also the frame work of the solution. Thus it
should be studied thoroughly by collecting data about the system. Then the proposed system
should be analyzed thoroughly in accordance with the needs.

System analysis can be categorized into four parts.

 System planning and initial investigation

 Information Gathering
 Applying analysis tools for structured analysis
 Feasibility study
 Cost/ Benefit analysis.

In the current system we need to keep a number of records related to the student and
want to enter the details of the student and the marks manually. In this system only the
teacher or the school authority views the mark of the student and they want to enter the
details of the student. This is time consuming and has much cost.


In our proposed system we have the provision for adding the details of the
students by themselves. So the overhead of the school authorities and the teachers is become
\less. Another advantage of the system is that it is very easy to edit the details of the student
and delete a student when it found unnecessary. The marks of the student are added in the
database and so students can also view the marks whenever they want. Our proposed system has
several advantages

 User friendly interface

 Fast access to database
 Less error
 More Storage Capacity
 Search facility
 Look and Feel Environment
 Quick transaction

All the manual difficulties in managing the student details in a school or college
have been rectified by implementing computerization.



This management system can be used in windows 98, Windows2000, Windows XP

and Windows NT, supported for other platform such as Applet, Macintosh and UNIX.

The system must be running Windows 98, Windows 98 or Windows NT4.0

operating system and must meet the following hardware requirements.

For Windows 95 based computers , a 486 / 66 MHz or higher processor with 8MB of
For Windows 98 based computers , a 500/88MHz or higher processor with 32 Mb of
For Windows NT based computers , a 488 / 66 MHz or higher processor with 16 MB
of RAM
For Windows 200 based computers , a 700/850 MHz or higher processor with 512 MB
of Ram

Hardware Requirements
 Pentium IV Processor.

 128 MB RAM.

 20GB Hard Disk space.

 Ethernet card with an Internet and Internet zone.

Software Requirements

 Windows 2000 XP operating system.

 Internet explorer 5.0 and Netscape navigator.

 SQL Server 2000 or SQL Server 2005.

 Microsoft visual studio 2005

 TCP/IP Protocol suite.




The system after careful analysis has been identified to be presented with the
1. Administrator module: The module manages the information of all the members
who practically exist for this organization. Each member is exclusively associated
with a specific department and authorized designation. The module manages all the
transactional relations that generically arise as and when the system has been
executed, upon the requirements. In this Admin can able to change the password.
2. Members(Users) information module: The module maintains the actual members
list that have availed books upon this system. Users can find items, change profile
details, etc., from their homes as the library’s transactions are online. In this module
the user can have limited actions.
3. Search/Issue Book module: This module maintains the information related to
searching for the Books with types and Issue the books Search/Issue Books page
accessed from actions page, in this page search and issue is done. First user enters the
criteria for book searching and a book is successfully find than user can select the
book he wishes to get issued in grid and get it issued.
4. Manage Categories module: This module maintains the information related to Add
categories and Edit categories. It can have the description and status of categories.
5. Add/Remove books module: This module maintains the information related to
add/remove issues by the admin. For adding there should be at least one category
.Books can be removed, all books in system are shown in Remove books section user
can use Remove button to remove books after setting Quantity to be removed of book



3.1 Technical Descriptions:

The total number of databases that were identified to build system. The major parts of the
databases are categorized as student master components. The student master components are
useful is managing and maintain the consistency of the system. These databases purely used for
the internal organizational needs and necessities.
They can monitor any item, its stock and other related information. A student master can search
and add the students into the school system, and save their details and give the promotions,
marks and remarks to the students.

3.2 GUI’S
In the flexibility of the uses the interface has been developed a graphics concept in mind,
associated through a browses interface. The GUI’S at the top level have been categorized

1. Student master interface

The Student Master interface concentrate on the A Secure and easy to share database. An
efficient Student Management Solution that, enables in maintaining and give the promotions and
remarks for the student in the School management system.

Overview of the .NET Framework

The .NET Framework is a new computing platform that simplifies
application development in the highly distributed environment of the
Internet. The .NET Framework is designed to fulfill the following

• 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 guarantees 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 ensure 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 Web Forms 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 secure isolated file storage.

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 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

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.

Common Type System

The common type system defines how types are declared, used, and
managed in the runtime, and is also an important part of the runtime's
support for cross-language integration. The common type system performs
the following functions:

Establishes a framework that enables cross-language integration, type

safety, and high performance code execution.

Provides an object-oriented model that supports the complete

implementation of many programming languages.

Defines rules that languages must follow, which helps ensure that objects
written in different languages can interact with each other.

In This Section Common Type System Overview

Describes concepts and defines terms relating to the common type system.

Type Definitions

Describes user-defined types.

Type Members
Describes events, fields, nested types, methods, and properties, and
concepts such as member overloading, overriding, and inheritance.

Value Types

Describes built-in and user-defined value types.


Describes the characteristics of common language runtime classes.


Describes the delegate object, which is the managed alternative to

unmanaged function pointers.


Describes common language runtime array types.


Describes characteristics of interfaces and the restrictions on interfaces

imposed by the common language runtime.


Describes managed pointers, unmanaged pointers, and unmanaged function


Related Sections

. NET Framework Class Library

Provides a reference to the classes, interfaces, and value types included in

the Microsoft .NET Framework SDK.

Common Language Runtime

Describes the run-time environment that manages the execution of code and
provides application development services.

Cross-Language Interoperability

The common language runtime provides built-in support for language

interoperability. However, this support does not guarantee that developers
using another programming language can use code you write. To ensure
that you can develop managed code that can be fully used by developers
using any programming language, a set of language features and rules for
using them called the Common Language Specification (CLS) has been
defined. Components that follow these rules and expose only CLS features
are considered CLS-compliant.

This section describes the common language runtime's built-in support for
language interoperability and explains the role that the CLS plays in
enabling guaranteed cross-language interoperability. CLS features and
rules are identified and CLS compliance is discussed.

In This Section

Language Interoperability

Describes built-in support for cross-language interoperability and

introduces the Common Language Specification.

What is the Common Language Specification?

Explains the need for a set of features common to all languages and
identifies CLS rules and features.

Writing CLS-Compliant Code

Discusses the meaning of CLS compliance for components and identifies

levels of CLS compliance for tools.

Common Type System

Describes how types are declared, used, and managed by the common
language runtime.

Metadata and Self-Describing Components

Explains the common language runtime's mechanism for describing a type

and storing that information with the type itself.

. 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

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.

Scripted or hosted applications.

Windows GUI applications (Windows Forms).

ASP.NET applications.

XML Web services.

Windows services.

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 safely deployed

through the Web. Your applications can implement the features of a local
application while being deployed like a Web page.

Managed Execution Process

The managed execution process includes the following steps:

Choosing a Complier

To obtain the benefits provided by the common language runtime, you must
use one or more language compilers that target the runtime.

Compiling your code to Microsoft Intermediate Language (MSIL)

Compiling translates your source code into MSIL and generates the
required metadata.

Compiling MSIL to native code

At execution time, a just-in-time (JIT) compiler translates the MSIL into

native code. During this compilation, code must pass a verification process
that examines the MSIL and metadata to find out whether the code can be
determined to be type safe.

Executing your code

The common language runtime provides the infrastructure that enables

execution to take place as well as a variety of services that can be used
during execution.

Assemblies Overview

Assemblies are a fundamental part of programming with the .NET

Framework. An assembly performs the following functions:

It contains code that the common language runtime executes. Microsoft

intermediate language (MSIL) code in a portable executable (PE) file will
not be executed if it does not have an associated assembly manifest. Note
that each assembly can have only one entry point (that is, DllMain,
WinMain, or Main).

It forms a security boundary. An assembly is the unit at which permissions

are requested and granted. For more information about security boundaries
as they apply to assemblies, see Assembly Security Considerations

It forms a type boundary. Every type's identity includes the name of the
assembly in which it resides. A type called MyType loaded in the scope of
one assembly is not the same as a type called MyType loaded in the scope
of another assembly.

It forms a reference scope boundary. The assembly's manifest contains

assembly metadata that is used for resolving types and satisfying resource
requests. It specifies the types and resources that are exposed outside the
assembly. The manifest also enumerates other assemblies on which it

It forms a version boundary. The assembly is the smallest versionable unit

in the common language runtime; all types and resources in the same
assembly are versioned as a unit. The assembly's manifest describes the
version dependencies you specify for any dependent assemblies. For more
information about versioning, see Assembly Versioning

It forms a deployment unit. When an application starts, only the assemblies

that the application initially calls must be present. Other assemblies, such
as localization resources or assemblies containing utility classes, can be
retrieved on demand. This allows applications to be kept simple and thin
when first downloaded. For more information about deploying assemblies,
see Deploying Applications

It is the unit at which side-by-side execution is supported. For more

information about running multiple versions of the same assembly, see
Side-by-Side Execution

Assemblies can be static or dynamic. Static assemblies can include .NET

Framework types (interfaces and classes), as well as resources for the
assembly (bitmaps, JPEG files, resource files, and so on). Static assemblies
are stored on disk in PE files. You can also use the .NET Framework to
create dynamic assemblies, which are run directly from memory and are not
saved to disk before execution. You can save dynamic assemblies to disk
after they have executed.

There are several ways to create assemblies. You can use development
tools, such as Visual Studio .NET, that you have used in the past to
create .dll or .exe files. You can use tools provided in the .NET Framework
SDK to create assemblies with modules created in other development
environments. You can also use common language runtime APIs, such as
Reflection. Emit, to create dynamic assemblies.

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.

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 offers. 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.

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.

Programming with the .NET Framework

This section describes the programming essentials you need to build .NET
applications, from creating assemblies from your code to securing your

application. Many of the fundamentals covered in this section are used to

create any application using the .NET Framework. This section provides
conceptual information about key programming concepts, as well as code
samples and detailed explanations.

Accessing Data with ADO.NET

Describes the ADO.NET architecture and how to use the ADO.NET classes
to manage application data and interact with data sources including
Microsoft SQL Server, OLE DB data sources, and XML.

Accessing Objects in Other Application Domains using .NET Remoting

Describes the various communications methods available in the .NET

Framework for remote communications.

Accessing the Internet

Shows how to use Internet access classes to implement both Web- and
Internet-based applications.

Creating Active Directory Components

Discusses using the Active Directory Services Interfaces.

Creating Scheduled Server Tasks

Discusses how to create events that are raised on reoccurring intervals.

Developing Components

Provides an overview of component programming and explains how those

concepts work with the .NET Framework.

Developing World-Ready Applications

Explains the extensive support the .NET Framework provides for

developing international applications.

Discovering Type Information at Runtime

Explains how to get access to type information at run time by using


Drawing and Editing Images

Discusses using GDI+ with the .NET Framework.

Emitting Dynamic Assemblies

Describes the set of managed types in the System.Reflection.Emit


Employing XML in the .NET Framework

Provides an overview to a comprehensive and integrated set of classes that

work with XML documents and data in the .NET Framework.

Extending Metadata Using Attributes

Describes how you can use attributes to customize metadata.

Generating and Compiling Source Code Dynamically in Multiple Languages

Explains the .NET Framework SDK mechanism called the Code Document
Object Model (CodeDOM) that enables the output of source code in
multiple programming languages.

Grouping Data in Collections

Discusses the various collection types available in the .NET Framework,

including stacks, queues, lists, arrays, and structs.

Handling and Raising Events

Provides an overview of the event model in the .NET Framework.


Handling and Throwing Exceptions

Describes error handling provided by the .NET Framework and the

fundamentals of handling exceptions.

Hosting the Common Language Runtime

Explains the concept of a runtime host, which loads the runtime into a
process, creates the application domain within the process, and loads and
executes user code.

Including Asynchronous Calls

Discusses asynchronous programming features in the .NET Framework.

Interoperating with Unmanaged Code

Describes interoperability services provided by the common language


Managing Applications Using WMI

Explains how to create applications using Windows Management

Instrumentation (WMI), which provides a rich set of system management
services built in to the Microsoft® Windows® operating systems.

Creating Messaging Components

Discusses how to build complex messaging into your applications.

Processing Transactions

Discusses the .NET Framework support for transactions.

Programming Essentials for Garbage Collection

Discusses how the garbage collector manages memory and how you can
program to use memory more efficiently.

Programming with Application Domains and Assemblies

Describes how to create and work with assemblies and application domains.

Securing Applications

Describes .NET Framework code access security, role-based security,

security policy, and security tools.

Serializing Objects

Discusses XML serialization.

Creating System Monitoring Components

Discusses how to use performance counters and event logs with your


Explains the runtime support for threading and how to program using
various synchronization techniques.

Working With Base Types

Discusses formatting and parsing base data types and using regular
expressions to process text.

Working with I/O

Explains how you can perform synchronous and asynchronous file and data
stream access and how to use to isolated storage.

Writing Serviced Components

Describes how to configure and register serviced components to access

COM+ services.

Creating ASP.NET Web Applications

Discusses how to create and optimize ASP.NET Web applications.

Creating Windows Forms Applications

Describes how to create Windows Forms and Windows controls


Building Console Applications

Discusses how to create console-based .NET applications.

Introduction to ASP.NET

ASP.NET is more than the next version of Active Server Pages (ASP); it is
a unified Web development platform that provides the services necessary
for developers to build enterprise-class Web applications. While ASP.NET
is largely syntax compatible with ASP, it also provides a new programming
model and infrastructure for more secure, scalable, and stable applications.
You can feel free to augment your existing ASP applications by
incrementally adding ASP.NET functionality to them.

ASP.NET is a compiled,. NET-based environment; you can author

applications in any .NET compatible language, including Visual Basic
.NET, C#, and JScript .NET. Additionally, the entire .NET Framework is
available to any ASP.NET application. Developers can easily access the
benefits of these technologies, which include the managed common
language runtime environment, type safety, inheritance, and so on.

ASP.NET has been designed to work seamlessly with WYSIWYG HTML

editors and other programming tools, including Microsoft Visual Studio
.NET. Not only does this make Web development easier, but it also
provides all the benefits that these tools have to offer, including a GUI that
developers can use to drop server controls onto a Web page and fully
integrated debugging support.

Developers can choose from the following two features when creating an
ASP.NET application, Web Forms and Web services, or combine these in
any way they see fit. Each is supported by the same infrastructure that
allows you to use authentication schemes, cache frequently used data, or
customize your application's configuration, to name only a few

Web Forms allows you to build powerful forms-based Web pages. When
building these pages, you can use ASP.NET server controls to create
common UI elements, and program them for common tasks. These controls
allow you to rapidly build a Web Form out of reusable built-in or custom
components, simplifying the code of a page. For more information, see Web
Forms Pages. For information on how to develop ASP.NET server controls,
see Developing ASP.NET Server Controls

An XML Web service provides the means to access server functionality

remotely. Using Web services, businesses can expose programmatic
interfaces to their data or business logic, which in turn can be obtained and
manipulated by client and server applications. XML Web services enable
the exchange of data in client-server or server-server scenarios, using
standards like HTTP and XML messaging to move data across firewalls.
XML Web services are not tied to a particular component technology or
object-calling convention. As a result, programs written in any language,
using any component model, and running on any operating system can
access XML Web services. For more information, see XML Web Services
and XML Web Service Clients Created Using ASP.NET

Each of these models can take full advantage of all ASP.NET features, as
well as the power of the .NET Framework and .NET Framework common
language runtime. These features and how you can use them are outlined as

If you have ASP development skills, the new ASP.NET programming model
will seem very familiar to you. However, the ASP.NET object model has
changed significantly from ASP, making it more structured and object-
oriented. Unfortunately this means that ASP.NET is not fully backward
compatible; almost all existing ASP pages will have to be modified to some
extent in order to run under ASP.NET. In addition, major changes to Visual
Basic .NET mean that existing ASP pages written with Visual Basic
Scripting Edition typically will not port directly to ASP.NET. In most
cases, though, the necessary changes will involve only a few lines of code.
For more information, see Migrating from ASP to ASP.NET

Accessing databases from ASP.NET applications is an often-used technique

for displaying data to Web site visitors. ASP.NET makes it easier than ever
to access databases for this purpose. It also allows you to manage the
database from your code. For more information, see Accessing Data with

ASP.NET provides a simple model that enables Web developers to write

logic that runs at the application level. Developers can write this code in
the global.asax text file or in a compiled class deployed as an assembly.
This logic can include application-level events, but developers can easily
extend this model to suit the needs of their Web application. For more
information, see ASP.NET Applications

ASP.NET provides easy-to-use application and session-state facilities that

are familiar to ASP developers and are readily compatible with all other
.NET Framework APIs. For more information, see ASP.NET State

For advanced developers who want to use APIs as powerful as the ISAPI
programming interfaces that were included with previous versions of ASP,
ASP.NET offers the IHttpHandler and IHttpModule interfaces.

Implementing the IHttpHandler interface gives you a means of interacting

with the low-level request and response services of the IIS Web server and
provides functionality much like ISAPI extensions, but with a simpler
programming model. Implementing the IHttpModule interface allows you to
include custom events that participate in every request made to your
application. For more information, see HTTP Runtime Support

ASP.NET takes advantage of performance enhancements found in the .NET

Framework and common language runtime. Additionally, it has been
designed to offer significant performance improvements over ASP and
other Web development platforms. All ASP.NET code is compiled, rather
than interpreted, which allows early binding, strong typing, and just-in-
time (JIT) compilation to native code, to name only a few of its benefits.
ASP.NET is also easily factorable, meaning that developers can remove
modules (a session module, for instance) that are not relevant to the
application they are developing. ASP.NET also provides extensive caching
services (both built-in services and caching APIs). ASP.NET also ships
with performance counters that developers and system administrators can
monitor to test new applications and gather metrics on existing
applications. For more information, see ASP.NET Caching Features and
ASP.NET Optimization

Writing custom debug statements to your Web page can help immensely in
troubleshooting your application's code. However, it can cause
embarrassment if it is not removed. The problem is that removing the debug
statements from your pages when your application is ready to be ported to a
production server can require significant effort. ASP.NET offers the Trace
Context class, which allows you to write custom debug statements to your
pages as you develop them. They appear only when you have enabled
tracing for a page or entire application. Enabling tracing also appends
details about a request to the page, or, if you so specify, to a custom trace

viewer that is stored in the root directory of your application. For more
information, see ASP.NET Trace

The .NET Framework and ASP.NET provide default authorization and

authentication schemes for Web applications. You can easily remove, add
to, or replace these schemes, depending upon the needs of your application.
For more information, see ASP.NET Web Application Security

ASP.NET configuration settings are stored in XML-based files, which are

human readable and writable. Each of your applications can have a distinct
configuration file and you can extend the configuration scheme to suit your
requirements. For more information, see ASP.NET Configuration

Building Applications

The .NET Framework enables powerful new Web-based applications and

services, including ASP.NET applications, Windows Forms applications,
and Windows services. This section contains instructive overviews and
detailed, step-by-step procedures for creating applications.

This section also includes information on using the .NET Framework

design-time architecture to support visual design environments for
authoring custom components and controls.

Creating ASP.NET Web Applications

Provides the information you need to develop enterprise-class Web

applications with ASP.NET.

Creating Windows Forms Applications

Introduces Windows Forms, the new object-oriented framework for

developing Windows-based applications.

Windows Service Applications

Describes creating, installing, starting, and stopping Windows system


Building Console Applications

Describes writing applications that use the system console for input and

Enhancing Design-Time Support

Describes the .NET Framework's rich design-time architecture and support

for visual design environments.

Debugging and Profiling Applications

Explains how to test and profile .NET Framework applications.

Deploying Applications

Shows how to use the .NET Framework and the common language runtime
to create self-described, self-contained applications.

Configuring Applications

Explains how developers and administrators can apply settings to various

types of configuration files.

Debugging and Profiling Applications

To debug a .NET Framework application, the compiler and runtime

environment must be configured to enable a debugger to attach to the
application and to produce both symbols and line maps, if possible, for the
application and its corresponding Microsoft Intermediate Language (MSIL).
Once a managed application is debugged, it can be profiled to boost
performance. Profiling evaluates and describes the lines of source code that

generate the most frequently executed code, and how much time it takes to
execute them.

The .NET Framework applications are easily debugged using Visual

Studio .NET, which handles many of the configuration details. If Visual
Studio .NET is not installed, you can examine and improve the performance
of .NET Framework applications in several alternative ways using the

Systems. Diagnostics classes.

Runtime Debugger (Cordbg.exe), which is a command-line debugger.

Microsoft common language runtime Debugger (DbgCLR.exe), which is a

Windows debugger.

The .NET Framework namespace System. Diagnostics includes the Trace

and Debug classes for tracing execution flow, and the Process, Event Log,
and Performance Counter classes for profiling code. The Cordbg.exe
command-line debugger can be used to debug managed code from the
command-line interpreter. DbgCLR.exe is a debugger with the familiar
Windows interface for debugging managed code. It is located in the
Microsoft.NET/FrameworkSDK/GuiDebug folder.

Enabling JIT-attach debugging

Shows how to configure the registry to JIT-attach a debug engine to a .NET

Framework application.

Making an Image Easier to Debug

Shows how to turn JIT tracking on and optimization off to make an

assembly easier to debug.

Enabling Profiling

Shows how to set environment variables to tie a .NET Framework

application to a profiler.

Introduction to ASP.NET Server Controls

When you create Web Forms pages, you can use these types of controls:

HTML server controls HTML elements exposed to the server so you can
program them. HTML server controls expose an object model that maps
very closely to the HTML elements that they render.

Web server controls Controls with more built-in features than HTML
server controls. Web server controls include not only form-type controls
such as buttons and text boxes, but also special-purpose controls such as a
calendar. Web server controls are more abstract than HTML server controls
in that their object model does not necessarily reflect HTML syntax.

Validation controls Controls that incorporate logic to allow you to test a

user's input. You attach a validation control to an input control to test what
the user enters for that input control. Validation controls are provided to
allow you to check for a required field, to test against a specific value or
pattern of characters, to verify that a value lies within a range, and so on.

User controls Controls that you create as Web Forms pages. You can
embed Web Forms user controls in other Web Forms pages, which is an
easy way to create menus, toolbars, and other reusable elements.

You can use all types of controls on the same page. The following sections
provide more detail about ASP.NET server controls. For more information
about validation controls, see Web Forms Validation for information about
user controls; see Introduction to Web User Controls

HTML Server Controls

HTML server controls are HTML elements containing attributes that make
them visible to — and programmable on — the server. By default, HTML
elements on a Web Forms page are not available to the server; they are
treated as opaque text that is passed through to the browser. However, by
converting HTML elements to HTML server controls, you expose them as
elements you can program on the server.

The object model for HTML server controls maps closely to that of the
corresponding elements. For example, HTML attributes are exposed in
HTML server controls as properties.

Any HTML element on a page can be converted to an HTML server control.

Conversion is a simple process involving just a few attributes. As a
minimum, an HTML element is converted to a control by the addition of the
attribute RUNAT="SERVER". This alerts the ASP.NET page framework
during parsing that it should create an instance of the control to use during
server-side page processing. If you want to reference the control as a
member within your code, you should also assign an ID attribute to the

The page framework provides predefined HTML server controls for the
HTML elements most commonly used dynamically on a page: forms, the
HTML <INPUT> elements (text box, check box, Submit button, and so on),
list box (<SELECT>), table, image, and so on. These predefined HTML
server controls share the basic properties of the generic control, and in
addition, each control typically provides its own set of properties and its
own event.

HTML server controls offer the following features

An object model that you can program against on the server using the
familiar object-oriented techniques. Each server control exposes properties
that allow you to manipulate the control's HTML attributes
programmatically in server code.

A set of events for which you can write event handlers in much the same
way you would in a client-based form, except that the event is handled in
server code.

The ability to handle events in client script.

Automatic maintenance of the control's state. If the form makes a round

trip to the server, the values that the user entered into HTML server
controls are automatically maintained when the page is sent back to the

Interaction with validation controls you can easily verify that a user has
entered appropriate information into a control.

Web Server Controls

Web server controls are a second set of controls designed with a different
emphasis. They do not map one-to-one to HTML server controls. Instead,
they are defined as abstract controls in which the actual HTML rendered by
the control can be quite different from the model that you program against.
For example, a RadioButtonList Web server control might be rendered in a
table or as inline text with other HTML.

Web server controls include traditional form controls such as buttons and
text boxes as well as complex controls such as tables. They also include
controls that provide commonly used form functionality such as displaying
data in a grid, choosing dates, and so on.

Web server controls offer all of the features described above for HTML
server controls (except one-to-one mapping to HTML elements) and these
additional features:

A rich object model that provides type-safe programming capabilities.

Automatic browser detection. The controls can detect browser capabilities

and create appropriate output for both basic and rich (HTML 4.0) browsers.

For some controls, the ability to define your own look for the control using

For some controls, the ability to specify whether a control's event causes
immediate posting to the server or is instead cached and raised when the
form is submitted.

Ability to pass events from a nested control (such as a button in a table) to

the container control.

At design time in HTML view, the controls appear in your page in a format
such as:

<asp: button attributes run at="server"/>

The attributes in this case are not those of HTML elements. Instead, they
are properties of the Web control.

When the Web Forms page runs, the Web server control is rendered on the
page using appropriate HTML, which often depends not only on the browser
type but also on settings that you have made for the control. For example, a
Textbox control might render as an <INPUT> tag or a <TEXTAREA> tag,
depending on its properties.

D e s i g n



• The entity Relationship Diagram (ERD) depicts the relationship

between the data objects. The ERD is the notation that is used to conduct the
date modeling activity the attributes of each data object noted is the ERD can be
described resign a data object descriptions.

• The set of primary components that are identified by the ERD are

 Data object  Relationships

 Attributes  Various types of indicators.

• The primary purpose of the ERD is to represent data objects and

their relationships.

Unified Modeling Language Diagrams

1. The unified modeling language allows the software engineer to express an

analysis model using the modeling notation that is governed by a set of syntactic
semantic and pragmatic rules.

2. A UML system is represented using five different views that describe the
system from distinctly different perspective. Each view is defined by a set of
diagram, which is as follows.

3. User Model View

4. This view represents the system from the users perspective.

5. The analysis representation describes a usage scenario from the end-users


Structural model view

 In this model the data and functionality are arrived from inside the system.

 This model view models the static structures.

Behavioral Model View
 It represents the dynamic of behavioral as parts of the system, depicting the
interactions of collection between various structural elements described in the
user model and structural model view.

Implementation Model View

 In this the structural and behavioral as parts of the system are represented as
they are to be built.

Environmental Model View

In this the structural and behavioral aspects of the environment in which the system is to
be implemented are represented.

UML is specifically constructed through two different domains they are

 UML Analysis modeling, which focuses on the user model and structural model
views of the system.

 UML design modeling, which focuses on the behavioral modeling,

implementation modeling and environmental model views.

Use Case Diagrams

Databases used

The actors who have been identified in this system are

. Student Master
Student Master:
There are the actors who statistically work upon the system with respect to the expected
services what they need to avail. They are mostly restricted on to such areas where query
standardization has the highest priority.
Search for


Add details
for students

Edit the data

 of students

master Save the
updated data
of students

View the

Marks and



using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Data.OleDb;
using System.Windows.Forms;

namespace StudentManagementSystem
/// <summary>
/// Summary description for StudentDetails.
/// </summary>
public class StudentDetails : System.Windows.Forms.UserControl
private System.Windows.Forms.GroupBox grpControls;
public System.Windows.Forms.DataGrid grdStudent;
private System.Windows.Forms.Button btnClose;
private System.Windows.Forms.Button btnSave;
private System.Windows.Forms.Button btnDelete;
private System.Windows.Forms.Button btnEdit;
private System.Windows.Forms.Button btnAdd;
private System.Windows.Forms.DataGridTableStyle
private System.Windows.Forms.Panel panel1;
private System.Windows.Forms.TextBox txtSearchByRegNo;
public System.Windows.Forms.TextBox txtSearchByName;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.DataGridTextBoxColumn
private System.Windows.Forms.DataGridTextBoxColumn
private System.Windows.Forms.DataGridTextBoxColumn
private System.Windows.Forms.TabControl tabControl1;
private System.Windows.Forms.TabPage tbpPersonel;
private System.Windows.Forms.TabPage tbpAdmission;
private System.Windows.Forms.TabPage tbpFamily;
private System.Windows.Forms.TabPage tbpMarks;
private System.Windows.Forms.GroupBox grpField;
private System.Windows.Forms.TextBox txtHomepage;
private System.Windows.Forms.Label label16;
private System.Windows.Forms.TextBox txtEmail;
private System.Windows.Forms.TextBox txtPhone;
private System.Windows.Forms.Label label9;
private System.Windows.Forms.Label label10;
private System.Windows.Forms.Label label12;
private System.Windows.Forms.TextBox txtAddress;
public System.Windows.Forms.TextBox txtName;
private System.Windows.Forms.Label label7;

private System.Windows.Forms.Label label4;

private System.Windows.Forms.TabPage tbpPromotion;
private System.Windows.Forms.TabPage tbpExtraCurricular;
private System.Windows.Forms.TabPage tbpRemarks;
private System.Windows.Forms.GroupBox grpAdmission;
private System.Windows.Forms.Label label18;
private System.Windows.Forms.Label label19;
private System.Windows.Forms.Label label20;
private System.Windows.Forms.Label label21;
private System.Windows.Forms.Label label22;
private System.Windows.Forms.TextBox txtAdmittedBy;
private System.Windows.Forms.TextBox txtPrevSchool;
private System.Windows.Forms.TextBox txtReasonForLeaving;
private System.Windows.Forms.TextBox txtPrevSchoolPhone;
private System.Windows.Forms.TextBox txtPrevSchoolAddress;
private System.Windows.Forms.TextBox txtRemarks;
private System.Windows.Forms.TabPage tbpCurricular;
private System.Windows.Forms.DateTimePicker dtAdmissionDate;
private System.Windows.Forms.Label label8;
private System.Windows.Forms.TextBox txtFather;
private System.Windows.Forms.Label label6;
internal System.Windows.Forms.ComboBox cmbBatch;
private System.Windows.Forms.Label label5;
public System.Windows.Forms.TextBox txtRegNo;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.TextBox txtMother;
private System.Windows.Forms.Label label11;
private System.Windows.Forms.TextBox txtFatherOfficePhone;
private System.Windows.Forms.Label label13;
private System.Windows.Forms.TextBox txtFatherCellPhone;
private System.Windows.Forms.Label label15;
private System.Windows.Forms.TextBox txtMotherOfficePhone;
private System.Windows.Forms.Label label23;
private System.Windows.Forms.TextBox txtMotherCellPhone;
private System.Windows.Forms.Label label24;
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.GroupBox groupBox2;
private System.Windows.Forms.GroupBox groupBox3;
private System.Windows.Forms.Label label25;
private System.Windows.Forms.TextBox txtResPhone;
private System.Windows.Forms.Label label26;
private System.Windows.Forms.GroupBox groupBox4;
private System.Windows.Forms.GroupBox groupBox5;
private System.Windows.Forms.GroupBox groupBox6;
private System.Windows.Forms.GroupBox groupBox7;
private System.Windows.Forms.TextBox txtResidenceAddress;
private System.Windows.Forms.DateTimePicker dtBirthDate;
private System.Windows.Forms.Button btnCancel;
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;

public StudentDetails()
// This call is required by the Windows.Forms Form


// TODO: Add any initialization after the InitForm


/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose( bool disposing )
if( disposing )
if(components != null)
base.Dispose( disposing );

#region Component Designer generated code

/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
this.grpControls = new
this.btnCancel = new System.Windows.Forms.Button();
this.grdStudent = new System.Windows.Forms.DataGrid();
this.dataGridTableStyle1 = new
this.dataGridTextBoxColumn7 = new
this.dataGridTextBoxColumn8 = new
this.dataGridTextBoxColumn9 = new
this.btnClose = new System.Windows.Forms.Button();
this.btnSave = new System.Windows.Forms.Button();
this.btnDelete = new System.Windows.Forms.Button();
this.btnEdit = new System.Windows.Forms.Button();
this.btnAdd = new System.Windows.Forms.Button();
this.panel1 = new System.Windows.Forms.Panel();
this.txtSearchByRegNo = new
this.txtSearchByName = new
this.label1 = new System.Windows.Forms.Label();
this.label2 = new System.Windows.Forms.Label();
this.tabControl1 = new
this.tbpPersonel = new System.Windows.Forms.TabPage();
this.grpField = new System.Windows.Forms.GroupBox();

this.dtBirthDate = new
this.txtHomepage = new System.Windows.Forms.TextBox();
this.label16 = new System.Windows.Forms.Label();
this.txtEmail = new System.Windows.Forms.TextBox();
this.txtPhone = new System.Windows.Forms.TextBox();
this.label9 = new System.Windows.Forms.Label();
this.label10 = new System.Windows.Forms.Label();
this.label12 = new System.Windows.Forms.Label();
this.txtAddress = new System.Windows.Forms.TextBox();
this.txtName = new System.Windows.Forms.TextBox();
this.label7 = new System.Windows.Forms.Label();
this.label4 = new System.Windows.Forms.Label();
this.tbpFamily = new System.Windows.Forms.TabPage();
this.groupBox6 = new System.Windows.Forms.GroupBox();
this.groupBox2 = new System.Windows.Forms.GroupBox();
this.txtFatherOfficePhone = new
this.label6 = new System.Windows.Forms.Label();
this.label15 = new System.Windows.Forms.Label();
this.txtFatherCellPhone = new
this.txtFather = new System.Windows.Forms.TextBox();
this.label13 = new System.Windows.Forms.Label();
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.txtMotherCellPhone = new
this.label23 = new System.Windows.Forms.Label();
this.label11 = new System.Windows.Forms.Label();
this.txtMotherOfficePhone = new
this.label24 = new System.Windows.Forms.Label();
this.txtMother = new System.Windows.Forms.TextBox();
this.groupBox3 = new System.Windows.Forms.GroupBox();
this.txtResidenceAddress = new
this.label26 = new System.Windows.Forms.Label();
this.label25 = new System.Windows.Forms.Label();
this.txtResPhone = new System.Windows.Forms.TextBox();
this.tbpAdmission = new
this.grpAdmission = new
this.groupBox5 = new System.Windows.Forms.GroupBox();
this.txtAdmittedBy = new
this.label8 = new System.Windows.Forms.Label();
this.dtAdmissionDate = new
this.label18 = new System.Windows.Forms.Label();
this.groupBox4 = new System.Windows.Forms.GroupBox();
this.label19 = new System.Windows.Forms.Label();
this.txtPrevSchool = new
this.txtPrevSchoolAddress = new
this.label22 = new System.Windows.Forms.Label();

this.txtPrevSchoolPhone = new
this.label21 = new System.Windows.Forms.Label();
this.txtReasonForLeaving = new
this.label20 = new System.Windows.Forms.Label();
this.tbpCurricular = new
this.groupBox7 = new System.Windows.Forms.GroupBox();
this.txtRegNo = new System.Windows.Forms.TextBox();
this.cmbBatch = new System.Windows.Forms.ComboBox();
this.label5 = new System.Windows.Forms.Label();
this.label3 = new System.Windows.Forms.Label();
this.tbpExtraCurricular = new
this.tbpPromotion = new
this.tbpMarks = new System.Windows.Forms.TabPage();
this.tbpRemarks = new System.Windows.Forms.TabPage();
this.txtRemarks = new System.Windows.Forms.TextBox();
// grpControls
this.grpControls.Dock =
this.grpControls.FlatStyle =
this.grpControls.Location = new
System.Drawing.Point(0, 0);
this.grpControls.Name = "grpControls";

this.grpControls.Size = new System.Drawing.Size(800,

this.grpControls.TabIndex = 12;
this.grpControls.TabStop = false;
// btnCancel
this.btnCancel.Location = new
System.Drawing.Point(528, 16);
this.btnCancel.Name = "btnCancel";
this.btnCancel.Size = new System.Drawing.Size(78, 32);
this.btnCancel.TabIndex = 6;
this.btnCancel.Text = "Cance&l";
this.btnCancel.Click += new
// grdStudent
this.grdStudent.Anchor =
((((System.Windows.Forms.AnchorStyles.Top |
| System.Windows.Forms.AnchorStyles.Left)
| System.Windows.Forms.AnchorStyles.Right)));
this.grdStudent.CaptionText = "Student Master";
this.grdStudent.DataMember = "";
this.grdStudent.HeaderForeColor =
this.grdStudent.Location = new
System.Drawing.Point(8, 61);
this.grdStudent.Name = "grdStudent";
this.grdStudent.ReadOnly = true;
this.grdStudent.Size = new System.Drawing.Size(784,
this.grdStudent.TabIndex = 5;
System.Windows.Forms.DataGridTableStyle[] {

this.grdStudent.CurrentCellChanged += new
// dataGridTableStyle1
this.dataGridTableStyle1.DataGrid = this.grdStudent;
System.Windows.Forms.DataGridColumnStyle[] {



this.dataGridTableStyle1.HeaderForeColor =
this.dataGridTableStyle1.MappingName = "Student";
this.dataGridTableStyle1.ReadOnly = true;
// dataGridTextBoxColumn7
this.dataGridTextBoxColumn7.Format = "";
this.dataGridTextBoxColumn7.FormatInfo = null;
this.dataGridTextBoxColumn7.MappingName = "Id";
this.dataGridTextBoxColumn7.NullText = "";
this.dataGridTextBoxColumn7.ReadOnly = true;
this.dataGridTextBoxColumn7.Width = 0;
// dataGridTextBoxColumn8
this.dataGridTextBoxColumn8.Format = "";
this.dataGridTextBoxColumn8.FormatInfo = null;
this.dataGridTextBoxColumn8.HeaderText = "Register
this.dataGridTextBoxColumn8.MappingName = "RegNo";
this.dataGridTextBoxColumn8.NullText = "";
this.dataGridTextBoxColumn8.ReadOnly = true;
this.dataGridTextBoxColumn8.Width = 75;
// dataGridTextBoxColumn9
this.dataGridTextBoxColumn9.Format = "";
this.dataGridTextBoxColumn9.FormatInfo = null;
this.dataGridTextBoxColumn9.HeaderText = "Name";
this.dataGridTextBoxColumn9.MappingName =
this.dataGridTextBoxColumn9.NullText = "";
this.dataGridTextBoxColumn9.ReadOnly = true;
this.dataGridTextBoxColumn9.Width = 250;
// btnClose
this.btnClose.Location = new
System.Drawing.Point(616, 16);
this.btnClose.Name = "btnClose";
this.btnClose.Size = new System.Drawing.Size(78, 32);
this.btnClose.TabIndex = 4;
this.btnClose.Text = "&Close";
this.btnClose.Click += new
// btnSave
this.btnSave.Location = new System.Drawing.Point(431,
this.btnSave.Name = "btnSave";
this.btnSave.Size = new System.Drawing.Size(78, 32);
this.btnSave.TabIndex = 3;

this.btnSave.Text = "&Save";
this.btnSave.Click += new
// btnDelete
this.btnDelete.Location = new
System.Drawing.Point(319, 16);
this.btnDelete.Name = "btnDelete";
this.btnDelete.Size = new System.Drawing.Size(78, 32);
this.btnDelete.TabIndex = 2;
this.btnDelete.Text = "&Delete";
this.btnDelete.Click += new
// btnEdit
this.btnEdit.Location = new System.Drawing.Point(215,
this.btnEdit.Name = "btnEdit";
this.btnEdit.Size = new System.Drawing.Size(78, 32);
this.btnEdit.TabIndex = 1;
this.btnEdit.Text = "&Edit";
this.btnEdit.Click += new
// btnAdd
this.btnAdd.Location = new System.Drawing.Point(103,
this.btnAdd.Name = "btnAdd";
this.btnAdd.Size = new System.Drawing.Size(72, 32);
this.btnAdd.TabIndex = 0;
this.btnAdd.Text = "&Add";
this.btnAdd.Click += new
// panel1
this.panel1.BackColor =
this.panel1.BorderStyle =
this.panel1.Dock =
this.panel1.Location = new System.Drawing.Point(0,
this.panel1.Name = "panel1";
this.panel1.Size = new System.Drawing.Size(800, 34);
this.panel1.TabIndex = 14;
// txtSearchByRegNo

this.txtSearchByRegNo.Location = new
System.Drawing.Point(434, 5);
this.txtSearchByRegNo.Name = "txtSearchByRegNo";
this.txtSearchByRegNo.Size = new
System.Drawing.Size(144, 20);
this.txtSearchByRegNo.TabIndex = 1;
this.txtSearchByRegNo.Text = "";
this.txtSearchByRegNo.TextChanged += new
// txtSearchByName
this.txtSearchByName.Location = new
System.Drawing.Point(106, 5);
this.txtSearchByName.Name = "txtSearchByName";
this.txtSearchByName.Size = new
System.Drawing.Size(144, 20);
this.txtSearchByName.TabIndex = 0;
this.txtSearchByName.Text = "";
this.txtSearchByName.TextChanged += new
// label1
this.label1.Location = new System.Drawing.Point(10,
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(104, 23);
this.label1.TabIndex = 5;
this.label1.Text = "Search By Name:";
// label2
this.label2.Location = new System.Drawing.Point(330,
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(120, 23);
this.label2.TabIndex = 8;
this.label2.Text = "Search By Reg.No:";
// tabControl1

this.tabControl1.Dock =
this.tabControl1.Location = new
System.Drawing.Point(0, 317);
this.tabControl1.Name = "tabControl1";

this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(800,
this.tabControl1.TabIndex = 15;
// tbpPersonel
this.tbpPersonel.Location = new
System.Drawing.Point(4, 22);
this.tbpPersonel.Name = "tbpPersonel";
this.tbpPersonel.Size = new System.Drawing.Size(792,
this.tbpPersonel.TabIndex = 0;
this.tbpPersonel.Text = "Personal";
// grpField
this.grpField.BackColor =
this.grpField.Dock =
this.grpField.Location = new System.Drawing.Point(0,
this.grpField.Name = "grpField";
this.grpField.Size = new System.Drawing.Size(792,
this.grpField.TabIndex = 14;
this.grpField.TabStop = false;
// dtBirthDate
this.dtBirthDate.CustomFormat = "dd / MMM / yyyy";
this.dtBirthDate.Format =
this.dtBirthDate.Location = new
System.Drawing.Point(384, 24);
this.dtBirthDate.Name = "dtBirthDate";
this.dtBirthDate.ShowCheckBox = true;
this.dtBirthDate.ShowUpDown = true;
this.dtBirthDate.TabIndex = 26;
// txtHomepage

this.txtHomepage.BackColor =
this.txtHomepage.Location = new
System.Drawing.Point(384, 88);
this.txtHomepage.Name = "txtHomepage";
this.txtHomepage.Size = new System.Drawing.Size(192,
this.txtHomepage.TabIndex = 12;
this.txtHomepage.Text = "";
// label16
this.label16.Location = new System.Drawing.Point(304,
this.label16.Name = "label16";
this.label16.Size = new System.Drawing.Size(67, 23);
this.label16.TabIndex = 25;
this.label16.Text = "Home Page";
// txtEmail
this.txtEmail.BackColor = System.Drawing.Color.White;
this.txtEmail.Location = new
System.Drawing.Point(384, 56);
this.txtEmail.Name = "txtEmail";
this.txtEmail.Size = new System.Drawing.Size(192, 20);
this.txtEmail.TabIndex = 9;
this.txtEmail.Text = "";
// txtPhone
this.txtPhone.BackColor = System.Drawing.Color.White;
this.txtPhone.Location = new System.Drawing.Point(72,
this.txtPhone.Name = "txtPhone";
this.txtPhone.Size = new System.Drawing.Size(184, 20);
this.txtPhone.TabIndex = 6;
this.txtPhone.Text = "";
// label9
this.label9.Location = new System.Drawing.Point(304,
this.label9.Name = "label9";
this.label9.Size = new System.Drawing.Size(72, 16);
this.label9.TabIndex = 17;
this.label9.Text = "Email";
// label10
this.label10.Font = new
System.Drawing.Font("Microsoft Sans Serif", 8.25F,
System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point,
this.label10.Location = new System.Drawing.Point(304,
this.label10.Name = "label10";

this.label10.Size = new System.Drawing.Size(72, 16);

this.label10.TabIndex = 16;
this.label10.Text = "Date of birth";
// label12
this.label12.Location = new System.Drawing.Point(8,
this.label12.Name = "label12";
this.label12.Size = new System.Drawing.Size(56, 23);
this.label12.TabIndex = 14;
this.label12.Text = "Phone";
// txtAddress
this.txtAddress.BackColor =
this.txtAddress.Location = new
System.Drawing.Point(72, 64);
this.txtAddress.Multiline = true;
this.txtAddress.Name = "txtAddress";
this.txtAddress.Size = new System.Drawing.Size(184,
this.txtAddress.TabIndex = 5;
this.txtAddress.Text = "";
// txtName
this.txtName.BackColor = System.Drawing.Color.White;
this.txtName.Location = new System.Drawing.Point(72,
this.txtName.Name = "txtName";
this.txtName.Size = new System.Drawing.Size(184, 20);
this.txtName.TabIndex = 2;
this.txtName.Text = "";
// label7
this.label7.Location = new System.Drawing.Point(8,
this.label7.Name = "label7";
this.label7.Size = new System.Drawing.Size(64, 17);
this.label7.TabIndex = 4;
this.label7.Text = "Address";
// label4
this.label4.Location = new System.Drawing.Point(8,
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(56, 23);
this.label4.TabIndex = 1;
this.label4.Text = "Name";
// tbpFamily

this.tbpFamily.BackColor =
this.tbpFamily.Location = new System.Drawing.Point(4,
this.tbpFamily.Name = "tbpFamily";
this.tbpFamily.Size = new System.Drawing.Size(792,
this.tbpFamily.TabIndex = 2;
this.tbpFamily.Text = "Family";
// groupBox6
this.groupBox6.Dock =
this.groupBox6.Location = new System.Drawing.Point(0,
this.groupBox6.Name = "groupBox6";
this.groupBox6.Size = new System.Drawing.Size(792,
this.groupBox6.TabIndex = 20;
this.groupBox6.TabStop = false;
// groupBox2

this.groupBox2.Location = new System.Drawing.Point(8,
this.groupBox2.Name = "groupBox2";
this.groupBox2.Size = new System.Drawing.Size(264,
this.groupBox2.TabIndex = 18;
this.groupBox2.TabStop = false;
this.groupBox2.Text = "Father";
// txtFatherOfficePhone
this.txtFatherOfficePhone.BackColor =
this.txtFatherOfficePhone.Location = new
System.Drawing.Point(80, 64);
this.txtFatherOfficePhone.Name =
this.txtFatherOfficePhone.Size = new
System.Drawing.Size(166, 20);
this.txtFatherOfficePhone.TabIndex = 10;
this.txtFatherOfficePhone.Text = "";

// label6
this.label6.Location = new System.Drawing.Point(8,
this.label6.Name = "label6";
this.label6.Size = new System.Drawing.Size(48, 16);
this.label6.TabIndex = 5;
this.label6.Text = "Name";
// label15
this.label15.Location = new System.Drawing.Point(8,
this.label15.Name = "label15";
this.label15.Size = new System.Drawing.Size(64, 16);
this.label15.TabIndex = 11;
this.label15.Text = "Cell Phone";
// txtFatherCellPhone
this.txtFatherCellPhone.BackColor =
this.txtFatherCellPhone.Location = new
System.Drawing.Point(80, 96);
this.txtFatherCellPhone.Name = "txtFatherCellPhone";
this.txtFatherCellPhone.Size = new
System.Drawing.Size(166, 20);
this.txtFatherCellPhone.TabIndex = 12;
this.txtFatherCellPhone.Text = "";
// txtFather
this.txtFather.BackColor = System.Drawing.Color.White;
this.txtFather.Location = new
System.Drawing.Point(80, 32);
this.txtFather.Name = "txtFather";
this.txtFather.Size = new System.Drawing.Size(166,
this.txtFather.TabIndex = 6;
this.txtFather.Text = "";
// label13
this.label13.Location = new System.Drawing.Point(8,
this.label13.Name = "label13";
this.label13.Size = new System.Drawing.Size(56, 16);
this.label13.TabIndex = 9;
this.label13.Text = "Off Phone";
// groupBox1

this.groupBox1.Location = new
System.Drawing.Point(280, 16);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(272,
this.groupBox1.TabIndex = 17;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "Name";
// txtMotherCellPhone
this.txtMotherCellPhone.BackColor =
this.txtMotherCellPhone.Location = new
System.Drawing.Point(88, 88);
this.txtMotherCellPhone.Name = "txtMotherCellPhone";
this.txtMotherCellPhone.Size = new
System.Drawing.Size(166, 20);
this.txtMotherCellPhone.TabIndex = 16;
this.txtMotherCellPhone.Text = "";
// label23
this.label23.Location = new System.Drawing.Point(16,
this.label23.Name = "label23";
this.label23.Size = new System.Drawing.Size(56, 16);
this.label23.TabIndex = 13;
this.label23.Text = "Off Phone";
// label11
this.label11.Location = new System.Drawing.Point(16,
this.label11.Name = "label11";
this.label11.Size = new System.Drawing.Size(64, 23);
this.label11.TabIndex = 7;
this.label11.Text = "Name";
// txtMotherOfficePhone
this.txtMotherOfficePhone.BackColor =
this.txtMotherOfficePhone.Location = new
System.Drawing.Point(88, 56);
this.txtMotherOfficePhone.Name =
this.txtMotherOfficePhone.Size = new
System.Drawing.Size(166, 20);
this.txtMotherOfficePhone.TabIndex = 14;
this.txtMotherOfficePhone.Text = "";

// label24
this.label24.Location = new System.Drawing.Point(16,
this.label24.Name = "label24";
this.label24.Size = new System.Drawing.Size(72, 16);
this.label24.TabIndex = 15;
this.label24.Text = "Cell Phone";
// txtMother
this.txtMother.BackColor = System.Drawing.Color.White;
this.txtMother.Location = new
System.Drawing.Point(88, 24);
this.txtMother.Name = "txtMother";
this.txtMother.Size = new System.Drawing.Size(166,
this.txtMother.TabIndex = 8;
this.txtMother.Text = "";
// groupBox3
this.groupBox3.Location = new
System.Drawing.Point(560, 16);
this.groupBox3.Name = "groupBox3";
this.groupBox3.Size = new System.Drawing.Size(296,
this.groupBox3.TabIndex = 19;
this.groupBox3.TabStop = false;
this.groupBox3.Text = "Residence";
// txtResidenceAddress
this.txtResidenceAddress.BackColor =
this.txtResidenceAddress.Location = new
System.Drawing.Point(80, 48);
this.txtResidenceAddress.Multiline = true;
this.txtResidenceAddress.Name = "txtResidenceAddress";
this.txtResidenceAddress.Size = new
System.Drawing.Size(184, 80);
this.txtResidenceAddress.TabIndex = 18;
this.txtResidenceAddress.Text = "";
// label26
this.label26.Location = new System.Drawing.Point(8,
this.label26.Name = "label26";
this.label26.Size = new System.Drawing.Size(64, 17);
this.label26.TabIndex = 17;
this.label26.Text = "Address";

// label25
this.label25.Location = new System.Drawing.Point(8,
this.label25.Name = "label25";
this.label25.Size = new System.Drawing.Size(64, 16);
this.label25.TabIndex = 15;
this.label25.Text = "Res Phone";
// txtResPhone
this.txtResPhone.BackColor =
this.txtResPhone.Location = new
System.Drawing.Point(80, 24);
this.txtResPhone.Name = "txtResPhone";
this.txtResPhone.Size = new System.Drawing.Size(166,
this.txtResPhone.TabIndex = 16;
this.txtResPhone.Text = "";
// tbpAdmission
this.tbpAdmission.Location = new
System.Drawing.Point(4, 22);
this.tbpAdmission.Name = "tbpAdmission";
this.tbpAdmission.Size = new System.Drawing.Size(792,
this.tbpAdmission.TabIndex = 1;
this.tbpAdmission.Text = "Admission";
// grpAdmission
this.grpAdmission.BackColor =
this.grpAdmission.Dock =
this.grpAdmission.Location = new
System.Drawing.Point(0, 0);
this.grpAdmission.Name = "grpAdmission";
this.grpAdmission.Size = new System.Drawing.Size(792,
this.grpAdmission.TabIndex = 0;
this.grpAdmission.TabStop = false;
// groupBox5
this.groupBox5.Location = new System.Drawing.Point(8,
this.groupBox5.Name = "groupBox5";

this.groupBox5.Size = new System.Drawing.Size(248,

this.groupBox5.TabIndex = 29;
this.groupBox5.TabStop = false;
this.groupBox5.Text = "Admission";
// txtAdmittedBy
this.txtAdmittedBy.BackColor =
this.txtAdmittedBy.Location = new
System.Drawing.Point(96, 64);
this.txtAdmittedBy.Name = "txtAdmittedBy";
this.txtAdmittedBy.Size = new
System.Drawing.Size(136, 20);
this.txtAdmittedBy.TabIndex = 4;
this.txtAdmittedBy.Text = "";
// label8
this.label8.Location = new System.Drawing.Point(8,
this.label8.Name = "label8";
this.label8.Size = new System.Drawing.Size(72, 17);
this.label8.TabIndex = 27;
this.label8.Text = "Admn: Date";
// dtAdmissionDate
this.dtAdmissionDate.CalendarMonthBackground =
this.dtAdmissionDate.CalendarTitleBackColor =
this.dtAdmissionDate.CalendarTitleForeColor =
this.dtAdmissionDate.CalendarTrailingForeColor =
this.dtAdmissionDate.CustomFormat = "dd / MMM / yyyy";
this.dtAdmissionDate.Format =
this.dtAdmissionDate.Location = new
System.Drawing.Point(96, 24);
this.dtAdmissionDate.Name = "dtAdmissionDate";
this.dtAdmissionDate.ShowCheckBox = true;
this.dtAdmissionDate.ShowUpDown = true;
this.dtAdmissionDate.Size = new
System.Drawing.Size(136, 20);
this.dtAdmissionDate.TabIndex = 25;
// label18
this.label18.Location = new System.Drawing.Point(8,
this.label18.Name = "label18";
this.label18.Size = new System.Drawing.Size(72, 23);
this.label18.TabIndex = 1;
this.label18.Text = "Admitted By";

// groupBox4

this.groupBox4.Location = new
System.Drawing.Point(264, 16);
this.groupBox4.Name = "groupBox4";
this.groupBox4.Size = new System.Drawing.Size(544,
this.groupBox4.TabIndex = 28;
this.groupBox4.TabStop = false;
this.groupBox4.Text = "Previous Institute";
// label19
this.label19.Location = new System.Drawing.Point(16,
this.label19.Name = "label19";
this.label19.Size = new System.Drawing.Size(56, 16);
this.label19.TabIndex = 2;
this.label19.Text = "Name";
// txtPrevSchool
this.txtPrevSchool.BackColor =
this.txtPrevSchool.Location = new
System.Drawing.Point(80, 24);
this.txtPrevSchool.Name = "txtPrevSchool";
this.txtPrevSchool.Size = new
System.Drawing.Size(200, 20);
this.txtPrevSchool.TabIndex = 5;
this.txtPrevSchool.Text = "";
// txtPrevSchoolAddress
this.txtPrevSchoolAddress.BackColor =
this.txtPrevSchoolAddress.Location = new
System.Drawing.Point(80, 48);
this.txtPrevSchoolAddress.Multiline = true;
this.txtPrevSchoolAddress.Name =
this.txtPrevSchoolAddress.Size = new
System.Drawing.Size(200, 48);
this.txtPrevSchoolAddress.TabIndex = 9;
this.txtPrevSchoolAddress.Text = "";

// label22
this.label22.Location = new System.Drawing.Point(16,
this.label22.Name = "label22";
this.label22.Size = new System.Drawing.Size(48, 24);
this.label22.TabIndex = 6;
this.label22.Text = "Address";
// txtPrevSchoolPhone
this.txtPrevSchoolPhone.BackColor =
this.txtPrevSchoolPhone.Location = new
System.Drawing.Point(80, 104);
this.txtPrevSchoolPhone.Name = "txtPrevSchoolPhone";
this.txtPrevSchoolPhone.Size = new
System.Drawing.Size(136, 20);
this.txtPrevSchoolPhone.TabIndex = 10;
this.txtPrevSchoolPhone.Text = "";
// label21
this.label21.Location = new System.Drawing.Point(16,
this.label21.Name = "label21";
this.label21.Size = new System.Drawing.Size(48, 16);
this.label21.TabIndex = 7;
this.label21.Text = "Phone";
// txtReasonForLeaving
this.txtReasonForLeaving.BackColor =
this.txtReasonForLeaving.Location = new
System.Drawing.Point(296, 32);
this.txtReasonForLeaving.Multiline = true;
this.txtReasonForLeaving.Name = "txtReasonForLeaving";
this.txtReasonForLeaving.Size = new
System.Drawing.Size(240, 88);
this.txtReasonForLeaving.TabIndex = 11;
this.txtReasonForLeaving.Text = "";
// label20
this.label20.Location = new System.Drawing.Point(296,
this.label20.Name = "label20";
this.label20.Size = new System.Drawing.Size(176, 16);
this.label20.TabIndex = 8;
this.label20.Text = "Reason For Leaving";
// tbpCurricular
this.tbpCurricular.BackColor =

this.tbpCurricular.Location = new
System.Drawing.Point(4, 22);
this.tbpCurricular.Name = "tbpCurricular";
this.tbpCurricular.Size = new
System.Drawing.Size(792, 209);
this.tbpCurricular.TabIndex = 7;
this.tbpCurricular.Text = "Academic";
// groupBox7
this.groupBox7.Dock =
this.groupBox7.Location = new System.Drawing.Point(0,
this.groupBox7.Name = "groupBox7";
this.groupBox7.Size = new System.Drawing.Size(792,
this.groupBox7.TabIndex = 8;
this.groupBox7.TabStop = false;
// txtRegNo
this.txtRegNo.BackColor = System.Drawing.Color.White;
this.txtRegNo.Location = new
System.Drawing.Point(104, 24);
this.txtRegNo.Name = "txtRegNo";
this.txtRegNo.Size = new System.Drawing.Size(96, 20);
this.txtRegNo.TabIndex = 7;
this.txtRegNo.Text = "";
// cmbBatch
this.cmbBatch.BackColor = System.Drawing.Color.White;
this.cmbBatch.DropDownStyle =
this.cmbBatch.Location = new
System.Drawing.Point(104, 56);
this.cmbBatch.Name = "cmbBatch";
this.cmbBatch.Size = new System.Drawing.Size(144, 21);
this.cmbBatch.TabIndex = 5;
// label5
this.label5.Location = new System.Drawing.Point(24,
this.label5.Name = "label5";
this.label5.TabIndex = 4;
this.label5.Text = "Batch";
// label3
this.label3.Location = new System.Drawing.Point(24,

this.label3.Name = "label3";
this.label3.TabIndex = 6;
this.label3.Text = "Register No:";
// tbpExtraCurricular
this.tbpExtraCurricular.BackColor =
this.tbpExtraCurricular.Location = new
System.Drawing.Point(4, 22);
this.tbpExtraCurricular.Name = "tbpExtraCurricular";
this.tbpExtraCurricular.Size = new
System.Drawing.Size(792, 209);
this.tbpExtraCurricular.TabIndex = 5;
this.tbpExtraCurricular.Text = "ExtraCurricular";
// tbpPromotion
this.tbpPromotion.BackColor =
this.tbpPromotion.Location = new
System.Drawing.Point(4, 22);
this.tbpPromotion.Name = "tbpPromotion";
this.tbpPromotion.Size = new System.Drawing.Size(792,
this.tbpPromotion.TabIndex = 4;
this.tbpPromotion.Text = "Promotions";
// tbpMarks
this.tbpMarks.BackColor =
this.tbpMarks.Location = new System.Drawing.Point(4,
this.tbpMarks.Name = "tbpMarks";
this.tbpMarks.Size = new System.Drawing.Size(792,
this.tbpMarks.TabIndex = 3;
this.tbpMarks.Text = "Marks";
// tbpRemarks
this.tbpRemarks.Location = new
System.Drawing.Point(4, 22);
this.tbpRemarks.Name = "tbpRemarks";
this.tbpRemarks.Size = new System.Drawing.Size(792,
this.tbpRemarks.TabIndex = 6;
this.tbpRemarks.Text = "Remarks";
// txtRemarks
this.txtRemarks.BackColor =
this.txtRemarks.Dock =

this.txtRemarks.Location = new
System.Drawing.Point(0, 0);
this.txtRemarks.Multiline = true;
this.txtRemarks.Name = "txtRemarks";
this.txtRemarks.Size = new System.Drawing.Size(792,
this.txtRemarks.TabIndex = 27;
this.txtRemarks.Text = "";
// StudentDetails
this.BackColor = System.Drawing.Color.AliceBlue;
this.Name = "StudentDetails";
this.Size = new System.Drawing.Size(800, 552);
this.Load += new


private DataTable studentTable;

public string pageAction;
public string deleted;
public string reLoad;

private void StudentDetails_Load(object sender,

System.EventArgs e)
// Load records into the grid.

// make sure all fields (like text boxes etc) are

read only.
EnableFields( false );

// Enabel / Disable appropriate buttons.

SetEditState( false );

String connectionString =
util.PopulateCombo( cmbBatch, connectionString,
"Batch", "BatchName", "BatchId", "1" );


//// DisableFields();
//// LoadCurrentItem();
//// txtSearchByName.Focus();
//// btnSave.Enabled=false;
//// deleted="false";

private void EnableFields( bool enable )

bool readOnly = !enable;

txtHomepage.ReadOnly = readOnly;
txtEmail.ReadOnly = readOnly;
txtPhone.ReadOnly = readOnly;
txtAddress.ReadOnly = readOnly;
txtName.ReadOnly = readOnly;
txtAdmittedBy.ReadOnly = readOnly;
txtPrevSchool.ReadOnly = readOnly;
txtReasonForLeaving.ReadOnly = readOnly;
txtPrevSchoolPhone.ReadOnly = readOnly;
txtPrevSchoolAddress.ReadOnly = readOnly;
txtRemarks.ReadOnly = readOnly;
txtFather.ReadOnly = readOnly;
txtRegNo.ReadOnly = readOnly;
txtMother.ReadOnly = readOnly;
txtFatherOfficePhone.ReadOnly = readOnly;
txtFatherCellPhone.ReadOnly = readOnly;
txtMotherOfficePhone.ReadOnly = readOnly;
txtMotherCellPhone.ReadOnly = readOnly;
txtResPhone.ReadOnly = readOnly;
txtResidenceAddress.ReadOnly = readOnly;

cmbBatch.Enabled = enable;
dtBirthDate.Enabled = enable;
dtAdmissionDate.Enabled = enable;

txtSearchByRegNo.ReadOnly = enable;
txtSearchByName.ReadOnly = enable;

private void SetEditState ( bool edit )


// When a record is selected for edit, disable the

Add, Edit & Close buttons.
btnAdd.Enabled = !edit;
btnEdit.Enabled = !edit;
btnClose.Enabled = !edit;
btnDelete.Enabled = !edit;

// When we are editing, do not allow to navigate in

the grid.
grdStudent.Enabled = !edit;

// When we are editing, only Cancel and Save buttons

are enabled.
btnCancel.Enabled = edit;
btnSave.Enabled = edit;

private void LoadCurrentItem()

if ( grdStudent.CurrentRowIndex == -1 ) // Is
there any row selected now?

// The first column of the grid contains the id

field. Since the width of the
// field is set to zero, the column is not visible in
the grid. But we
// can still access the value in it.

// Retrieve the first column from the selected row.

int Id = int.Parse
( grdStudent[grdStudent.CurrentRowIndex, 0].ToString() );

Student student = StudentManager.GetStudent( Id );

if ( student == null )
MessageBox.Show ( "Couldn't retrieve the object
for the selected row.", "Error", MessageBoxButtons.OK,
MessageBoxIcon.Error );

txtHomepage.Text = student.Homepage;
txtEmail.Text = student.Email;
txtPhone.Text = student.Phone;
txtAddress.Text = student.StudentAddress;
txtName.Text = student.StudentName;
txtAdmittedBy.Text = student.AdmittedBy;
txtPrevSchool.Text = student.PrevSchoolName;
txtReasonForLeaving.Text = student.ReasonForLeaving;
txtPrevSchoolPhone.Text = student.PrevSchoolPhone;
txtPrevSchoolAddress.Text = student.PrevSchoolAddress;
txtRemarks.Text = student.Remarks;
txtFather.Text = student.FatherName;
txtRegNo.Text = student.RegNo;
txtMother.Text = student.MotherName;

txtFatherOfficePhone.Text =
txtFatherCellPhone.Text = student.FatherCellPhone;
txtMotherOfficePhone.Text = student.MotherResPhone;
txtMotherCellPhone.Text = student.MotherCellPhone;
txtResPhone.Text = student.ResidencePhone;
txtResidenceAddress.Text = student.ResidenceAddress;

cmbBatch.SelectedValue = student.BatchId;

dtAdmissionDate.Value = student.AdmissionDate;
dtAdmissionDate.Checked =

dtBirthDate.Value = student.DateOfBirth;
dtBirthDate.Checked = student.DateOfBirthSelected;

private void ClearFields()

txtHomepage.Text = String.Empty;
txtEmail.Text = String.Empty;
txtPhone.Text = String.Empty;
txtAddress.Text = String.Empty;
txtName.Text = String.Empty;
txtAdmittedBy.Text = String.Empty;
txtPrevSchool.Text = String.Empty;
txtReasonForLeaving.Text = String.Empty;
txtPrevSchoolPhone.Text = String.Empty;
txtPrevSchoolAddress.Text = String.Empty;
txtRemarks.Text = String.Empty;
txtFather.Text = String.Empty;
txtRegNo.Text = String.Empty;
txtMother.Text = String.Empty;
txtFatherOfficePhone.Text = String.Empty;
txtFatherCellPhone.Text = String.Empty;
txtMotherOfficePhone.Text = String.Empty;
txtMotherCellPhone.Text = String.Empty;
txtResPhone.Text = String.Empty;
txtResidenceAddress.Text = String.Empty;

cmbBatch.SelectedIndex = 0;
dtAdmissionDate.Value = DateTime.Today;
dtAdmissionDate.Checked = false;
dtBirthDate.Value = DateTime.Today;
dtBirthDate.Checked = false;
// Can be used to Search 2 diff text field values.
private void LoadGrid()
string criteria = "StudentName like '%" +
txtSearchByName.Text + "%' AND RegNo like '%" + txtSearchByRegNo.Text +
"%' AND Status <> " + (Int16)eStatus.Deleted;
studentTable = StudentManager.GetStudents( criteria );
grdStudent.DataSource = studentTable;

private void btnClose_Click(object sender, System.EventArgs

this.Visible = false;

private void txtSearchByName_TextChanged(object sender,

System.EventArgs e)

private void txtSearchByRegNo_TextChanged(object sender,

System.EventArgs e)

private void grdStudent_CurrentCellChanged(object sender,

System.EventArgs e)
grdStudent.Select ( grdStudent.CurrentRowIndex );
EnableFields( false );
SetEditState( false );

private void btnEdit_Click(object sender, System.EventArgs

pageAction= "EDIT";

EnableFields( true );
SetEditState( true );

private void btnAdd_Click(object sender, System.EventArgs e)

pageAction= "ADD";

EnableFields( true );
SetEditState( true );

private void btnSave_Click(object sender, System.EventArgs

if ( txtName.Text.Trim() == String.Empty )
MessageBox.Show ( "Please enter the student
name.", "Message", MessageBoxButtons.OK, MessageBoxIcon.Warning );

if ( txtRegNo.Text == String.Empty )
MessageBox.Show ( "Please enter the Register
Number.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning );

Student student;

if ( pageAction== "ADD" )
// We are creating a new student.

// Make sure the RegNo is not duplicated.

DataTable table = StudentManager.GetStudents(
"RegNo='" + txtRegNo.Text + "'" );
if ( table.Rows.Count != 0 )
MessageBox.Show("Register Number already
exists. Please choose a different number.", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Warning );

student = new Student();

int id = IdManager.GetNextID( "Student", "Id" );
student.Id = id;

student.Status = (int)eStatus.New;
// We are editing an existing student.
int id = int.Parse
( grdStudent[grdStudent.CurrentRowIndex, 0].ToString() );
student = StudentManager.GetStudent( id );

student.Homepage = txtHomepage.Text;
student.Email = txtEmail.Text;
student.Phone = txtPhone.Text;
student.StudentAddress = txtAddress.Text;
student.StudentName = txtName.Text;
student.AdmittedBy = txtAdmittedBy.Text;
student.PrevSchoolName = txtPrevSchool.Text;
student.ReasonForLeaving = txtReasonForLeaving.Text;
student.PrevSchoolPhone = txtPrevSchoolPhone.Text;
student.PrevSchoolAddress = txtPrevSchoolAddress.Text;
student.Remarks = txtRemarks.Text;
student.FatherName = txtFather.Text;
student.RegNo = txtRegNo.Text;
student.MotherName = txtMother.Text;
student.FatherOfficePhone = txtFatherOfficePhone.Text;
student.FatherCellPhone = txtFatherCellPhone.Text;
student.MotherResPhone = txtMotherOfficePhone.Text;
student.MotherCellPhone = txtMotherCellPhone.Text;

student.ResidencePhone = txtResPhone.Text;
student.ResidenceAddress = txtResidenceAddress.Text;

student.BatchId = (int)cmbBatch.SelectedValue;

student.LastModifiedTime = DateTime.Now;

student.AdmissionDateSelected =
student.AdmissionDate = dtAdmissionDate.Value;

student.DateOfBirthSelected = dtBirthDate.Checked;
student.DateOfBirth = dtBirthDate.Value;

if ( pageAction== "ADD" )
int id = IdManager.GetNextID( "Student", "Id" );
student.Id = id;
StudentManager.CreateStudent( student );
StudentManager.UpdateStudent( student );

MessageBox.Show( "Saved successfully.", "Message",

MessageBoxButtons.OK, MessageBoxIcon.Information );

// Make sure all fields (like text boxes etc) are

read only.
EnableFields( false );

// Enable / Disable appropriate buttons.

SetEditState( false );


private void btnCancel_Click(object sender, System.EventArgs


// Make sure all fields (like text boxes etc) are

read only.
EnableFields( false );

// Enable / Disable appropriate buttons.

SetEditState( false );

private void btnDelete_Click(object sender, System.EventArgs

// Ask the user to confirm whether he really want to

DialogResult result = MessageBox.Show( "Are you sure

to delete the selected item ?", "Please confirm",
MessageBoxButtons.YesNo, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2 );
if ( result == DialogResult.Yes )
// user selected 'Yes' in the confirmation

// We are not permanently deleting any

record... just changing the status field to 'Deleted'.

int id = int.Parse
( grdStudent[grdStudent.CurrentRowIndex, 0].ToString() );
Student student = StudentManager.GetStudent( id
student.Status = (int)eStatus.Deleted;
// Change status
StudentManager.UpdateStudent( student ); //
Update record.

EnableFields( false );
SetEditState( false );

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<add key="dsn" value="Provider=Microsoft.Jet.OLEDB.4.0;Data

<add key="dsn" value="Provider=Microsoft.Jet.OLEDB.4.0;Data

Program Design Language


The program design language is also called as structured English or pseudopodia.

PDL is a generic reference for a design language PDL looks like a modern language.
The difference between PDL and real programming language lies in the narrative text
embedded directly within PDL statements.

The characteristics required by a design language are:

 A fixed system of keywords that provide for all structured constructs date declaration
and modularity characteristics.

 A free syntax of natural language that describes processing features.

 Date declaration facilities that should include both simple and complex data

 Subprogram definition and calling techniques that support various nodes of interface

PDL syntax should include constructs for subprogram definition,

interface description date declaration techniques for structuring,
conditions constructs, repetition constructs and I/O constructs.

PDL can be extended to include keywords for multitasking and/or

concurrent processing interrupt handling, interposes synchronization
the application design for which PDL is to be used should dictate the
final form for the design language.


 The database as it is developed by SQL server 2005 can be installed only
by using the export and import concepts.

 Using Dot Net and components like C# need proper deployment as per
general specifications developed the front end as it.

Main page:

Personal details:

Saved successfully:

When clicked on close:


When clicked on close:






Testing & Debugging


Testing is the process of detecting errors. Testing performs a very critical role for quality
assurance and for ensuring the reliability of software. The results of testing are used later
on during maintenance also.

Psychology of Testing
The aim of testing is often to demonstrate that a program works by showing that it has no
errors. The basic purpose of testing phase is to detect the errors that may be present in the
program. Hence one should not start testing with the intent of showing that a program
works, but the intent should be to show that a program doesn’t work. Testing is the
process of executing a program with the intent of finding errors.

Testing Objectives
The main objective of testing is to uncover a host of errors, systematically and with

minimum effort and time. Stating formally, we can say,

 Testing is a process of executing a program with the intent of finding an error.

 A successful test is one that uncovers an as yet undiscovered error.

 A good test case is one that has a high probability of finding error, if it exists.

 The tests are inadequate to detect possibly present errors.

 The software more or less confirms to the quality and reliable standards.

6.1 Levels of Testing:

In order to uncover the errors present in different phases we have the concept of levels of

testing. The basic levels of testing are as shown below…


Client Needs

System Testing

Integration Testing

Unit Testing

6.2 Requirement:

System Testing:

The philosophy behind testing is to find errors. Test cases are devised with this in mind.

A strategy employed for system testing is code testing.

Code Testing:

This strategy examines the logic of the program. To follow this method we developed
some test data that resulted in executing every instruction in the program and module i.e.
every path is tested. Systems are not designed as entire nor are they tested as single
systems. To ensure that the coding is perfect two types of testing is performed or for that

matter is performed or that matter is performed or for that matter is performed on all

Types Of Testing

 Unit Testing
 Link Testing

Unit Testing
Unit testing focuses verification effort on the smallest unit of software i.e. the module.
Using the detailed design and the process specifications testing is done to uncover errors
within the boundary of the module. All modules must be successful in the unit test before
the start of the integration testing begins.

In this project each service can be thought of a module. There are so many modules like
Login, MasterAdmin, Normal User. Giving different sets of inputs has tested each
module. When developing the module as well as finishing the development so that each
module works without any error. The inputs are validated when accepting from the user.

In this application developer tests the programs up as system. Software units in a system
are the modules and routines that are assembled and integrated to form a specific
function. Unit testing is first done on modules, independent of one another to locate
errors. This enables to detect errors. Through this errors resulting from interaction
between modules initially avoided.

Link Testing
Link testing does not test software but rather the integration of each module in system.
The primary concern is the compatibility of each module. The Programmer tests where
modules are designed with different parameters, length, type etc.

Integration Testing
After the unit testing we have to perform integration testing. The goal here is to see if
modules can be integrated proprerly, the emphasis being on testing interfaces between

modules. This testing activity can be considered as testing the design and hence the
emphasis on testing module interactions.

In this project integrating all the modules forms the main system. When integrating all
the modules I have checked whether the integration effects working of any of the services
by giving different combinations of inputs with which the two services run perfectly
before Integration.

System Testing
Here the entire software system is tested. The reference document for this process is the
requirements document, and the goal os to see if software meets its requirements.

Here entire ‘ATM’ has been tested against requirements of project and it is checked
whether all requirements of project have been satisfied or not.

Acceptance Testing
Acceptance Test is performed with realistic data of the client to demonstrate that the
software is working satisfactorily. Testing here is focused on external behavior of the
system; the internal logic of program is not emphasized.

In this project ‘Network Management Of Database System’ I have collected some data
and tested whether project is working correctly or not.

Test cases should be selected so that the largest number of attributes of an equivalence
class is exercised at once. The testing phase is an important part of software development.
It is the process of finding errors and missing operations and also a complete verification
to determine whether the objectives are met and the user requirements are satisfied.

White Box Testing

This is a unit testing method where a unit will be taken at a time and tested thoroughly at

a statement level to find the maximum possible errors. I tested step wise every piece of

code, taking care that every statement in the code is executed at least once. The white box

testing is also called Glass Box Testing.


I have generated a list of test cases, sample data. which is used to check all possible
combinations of execution paths through the code at every module level.

Black Box Testing

This testing method considers a module as a single unit and checks the unit at interface
and communication with other modules rather getting into details at statement level. Here
the module will be treated as a block box that will take some input and generate output.
Output for a given set of input combinations are forwarded to other modules.

6.3 Criteria Satisfied by Test Cases

• Test cases that reduced by a count that is greater than one, the number of
additional test cases that much be designed to achieve reasonable testing.

• Test cases that tell us something about the presence or absence of classes
of errors, rather than an error associated only with the specific test at hand.


Conclusions and Recommendations:

The entire project has been developed and deployed as per the requirements stated by the

user as student master, it is found to be bug free as per the testing standards that are

implemented. Any specification untraced errors will be concentrated in the coming

versions, which are planned to be developed in near future. The system at present does

not take care off the money payment methods, as the consolidated constructs need SSL

standards and are critically to be initiated in the first face, the application of the credit

card transactions is applied as a developmental phase in the coming days. The system

needs more elaborative technicality for its inception and evolution.



Bi b l i o g r a p h y :

References for the Project Development Were Taken From the

following Books and Web Sites.
SQL Server

Mastering SQL Server 2000 by Gunderloy, Jorden BPB Publications

Beginning SQL Server 2005 by Thereon Willis work publications

Visual Basic .NET

Programming Visual Basic .NET, Mircrosoft Press

Visual Basic .NET by Mc Donald, Microsoft Press