Mobile Banking Report

8/20/2019 Mobile Banking Report

1/74

Mobile Banking

ABSTRACT:

"Mobile Banking refers to provision and availment of banking- and financial services

with the help of mobile telecommunication devices.The scope of offered services may

include facilities to conduct bank and stock market transactions, to administer accounts

and to access customised information."

According to this model Mobile Banking can be said to consist of three inter-related

concepts

! Mobile Accounting

! Mobile Brokerage

! Mobile inancial #nformation $ervices

Most services in the categories designated Accounting and Brokerage are transaction-

based. The non-transaction-based services of an informational nature are however

essential for conducting transactions - for instance, balance en%uiries might be needed

before committing a money remittance. The accounting and brokerage services are

therefore offered invariably in combination with information services. #nformation

services, on the other hand, may be offered as an independent module.


2/74

Project Overall Description:

Many believe that mobile users have &ust started to fully utili'e the data capabilities in

their mobile phones. #n Asian countries like #ndia, (hina, Bangladesh, #ndonesia and

)hilippines, where mobile infrastructure is comparatively better than the fi*ed-line

infrastructure, and in +uropean countries, where mobile phone penetration is very high

at least / of consumers use a mobile phone0, mobile banking is likely to appeal even

more.

Mobile devices, especially $mart phone are the most promising way to reach the masses

and to create 1stickiness2 among current customers, due to their ability to provide

services anytime, anywhere, high rate of penetration and potential to grow. According to

3artner, shipment of smartphones is growing fast, and should top 4 million units of

over million sold0 in 45 alone.

#n the last 6 years, banks across the globe have invested billions of dollars to build

sophisticated internet banking capabilities. As the trend is shifting to mobile banking,

there is a challenge for (#7s and (T7s of these banks to decide on how to leverage their

investment in internet banking and offer mobile banking, in the shortest possible time.

Mobile Banking is a web based application which is developed to serve the people for their money transferring purpose and in order to relive the customers workload in their

busy lives. #t helps in transferring money in time and in a hassle free manner which also

ensures reliability that the money is securely transferred to the receiving authority.

8ow a days money transferring includes a lot of manual work and a hefty &ob. #t is a

difficult task for the people in their busy lives. The customers are forced to wait in %ueue

in the bank for this transfer process and to fill in the details and it is unavoidable. Though

these can be done at multiple counters at different locations working people and business

people find it more difficult of this unavoidable inconvenience.


3/74

$o as to overcome these difficulties Mobile Banking is developed. #t ensures transfer of

money from the senders account to the receivers account provided that the users have

supplied proper account number and secret code and the receivers account number. The

end user can transfer and check the information about every transaction about their

transfers and withdrawals from the internet itself. The added advantage of this application

is, it ensures checkpoint reliability at every step even if there is power shut downs or

system crashes. $ince at any moment the transaction details are maintained the transfer

process is ensured.

The customer has also an option of checking all the previous transactions, whether the

transaction process is success, the date and e*act time of the transaction, and the number

of transactions performed in a particular date and etc.

Existing Syste:

7ver the last few years, the mobile and wireless market has been one of the fastest

growing markets in the world and it is still growing at a rapid pace. According to the

3$M Association and 7vum, the number of mobile subscribers e*ceeded 4 billion in$eptember 49, and now e*ceeds 4.9 billion of which more than 4 billion are 3$M0. #n

the last 6 years, banks across the globe have invested billions of dollars to build

sophisticated internet banking capabilities. As the trend is shifting to mobile banking,

there is a challenge for (#7s and (T7s of these banks to decide on how to leverage their

investment in internet banking and offer mobile banking, in the shortest possible time.

)roposed $ystem

:ith mobile banking, the customer may be sitting in any part of the world true anytime,

anywhere banking0 and hence banks need to ensure that the systems are up and running

in a true 46 * ; fashion. As customers will find mobile banking more and more useful,


4/74

their e*pectations from the solution will increase. Banks unable to meet the performance

and reliability e*pectations may lose customer confidence.There as systems such as

Mobile Transaction )latform which enable %uick and secure mobile enabling of various

banking service.


5/74

The syste# is very secure and prevents the account nu#ber and

secret code theft of the custo#ers "ho are transferring their #oney

online

So!t"are Re#$ireents Speci!ication:

%ar&"are 'nter!aces

)rocessor Type )entium -#=

$peed 4.6 3


6/74

%O( TO R)*:

irst step is to attach the database.

H. 7pen the database folder and copy the log and the mdf file in any one of the local

drives

4. 3o to enterprise manager and right click on the database and select attach

database

I. Browse the mdf file from the local drives and click ok

6. The database will be attached successfully.

7pen Microsoft visual studio then set the default page as the start page and run the

pro&ect.


7/74

Screen S+ots:

%oe Page:


8/74


9/74

Transaction Page , Entering A-c n$ber an& secret co&e.


10/74

Mini Stateent


11/74

/inance Process Main Page:


12/74

/inance Process Analy0e t+e C$stoer #$ery Page:


13/74

/inance Process Analy0e t+e C$stoer #$ery res$lt Page:


14/74

)ser access in!o page :


15/74


16/74


17/74

C+eck Book R#$est process page:


18/74

Table Design

TABG+

Table 8ame tblsavain

Col$n nae Datatype 1engt+$seri& nvarc+ar 23

acco$nti& nvarc+ar 43

p"& nvarc+ar 43

balance int 2

Table 8ame tblc$rain

Col$n nae Datatype 1engt+$seri& nvarc+ar 23

acco$nti& nvarc+ar 43

p"& nvarc+ar 43

balance n$eric 2


19/74

Table 8ame tblsavtran

Col$n nae Data type lengt+acci& nvarc+ar 23

ao$nt n$eric 43

&at &atetie 5

tran&etail varc+ar 43

trantype varc+ar 43

Table 8ame tblc$rtran

Col$n nae Data type lengt+

acci& nvarc+ar 23

ao$nt n$eric 43

&at &atetie 5tran&etail varc+ar 43

trantype varc+ar 43

DATA /1O( D'A6RAM:


20/74

TRA*S/ER MOD)1E:

MobileBanking

Transaction (heck book

re%uest

Jser access info

Mini $tatement inance:MG

Mobile Application>evelopment

##$ 3eneration


21/74

=erifies Accountnumber and

code

J$+


22/74

ACCO)*T STAT)S MOD)1E:

)ser Access MOD)1E:

=erifies Accountnumber and codeJ$+


23/74

(heck Book


24/74

E*T'T7 RE1AT'O*S%'P D'A6RAM:

)rocess the

user status

