CONTENTS

1. INTRODUCTION ...................................................................................
1.1.PROJECT OVERVIEW .........................................................................
1.2.PURPOSE ..........................................................................................
1.3.SCOPE ...............................................................................................
1.4.DEFINITIONS, ACRONYMS ................................................................
2.SYSTEM ANALYSIS .................................................................................
2.1.INTRODUCTION TO SYSTEM ANALYSIS .............................................
2.2. Existing System ...............................................................................
2.3.Proposed System ..............................................................................
2.4. FEASIBILITY STUDY...................................................................
2.4.1. TECHNICAL FEASIBILITY ....................................................
2.4.2. ECONOMIC FEASIBILITY .....................................................
3.EXTERNAL INTERFACE REQUIREMENTS ................................................
3.1.HARDWARE INTERFACE: ...........................................................
3.2.Software Interface: ...........................................................................
3.3. Communication Protocol .............................................................
3.4.Non-Functional Requirements.....................................................
3.5.Browser Compatibility ...................................................................
3.6.Security ..........................................................................................
3.7.Availability ......................................................................................
3.8.Portability .......................................................................................
4.SYSTEM DEVELOPMENT ........................................................................
4.1INTRODUCTION TO .NET PLATFORM .................................................
4.2FEATURES. .....................................................................................
4.3ARCHITECTURE. ...........................................................................
4.4 MICROSOFT VISUAL STUDIO 2008
4.5.SQL SERVER 2005: ........................................................................
5. ANALYSIS AND SYSTEM DESIGN ......................................
5.1 E-R DIAGRAM...
5.2 DFD CONSTRUCTION...
6.CODING ...............................................................................................
7. DATABASE DESIGN AND SCREENSHOTS.........................
8.TESTING ...............................................................................................
8.1. Unit Testing .....................................................................................
8.2. Integration Testing ..........................................................................
8.3. Validation Testing ........................................................................
8.4.. Black Box Testing .......................................................................
8.5.White Box Testing .........................................................................
8.6.Acceptance Testing: .....................................................................
8.7.Functional Testing: .......................................................................
8.8.Positive Testing: ............................................................................
8.9.Negative Testing: ..........................................................................
9.MAINTENANCE ............................................................
10. CONCLUSION ..................................................... 56
11. FUTURE SCOPE AND BIBLIOGRAPHY 58
















Chapter 1
INTRODUCTION
Social networking is all about developing connections or ties between friends and
associates. While people have always networked with one another, the Internet has
allowed us to do this in a global manner. Some great examples of popular social
networks are Digg, LinkedIn, Facebook, and Twitter. Most people have heard of
these services and many use them on a daily basis. These communities are able to
generate income from advertising and additional paid services.

Features of our social network
Following are the desirable features that our social networking site will possess:

Accounts
I think that this section of the book is pretty much given on any data-driven site where you have users who
are contributing to the site. If you need to know who your users are, then you need some way of tracking
their accounts. Instead of showing you accounts from the pure ASP.NET way, this section will show you
how to build your own accounting system from scratch. This will include looking at the registration
process where our users create their initial accounts. To make sure that we block bots and other programs
from creating accounts in an automated manner, we will implement a CAPTCHA system and discuss
some other options that are out there for this.

Profiles
A user's profile is really just an extension of his/her account. The difference being
That the account holds the login information and the profile holds all the personal
identifiers. It holds the description of the user, the user's attributes, and their photo
(avatar). We will discuss creating a user's profile in a way that is flexible enough for
all systems to use. We will also discuss how to handle creating an avatar in such a
way that a user can upload a picture, and select from that picture only the part
that they want to include in their avatar. As the profile contains a great deal
of information about the user, we will also implement some forms of privacy to
allow them to hide some bits and show others.


Friends
The concept of having friends in a community is the glue that keeps people coming back to your site. A
friend is a user whom you have stated, whom you trust andallow seeing information about you, and about
whom you are generally interestedin knowing. Think of a friend as a connection, a colleague, and so on.

Messaging
Messaging is essential to any community site as it allows users to communicate with one another
directly.This can come in many forms. You can send a message to a user, which is sent directly to the user
via email. Or you can allow your user to send a message via the site, which is then stored in the recipient's
inbox. A notification is then sent out to the recipient. This last form will be easier for you to manage as a
site administrator.

Blogging
Blogging is often a major feature in any community site as it gives those who enjoy speaking to the world a
tool to do just that. On the other hand though, the output of your blog generates free content for those who are
more on the voyeuristic side to read up and follow along with your blogs. One of the biggest benefits for
a community with active bloggers is that you are acquiring a large amount of free content to feed the various
search engine spiders with. This in turn will help you get your search ranking up, which will drive more traffic
to your site, and will in turn grow your community.