(heck book


25/74

1'ST O/ MOD)1ES:

H0 Mobile Application >evelopment.

$ender Transf er


26/74

40 3enerate ##$.

I0 :MG (reation.

60 Transfers.

90 Accounts status module.

50 inance +n%uiry module.

;0 (heck book re%uest.

0 Access Jser details.

Mo&$le Description:

Mobile Application Developent8

#n the mobile world we are coming across different varieties of mobile devices. $ome

mobiles are capable of rendering rich graphics, a few are able to render even low %uality

graphics and others are capable of displaying te*t only. >eveloping application targeting

these devices had been a nightmare prior to .8+T mobile development facilities0,

developers were writing additional code to render the same application for different

devices and it was not so easy to do. 8ow .8+T mobile development facilities make the

work easier and rela* the developers from understanding the target mobile device

capability and gives guarantee to run the same application under different mobile platforms without writing any additional code. But again the %uestion is "ow is it

possibleL". :ell the short answer is everything is possible in .8+T and the long answer is

you need to understand the rendering process and the flow of communication between the

web application and the mobile devices. By using the .net emulator we can run our

mobile application, there are some types of emulator in .net . they are smart phone 4I

and pocket pc 4I.

''S 6eneration:

##$ #nternet #nformation $erver0 is a group of #nternet servers including a :eb or

yperte*t Transfer )rotocol server and a ile Transfer )rotocol server0 with additional

capabilities for Microsofts :indows 8T and :indows 4 $erver operating systems.


27/74

##$ can create pages for :eb sites using Microsofts ront )age product with its

:K$#:K3 user interface0. :eb developers can use Microsofts Active $erver )age

A$)0technology, which means that applications - including ActiveD controls - can be

imbedded in :eb pages that modify the content sent back to users. >evelopers can also

write programs that filter re%uests and get the correct :eb pages for different users by

using Microsofts #nternet $erver Application )rogram #nterface #$A)#0 interface. By

using this ##$ we generate the mobile application in the local host.

(M1:

:MG pages are often called "decks". A deck contains a set of cards. A card element can

contain te*t, markup, links, input-fields, tasks, images and more. (ards can be related to

each other with links.

:hen a :MG page is accessed from a mobile phone, all the cards in the page are

downloaded from the :A) server. 8avigation between the cards is done by the phone

computer - inside the phone - without any e*tra access trips to the server

#n our pro&ect we using the M#(


28/74

/inance /inance En#$iry:

#n This module the customer can process the on line +n%uiry for the different loan details

such as car loan, two-wheeler loan, education loan ,home loan and then calculate the +M#

and the number of months for the corresponding finance process +n%uiry.

C+eck book re#$est:

#n this module the user can apply the re%uest for the check book depend their accounts.

ere the hackers cannot apply for the check book re%uest.

Access )ser &etails:

the user can accsess the details about the user maintain the low balance in the bank . and

also they can access the user who maintain the high balance .

HARDWARE INTERFACE:

%ard"are includes any physical device that is connected to the

co#puter and it is controlled by the co#puter&s #icroprocessor This

includes e'uip#ent that "as connected to the co#puter "hen it "as

#anufactured( as "ell as peripheral e'uip#ent that added later So#e

exa#ples of devices are #ode#s( disk drives( printers and keyboards

etc


29/74

%ard"are interfaces are the plugs( sockets( "ires( and the electrical

pulses traveling through the# in a particular pattern

)very interface i#plies a function *t the hard"are level( electronic

signals activate functions( data&s are read( "ritten( trans#itted(

serviced( analy+ed for error etc

SO/T(ARE DE9E1OPME*T

The following are the software?s used in our pro&ect. :e have used A$).8et with (E as

front end and $FG $erver as backend.

/RO*T E*D O/ SO/T(ARE:

'ntro&$ction to 8net !rae"ork

8+T dot-net0 is the name Microsoft gives to its general vision of the future of

computing, the view being of a world in which many applications run in a distributed

manner across the #nternet. :e can identify a number of different motivations driving this

vision.

irstly, distributed computing is rather like ob&ect oriented programming, in that it

encourages speciali'ed code to be collected in one place, rather than copied redundantly

in lots of places. There are thus potential efficiency gains to be made in moving to the

distributed model.


30/74

$econdly, by collecting speciali'ed code in one place and opening up a generally

accessible interface to it, different types of machines phones, handhelds, desktops, etc.0

can all be supported with the same code. ence Microsofts run-anywhere aspiration.

Thirdly, by controlling real-time access to some of the distributed nodes

especially those concerning authentication0, companies like Microsoft can control more

easily the running of its applications. #t moves applications further into the area of

services provided rather than ob&ects owned.

#nterestingly, in taking on the .8+T vision, Microsoft seems to have given up

some of its proprietary tendencies whereby all the technology it touched was warped

towards its :indows operating system0.

Because it sees its future as providing software services in distributed

applications, the .8+T framework has been written so that applications on other

platforms will be able to access these services. or e*ample, .8+T has been built upon

open standard technologies like DMG and $7A).

At the development end of the .8+T vision is the .8+T ramework. This contains

the (ommon Ganguage


31/74

been released in con&unction with the .8+T framework, and is likely to be the language of

choice for many developers working on .8+T applications.

Asp.net

A$).8+T is a programming framework built on the common language runtime that

can be used on a server to build powerful :eb applications. A$).8+T offers several

important advantages over previous :eb development models

• +nhanced )erformance. A$).8+T is compiled common language runtime code

running on the server. Jnlike its interpreted predecessors, A$).8+T can take advantage

of early binding, &ust-in-time compilation, native optimi'ation, and caching services right

out of the bo*. This amounts to dramatically better performance before you ever write a

line of code.

• :orld-(lass Tool $upport. The A$).8+T framework is complemented by a rich

toolbo* and designer in the =isual $tudio integrated development environment.

:K$#:K3 editing, drag-and-drop server controls, and automatic deployment are &ust a

few of the features this powerful tool provides.

• )ower and le*ibility. Because A$).8+T is based on the common language

runtime, the power and fle*ibility of that entire platform is available to :eb application

developers. The .8+T ramework class library, Messaging, and >ata Access solutions are

all seamlessly accessible from the :eb. A$).8+T is also language-independent, so you

can choose the language that best applies to your application or partition your application

across many languages.

• urther, common language runtime interoperability guarantees that your e*isting

investment in (7M-based development is preserved when migrating to A$).8+T.


32/74

• $implicity. A$).8+T makes it easy to perform common tasks, from simple form

submission and client authentication to deployment and site configuration. or e*ample,

the A$).8+T page framework allows you to build user interfaces that cleanly separate

application logic from presentation code and to handle events in a simple, =isual Basic -

like forms processing model. Additionally, the common language runtime simplifies

development, with managed code services such as automatic reference counting and

garbage collection.

• Manageability. A$).8+T employs a te*t-based, hierarchical configuration

system, which simplifies applying settings to your server environment and :eb

applications. Because configuration information is stored as plain te*t, new settings may

be applied without the aid of local administration tools. This "'ero local administration"