Comments
Commenting is just another way of allowing your users to interact with the content and other members of
your social network. There isn't a lot that is special about the commenting concept. This is a custom user
control to handle commenting any physical object in our system that has a supporting table behind it. This
means that we can have comments on anything such as photos, videos, profiles, forum postings, blogs, and so
on. To sum up, anything can have a comment!



















2. SYSTEM ANALYSIS
2.1.INTRODUCTION TO SYSTEM ANALYSIS
System analysis is a process of gathering and interpreting facts, diagnosing
problems and the information to recommend improvements on the system.
It is a problem solving activity that requires intensive communication
between the system users and system developers. System analysis or
study is an important phase of any system development process. The
system is studied to the minutest detail and analyzed. The system analyst
plays the role of the interrogator and dwells deep into the working of the
present system. The system is viewed as a whole and the input to the
system are identified. The outputs from the organizations are traced to the
various processes. System analysis is concerned with becoming aware of
the problem, identifying the relevant and decisional variables, analyzing
and synthesizing the various factors and determining an optimal or at least
a satisfactory solution or program of action. A detailed study of the process
must be made by various techniques like interviews, questionnaires etc.
The data collected by these sources must be scrutinized to arrive to a
conclusion. The conclusion is an understanding of how the system
functions. This system is called the existing system. Now the existing
system is subjected to close study and problem areas are identified. The
designer now functions as a problem solver and tries to sort out the
difficulties that the enterprise faces. The solutions are given as proposals.
The proposal is then weighed with the existing system analytically and the
best one is selected. The proposal is presented to the user for an
endorsement by the user. The proposal is reviewed on user request and
suitable changes are made. This is loop that ends as soon as the user is
satisfied with proposal. Preliminary study is the process of gathering and
interpreting facts, using the information for further studies on the system.
Preliminary study is problem solving activity that requires intensive
communication between the system users and system developers. It does
various feasibility studies. In these studies a rough figure of the system
activities can be obtained, from which the decision about the strategies to
be followed for effective system study and analysis can be taken.

2.2. Existing System
In the existing system the exams are done only manually but in proposed
system we have to computerize the exams using this application.
Lack of security of data.
More man power.
Time consuming.
Consumes large volume of pare work.
Needs manual calculations.
No direct role for the higher officials

2.3.Proposed System
The aim of proposed system is to develop a system of improved facilities.
The proposed system can overcome all the limitations of the existing
system. The system provides proper security and reduces the manual
work.
Security of data.
Ensure data accuracys.
Proper control of the higher officials.
Minimize manual data entry.
Minimum time needed for the various processing.
Greater efficiency.
Better service.
User friendliness and interactive.
Minimum time required.
2.4. FEASIBILITY STUDY
Feasibility study is made to see if the project on completion will serve the
purpose of the organization for the amount of work, effort and the time that
spend on it. Feasibility study lets the developer foresee the future of the
project and the usefulness. A feasibility study of a system proposal is
according to its workability, which is the impact on the organization, ability
to meet their user needs and effective use of resources. Thus when a new
application is proposed it normally goes through a feasibility study .The
document provide the feasibility of the project that is being designed and
lists various areas that were considered very carefully during the feasibility
study of this project such as Technical, Economic and Operational
feasibilities. The following are its features:
2.4.1. TECHNICAL FEASIBILITY
The system must be evaluated from the technical point of view first. The
assessment of this feasibility must be based on an outline design of the
system requirement in the terms of input, output, programs and
procedures. Having identified an outline system, the investigation must go
on to suggest the type of equipment, required method developing the
system, of running the system once it has been designed.


Technical issues raised during the investigation are:
Does the existing technology sufficient for the suggested one?
Can the system expand if developed?
The project should be developed such that the necessary functions and
performance are achieved within the constraints. The project is developed
within latest technology. Through the technology may become obsolete
after some period of time, due to the fact that never version of same
software supports older versions, the system may still be used. So there
are minimal constraints involved with this project. The system has been
developed using Java the project is technically feasible for development.
2.4.2. ECONOMIC FEASIBILITY
The developing system must be justified by cost and benefit. Criteria to
ensure that effort is concentrated on project, which will give best, return at
the earliest. One of the factors, which affect the development of a new
system, is the cost it would require.
The following are some of the important financial questions asked during
preliminary investigation:
The costs conduct a full system investigation.
The cost of the hardware and software.
The benefits in the form of reduced costs or fewer costly errors.

Since the system is developed as part of project work, there is no manual
cost to spend for the proposed system. Also all the resources are already
available, it give an indication of the system is economically possible for
development.

3. EXTERNAL INTERFACE
REQUIREMENTS
3.1.HARDWARE INTERFACE:
Processor : Intel Pentium IV or more
Ram : 512 MB or more
Cache : 1 MB
Hard Disk : 10 GB recommended
3.2.Software Interface:
Client on Internet: Web Browser, Operating System (any)
Web Server:, Operating System (any)
Database: Microsoft SQL Server 2005
IDE: Microsoft Visual Studio 2008

3.3. Communication Protocol
Following protocols are required to be permitted on the server side
HTTP incoming request

3.4.Non-Functional Requirements
System should be able handle single users
Database updating should follow transaction processing to avoid data
inconsistency.
3.5.Browser Compatibility
The project being web based required compatibility with at least the popular
web browsers. Microsoft Windows XP and above, Linux and Macintosh
being the current popular operating system and Microsoft Internet Explorer,
Mozilla Firefox, Opera, Safari and Google Chrome being the currently
popular web browser.

3.6.Security
Students can only view their test records.
Critical information like passwords should be transferred in encrypted
form
Data validation and verification needs to be done at every stage of
activity.
3.7.Availability
The examination system being an online system should be available
anytime.
Constraints:
Though the system should be available 24x7 some features may be
restricted.
Quiz creator may allow the specific test to be available only at certain
time like scheduled examination.
The test may be time limited so the candidates appearing will have
limited time to answer the test.

3.8.Portability
The web application will be built using JAVA which has support to run
on any platform provided the required compilers are available.
For database ORACLE-10g would be used, that too has extensive
support over many popular architectures and operating systems.



4. SYSTEM DEVELOPMENT

Introduction to the .NET Framework: The .NET
Framework (pronounced dot net) is a software framework that runs on
Microsoft Windows. Programs written for the .NET Framework execute in
a software environment (as contrasted to hardware environment), known
as the Common Language Runtime (CLR). The CLR is an application
virtual machine. The .Net Framework mainly constitutes of he Common
Language Runtime (CLR), a set of class libraries, a set of programming
languages, and the ASP.Net environment.







A program written for .NET requires that the .NET framework must be
installed before the new program can run.
.NET not only works on Windows computers, but is also available for other
platforms like Linux and Mac OS.
.NET is not specific to computers, Compact .NET also runs on PDA,
Smartphones etc.
The .NET Framework includes a large library. It supports
several programming languages which allows language interoperability
(each language can use code written in other languages). The .NET library
is available to all the programming languages that .NET supports. The
class library and the CLR together constitute the .NET Framework. The
.NET framework's Base Class Library provides user interface, data
access, database connectivity, cryptography, web application development,
numeric algorithms, and network communications. The class library is used
by programmers, who combine it with their own code to produce
applications.
Features:
Interoperability
Because computer systems commonly require interaction between new
and older applications, the .NET Framework provides means to access
functionality that is implemented in programs that execute outside the .NET
environment. Access to COM components is provided in the System.
Common Language Runtime Engine
The Common Language Runtime (CLR) is the execution engine of the
.NET Framework. All .NET programs execute under the supervision of the
CLR, guaranteeing certain properties and behaviors in the areas of
memory management, security, and exception handling.
Language Independence
The .NET Framework introduces a Common Type System, or CTS. The
CTS specification defines all possible data types and
programming constructs supported by the CLR and how they may or may
not interact with each other conforming to the Common Language
Infrastructure (CLI) specification. Because of this feature, the .NET
Framework supports the exchange of types and object instances between
libraries and applications written using any conforming .NET language.
Base Class Library
The Base Class Library (BCL), part of the Framework Class Library (FCL),
is a library of functionality available to all languages using the .NET
Framework. The BCL provides classes which encapsulate a number of
common functions, including file reading and writing, graphic
rendering, database interaction, XML document manipulation and so on.
Simplified Deployment
The .NET Framework includes design features and tools that help manage
the installation of computer software to ensure that it does not interfere with
previously installed software, and that it conforms to security requirements.
Security
The design is meant to address some of the vulnerabilities, such as buffer
overflows, that have been exploited by malicious software. Additionally,
.NET provides a common security model for all applications.
Portability
The design of the .NET Framework allows it theoretically to be platform
agnostic, and thus cross-platform compatible. That is, a program written to
use the framework should run without change on any type of system for
which the framework is implemented.