philosophy e*tends to deploying A$).8+T ramework applications as well. An A$).8+T

ramework application is deployed to a server simply by copying the necessary files to

the server. 8o server restart is re%uired, even to deploy or replace running compiled code.

• $calability and Availability. A$).8+T has been designed with scalability in

mind, with features specifically tailored to improve performance in clustered and

multiprocessor environments. urther, processes are closely monitored and managed by

the A$).8+T runtime, so that if one misbehaves leaks, deadlocks0, a new process can be

created in its place, which helps keep your application constantly available to handle

re%uests.

• (ustomi'ability and +*tensibility. A$).8+T delivers a well-factored architecture

that allows developers to "plug-in" their code at the appropriate level. #n fact, it is


33/74

possible to e*tend or replace any subcomponent of the A$).8+T runtime with your own

custom-written component. #mplementing custom authentication or state services has

never been easier.

• $ecurity. :ith built in :indows authentication and per-application

configuration, you can be assured that your applications are secure.

• A$) .8+T has better language support, a large set of new controls and DMG

based components, and better user authentication.

• A$) .8+T provides increased performance by running compiled code.

• A$) .8+T code is not fully backward compatible with A$).

*e" in ASP 8*ET


34/74

Better language support

)rogrammable controls

+vent-driven programming

DMG-based components

Jser authentication, with accounts and roles

igher scalability

#ncreased performance - (ompiled code

+asier configuration and deployment

8ot fully A$) compatible

1ang$age S$pport

A$) .8+T uses the new A>7 .8+T.

A$) .8+T supports full =isual Basic, not =B$cript.

A$) .8+T supports (E ( sharp0 and (NN.

A$) .8+T supports @$cript as before.

A$) .8+T (ontrols

A$) .8+T contains a large set of TMG controls. Almost all TMG elements on

a page can be defined as A$) .8+T control ob&ects that can be controlled by scripts.

A$) .8+T also contains a new set of ob&ect oriented input controls, like

programmable list bo*es and validation controls.

A new data grid control supports sorting, data paging, and everything you e*pect

from a dataset control.

Event A"are Controls


35/74

All A$) .8+T ob&ects on a :eb page can e*pose events that can be processed by

A$) .8+T code.

Goad, (lick and (hange events handled by code makes coding much simpler and

much better organi'ed.

A$) .8+T (omponents

A$) .8+T components are heavily based on DMG. Gike the new A>


36/74

Much has been done with A$) .8+T to provide greater scalability. $erver to server

communication has been greatly enhanced, making it possible to scale an application

over several servers. 7ne e*ample of this is the ability to run DMG parsers, D$G

transformations and even resource hungry session ob&ects on other servers.

Copile& Co&e

The first re%uest for an A$) .8+T page on the server will compile the A$) .8+T code

and keep a cached copy in memory. The result of this is greatly increased performance.

Easy Con!ig$ration

(onfiguration of A$) .8+T is done with plain te*t files.

(onfiguration files can be uploaded or changed while the application is running. 8o need

to restart the server. 8o more metabase or registry pu''le.

Easy Deployent

8o more server restart to deploy or replace compiled code. A$) .8+T simply redirects all

new re%uests to the new code.

Copatibility

A$) .8+T is not fully compatible with earlier versions of A$), so most of the old

A$) code will need some changes to run under A$) .8+T.

To overcome this problem, A$) .8+T uses a new file e*tension ".asp*". This will

make A$) .8+T applications able to run side by side with standard A$) applications on

the same server.


37/74

%TM1 Server Controls

TMG elements in A$).8+T files are, by default, treated as te*t. To make these elements

programmable, add a runatO"server" attribute to the TMG element. This attribute

indicates that the element should be treated as a server control.

8ote All TMG server controls must be within a PformQ tag with the runatO"server"

attributeR

8ote A$).8+T re%uires that all TMG elements must be properly closed and properly

nested.