ARCHITECTURE
Common Language Infrastructure (CLI)
The purpose of the Common Language Infrastructure, is to provide a
language-neutral platform for application development and execution,
including functions for Exception handling, Garbage Collection, security,
and interoperability. By implementing the core aspects of the .NET
Framework within the scope of the CLI, this functionality will not be tied to a
single language but will be available across the many languages supported
by the framework. Microsoft's implementation of the CLI is called
the Common Language Runtime, or CLR.
Features of the Common Language Runtime (CLR):
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 references.
The runtime also accelerates developer productivity. For example,
programmers can write applications in their development language of
choice, yet take full advantage of the runtime, the class library, and
components written in other languages by other developers. Any compiler
vendor who chooses to target the runtime can do so. Language compilers
that target the .NET Framework make the features of the .NET Framework
available to existing code written in that language, greatly easing the
migration process for existing applications.
While the runtime is designed for the software of the future, it also supports
software of today and yesterday. Interoperability between managed and
unmanaged code enables developers to continue to use necessary COM
components and DLLs.
The runtime is designed to enhance performance. Although the common
language runtime provides many standard runtime services, managed code
is never interpreted. A feature called just-in-time (JIT) compiling enables all
managed code to run in the native machine language of the system on
which it is executing. Meanwhile, the memory manager removes the
possibilities of fragmented memory and increases memory locality-of-
reference to further increase performance.
Finally, the runtime can be hosted by high-performance, server-side
applications, such as Microsoft SQL Server and Internet Information
Services (IIS). This infrastructure enables you to use managed code to
write your business logic, while still enjoying the superior performance of
the industry's best enterprise servers that support runtime hosting.



Figure: Visual overview of the Common Language Infrastructure (CLI).


Assemblies
The CIL code is housed in .NET assemblies. Assemblies are stored in
the Portable Executable (PE) format, common on the Windows platform for
all DLL and EXE files. The assembly consists of one or more files, one of
which must contain the manifest, which has the metadata for the assembly.
The complete name of an assembly (not to be confused with the filename
on disk) contains its simple text name, version number, culture, and public
key token. The public key token is a unique hash generated when the
assembly is compiled, thus two assemblies with the same public key token
are guaranteed to be identical from the point of view of the framework.A
private key can also be specified known only to the creator of the assembly
and can be used for strong naming and to guarantee that the assembly is
from the same author when a new version of the assembly is compiled
(required to add an assembly to the Global Assembly Cache).

Security
.NET has its own security mechanism with two general features: Code
Access Security (CAS), and validation and verification. Code Access
Security is based on evidence that is associated with a specific assembly.
Typically the evidence is the source of the assembly (whether it is installed
on the local machine or has been downloaded from the intranet or Internet).
Code Access Security uses evidence to determine the permissions granted
to the code. Other code can demand that calling code is granted a
specified permission. The demand causes the CLR to perform a call stack
walk: every assembly of each method in the call stack is checked for the
required permission; if any assembly is not granted the permission a
security exception is thrown. however, has to split the application into
subdomains; it is not done by the CLR.

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.
The .NET Framework includes a set of standard class libraries. The class
library is organized in a hierarchy of namespaces. Most of the built in APIs
are part of either System.* or Microsoft.* namespaces. These class libraries
implement a large number of common functions, such as file reading and
writing, graphic rendering, database interaction, and XML document
manipulation, among others. The .NET class libraries are available to
all CLI compliant languages. The .NET Framework class library is divided
into two parts: the Base Class Library and the Framework Class Library.
The Base Class Library (BCL) includes a small subset of the entire class
library and is the core set of classes that serve as the basic API of
the Common Language Runtime. The classes in mscorlib.dll and some of
the classes in System.dll and System.core.dll are considered to be a part of
the BCL. The BCL classes are available in both .NET Framework as well
as its alternative implementations including .NET Compact
Framework, Microsoft Silverlight and Mono.
The Framework Class Library (FCL) is a superset of the BCL classes and
refers to the entire class library that ships with .NET Framework. It includes
an expanded set of libraries, including Windows
Forms, ADO.NET, ASP.NET, Language Integrated Query, Windows
Presentation Foundation, Windows Communication Foundation among
others. The FCL is much larger in scope than standard libraries for
languages like C++, and comparable in scope to the standard libraries of
Java.

Namespaces in the BCL
[8]

System
System. CodeDom
System. Collections
System. Diagnostics
System. Globalization
System. IO
System. Resources
System. Text
System.
Text.RegularExpressions


As we would expect from an object-oriented class library, the .NET
Framework types enable us to accomplish a range of common
programming tasks, including tasks such as string management, data
collection, database connectivity, and file access. In addition to these
common tasks, the class library includes types that support a variety of
specialized development scenarios. For example, you can use the .NET
Framework to develop the following types of applications and services:
Console applications.
Windows GUI applications (Windows Forms).
Windows Presentation Foundation (WPF) applications.
ASP.NET applications.
Web services.
Windows services.
Service-oriented applications using Windows Communication
Foundation (WCF).
Workflow-enabled applications using Windows Workflow Foundation
(WF).


Memory management

The .NET Framework CLR frees the developer from the burden of
managing memory (allocating and freeing up when done); instead it does
the memory management itself even though there are no actual guarantees
as to when the Garbage Collector will perform its work, unless an explicit
double-call is issued. To this end, the memory allocated to instantiations of
.NET types (objects) is done contiguously from the managed heap, a pool
of memory managed by the CLR. As long as there exists a reference to an
object, which might be either a direct reference to an object or via
a graph of objects, the object is considered to be in use by the CLR. When
there is no reference to an object, and it cannot be reached or used, it
becomes garbage. However, it still holds on to the memory allocated to it.
.NET Framework includes a garbage collector which runs periodically, on a
separate thread from the application's thread, that enumerates all the
unusable objects and reclaims the memory allocated to them.

Versions
Microsoft started development on the .NET Framework in the late 1990s
originally under the name of Next Generation Windows Services (NGWS).
By late 2000 the first beta versions of .NET 1.0 were released. Version 3.0
of the .NET Framework is included with Windows Server
2008 and Windows Vista. Version 3.5 is included with Windows 7, and can
also be installed on Windows XP and the Windows Server 2003 family of
operating systems. On April 12, 2010, .NET Framework 4 was released
alongside Visual Studio 2010.
The .NET Framework family also includes two versions
for mobile or embedded device use. A reduced version of the framework,
the .NET Compact Framework, is available on Windows CE platforms,
including Windows Mobile devices such as smartphones.







Version Version
Number
Release
Date
Visual Studio Default in Windows
1.0 1.0.3705.0 2002-02-13 Visual Studio .NET
1.1 1.1.4322.573 2003-04-24 Visual Studio .NET
2003
Windows Server 2003
2.0 2.0.50727.42 2005-11-07 Visual Studio 2005 Windows Server 2003 R2
3.0 3.0.4506.30 2006-11-06 Windows Vista, Windows
Server 2008
3.5 3.5.21022.8 2007-11-19 Visual Studio 2008 Windows 7, Windows
Server 2008 R2
4.0 4.0.30319.1 2010-04-12 Visual Studio 2010


Figure: The .NET Framework stack.











HARDWARE REQUIREMENTS

Hardware requirements Version 4
full
Version 4
client
Version 3.5 Version 3.0 Version 2.0
Processor
Minimum 1 GHz 1 GHz 400 MHz 400 MHz 400 MHz
Recommended 1 GHz 1 GHz 1 GHz 1 GHz -
RAM
Minimum 512 MB 512 MB 96 MB 96 MB 96 MB
Recommended 512 MB 512 MB 256 MB 256 MB -
Disk space (minimum)
32-bit 850 MB 600 MB 280 MB 280 MB 280 MB
64-bit 2 GB 1.5 GB 610 MB 610 MB 610 MB




VISUAL STUDIO 2008
Microsoft Visual Studio is an Integrated Development Environment (IDE)
from Microsoft. It can be used to develop console and graphical user
interface applications along with Windows Forms applications, web
sites, web applications, and web services in both native code together
with managed code for all platforms supported by Microsoft
Windows, Windows Mobile, Windows CE, .NET Framework, .NET Compact
Framework and Microsoft Silverlight.
Visual Studio includes a code editor supporting IntelliSense as well as code
refactoring. The integrated debugger works both as a source-level
debugger and a machine-level debugger. Other built-in tools include a
forms designer for building GUI applications, web designer, class designer,
and database schema designer. It allows plug-ins to be added that
enhance the functionality at almost every level - including adding support
for source control systems (like Subversion and Visual SourceSafe) to
adding new toolsets like editors and visual designers fordomain-specific
languages or toolsets for other aspects of the software development
lifecycle (like the Team Foundation Server client: Team Explorer).
Visual Studio supports different programming languages by means of
language services, which allow the code editor and debugger to support (to
varying degrees) nearly any programming language, provided a language-
specific service exists. Built-in languages include C/C++ (via Visual
C++), VB.NET (via Visua Basic .NET), C#(via Visual C#), and F# (as of
Visual Studio 2010). Support for other languages such as M, Python,
and Ruby among others is available via language services installed
separately. It also
supports XML/XSLT, HTML/XHTML, JavaScript and CSS. Individual
language-specific versions of Visual Studio also exist which provide more
limited language services to the user: Microsoft Visual Basic, Visual J#,
Visual C#, and Visual C++.