TMG $erver (ontrol >escriptiontmlAnchor (ontrols an PaQ TMG element

tmlButton (ontrols a PbuttonQ TMG element

tmlorm (ontrols a PformQ TMG element

tml3eneric (ontrols other TMG element not specified by a specific

TMG server control, like PbodyQ, PdivQ, PspanQ, etc.

tml#mage (ontrols an PimageQ TMG element

tml#nputButton (ontrols Pinput typeO"button"Q, Pinput typeO"submit"Q, and

Pinput typeO"reset"Q TMG elements

tml#nput(heckBo* (ontrols an Pinput typeO"checkbo*"Q TMG element

tml#nputile (ontrols an Pinput typeO"file"Q TMG element

tml#nputidden (ontrols an Pinput typeO"hidden"Q TMG element

tml#nput#mage (ontrols an Pinput typeO"image"Q TMG element

tml#nput


38/74

:eb $erver (ontrols

Gike TMG server controls, :eb server controls are also created on the server and they

re%uire a runatO"server" attribute to work. owever, :eb server controls do not

necessarily map to any e*isting TMG elements and they may represent more comple*

elements.

The synta* for creating a :eb server control is

PaspcontrolSname idO"someSid" runatO"server" CQ

:eb $erver (ontrol >escription

Adisplays a se%uence of images

Button >isplays a push button

(alendar >isplays a calendar

(heckBo* >isplays a check bo*

(heckBo*Gist (reates a multi-selection check bo* group

>ata3rid >isplays fields of a data source in a grid

>ataGist >isplays items from a data source by using templates

>rop>ownGist (reates a drop-down list

yperGink (reates a hyperlink

#mage >isplays an image

#mageButton >isplays a clickable image

Gabel >isplays static content which is programmable lets you apply

styles to its content0

GinkButton (reates a hyperlink button

GistBo* (reates a single- or multi-selection drop-down list

Giteral >isplays static content which is programmable does not let

you apply styles to its content0)anel )rovides a container for other controls

)laceolder


39/74

Table (reates a table

Table(ell (reates a table cell

Tableisplays an DMG file or the results of an D$G transform

9ali&ation Server Controls

A =alidation server control is used to validate the data of an input control. #f the data does

not pass validation, it will display an error message to the user.

The synta* for creating a =alidation server control is

PaspcontrolSname idO"someSid" runatO"server" CQ

=alidation $erver (ontrol >escription

(ompare=alidator (ompares the value of one input control to the value

of another input control or to a fi*ed value

(ustom=alidator Allows you to write a method to handle the validation

of the value entered


40/74

ADO 8*ET

Most applications need data access at one point of time making it a crucial component

when working with applications. >ata access is making the application interact with a

database, where all the data is stored. >ifferent applications have different re%uirements

for database access. =B .8+T uses A>7 .8+T Active D >ata 7b&ect0 as its data access

and manipulation protocol which also enables us to work with data on the #nternet. Gets

take a look why A>7 .8+T came into picture replacing A>7.

Evol$tion o! ADO8*ET

The first data access model, >A7 data access model0 was created for local databases

with the built-in @et engine which had performance and functionality issues. 8e*t came

7 ata 7b&ect0 and A>7 Active >ata 7b&ect0 which were designed for

(lient $erver architectures but soon A>7 took over 7. A>7 was a good architecture

but as the language changes so is the technology. :ith A>7, all the data is contained in a

recordset ob&ect which had problems when implemented on the network and penetrating

firewalls. A>7 was a connected data access, which means that when a connection to the

database is established the connection remains open until the application is closed.Geaving the connection open for the lifetime of the application raises concerns about

database security and network traffic. Also, as databases are becoming increasingly

important and as they are serving more people, a connected data access model makes us

think about its productivity. or e*ample, an application with connected data access may

do well when connected to two clients, the same may do poorly when connected to H

http://www.w3schools.com/aspnet/control_xml.asphttp://www.w3schools.com/aspnet/control_rangevalidator.asphttp://www.w3schools.com/aspnet/control_regularexpvalidator.asphttp://www.w3schools.com/aspnet/control_reqfieldvalidator.asphttp://www.w3schools.com/aspnet/control_table.asphttp://www.w3schools.com/aspnet/control_tablecell.asphttp://www.w3schools.com/aspnet/control_tablerow.asphttp://www.w3schools.com/aspnet/control_textbox.asphttp://www.w3schools.com/aspnet/control_xml.asphttp://www.w3schools.com/aspnet/control_comparevalidator.asphttp://www.w3schools.com/aspnet/control_customvalidator.asphttp://www.w3schools.com/aspnet/control_rangevalidator.asphttp://www.w3schools.com/aspnet/control_regularexpvalidator.asphttp://www.w3schools.com/aspnet/control_reqfieldvalidator.asphttp://www.w3schools.com/aspnet/control_validationsummary.asp


41/74

and might be unusable when connected to H or more. Also, open database connections

use system resources to a ma*imum e*tent making the system performance less effective.

ADO8*ET

To cope up with some of the problems mentioned above, A>7 .8+T came into e*istence.

A>7 .8+T addresses the above mentioned problems by maintaining a disconnected

database access model which means, when an application interacts with the database, the

connection is opened to serve the re%uest of the application and is closed as soon as the

re%uest is completed. Gikewise, if a database is Jpdated, the connection is opened long

enough to complete the Jpdate operation and is closed.

By keeping connections open for only a minimum period of time, A>7

.8+T conserves system resources and provides ma*imum security for databases and also

has less impact on system performance.

Also, A>7 .8+T when interacting with the database uses DMG and converts allthe data into DMG format for database related operations making them more efficient.

T+e ADO8*ET Data Arc+itect$re

>ata Access in A>7.8+T relies on two components >ata$et and >ata )rovider.

DataSet

The dataset is a disconnected, in-memory representation of data. #t can be considered as a

local copy of the relevant portions of the database. The >ata$et is persisted in memory

and the data in it can be manipulated and updated independent of the database. :hen the

use of this >ata$et is finished, changes can be made back to the central database for


42/74

updating. The data in >ata$et can be loaded from any valid data source like Microsoft

$FG server database, an 7racle database or from a Microsoft Access database.

Data Provi&er

The >ata )rovider is responsible for providing and maintaining the connection to

the database. A >ata)rovider is a set of related components that work together to provide

data in an efficient and performance driven manner. The .8+T ramework currently

comes with two >ata)roviders the $FG >ata )rovider which is designed only to work

with Microsofts $FG $erver ;. or later and the 7le>b >ata)rovider which allows us to

connect to other types of databases like Access and 7racle. +ach >ata)rovider consists of

the following component classes

The (onnection ob&ect which provides a connection to the database

The (ommand ob&ect which is used to e*ecute a command

The >ataataAdapter ob&ect which populates a disconnected >ata$et with data and performs

update .

Data access "it+ ADO8*ET can be s$ari0e& as !ollo"s:

A connection ob&ect establishes the connection for the application with the database. The

command ob&ect provides direct e*ecution of the command to the database. #f the

command returns more than a single value, the command ob&ect returns a >ataataAdapter can be used to fill the >atasetdatabase


43/74

be updated using the command ob&ect or the >ataAdapter.


44/74

Coponent classes t+at ake $p t+e Data Provi&ers


45/74

T+e Connection Object

The (onnection ob&ect creates the connection to the database. Microsoft =isual $tudio

.8+T provides two types of (onnection classes the $%l(onnection ob&ect, which is

designed specifically to connect to Microsoft $FG $erver ;. or later, and the

7le>b(onnection ob&ect, which can provide connections to a wide range of database

types like Microsoft Access and 7racle. The (onnection ob&ect contains all of the

information re%uired to open a connection to the database.

T+e Coan& Object

The (ommand ob&ect is represented by two corresponding classes $%l(ommand and

7le>b(ommand. (ommand ob&ects are used to e*ecute commands to a database across a

data connection. The (ommand ob&ects can be used to e*ecute stored procedures on the

database, $FG commands, or return complete tables directly. (ommand ob&ects provide

three methods that are used to e*ecute commands on the database

+*ecute8onFuery +*ecutes commands that have no return values such as #8$+AT+ or >+G+T+

+*ecute$calar


46/74

The >ataataataataAdapter is the class at the core of A>7 .8+Ts disconnected data access. #t is

essentially the middleman facilitating all communication between the database and a

>ata$et. The >ataAdapter is used either to fill a >ataTable or >ata$et with data from the

database with its ill method. After the memory-resident data has been manipulated, the

>ataAdapter can commit the changes to the database by calling the Jpdate method. The

>ataAdapter provides four properties that represent database commands

$elect(ommand

#nsert(ommand

>elete(ommand

Jpdate(ommand

:hen the Jpdate method is called, changes in the >ata$et are copied back to the

database and the appropriate #nsert(ommand, >elete(ommand, or Jpdate(ommand is

e*ecuted.


47/74

BAC E*D O/ SO/T(ARE:

S;1 'ntro&$ction:

$FG stands for $tructured Fuery Ganguage and is used to pull information from

databases.$FG offers many features making it a powerfully diverse language that also

offers a secure way to work with databases.

$FG commonly e*panded to $tructured Fuery Ganguage is the most popular

computer language used to create, modify, retireve and manipulate data from relational

database management systems. The language has evolved beyond its original purpose tosupport ob&ect-relational database management systems. #t is an A8$#C#$7 standard.

$FG alone can input, modify, and drop data from databases. #n this tutorial we use

command line e*amples to show you the basics of what we are able to accomplish. :ith

the use of web languages such as TMG and )), $FG becomes an even greater tool for

building dynamic web pages.

Database:

A database is nothing more than an empty shell, like a vacant warehouse. #t offers no real

functionality what so ever, other than holding a name. Tables are the ne*t tier of our tree

offering a wide scope of functionality. #f you follow our warehouse e*ample, a $FG table

would be the physical shelving inside our vacant warehouse. +ach $FG table is capable

of housing H46 columnsshelves0. >epending on the situation, your goods may re%uirereorgani'ation, reserving, or removal. $FG tables can be manipulated in this same way or

in any fashion the situation calls for.


48/74

S;1 Server:

Microsofts $FG $erver is steadily on the rise in the commercial world gaining popularity

slowly. This platform has a 3J# ":indows" type interface and is also rich with

functionality. A free trial version can be downloaded at the Microsoft web site, however it

is only available to :indows users.

S;1 ;$eries:

Fueries are the backbone of $FG. Fuery is a loose term that refers to a widely available

set of $FG commands called clauses. +ach clause command0 performs some sort of

function against the database. or instance, the create clause creates tables and databases

and the select clause selects rows that have been inserted into your tables. :e will dive

deeper in detail as this tutorial continues but for now lets take a look at some %uery

structure.

9ie"s:

=iews are nothing but saved $FG statements, and are sometimes referred as 1=irtual

Tables2. Ueep in mind that =iews cannot store data e*cept for #nde*ed =iews0V rather

they only refer to data present in tables.

Get?s checkout the basic synta* for creating a view

(


49/74

There are two important options that can be used when a view is created. They are

$(+MAB#8>#83 and +8(Ts0 to be defined and used. $FG

$erver also makes server statistics available as virtual tables and views called >ynamic

Management =iews or >M=s0. A database can also contain other ob&ects including

views, stored procedures, inde*es and constraints, in addition to tables, along with a

transaction log. A $FG $erver database can contain a ma*imum of 4 IH ob&ects, and can

span multiple 7$-level files with a ma*imum file si'e of 44 TB. The data in the database

are stored in primary data files with an e*tension .mdf. $econdary data files, identified

with an .ndf e*tension, are used to store optional metadata. Gog files are identified with

the .ldf e*tension.

$torage space allocated to a database is divided into se%uentially numbered pages,

each UB in si'e. A page is the basic unit of #C7 for $FG $erver operations. A page is

marked with a W5-byte header which stores metadata about the page including the page

number, page type, free space on the page and the #> of the ob&ect that owns it. )age type

defines the data contained in the page - data stored in the database, inde*, allocation map

which holds information about how pages are allocated to tables and inde*es, change

map which holds information about the changes made to other pages since last backup or

logging, or contain large data types such as image or te*t. :hile page is the basic unit of

an #C7 operation, space is actually managed in terms of an extent which consists of

pages. A database ob&ect can either span all pages in an e*tent "uniform e*tent"0 or

share an e*tent with up to ; more ob&ects "mi*ed e*tent"0.

http://www.sql-server-performance.com/nn_views.asp#%23http://www.sql-server-performance.com/nn_views.asp#%23


50/74

A row in a database table cannot span more than one page, so is limited to UB

in si'e. owever, if the data e*ceeds UB and the row contains Varchar or Varbinary

data, the data in those columns are moved to a new page or possible a se%uence of pages,

called Allocation unit 0 and replaced with a pointer to the data.

or physical storage of a table, its rows are divided into a series of partitions

numbered H to n0. The partition si'e is user definedV by default all rows are in a single

partition. A table is split into multiple partitions in order to spread a database over a

cluster.


51/74

:hen reading the page back, its checksum is computed again and matched with

the stored version to ensure the page has not been damaged or tampered with in the mean

time.

1ogging an& Transaction

$FG $erver ensures that any change to the data is A(#>-compliant, i.e., it uses

transactions to ensure that any operation either totally completes or is undone if fails, but

never leave the database in an intermediate state. Jsing transactions, a se%uence of

actions can be grouped together, with the guarantee that either all actions will succeed or

none will. $FG $erver implements transactions using a write-ahead log. Any changes

made to any page will update the in-memory cache of the page, simultaneously all the

operations performed will be written to a log, along with the transaction #> which the

operation was a part of.

+ach log entry is identified by an increasing Log Seuence !umber G$80 which

ensure that no event overwrites another. $FG $erver ensures that the log will be written

onto the disc before the actual page is written back. This enables $FG $erver to ensure

integrity of the data, even if the system fails. #f both the log and the page were written

before the failure, the entire data is on persistent storage and integrity is ensured. #f only

the log was written the page was either not written or not written completely0, then the

actions can be read from the log and repeated to restore integrity.

#f the log wasnt written, then also the integrity is maintained, even though the

database is in a state when the transaction as if never occurred. #f it was only partially

written, then the actions associated with the unfinished transaction are discarded. $ince

the log was only partially written, the page is guaranteed to have not been written, again

ensuring data integrity.


52/74

Conc$rrency an& locking

$FG $erver 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. $FG $erver provides two modes of concurrency

control pessimistic concurrency and optimistic concurrency. :hen pessimistic

concurrency control is being used, $FG $erver controls concurrent access by using locks.

Gocks can be either shared or e*clusive. +*clusive lock grants the user e*clusive access

to the data - no other user can access the data as long as the lock is held. $hared locks are

used when some data is being read - multiple users can read from data locked with ashared lock, but not ac%uire an e*clusive lock. The latter would have to wait for all

shared locks to be released. Gocks can be applied on different levels of granularity - on

entire tables, pages, or even on a per-row basis on tables. or inde*es, it can either be on

the entire inde* or on inde* leaves.

The level of granularity to be used is defined on a per-database basis by the

database administrator. :hile a fine grained locking system allows more users to use the

table or inde* simultaneously, it re%uires more resources. $o it does not automatically

turn into higher performing solution. $FG $erver also includes two more lightweight

mutual e*clusion solutions - latches and spin locks - which are less robust than locks but

are less resource intensive.

$FG $erver uses them for >M=s and other resources that are usually not busy.

$FG $erver also monitors all worker threads that ac%uire locks to ensure that they do not

end up in deadlocks - in case they do, $FG $erver takes remedial measures, which in

many cases is to kill one of the threads entangled in a deadlock and rollback the

transaction it started. To implement locking, $FG $erver contains the Loc" Manager .


53/74

The Gock Manager maintains an in-memory table that manages the database

ob&ects and locks, if any, on them along with other metadata about the lock. Access to any

shared ob&ect is mediated by the lock manager, which either grants access to the resource

or blocks it.

$FG $erver also provides the optimistic concurrency control mechanism, which is

similar to the multiversion concurrency control used in other databases. The mechanism

allows a new version of a row to be created whenever the row is updated, as opposed to

overwriting the row, i.e., a row is additionally identified by the #> of the transaction that

created the version of the row. Both the old as well as the new versions of the row are

stored and maintained, though the old versions are moved out of the database into a

system database identified as Tempdb.

:hen a row is in the process of being updated, any other re%uests are not blocked

unlike locking0 but are e*ecuted on the older version of the row. #f the other re%uest is an

update statement, it will result in two different versions of the rows - both of them will be

stored by the database, identified by their respective transaction #>s.

Data retrieval

The main mode of retrieving data from an $FG $erver database is %uerying for it.

The %uery is e*pressed using a variant of $FG called T-$FG, a dialect Microsoft $FG

$erver shares with $ybase $FG $erver due to its legacy. The %uery declaratively specifies

what is to be retrieved. #t is processed by the %uery processor, which figures out the

se%uence of steps that will be necessary to retrieve the re%uested data.

The se%uence of actions necessary to e*ecute a %uery is called a %uery plan.

There might be multiple ways to process the same %uery. or e*ample, for a %uery that

contains a &oin statement and a select statement, e*ecuting &oin on both the tables and

then e*ecuting select on the results would give the same result as selecting from each

table and then e*ecuting the &oin, but result in different e*ecution plans. #n such case,

$FG $erver chooses the plan that is supposed to yield the results in the shortest possible

time. This is called %uery optimi'ation and is performed by the %uery processor itself.


54/74

$FG $erver includes a cost-based %uery optimi'er which tries to optimi'e on the

cost, in terms of the resources it will take to e*ecute the %uery. 3iven a %uery, the %uery

optimi'er looks at the database schema, the database statistics and the system load at that

time.

#t then decides which se%uence to access the tables referred in the %uery, which

se%uence to e*ecute the operations and what access method to be used to access the

tables. or e*ample, if the table has an associated inde*, whether the inde* should be

used or not - if the inde* is on a column which is not uni%ue for most of the columns low

"selectivity"0, it might not be worthwhile to use the inde* to access the data. inally, it

decides whether to e*ecute the %uery concurrently or not.

:hile a concurrent e*ecution is more costly in terms of total processor time,

because the e*ecution is actually split to different processors might mean it will e*ecute

faster. 7nce a %uery plan is generated for a %uery, it is temporarily cached. or further

invocations of the same %uery, the cached plan is used. Jnused plans are discarded after

some time.

$FG $erver also allows stored procedures to be defined. $tored procedures are

parameteri'ed T-$FG %ueries that are stored in the server itself and not issued by theclient application as is the case with general %ueries0. $tored procedures can accept

values sent by the client as input parameters, and send back results as output parameters.

They can also call other stored procedures, and can be selectively provided access

to. Jnlike other %ueries, stored procedures have an associated name, which is used at

runtime to resolve into the actual %ueries. Also because the code need not be sent from

the client every time as it can be accessed by name0, it reduces network traffic and

somewhat improves performance. +*ecution plans for stored procedures are also cached

as necessary.


55/74

S;1 C1R

Microsoft $FG $erver 49 includes a component named S;1 C1R via which it

integrates with .8+T ramework. Jnlike most other applications that use .8+T

ramework, $FG $erver itself hosts the .8+T ramework runtime, i.e., memory,threading and resource management re%uirements of .8+T ramework are satisfied by

$FG7$ itself, rather than the underlying :indows operating system.

$FG7$ provides deadlock detection and resolution services for .8+T code as

well. :ith $FG (GTs

which can be persisted in the database. Managed code is compiled to .8et assemblies and

after being verified for type safety, registered at the database. After that, they can be

invoked like any other procedure. owever, only a subset of the Base (lass Gibrary is

available, when running code under $FG (G7.8+T provider that allows the connection to be redirected to

the same session which already hosts the running code. $uch connections are called

conte*t connections and are set by setting conte*t connection parameter to true in the

connection string. $FG $erver also provides several other enhancements to the

A>7.8+T A)#, 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. #t

also provides access to the DMG features in $FG $erver, including DFuery support.

These enhancements are also available in T-$FG )rocedures in conse%uence of the

introduction of the new DMG >atatype %uery, value, nodes functions0.


56/74

Services

$FG $erver also includes an assortment of add-on services. :hile these are not

essential for the operation of the database system, these provide value added services on

top of the core database management system. These services either run as a part of some$FG $erver component or out-of-process as :indows $ervice and presents their own A)#

to control and interact with them.

Service Broker

The $ervice Broker, which runs as a part of the database engine, provides a

reliable messaging and message %ueuing platform for $FG $erver applications. Jsed

inside an instance, it is used to provide an asynchronous programming environment. or

cross instance applications, $ervice Broker communicates over T()C#) and allows the

different components to be synchroni'ed together, via e*change of messages.

Replication Services

$FG $erver


57/74

Transaction replication

+ach transaction made to the publisher database master database0 is synced out to

subscribers, who update their databases with the transaction. Transactional

replication synchroni'es databases in near real time.

Merge replication

(hanges made at both the publisher and subscriber databases are tracked, and

periodically the changes are synchroni'ed bi-directionally between the publisher

and the subscribers. #f the same data has been modified differently in both the

publisher and the subscriber databases, synchroni'ation will result in a conflict

which has to be resolved - either manually or by using pre-defined policies.

Snaps+ot replication

$napshot replication published a copy of the entire database the then-snapshot of

the data0 and replicates out to the subscribers. urther changes to the snapshot are

not tracked.

Analysis Services

$FG $erver Analysis $ervices adds 7GA) and data mining capabilities for $FG

$erver databases. The 7GA) engine supports M7GA), D %ueries.

>ata mining specific functionality is e*posed via the >MD %uery language. Analysis

$ervices includes various algorithms >ecision trees, clustering algorithm, 8aXve Bayes

algorithm, time series analysis, se%uence clustering algorithm, linear and logistic

regression analysis, and neural networks - for use in data mining.


58/74

Reporting Services

$FG $erver


59/74

Syste Analysis

Assuming that a new system is to be developed, the ne*t phase is system analysis.

Analysis involved a detailed study of the current system, leading to specifications of a

new system. Analysis is a detailed study of various operations performed by a system and

their relationships within and outside the system. >uring analysis, data are collected on

the available files, decision points and transactions handled by the present system.

#nterviews, on-site observation and %uestionnaire are the tools used for system analysis

All procedures, re%uirements must be analy'ed and documented in the form of detailed data flow diagrams >>s0, data dictionary, logical data structures and miniature

specifications. $ystem Analysis also includes sub-dividing of comple* process involving

the entire system, identification of data store and manual processes.

The important steps in system analysis are

• $pecification of what the new system is to accomplish based on the user

re%uirements.

• unctional hierarchy showing the functions to be performed by the new

system and their relationship with each other.

• unction network, which are similar to function hierarchy but they

highlight those functions, which are common to more than one procedure.

• Gist of attributes of the entities - these are the data items which need to be

held about each entity record0


60/74

/easibility St$&y

easibility is the determination of whether or not a pro&ect is worth doing. The

processes is followed in making this determination is called a feasibility study. easibility

study is the test of system proposal according to its workability, #mpact on the

organi'ation ability to meet user?s needs, and effective use of resources. The result of

feasibility study is a formal proposal. This is simply a report a formal document

detailing the nature and scope of the proposed solution .The main ob&ective of a

feasibility study is to test the technical, social and economic feasibility of developing a

computer system. This is done by investigation the e*isting system in the area under

investigation and generating ideas about a new system. 7n studying the feasibility of the

system, three ma&or considerations are dealt with, to find whether the automation of the

system is feasible. They are discussed as followsV

TEC%*'CA1 /EAS'B'1'T7

A system that can be developed technically and that will be used if installed must

still be a good invested for the organi'ation. The assessment of technical feasibility must

be based on an outline design on system re%uirements in terms of inputs, outputs, files,

programs, procedures. Technical feasibility centers around the e*isting computer system

and to what e*tend it can support the proposed system. The current technical resources,

which are available in the organi'ation, are capable of handling the re%uirements in the

aspect of technical staff. Technical feasibility also involves the investigations such as


61/74

whether the proposed system provides ade%uate response to in%uiries and whether it can

be e*panded if developed. The current pro&ect is to be designed so as to fit to the

e*pectations of various categories of people concerned with it. Besides some technical

e*perts who also have the computer knowledge are to be trained over the pro&ect enabling

them to take care of the technical problems. The system is developed to meet the

demands of the e*isting . The system is also reliable and easy to use. $o it is found that

this pro&ect is technically practicable keeping the clients re%uirements in mind.

ECO*OM'C /EAS'B'1'T7

The techni%ue of cost benefit analysis is often used as a basis for assessing

economic feasibility. +conomic feasibility deals with the analysis of costs against benefits

i.e0 whether the benefits to the en&oyed due to the new system are worthy when

compared to the costs to be spent on the system. +conomic analysis is the nose fre%uently

used techni%ue for evaluating the cost effectiveness of the proposed pro&ect. More

commonly know as cost C benefit analysis, the procedure is to determine whether the

pro&ect have the benefits and savings. urther compared with the e*isting-costs in the

manual procedure, the current pro&ect involves less investment.

The cost when compared to the benefits of the system are much low. ence the

system is economically feasible.The conversion of the staff in maintaining the paper

records to some other important work is possible which may be taken as the added

advantages of this pro&ect. Accurate and reliable information e*change with reasonable

cost is possible. Taking this into consideration, the system is found to be economically

feasible.


62/74

OPERAT'O*A1 /EAS'B'1'T7

)roposed pro&ects are beneficial only if they can be turned into information

systems that will meet the company?s operating re%uirements. $imply stated, this test of

feasibility asks if the system will work when it is developed and installed. There are

%uestions that will help to test the operational feasibility of a pro&ect.

The following aspects are considered during the time of feasibility study

H. The changes brought to the system.

The operational skills that will be re%uired for entering data and the training to be given

are also considered.

T'ME /EAS'B'1'T7

The only point is 1(an the pro&ect be developed in time so that it can be used

before any new proposal come to the company. The software is feasible with time as it

will be developed in the estimated time limit.

RESO)RCE /EAS'B'1'T7

The issue of consideration here is 1does the developer has enough resources to

develop such software and to succeed in itL2 i.e. the resources that would be re%uired to

develop and implement the software. The resources not only include the hardware,

software, and technology but also re%uire money, men power. #t also takes into

consideration the resources re%uired at client side when the software has been installed.


63/74

BE%A9'ORA1 /EAS'B'1'T7

)eople are inherently resistant to change, and because of any new thing changes

are made. +volution of any new system over e*isting system is a reason for resistant by

people. $o, for a pro&ect the respective behavioral feasibility is calculated, so as to have

complete knowledge of what problems would be faced after implementing the software.

#n this software, the user can never face any kind of problems, as the software is highly

user friendly.


64/74

So!t"are Re#$ireents Speci!ication:

%ar&"are 'nter!aces

)rocessor Type )entium -#=

$peed 4.6 3


65/74

Co&ings:

(urrent )age

using System;using System.Collections;using System.ComponentModel;using System.Data;using System.Drawing;using System.Web;using System.Web.Mobile;using System.Web.SessionState;using System.Web.UI;using System.Web.UI.MobileControls;using System.Web.UI.WebControls;using System.Web.UI.HtmlControls;using System.Data.SqlClient;

public partial class _Deault ! System.Web.UI.MobileControls.Mobile"age#

SqlConnection con; SqlCommand com; $$SqlData%dapter da; SqlData&eader dr; string rm' to; string a' d' p' q; int b' c' o' r' s' t; protected (oid "age_)oad*ob+ect sender' ,(ent%rgs e- # con new SqlConnection*/Data Source.;InitialCatalogmobileban0ing;User IDsa/-; i *1Is"ost2ac0- #

)abel3.4e5t Date4ime.4oday.4oS6ortDateString*-; )abel7.4e5t Date4ime.8ow.4oS6ort4imeString*-;

9 9 protected (oid Command:_Clic0*ob+ect sender' ,(ent%rgs e- #

i *4e5t2o5:.4e5t 4e5t2o5.4e5t- # )abels are same so

unable to preare transaction/; 9 else #

c6*-;

9 9 public (oid rom*-


66/74

#

rm /wit6draw/; con.?pen*-; com new SqlCommand*/sp_ins3:/' con-; com.Command4ype Command4ype.Stored"rocedure; com."arameters.%ddWit6=alue*/@acc/' 4e5t2o5:.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@amo/' 4e5t2o5A.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@dat/' )abel3.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@tim/' )abel7.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@tran/' rm.4oString*--; com."arameters.%ddWit6=alue*/@to/' 4e5t2o5.4e5t.4oString*--;

com.,5ecute8onBuery*-; $$con.Close*-;

9 public (oid to:*- # con.Close*-;

to /deposit/; con.?pen*-; com new SqlCommand*/sp_ins3:/' con-; com.Command4ype Command4ype.Stored"rocedure; com."arameters.%ddWit6=alue*/@acc/' 4e5t2o5.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@amo/' 4e5t2o5A.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@dat/' )abel3.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@tim/' )abel7.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@tran/' to.4oString*--; com."arameters.%ddWit6=alue*/@to/' 4e5t2o5:.4e5t.4oString*--;

com.,5ecute8onBuery*-; $$con.Close*-;

9 public (oid upd:*- # con.Close*-; d Con(ert.4oString*c-; con.?pen*-; com new SqlCommand*/sp_Up:/' con-; com.Command4ype Command4ype.Stored"rocedure; com."arameters.%ddWit6=alue*/@acc/' 4e5t2o5:.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@q/' d.4oString*--; com.,5ecute8onBuery*-; $$con.Close*-;

9 public (oid updA*- # con.Close*-; q Con(ert.4oString*t-; con.?pen*-; com new SqlCommand*/sp_Up:/' con-;


67/74

com.Command4ype Command4ype.Stored"rocedure; com."arameters.%ddWit6=alue*/@acc/' 4e5t2o5.4e5t.4oString*--; com."arameters.%ddWit6=alue*/@q/' q.4oString*--; com.,5ecute8onBuery*-; $$con.Close*-;

9 public (oid un*- # $$ dr.Close*-; con.Close*-; rom*-; to:*-; con.Close*-; con.?pen*-; com new SqlCommand*/select balance rom tblcurmain w6ereaccountid>/ 4e5t2o5:.4e5t />/' con-; dr com.,5ecute&eader*-;

w6ile *dr.&ead*-- # a drEF.4oString*-;

9 $$dr.Close*-; $$con.Close*-; b Con(ert.4oIntA*4e5t2o5A.4e5t-; o Con(ert.4oIntA*a.4oString*--; c o G b; upd:*-; con.Close*-; con.?pen*-; com new SqlCommand*/select balance rom tblcurmain w6ereaccountid>/ 4e5t2o5.4e5t />/' con-; dr com.,5ecute&eader*-; w6ile *dr.&ead*-- # p drEF.4oString*-;

9 $$ dr.Close*-; $$con.Close*-; r Con(ert.4oIntA*4e5t2o5A.4e5t-; s Con(ert.4oIntA*p.4oString*--; t r s; updA*-;

9 public (oid un:*- # un*-;

9 public (oid c6ec0*- #


68/74

con.Close*-; con.?pen*-; com new SqlCommand*/select rom tblcurmain w6ere accountid >/ 4e5t2o5.4e5t.4oString*- /> /' con-; dr com.,5ecute&eader*-; i *dr.&ead*-- # $$i *4e5t2o5.4e5t.4oString*- drEF.4oString*-- $$# un:*-; 9 else # )abel


69/74

con.Close*-;

9 public (oid bal*- #

int u'u:; con.Close*-; con.?pen*-; com new SqlCommand*/select balance rom tblcurmain w6ereaccountid>/ 4e5t2o5:.4e5t.4oString*- />/' con-; dr com.,5ecute&eader*-; i *dr.&ead*-- #

u Con(ert.4oIntA*drEF.4oString*--; u: Con(ert.4oIntA*4e5t2o5A.4e5t-; i *u J u:- # )abel


70/74

vie" Page

using System;using System.Collections;using System.ComponentModel;

using System.Data;using System.Drawing;using System.Web;using System.Web.Mobile;using System.Web.SessionState;using System.Web.UI;using System.Web.UI.MobileControls;using System.Web.UI.WebControls;using System.Web.UI.HtmlControls;using System.Data.SqlClient;

public partial class cur: ! System.Web.UI.MobileControls.Mobile"age# SqlConnection con;

SqlCommand com; SqlData%dapter da; $$SqlData&eader dr; DataSet ds new DataSet*-; protected (oid "age_)oad*ob+ect sender' ,(ent%rgs e- # con new SqlConnection*/Data Source.;InitialCatalogmobileban0ing;User IDsa/-; i *1Is"ost2ac0- # string ac' da:; ac Session/accid:/F.4oString*-; da: Session/dat:/F.4oString*-;

con.?pen*-; com new SqlCommand*/select tim 4ime'trans%ccount_Id'amount %mount'trandetail 4ransaction_4ype rom tblcurtranw6ere dat >/ da:.4oString*- />and accid>/ ac.4oString*- />/'con-; da new SqlData%dapter*com-; da.Kill*ds-; ?b+ect)ist:.DataSource ds; ?b+ect)ist:.Data2ind*-; con.Close*-;

9 99


71/74

Syste Testing

Testing Stages

There are four main testing stages

Jnit Testing

#ntegration Testing

$ystem Testing

Jser Acceptance Testing

)nit Testing:

This test demonstrates that a single program, module or unit of code function as

designed. The unit testing is normally white bo* oriented, and the step can be conducted

in parallel for multiple modules.

'ntegration Testing:

This test is done to validate the multiple parts of the system interact according to

the system design. +ach integrated portion of the system is ready for testing with other

parts of the system. The ob&ective is to take unit tested modules and built a program

structure that has been dictated by design.

Syste testing:

This test simulates operation of the entire system and confirms that it runs

correctly. The total system is also tested for recovery and fall back after various ma&or

failures to ensure that no data is lost during the emergency


72/74

)ser Acceptance Testing:

#nternal staff, customers, vendor or other users interact with the system to ensure

that it will function as desired regardless of the system re%uirements. An acceptance test

has the ob&ective of selling the user on the validity and reliability of the system. #t verifies

that the system?s procedures operate to system specification and that the integrity of vital

data is maintained.

Concl$sion

The $oftwareCsystem was successfully developed to meet the needs of the client.

#t was found to provide all the features that re%uired for the organi'ation. The accuracy

and comple*ity of the software are also ensured.The $ystem provides benefits such as user-friendly environment, effective

problem resolution and powerful search mechanisms. There is no limitations for the

(oncurrent users.

Apart from the above benefits, the system also holds the benefits provided by the

technologies used in the development. They are

/lexibilities

The $ystem is more fle*ible in the sense that the changing re%uirements of the

user can be easily added to the application thereby making the application recent in future

too.


73/74

$ince, the >esigning of the $creens is by using the .8+T Technology, anyone

knows the .8+T >esigning steps, can continue the process from which anyone else has

%uit from.

$ince the system is a :eb-based one, the client can access the very same server

from anywhere in the 3lobe.

En+anceents

All software products aim at lesser degree of maintenance. This is %uite natural,

but enhancements also pour in, in due course of time, which is unavoidable Better

technologies developers aiming for sophistication and increasing need of customers are

all part and parcel of the software.

Re!erence:

B'B1'O6RAP%7

Asp.8et >ata :eb (ontrols - by $cott Mitchell

Asp.8et - by $tephen :alther

Asp.8et for :eb >esigners -by )eter Gadka

Cyess(onsulting.(om


74/74
http://books.google.co.in/books?vid=ISBN0672325012&id=gWqg3kyQ8aEC&pg=PA1&lpg=PA1&ots=Id3JBgb7Ao&dq=ASP.NET+BOOKS&sig=Q6_6edMPKGrHy-4zKDbqKR1cDwYhttp://books.google.co.in/books?vid=ISBN0672324768&id=Std_w2T7T2cC&pg=PA1&lpg=PA1&ots=Wvii70nSbj&dq=ASP.NET+BOOKS&sig=MqzOmbfWHfVrJNWgmUB_PkWcrH0

Date post:	07-Aug-2018
Category:	Documents
Upload:	abhinav-garg
View:	216 times
Download:	0 times

Mobile Banking Report

Documents