ARCHITECTURE
Visual Studio does not support any programming language, solution or tool
intrinsically. Instead, it allows plugging in various types of functionality.
Specific functionality is coded as a VSPackage. When installed, the
functionality is available as a Service. The IDE provides three services:
SVsSolution, which provides the ability to enumerate projects and
solutions; SVsUIShell, which provides windowing and UI functionality
(including tabs, toolbars and tool windows); and SVsShell, which deals with
registration of VSPackages. In addition, the IDE is also responsible for
coordinating and enabling communication between services. All editors,
designers, project types and other tools are implemented as VSPackages.
Visual Studio uses COM to access the VSPackages. The Visual
Studio SDK also includes the Managed Package Framework (MPF), which
is a set of managed wrappers around the COM-interfaces that allow the
Packages to be written in any CLI compliant language. However, MPF
does not provide all the functionality exposed by the Visual Studio COM
interfaces.The services can then be consumed for creation of other
packages, which add functionality to the Visual Studio IDE.

FEATURES
Code editor
Visual Studio, like any other IDE, includes a code editor that
supports syntax highlighting and code completion using IntelliSense for not
only variables, functions and methods but also language constructs
like loops and queries. IntelliSense is supported for the included languages,
as well as for XML and for Cascading Style Sheets and JavaScript when
developing web sites and we applications. Autocomplete suggestions are
popped up in a modeless list box, overlaid on top of the code editor. In
Visual Studio 2008 onwards, it can be made temporarily semi-transparent
to see the code obstructed by it. The code editor is used for all supported
languages.
Debugger
Visual Studio includes a debugger that works both as a source-level
debugger and as a machine-level debugger. It works with both managed
code as well as native code and can be used for debugging applications
written in any language supported by Visual Studio. In addition, it can also
attach to running processes and monitor and debug those processes. If
source code for the running process is available, it displays the code as it is
being run. If source code is not available, it can show the disassembly. The
Visual Studio debugger can also create memory dumps as well as load
them later for debugging. Multi-threaded programs are also supported. The
debugger can be configured to be launched when an application running
outside the Visual Studio environment crashes.
he debugger allows setting breakpoints (which allow execution to be
stopped temporarily at a certain position) and watches (which monitor the
values of variables as the execution progresses).Breakpoints can be
conditional, meaning they get triggered when the condition is met. Code
can be stepped over, i.e., run one line (of source code) at a time.
Designer
Visual Studio includes a host of visual designers to aid in the development
of applications. These tools include:
Windows Forms Designer
WPF Designer
Web designer/development
Class designer
Data designer
Other tools
Properties Editor
The Properties Editor tool is used to edit properties in a GUI pane
inside Visual Studio. It lists all available properties (both read-only
and those which can be set) for all objects including classes, forms,
web pages and other items.
Object Browser
The Object Browser is a namespace and class library browser
for Microsoft .NET. It can be used to browse the namespaces (which
are arranged hierarchically) in managed assemblies. The hierarchy
may or may not reflect the organization in the file system.
Solution Explorer
In Visual Studio parlance, a solution is a set of code files and other
resources that are used to build an application. The files in a solution
are arranged hierarchically, which might or might not reflect the
organization in the file system. The Solution Explorer is used to
manage and browse the files in a solution.
Data Explorer
Data Explorer is used to manage databases on Microsoft SQL
Server instances. It allows creation and alteration of database tables
(either by issuing T-SQL commands or by using the Data designer). It
can also be used to create queries and stored procedures, with the
latter in either T-SQL or in managed code via SQL CLR. Debugging
and IntelliSense support is available as well.
Server Explorer
The Server Explorer tool is used to manage database connections on
an accessible computer. It is also used to browse running Windows
Services, performance counters, Windows Event Log and message
queues and use them as data source.


Version history
Prior to Visual Studio Version 4.0 there were Visual Basic 3, Visual C++,
Visual FoxPro and Source Safe as separate products.




Product name
Internal
version
.NET Framework
version
Release date
Visual Studio 4.0 N/A Spring 1995
Visual Studio 97 5.0 N/A 1997
Visual Studio 6.0 6.0 N/A 1998-06
Visual Studio .NET (2002) 7.0 1.0 2002-02-13
Visual Studio .NET 2003 7.1 1.1 2003-04-24
Visual Studio 2005 8.0 2.0 2005-11-07
Visual Studio 2008 9.0 3.5 2007-11-19
Visual Studio 2010 10.0 4.0 2010-04-12










SQL SERVER:-
Database:-
A database management, or DBMS, gives the user access to their data
and helps them transform the data into information. Such database
management systems include dBase, paradox, IMS, Sql Server and SQL
Server. These systems allow users to create, update and extract
information from their database.
A database is a structured collection of data. Data refers to the
characteristics of people, things and events. SQL Server stores each data
item in its own fields. In SQL Server, the fields relating to a particular
person, thing or event are bundled together to form a single complete unit
of data, called a record (it can also be referred to as raw or an occurrence).
Each record is made up of a number of fields. No two fields in a record can
have the same field name.
During an SQL Server Database design project, the analysis of your
business needs identifies all the fields or attributes of interest. If your
business needs change over time, you define any additional fields or
change the definition of existing fields.
ARCHITECTURE
Protocol layer-
Protocol layer implements the external interface to SQL Server. All
operations that can be invoked on SQL Server are communicated to it via a
Microsoft-defined format, called Tabular Data Stream (TDS). TDS is an
application layer protocol, used to transfer data between a database server
and a client.

Data storage
The main unit of data storage is a database, which is a collection of tables
with typed columns. SQL Server supports different data types,
including primary types such as Integer, Float, Decimal, Char (including
character strings), Varchar (variable length character strings), binary (for
unstructured blobs of data), Text (for textual data) among others.
The rounding of floats to integers uses either Symmetric Arithmetic
Rounding or Symmetric Round Down (Fix) depending on arguments.
Buffer management
SQL Server buffers pages in RAM to minimize disc I/O. Any 8 KB page can
be buffered in-memory, and the set of all pages currently buffered is called
the buffer cache. The amount of memory available to SQL Server decides
how many pages will be cached in memory. The buffer cache is managed
by the Buffer Manager. Either reading from or writing to any page copies it
to the buffer cache. Subsequent reads or writes are redirected to the in-
memory copy, rather than the on-disc version.
Logging and Transaction
SQL Server ensures that any change to the data is ACID-compliant, i.e. it
uses transactions to ensure that the database will always revert to a known
consistent state on failure. Each transaction may consist of multiple SQL
statements all of which will only make a permanent change to the database
if the last statement in the transaction (a COMMIT statement) completes
successfully. If the COMMIT successfully completes the transaction is
safely on disk.
Concurrency and locking
SQL Server allows multiple clients to use the same database concurrently.
As such, it needs to control concurrent access to shared data, to ensure
data integrity - when multiple clients update the same data, or clients
attempt to read data that is in the process of being changed by another
client. SQL Server provides two modes of concurrency control: pessimistic
concurrency and optimistic concurrency. When pessimistic concurrency
control is being used, SQL Server controls concurrent access by using
locks. Locks can be either shared or exclusive. Exclusive lock grants the
user exclusive access to the data - no other user can access the data as
long as the lock is held. Shared locks are used when some data is being
read - multiple users can read from data locked with a shared lock, but not
acquire an exclusive lock.
Data retrieval
The main mode of retrieving data from an SQL Server database is querying
for it. The query is expressed using a variant of SQL called T-SQL, a
dialect Microsoft SQL Server shares with Sybase SQL Server due to its
legacy. The query declaratively specifies what is to be retrieved. It is
processed by the query processor, which figures out the sequence of steps
that will be necessary to retrieve the requested data. The sequence of
actions necessary to execute a query is called a query plan. There might
be multiple ways to process the same query.
SQL CLR
Microsoft SQL Server 2005 includes a component named SQL
CLR ("Common Language Runtime") via which it integrates with .NET
Framework. Unlike most other applications that use .NET Framework, SQL
Server itself hosts the .NET Framework runtime, i.e., memory; threading
and resource management requirements of .NET Framework are satisfied
by SQLOS itself, rather than the underlying Windows operating system.
SQLOS provides deadlock detection and resolution services for .NET code
as well. With SQL CLR, stored procedures and triggers can be written in
any managed .NET language, including C# and VB.NET. Managed
code can also be used to define UDT's (user defined types), which can
persist in the database. Managed code is compiled to .NET assemblies and
after being verified for type safety, registered at the database. After that,
they can be invoked like any other procedure.However, only a subset of
the Base Class Library is available, when running code under SQL CLR.
Most APIs relating to user interface functionality are not available.
When writing code for SQL CLR, data stored in SQL Server databases can
be accessed using the ADO.NET APIs like any other managed
application that accesses SQL Server data. However, doing that creates a
new database session, different from the one in which the code is
executing. To avoid this, SQL Server provides some enhancements to
the ADO.NET provider that allows the connection to be redirected to the
same session which already hosts the running code. Such connections are
called context connections and are set by setting context
connection parameter to true in the connection string. SQL Server also
provides several other enhancements to the ADO.NET API, including
classes to work with tabular data or a single row of data as well as classes
to work with internal metadata about the data stored in the database. It also
provides access to the XML features in SQL Server,
including XQuery support. These enhancements are also available in T-
SQL Procedures in consequence of the introduction of the new XML
Datatype (query,value,nodes functions).







CODING ---
6.TESTING
Testing is a process of executing a program with the interest of finding an
error. A good test is one that has high probability of finding the yet
undiscovered error. Testing should systematically uncover different classes
of errors in a minimum amount of time with a minimum amount of efforts.
Testing is divided into several distinct operations:
6.1. Unit Testing
Unit test comprises of a set tests performed by an individual program prior
to the integration of the unit into large system. A program unit is usually the
smallest free functioning part of the whole system. Module unit testing
should be as exhaustive as possible to ensure that each representation
handled by each module has been tested. All the units that makeup the
system must be tested independently to ensure that they work as required.
During unit testing some errors were raised and all of them were rectified
and handled well. The result was quiet satisfactory and it worked well.
6.2. Integration Testing
Integration testing is a system technique for constructing the program
structure while at the same time conducting tests to uncover errors
associated with interfacing. The objective is to take unit tested modules and
build a program structure that has been dictated by design. Bottom-up
integration is the traditional strategy used to integrate the components of a
software system into functioning whole. Bottom-up integration consists of
unit test followed by testing of the entire system. A sub-system consists of
several modules that communicated with other defined interface. The
system was done the integration testing. All the modules were tested for
their compatibility with other modules .They test was almost successful.
All the modules coexisted very well, with almost no bugs. All the modules
were encapsulated very well so as to not hamper the execution of other
modules.
6.3. Validation Testing
After validation testing, software is completely assembled as a package,
interfacing errors that have been uncovered and corrected and the final
series of software test; the validation test begins. Steps taken during
software design and testing can greatly improve the probability of
successful integration in the larger system. System testing is actually a
series of different tests whose primary purpose is to fully exercise the
compute based system.
6.4.. Black Box Testing
Black box testing is done to find out the following information as shown in
below:
1. Incorrect or missing functions.
2. Interface errors.
3. Errors or database access.
4. Performance error.
5. Termination error.
The mentioned testing is carried out successfully for this application.


6.5. White Box Testing

White box sometimes called Glass box testing is a test case design uses
the control structure of the procedural design to drive test case.
Using white box testing methods, the following tests were made on the
system
a) All independent paths within a module have been exercised once. In our
system, ensuring that case was selected and executed checked all case
structures. The bugs that were prevailing in some part of the code where
fixed
b) All logical decisions were checked for the truth and falsity of the values.
6.6.Acceptance Testing:

Testing here focuses on the external behavior of the system; the
internal logic of the program is not emphasized. We have used some data
and tested whether the project is working correctly or not.
6.7.Functional Testing:
Here we identify the unit functions. For each unit function we take
each input function and identify the equivalence class for that function and
form test cases and we check those for boundary values. we also form test
cases for error checking.
6.8.Positive Testing:

Positive testing shows that whether correct output has arrived or not.
This means it gives correct input and produces correct output. It maps the
source fields and destination fields and produces the specified result.

6.9. Negative Testing:
Negative testing gives the wrong output for the input. It maps the
source and destination fields, and gives wrong result though we give the
correct information.



8. CONCLUSION

The project SOCIAL NETWORKING is completed, satisfying the required
design specifications. The system provides a user-friendly interface. The
software is developed with modular approach. All modules in the system
have been tested with valid data and invalid data and everything work
successfully. Thus the system has fulfilled all the objectives identified .The
constraints are met and overcome successfully. The system is designed as
like it was decided in the design phase. This software has a user-friendly
screen that enables the user to use without any inconvenience. The
application has been tested with live data and has provided a successful
result. Hence the software has proved to work efficiently.