Classic ASP

Program to print all prime numbers from 1 to nth number :: logic building 6

2013-08-05T05:47:00.002-07:00

typedef enum{false,true} bool;

void main()

{

int inputNum;

int count;

int number;

int i=0;

bool flage = true;

printf("Enter the number to print all prime numbers from 1 to :: ");

scanf("%d",&inputNum);

for(count = 2; count <=inputNum;count++)

{

i = 2;

for(i = 2 ; i < count;i++)

{

if(count%i == 0)

{

flage = false;

break;

}

if(flage == true)

{

printf("\n%d",i);

}

flage = true;

}

getch();

Program to enter the numbers till the user wants and at the end it should display the count of positive negative and zeros entered : Logic building(5)

2013-08-05T04:05:00.001-07:00

int inputNum;

int positive = 0;

int negative = 0;

int Zero=0;

int choice;

{

printf("\nEnter the number ");

scanf("%d",&inputNum);

inputNum >= 0 ? (inputNum == 0 ? (Zero +=1) :(positive += 1)) : (negative +=1);

printf("\nDo you want to enter more number(1/0) : ");

scanf("%d",&choice);

}

while(choice==1);

printf("\nPositive Number(s): %d \nNegative Number(s): %d \nZero(s): %d ",positive,negative,Zero);

Factorial , Armstrong numbers : Logic building (4)

2013-08-05T04:01:00.001-07:00

Program to find the Factorial of a number

int inputNum;

int i;

int factorial = 1;

int value;

printf("Please Enter Number less than or equal to 10:: ");

scanf("%d",&inputNum);

if(inputNum <= 10)

{

for(i =inputNum; i >= 1 ; i--)

{

value = i * factorial;

printf("\n%d * %d = %d\n" , i,factorial,value);

factorial = value;

}

printf("\nFactorial of %d is %d", inputNum,factorial );

}

else

{

printf("Please enter number less than or equal to 10");

}

Program to print out all Armstrong numbers between given numbers

int inputNum;

int i;

int armstrongNum ;

int j;

int digit;

printf("Please Enter Number max limit");

scanf("%d",&inputNum);

for(i =1; i<= inputNum ; i++)

{

armstrongNum = 0;

j = i;

while( j > 0)

{

digit = j%10;

armstrongNum += digit*digit*digit;

j = j/10;

}

if(armstrongNum == i)

{

printf("%d\n", armstrongNum);

}

Program to find out first day of the input year : Logic building (3)

2013-08-05T00:26:00.000-07:00

int dayNum;

int leapYear4, leapYear100, leapYear400;

int inputYear;

scanf("%d",&inputYear);

leapYear4 = (inputYear - 1)/4;

leapYear100 = (inputYear - 1)/100;

leapYear400 = (inputYear - 1)/400;

dayNum = (inputYear + leapYear4 - leapYear100 + leapYear400) %7;

switch (dayNum)

{

case 1 :

printf("Monday");

break;

case 2 :

printf("Tuesday");

break;

case 3 :

printf("Wednesday");

break;

case 4 :

printf("Thursday");

break;

case 5 :

printf("Friday");

break;

case 6 :

printf("Saturday");

break;

case 0 :

printf("Sunday");

break;

}

Program to determine whether the year is a leap year or not :: Logic building (2)

2013-08-04T23:20:00.000-07:00

Before writing the program for finding Leap year, I just want to give you a brief history about the leap year and what it is.

It takes the Earth approximately 365 days, 5 hours, 48 minutes, and 46 seconds to circle once around the Sun. Leap Years are needed to keep our calendar alignment with the Earth's revolutions around the sun. So if we didn't add a day on February 29 nearly every 4 years, we would lose almost six hours off our calendar every year. After only 100 years, our calendar would be off by approximately 24 days!

To determine whether a year is a leap year or not , follow the below mentioned algorithm

Algorithm

1. If the year is evenly divisible by 4, go to step 2. Otherwise, go to step 5.
2. If the year is evenly divisible by 100, go to step 3. Otherwise, go to step 4.
3. If the year is evenly divisible by 400, go to step 4. Otherwise, go to step 5.
4. The year is a leap year (it has 366 days).
5. The year is not a leap year (it has 365 days).

If the value in cell A1 is this The formula returns
----------------------------------------------------------
1992 Leap Year
2000 Leap Year
1900 NOT a Leap Year

Program to determine whether the year is a leap year or not

int inputYear;

printf("Please Enter Year");

scanf("%d",&inputYear);

if(inputYear%4 == 0)

if(inputYear%100 == 0 )

{

if(inputYear%400 == 0)

printf("%d is a Leap Year",inputYear);

else

printf("%d is not Leap Year",inputYear);}

else

{

printf("%d is Leap Year",inputYear);

}

else

{

printf("%d is not Leap Year",inputYear);

}

Simple program :: Logic Building (1)

2013-08-02T03:43:00.000-07:00

The below program is written in C , I think it's very easy for you guys to convert it into classic ASP.

Program to take input from the user and print a new number by adding one to each of its digits.

void main()

{

//Variable declaration

int Count = 0;

int NoOfdigits = 1;

int InputNumber;

int incri= 1;

int FinalResult= 0;

int i;

//Taking input from the user

printf("Enter the Number less than 10 digit ::");

scanf("%i",&InputNumber);

NoOfdigits = InputNumber;

//Calculating the length on input number

while(NoOfdigits > 0)

{

NoOfdigits = NoOfdigits/10;

Count = Count++;

}

//adding one in each digit of the input number

for(i = 0 ; i < Count;i++)

{

FinalResult += ((InputNumber%10) +1)*incri;

incri = incri*10;

InputNumber = InputNumber/10;

}

printf("\n%d Final result after adding one in each digit ::",FinalResult);

getch();

program to find out whether a input number is an odd number or even number.

int inputNumber;

printf("Enter the number :\t");

scanf("%d",&inputNumber);

if(inputNumber >= 0)

{

if(inputNumber%2 == 0)

{

printf("Number is Even");

}

else

{

printf("Number is Odd");

}

else

{

printf("Invalid Entry");

}

Things that need to be keep in mind about Web Site Design

2012-05-01T05:30:00.000-07:00

The biggest difficulty most Web developers face when building sites is that the mental processes involved in writing code, and designing graphics and layout are worlds apart. Developers who can not only write really tight, maintainable code but can also hold their own when it comes to designing company logos and laying out text are white tiger rare.

When I first started building Web sites, there were a few things I got wrong. Here's a list of what they were:

1. Not Everyone Works at 1024x768 Resolutions…

This was the first thing I got wrong.

Just because you've been using 1024x768 resolution on your desktop for the past six years, that doesn't mean other people don't use 640x480 screens.

Designing Web pages that look good at 1024x768 and 640x480 is an extremely difficult art. In short, you have to make the layout stretch and shrink in order to accommodate the user's browser size. Most public sites design for 640x480 resolution, which is why many sites seem to only take up a small region of the page In order to design for 640x480, don't make the elements that make up your page take more than 600 pixels total width. Intranets and private sites tend to have wider pages because they have a good idea of what their audience will be using.

Public sites, typically stick to the 640x480 layout. The magic number of 600 leaves space for the side of the browser and the scrollbars. Also, make sure that the important elements of the page fit into the first 400 pixels that make up the height. Allow 125 to 150 pixels for the left navigation bar (if you have one), leaving 450 pixels for the width content. Remember, you're building pages for iMacs and Linux boxes too.

2. Not Everyone Has 16 Million Colors…

You must design your graphics so they look good in 256 colors. In addition, graphics for logos and buttons, etc., should be in GIF format. In fact, the 256-color limit is not even true. When designing for the Web, you only have available to you 216 separate colors that you know will be there. This is known as the Webmaster Safety Palette and most graphic design programs, like Adobe Photoshop come with a palette that you can import into your graphics to ensure you're using the correct color spread.

3. Not Everyone Uses Internet Explorer

There are a lot of people who use Netscape. There's also a fair difference between Netscape and Internet Explorer, enough to make me have nightmares and spend hours re-engineering presentation code to make a site look cool in both.

4. Not everyone has a high speed internet connection

Luckily, I'm not alone on this one! Many Web developers forget that just because they have a high-bandwidth Internet connection, that doesn't mean everyone else does too. The issue is that if the site is not responsive, visitors to the site will grow frustrated and click out of the site and onto a competitor.

There are five tricks to enhancing the performance of your site:

1. Minimal use of graphics. Make sure you use just the right amount of graphics, and make sure that these graphics are as optimized as possible.

2. Make pages smaller. Convey just the right amount of information on a page. Don't keep the user waiting around to get all the information he or she needs. If necessary, spread information over a number of pages.

3. Keep URLs short. In dynamic sites, this is an interesting one. If you ever look at the URLs on Yahoo, you'll notice that instead of calling a folder "images", they'll call it just "i". The logic behind this is sound - there's no need to write "images" in full if the browser can understand "i". Wherever possible, keep the names of ASP pages and folders as short as possible.

4. Avoid the use of ActiveX controls or Java applets. Additional components that need to be downloaded and installed in order for your visitors to get the full benefit of site functionality can frustrate users both through the speed it takes to download the components, and possible problems they may encounter once they have been downloaded.

Designing the Model for E-Commerce Application in Classic ASP

2012-04-03T06:17:00.000-07:00

In developing the business tier for our application we are going to build a series of objects that we can classify as belonging to one of three distinct groups

Infrastructure
Service
Data

Before we look at the precise objects we'll be building, let's discuss these general groupings.

Infrastructure Objects

Infrastructure objects provide access to the resources that an application will use. In our case, we only need to actively manage one resource - the connection to the database. The application will use more resources, like memory, disk drives, and so on, but the application framework provided by Visual Basic and the Web server (IIS) will do this for us.

One sure way of ensuring the presentation layer code is not allowed to circumvent the business rules is to never allow the ASP code direct access to any of the infrastructure objects. In our case, we do this by creating an object that is only accessible to objects in the model. In other words, this object is private to the model as a whole and the ASP code will not be able to directly access or call methods on it.

Service Objects

Service objects provide access to application services. An application service is defined to be anything that an application can actually do. So, in our case we might have an object that can carry out operations like creating customers, deleting customers, viewing orders placed by a customer, etc. The activities outlined (for example the operation of creating a new customer) will have to conform to certain criteria - business rules.

We may decide that any object in our model can create a customer by calling the appropriate object; additionally we may decide that not only can another object call this object to create a customer but ASP code can as well. It is through these service objects that the presentation layer code can get to the business rules. We'll see more service objects in a little while.

Data Objects

Data objects define single instances of some entity in the system somewhere. This is a deliberately broad description, but in our case it nearly always refers to rows in the database. So, we may have an object to describe a single customer, or a single order, and so on. The advantage of this approach is that it lets you add a great degree of detail to the data objects.

Now we've seen the classifications, let's move on to see how we choose the actual objects we are going to put into our object model.

Choosing the Objects

Now we know what kinds of objects we are going to have in our model, we need to decide what objects will actually make up that model. To do this, we have to go through a process of deciding how the various users of the system will flow through the application. By that we mean that a user on the system will create some form of event (not the Visual Basic type) - they will do something that requires some action.

The Full Object Model for Ecommerce application

Infrastructure objects

Database - This object has a number of uses; it simplifies our database communications (which are subsequently achieved via the ADO Connection object) it provides a couple of extra functions to aid the ordering process, and allows direct access to the ADO Connection object. This object is not directly available to the ASP code.

Service objects

Catalog - This object provides access to the product catalogue. It enables creation of departments and products, and can query manufacturers, suppliers, departments, and products. It can also create instances of the Product data object.

Customers - This object manages customers. It can log a customer into the customers only areas of the site and can create new customers in the database and manage their address and credit card information.

Orders - This object manages orders. It can take a shopping basket and turn it into an order, and it can move an order through the order-processing pipeline It can also return audit trail information.

Search - This object provides a way of searching the product catalogue.

FireAndForget - This object provides a way of sending e-mails to customers and visitors at a given date and time

XML - This object provides a way of publishing data in our database as XML, and importing XML data into our system.

Data objects

Product - This object represents a single product stored in the database. It can return information about itself, get and set dynamic attribute data, and add and return up-sell/cross-sell recommendations.

Customer - This object represents a single customer stored in the database. It can return information about itself, along with stored address and credit card information and orders that have been placed.

Order - This object represents a single order stored in the database. It can return all of its information, including customer, addresses and credit cards, and the data that makes up the order.

Basket - This object represents a single cart (basket) stored in the database. Most often, this object is used to represent the current visitor's basket. It can return its contents and summary information (total price and total quantity), and it can add and remove items from itself.

Objects vs Components

2012-03-15T07:17:00.003-07:00

This article is in continuation with my previous article dated 27 Feb 2012

Components

Building on the idea of object-oriented programming comes component-oriented design, which facilitates even better reuse of the objects we design and build.

Objects vs Components

Objects are created from classes and classes are made up of source code - which is language specific and thus can only be used, easily, in one environment. In contrast components are pre-compiled units of binary code - thus they are language independent.

A component may consist of one object or a collection of objects.

A component based approach to software design enhances the OO approach we first looked at - in the case that a component consists of a group of objects, we can actually define which objects are accessible outside the component (and hence keep some objects restricted to being accessed by other objects inside the component) by defining the interface of the component.

COM

Of course the above section rather glosses over at least one very important topic; how do we get all these components talking to each other? That's where the Component Object Model (COM) comes in - it's Microsoft's standard for allowing objects and components to interact irrespective of the language in which the components were first built. So, using COM technology we can call up a component, and providing we know what interface it has, we can get it to go away and do things for us.

As part of the COM mechanism, components that we create in VB actually have a number of interfaces that are provided as part of the standard architecture in addition to any interfaces we define. We'll discuss this further at the appropriate time, but the important thing to note is that VB fits seamlessly into COM and as VB developers we are insulated from a great deal of complexity.

ActiveX

An ActiveX component is an application that stands alone and lets other applications use the classes and objects it contains.

Active Scripting

ASP pages are able to access ActiveX components through a technology called Active Scripting. We've skated over the previous general theory pretty quickly (as we alluded to, there are whole books written on the subject) but it's probably worth lingering over this particular aspect.

Active Scripting is a reusable scripting engine that, if you want, you can use in your own application. It can be found in use in Active Server Pages (ASP) and Windows Script Host (WSH). Active Scripting is capable of supporting many languages by allowing developers to write supporting language plug-ins.

Active Scripting ships with VBScript (a cut down version of Visual Basic) and JScript. Other vendors have developed PERL plug-ins, as well as support for other languages. Broadly, this means that you can write ASP code in whatever language plug-in you have available, as Active Scripting and the plug-in work together to make the call into the component and, through that call, tell Visual Basic to execute the code contained within the method or property.

ASP works (as illustrated below) by stripping out all of the VBScript code, creating an instance of Active Scripting, and asking it to execute the code on its behalf. ASP presents a set of its own ActiveX components to the context of the script (the environment that the script runs in). So, the Response object we call in ASP is actually an ActiveX component that ships with ASP, and when ASP fires up Active Scripting to run your code, it passes a reference to this component to Active Scripting and asks for it to be made available to your code as Response.

At this point we need to bring in the idea of a type library. A type library is a file that describes an object (here meaning component or control) in a standard format such that anything wanting to make use of that object can find out which classes are accessible (or supported). This type library is actually embedded into ActiveX DLL files created via Visual Basic; however, it's still available to programs interacting with it using COM.

So, when our ASP page attempts to call a method on the Response object, Active Scripting looks at the type information in the type library and determines if the method or property name is valid and, if it is valid, what parameters it takes (the type library is not just a list of the names of the methods and properties - it also includes the parameters that any call has and the possible types of value that can be returned). This inspection of the published information is part of the technology that makes up ActiveX, not Active Scripting.

Building the Object Model (concepts behind object oriented programming, COM and ActiveX)

2012-02-27T05:18:00.002-08:00

Most modern software can be controlled programmatically through its exposed object models. In fact, most of the applications you use everyday on your Windows PC have an object model, including Microsoft Word, Excel, and Internet

Explorer.

The careful design of these object models is the key to building good software. We're now going to embark on the design, and start the construction, of the business tier for Ecommerce application. This business tier will consist of a number of objects whose interrelationships are defined by their position in the object model. Implementing the object model will define what we can do within the application.

There are going to be three basic parts to this article - we're going to start off with the theory (concepts behind object oriented programming, COM and ActiveX) then we'll move onto see how that theory influences our design of the object model for Ecommerce application . Finally we'll begin to implement the design in VB project.

More specifically our path through the chapter will involve:

Looking at object-oriented programming
Understanding a little about components
Creating a project in Visual Basic
Building the Database object
Building the Catalog object

Let's start by looking at object-oriented programming.

Object-Oriented Programming

Object-oriented programming (OOP) is based on the idea that real-world entities or relationships can be represented in code as objects. These code objects have associated with them data and behave in certain ways when asked to. Objects Can be linked together to form programs and applications.

Objects may be regarded as black-boxes - the user of an object may know what information needs to be input to the object to get a certain result out, but does not need to know what process goes on inside the object.

OK, let's step back from that rather terse summary and use the metaphor of a television set to explain this concept. We're all pretty conversant with televisions in so much as we know if we input a signal (from aerial, cable, video or wherever) and we use the control set properly we'll get sound and vision. Pushing the buttons allows us to vary the channel we watch, raise or lower the volume, alter the picture brightness, and so on. Most of us don't know the precise workings of the electronics that control the TV, and neither do we care, because we know enough to be able to control it.

Classes

The vast majority of object-oriented programming work is concerned with building objects that have no user interface. These objects provide some function to an application. Imagine you are working on a development project in a team and you need access to a billing system that your company owns. One of your colleagues has built a set of objects for talking to this billing system, but it is used on another application. In an object-oriented world, if your colleague has done their job properly, they can give you a copy of the objects, you can plug them into your application and now your application code has access to a billing system through those objects. You haven't had to learn anything about how the billing system works; you've just plugged the objects in.

Let's say our colleague gives us their class module called BillingSystem, (and provides us with information about its properties, methods, and events) in VB we can create instances of it like this:

Dim MyBillingSystem

Set MyBillingSystem = New BillingSystem

Once we've created a billing system object, we can use it:

MyBillingSystem.BillCustomer "Neil", "Mcevoy", "$500", "1/27/2012"

What's happening there is that we know that the BillingSystem object supports a method called BillCustomer. We also know that the code that drives the BillCustomer object is something that we don't understand the internals of – our colleague has been through all that hard work, so we are reusing their efforts. The term reuse is something that comes up time and time again in software development and is an important facet of object-oriented programming. It means that the cost of the time and money we put into developing something can be offset by the fact that whatever original work we come up with can be reused in other applications. This is one of the reasons why people actually sell objects for use in other applications.

I will cover rest of the bullet points in next article

Software Required for Developing our ASP Ecommerce Application

2012-01-16T05:44:00.000-08:00

IIS
Microsoft Transaction Server (MTS)
Dreamweaver
Microsoft SQL Server 2008
Microsoft Visual Basic 6.0

IIS

Formerly called Internet Information Server – is a web server application and set of feature extension modules created by Microsoft for use with Microsoft Windows. IIS 7.5 supports HTTP, HTTPS, FTP, FTPS,SMTP and NNTP. It is an integral part of Windows Server family of products, as well as certain editions of Windows XP,Windows Vista and Windows 7. IIS is not turned on by default when Windows is installed.

MTS

Microsoft Transaction Server (MTS) was software that provided services to Component Object Model (COM) software components, to make it easier to create large distributed applications. The major services provided by MTS were automated transaction management, instance management (or just-in-time activation) and role-based security. MTS is considered to be the first major software to implement aspect-oriented programming

For more details please read my previous article on MTS dated, Monday, January 10, 2011

Microsoft SQL Server 2008:

This database product, rather than Microsoft Access, was chosen since it's a great product for use in building both small, but scalable, solutions and in the development of large distributed applications, like an e-commerce site. We use this database both for development and on the production server.

Microsoft Visual Basic 6.0

This will be used for building our business objects for the business tier of our application.

Dreamweaver

Macromedia Dreamweaver 8 is a professional HTML editor for designing, coding, and developing websites, web pages, and web applications. Whether you enjoy the control of hand-coding HTML or prefer to work in a visual editing environment, Dreamweaver provides you with helpful tools to enhance your web creation experience.

Dreamweaver also provides a full-featured coding environment that includes code-editing tools (such as code coloring and tag completion) and language reference material on Cascading Style Sheets (CSS), JavaScript, and ColdFusion Markup Language (CFML), among others. Macromedia Roundtrip HTML technology imports your hand-coded HTML documents without reformatting the code; you can then reformat code with your preferred formatting style.

Dreamweaver also enables you to build dynamic database-backed web applications using server technologies such as CFML, ASP.NET, ASP, JSP, and PHP.

Designing a scalable application

2012-01-10T23:30:00.000-08:00

Imagine your traditional non-Web-based distributed application has ten users. Chances are your application works just fine in this environment - responses to queries are fast, print jobs run on time, etc. Now imagine your company gets absorbed into a much, much larger one and now your distributed application has 10,000 users. Will your application run just as fast and will your users be just as happy?

Well, no. Not without, at the very least, hardware upgrades. But, even after you redo all the server hardware, will your application still perform to specification?

If it doesn't (and chances are it won't), we say that the application does not scale well; in other words the application is not capable of adapting itself to fit into a new environment where there are more users. If the application copes, then we say it does scale well.

Scalability is important in many areas, but the consequences of ignoring it can be particularly acutely felt if you suddenly find yourself with a successful Web-based distributed application, like an e-commerce site, where the original traffic of

1,000 visits a day suddenly jumps to 10,000,000. How do you design your application in such a way that increases of that magnitude are manageable?

Luckily, you're half way there. The first step in managing that kind of increase is to adopt a 3-tier architecture. In short, by separating the business tier away from presentation and database roles, you can build business objects that work smarter

and scale better. The trick with managing scale is to think about the perceived number of users concurrently working on the system at any one time. Say you do have 10,000,000 visits a day. At any given second, 116 users are on that system.

Imagine all of these users are using the same page. How many database connections do you need? The answer: 116. Now, how many database connections will be required at the same time? The answer: less than 116.

The trick to designing business objects to scale well is to understand that the resources you have are limited. Say your installation of SQL Server can handle only 500 simultaneous connections. If a user needs a database connection and all

500 are in use, that user will have to wait in a queue for one to become available. That is why we often see such a reduction in performance when we start to increase the load on distributed applications - the demand for resources

outstrips supply.

Imagine I write a business object that takes 5 seconds to walk through a list of 100 invoices and performs a complex calculation on each one. If I connect to the database as I enter the CalculateRefund method and close it just before I leave, chances are I've wasted a lot of the database's time as I read one record, process it for a little while, get the next record, and so on. If I, instead, design my object to open the database, read and cache all the records, and close the Database, the database resource is being used efficiently. Now, as the resource is being used more efficiently, other pages servicing other users can obtain database connections more readily, reducing the performance lag we were previously feeling.

Coming back to our 10,000,000 visits example: if we can build our business objects to use the database efficiently, we may be able to reduce the number of simultaneous database connections required to always be below 500, and our application won't feel a performance hit when we scale.

Now that we understand the online business model we're after and we have an understanding of what a 3-tier distributed application is, we can move on to designing the software we'll need to make our site a reality.

Architecture model for E- commerce application

2012-01-06T04:37:00.000-08:00

Let’s start considering the practical aspects of Ecommerce site construction. Let’s first discuss about the model we are going to use for our Ecommerce application. I found Three Tire model to be an extremely efficient development approach and is the one we'll be following in developing our ecommerce application

Let’s have a brief description of Three Tire model

The three-tier architecture model, which is the fundamental framework for the logical design model, segments an application's components into three tiers of services. These tiers do not necessarily correspond to physical locations on various computers on a network, but rather to logical layers of the application. How the pieces of an application are distributed in a physical topology can change, depending on the system requirements

· The presentation tier, or user services layer, gives a user access to the application. This layer presents data to the user and optionally permits data manipulation and data entry. The two main types of user interface for this layer are the traditional application and the Web-based application. Web-based applications now often contain most of the data manipulation features that traditional applications use. This is accomplished through use of Dynamic HTML and client-side data sources and data cursors.

· The middle tier, or business services layer, consists of business and data rules. Also referred to as the business logic tier, the middle tier is where COM+ developers can solve mission-critical business problems and achieve major productivity advantages. The components that make up this layer can exist on a server machine, to assist in resource sharing. These components can be used to enforce business rules, such as business algorithms and legal or governmental regulations, and data rules, which are designed to keep the data structures consistent within either specific or multiple databases. Because these middle-tier components are not tied to a specific client, they can be used by all applications and can be moved to different locations, as response time and other rules require. For example, simple edits can be placed on the client side to minimize network round-trips, or data rules can be placed in stored procedures.

· The data tier, or data services layer, interacts with persistent data usually stored in a database or in permanent storage. This is the actual DBMS access layer. It can be accessed through the business services layer and on occasion by the user services layer. This layer consists of data access components (rather than raw DBMS connections) to aid in resource sharing and to allow clients to be configured without installing the DBMS libraries and ODBC drivers on each client

During an application's life cycle, the three-tier approach provides benefits such as reusability, flexibility, manageability, maintainability, and scalability. You can share and reuse the components and services you create, and you can distribute them across a network of computers as needed. You can divide large and complex projects into simpler projects and assign them to different programmers or programming teams. You can also deploy components and services on a server to help keep up with changes, and you can redeploy them as growth of the application's user base, data, and transaction volume increases

Tracking Customers with Application Variables

2011-12-29T01:21:00.000-08:00

Like Session variables, Application variables can be used to store information over multiple pages. Unlike Session variables, however, Application variables aren't associated with a particular user. The values stored in an Application variable can be assigned and retrieved by every user of your Web site.

To create an Application variable, you use the Application object. For example, to create an Application variable named "myVar", you would use the following statement:

Application( "myVar" ) = "Hello World"

To retrieve an Application variable, you also use the Application object. The following statement displays the contents of the Application variable named "myVar":

Response.Write Application( "myVar" )

When the value of an Application variable is changed, it is changed for every user of your Web site. For example, imagine that Ruth retrieves a page from your Web site which assigns the value blue to the Application variable named favoriteColor. Now, suppose that Andrew comes along and retrieves a page that assigns the value red to the Application variable favoriteColor. After Andrew changes the value of the favoriteColor Application variable, the value of this variable will be changed for everyone. After Andrew retrieves the page, the favorite- Color variable also has the value red for Ruth.

Because the same Application variable can be changed by different users of your Web site, conflicts can occur. For example, a common use of Application variables is for tracking the number of times a page has been viewed. The ASP code display simple page counter

Application( "counter" ) = Application( "counter" ) + 1

Page Counter

This page has been viewed

<%=Application( "counter" )%> times.

There is an important problem with the ASP code above. Imagine that two people request the page at the same time. Ruth requests the page and the counter Application variable has the value 345. At the same time, Andrew requests the page, and the application variable has the value 345. After both visitors retrieve the page, the Application variable will have the value 346. However, because two people have requested the page, it should have the value 347. Fortunately, there is an easy way to fix this problem. The Application object has two methods named Lock and Unlock. The Lock method locks all the Application variables and prevents anyone except the current user from reading or modifying them. The Unlock method releases the

Application variables once again.

Application.Lock

Application( "counter" ) = Application( "counter" ) + 1

Application.Unlock

Page Counter

This page has been viewed

<%=Application( "counter" )%> times.

The ASP above is the same as the ASP code we have earlier except that both the Lock and Unlock methods of the Application object are called. The Lock method is called in line 2. This prevents anyone else from reading or modifying the counter Application variable. After the Application variable has been modified in line 3, the Unlock method is called in line 4 to release the Application variables.

It is important to understand that calling the Lock method locks all the Application variables in memory. You cannot selectively lock Application variables.

After you call the Lock method, all Application variables will continue to be locked until either the Unlock method is called or the page finishes processing. This means that you cannot accidentally lock all Application variables forever within an ASP script.

You should also be aware that locking Application variables doesn't prevent other users from modifying an Application variable. If a number of users attempt to modify an Application variable at the same time, and each user requests a page that calls the Lock method, all the modifications will happen. However, the modifications will take place serially rather than concurrently.

Storing Arrays in Application Variables

One common use of Application variables is to store frequently accessed but infrequently modified database records in memory. Retrieving database records can be a slow process. If the records do not change often, I recommend that you retrieve the database records only once and store them in an Application array. This way, the records can be retrieved very quickly from the Application array the next time they are requested.

The script below demonstrates how you can assign an array to an Application variable named myArray.

DIM myArray( 10 )

myArray( 0 ) = "Hello World!"

Application( "myArray" ) = myArray

Although you can directly read the value of an element contained in an Application array, you can't modify it. For example, the following statement will have no effect:

Application( "myArray" )(2) = "Goodbye!"

If you want to change the value of an element in an Application array, you must first assign the Application array to a local array. For example, the script in below properly changes the value of an element contained in an Application array.

Modifying an Element in an Application Array

Application.Lock

myArray = Application( "myArray" )

myArray( 0 ) = "Goodbye!"

Application( "myArray" ) = myArray

Application( "myArray" ).Unlock

The script above modifies an element of an Application array. In line 3, the Application array named myArray is assigned to a local array with the same name. Next, in line 4, an element of the local array is modified. Finally, in line 5, the local array is assigned to the Application array once again.

Removing Application Variables from Memory You should be careful when creating Application variables. Application variables take up memory. Unlike a Session variable, an Application variable is never automatically removed from memory.

Prior to the version of Active Server Pages included with Windows 2000, there was no way to remove an Application variable from memory using an ASP script. Application variables remained in memory until the Web service was stopped, the Global.asa file was modified, or your ASP Application was unloaded.

The new version of Active Server Pages included with Windows 2000 includes two new methods you can use to remove Application variables from memory: the Remove() and the RemoveAll() methods. The Remove() method removes a particular Application variable from memory. The RemoveAll() method removes all Application variables from memory.

For example, the script below creates two Application variables and then removes one of them.

Using the Remove() Method

Application( "myvar1" ) = "Red"

Application( "myvar2" ) = "Blue"

Application.Contents.Remove( "myvar1" )

In lines 2 and 3, two Application variables are created. In line 4, the Remove() method is used to remove the Application variable created in line 2. To remove all Application variables from memory, you can use the RemoveAll() method. The script below demonstrates how this method can be used.

Application( "myvar1" ) = "Red"

Application( "myvar2" ) = "Blue"

Application.Contents.RemoveAll()

Tracking customer with cookies/ Session and Application/ Global.asa in E-commerce applications (2/3)

2011-12-19T10:09:00.000-08:00

Tracking Customers with Session Variables

You can use Session variables as another method of tracking customer information as a customer moves from page to page on your Web site. Session variables are closely related to cookies. In fact, Session variables rely on cookies.

The Webserver automatically adds a special cookie to every visitor's browser. This cookie is called the ASPSessionID cookie (when it's added to a customer's computer, extra randomly generated characters are added to the name of the cookie for security reasons).

The Web server uses the ASPSessionID cookie to associate Session variables with a particular user. Session variables are stored in the memory of the Web server. You can use a Session variable to store any type of information including text, numbers, arrays and even ActiveX components.

Before you use Session variables, however, you should be warned that they have some of the same drawbacks as cookies. If a customer is using a browser that doesn't support cookies, the Web server cannot create the ASPSessionID cookie. Without the ASPSessionID cookie, Session variables cannot be associated with a customer as the customer moves between pages. So, it is a good idea to avoid using Session variables whenever possible:

Using Session variables in your ASP application can also make your application less scalable. Each Session variable uses server memory. Furthermore, using Session variables makes it more difficult to use multiple Web servers for a Web site (a Web farm) because Session variables are created on an individual server.

<HTML>

<HEAD><BODY><TITLE>Session Variable</TITLE></HEAD>

<BODY>

<% Session( "favoriteColor" ) = "blue" %>

</BODY>

</HTML>

The Session variable is created in above code. You should notice immediately that, unlike a cookie, a Session variable can be created anywhere within an ASP page. Unlike a cookie, you aren’t required to create Session variables before any content is sent to the browser. After the favoriteColor Session variable has been created and assigned a value, it will retain that value throughout the time that a user visits your Web site. The favoriteColor Session variable will be associated with a particular user by using the ASPSessionID cookie.

Below code is use for displaying a Session Variable

<HTML>

<HEAD><BODY><TITLE>Session Variable</TITLE></HEAD>

<BODY>

Your favorite color is <%=Session( "favoriteColor" )%>

</BODY>

</HTML>

It is important to understand that Session variables are created relative to particular users. For example, assume that Ruth visits your Web site and retrieves a page, which assigns the value blue to the Session variable named favoriteColor. Now assume that Andrew visits your Web site and retrieves a page, which assigns the value red to a Session variable named favoriteColor. After Andrew retrieves his page, the value of favorite Color doesn't change for Ruth. Each visitor has his own unique set of Session variables assigned to him.

Session variables persist until a user leaves your Web site. How does the Web server detect when this happens? By default, the Web server assumes that if a user doesn't request a page for more than 20 minutes, the user has left. You can change this default behavior with the Timeout property of the Session object.

For example, if you have a Web site that includes long product descriptions, which are time-consuming to read, you might want to change the Timeout property to 60 minutes. You can do this by adding the following statement at the top of a page:

Session.Timeout = 60

You specify the value of the Timeout property in minutes. The new value of Timeout will apply to the user throughout the remainder of her user session.

Storing Arrays in Session Variables

One common use for Session variables is for storing a customer's shopping cart. You can create a shopping cart by assigning an array to the Session variable. The elements in the array represent each of the products a customer has added to his shopping cart. The script in below illustrates how you can create an array, assign values to two of its elements, and then create a Session variable that contains the array.

DIM ShoppingCart( 20 )

ShoppingCart( 0 ) = "toothpaste"

ShoppingCart( 1 ) = "comb"

Session( "ShoppingCart" ) = ShoppingCart

The ShoppingCart array is created in line 2. The array has 20 elements. Next, in lines 3 and 4, two of the array’s elements are assigned a value. Finally, in line 5, the array is assigned to a Session variable named ShoppingCart. After an array has been assigned to a Session variable, you can display any element of the array by referring to its index. For example, the following statement displays the element of the Session array with an index of 1.

Response.Write Session( "ShoppingCart" )( 1 )

If the Session array were created with the script in Listing 3.4, the previous statement would display the value "comb".

However, you cannot change the value of an element in a Session array directly. To change any of the values in a Session array, you must first assign the Session array to a normal VBScript array, make the change, and then assign the array to the Session variable once again. For example, the script in Listing 3.5 demonstrates how to change the value of the second element of the ShoppingCart Session array from comb to toothbrush.

Changing the Value of a Session Array

ShoppingCart = Session( "ShoppingCart" )

ShoppingCart( 1 ) = "toothbrush"

Session( "ShoppingCart" ) = ShoppingCart

You might be tempted to try to change the value of a Session array directly. For example, you might try to use the following statement:

Session ( "ShoppingCart" )( 1 ) = "toothbrush"

This statement won't generate an error. However, it will have absolutely no effect. You cannot change a value of a Session array directly.

Tracking a Session with a SessionID

The Session object has a valuable property for uniquely identifying users: the SessionID property. Each visitor to your Web site is automatically assigned a unique number. You can retrieve that unique number with the SessionID property.

For example, the below ASP code displays the value of SessionID for the person who requests the page.

Displaying the SessionID Property

<HTML>

<HEAD><BODY><TITLE>Session ID</TITLE></HEAD>

<BODY>

Your unique Session ID is <%=Session.SessionID%>

</BODY>

</HTML>

A SessionID is guaranteed to be unique for each user who is currently at your Web site. However, the same SessionID might be used again after your Web server has been restarted. This means that you shouldn't attempt to track the same user over time by using her SessionID.

Ending a User Session

By default, a user session ends after the user hasn't requested a page from your Web site for more than 20 minutes. However, you can force a session to end earlier than this by calling the Abandon method of the Session object. Calling the Abandon method removes all the Session variables associated with the user who requested the page from memory.

After you call the Abandon method, the user's session doesn't actually end until the current page is completely processed. This means that all the user's Session variables retain their values until the page finishes processing. Furthermore, the user's SessionID retains its value throughout the page

For example, consider the code below.

<HTML>

<HEAD><TITLE>Session Abandon</TITLE></HEAD>

<BODY>

Session( "myVar" ) = "Hello World!"

The value of myVar is: <%=Session( "myVar" )%>

Session.Abandon

The value of myVar is: <%=Session( "myVar" )%>

</BODY>

</HTML>

The Abandon method is most often used when creating a Logoff page in a Web site. For example, you can store a customer’s username and password in Session variables to identify the customer on every page. When the customer is ready to leave your Web site, she can link to a page that calls the Abandon method to end her user session and remove her username and password from memory.

Tracking customer with cookies/ Session and Application/ Global.asa in E-commerce applications (1/3)

2011-12-15T04:26:00.000-08:00

Before developing an eCommerce application I would like to describe how to keep track of users visiting your E-commerce web application Using Application and Session objects. The ability to track customers and personalize content is important because you can use it to increase sales. To take a simple example, you might want to display different advertisements to different customers depending on their interests. If you have recorded the fact that a certain customer likes looking at pages in your Web site related to fishing rods, you can automatically show this customer more advertisements related to fishing rods.

In this article you will discuss

How to add cookies to customers' browsers so that you can automatically identify customers whenever they return to your Web site.
How to use Session and Application variables to store persistent information.
How to use the Global.asa file to detect when customers first arrive at your Web site and when they leave.

Tracking Customers with Cookies

We can use a cookie to store information on a customer’s computer when the customer visits our Web site. We can then use this information to identify the customer once again whenever the customer returns to our Web site. Without cookies, the interaction between Web servers and browsers is stateless. You cannot identify the same user of your Web site as the user moves from page to page. The stateless nature of Web server and browser interaction creates a number of problems for Web site developers. For example, imagine you have created a special area of your Web site that contains content, which only registered members can view. Without using cookies, it is difficult to track whether a particular user is a registered member. If the user logs in on one page, it is difficult to detect whether it is the same user on another page.

Types of cookies

There are two types of cookies:

Session cookies: Session cookies are stored in memory. They last on a customer's computer only while the customer is visiting your Web site.

Persistent Cookies: A persistent cookie, on the other hand, can last many months or even years. Persistent cookies are stored in a text file on the customer's computer. This text file is called the Cookie file on Windows computers and the Magic Cookie file on Macintosh computers.

You should never assume that a customer has cookies enabled on their browser. For example, a perfectly legitimate use of cookies is to automatically log in a user at your Web site. If you do this, however, you should include a way for users who do not have cookies enabled to log in.

Adding a Cookie to a Customer's Browser

You can add a cookie to a customer's browser by using the Cookies collection of the Response object. For example, imagine that you want to add a cookie named customer Name that contains a customer name. To add this cookie, you would use the following statement:

Response.Cookies( "customerName" ) = "Binay Tiwari"

This statement adds a cookie named "customerName" that has the value "Binay Tiwari". The cookie that is created is a session cookie. It last only while the customer is visiting your Web site.

To create a persistent cookie, you must include the date when the cookie will expire. You do this by using the Expires attribute of the Cookies collection. For example, the following two statements create a cookie that will last until July 4, 2012:

Response.Cookies( "customerName" ) = "Binay Tiwari"

Response.Cookies( "customerName" ).Expires = "July 4, 2012"

When creating cookies, you must create the cookie before any content is sent to the browser. Otherwise you will receive the following error:

Header Error

“The HTTP headers are already written to the client browser. Any HTTP header modifications must be made before writing page content.”

If you want to get around this limitation, you can buffer your ASP page. When you buffer an ASP page, the page is not sent immediately to a browser. It is retained in memory until the whole page is processed. To buffer an ASP page, include the following statement at the top of the page:

<% Response.Buffer = TRUE %>

According to the original cookie specification a single computer can hold a maximum of 300 cookies from all Web sites. Furthermore, a single Web site cannot add more than 20 cookies to a customer's computer. Finally, an individual cookie can hold no more than 4KB of data. This limit applies to a combination of the size of the cookie's name and the size of the data contained in the cookie.

Reading Cookies from a Customer's Browser

You can read a cookie you have placed on a customer’s computer by using the Cookies collection of the Request object. For example, to retrieve a cookie named username and assign it to a local variable named username, you would use the following statement:

username = Request.Cookies( "username" )

You can display all the cookies that have been added by your Web site by iterating through the contents of the Cookies collection.

<HTML><HEAD><TITLE>All Cookies</TITLE></HEAD>

<BODY>

FOR EACH cookie IN Request.Cookies

Response.Write cookie& "=" &Request.Cookies( cookie )& " "

</BODY>

</HTML>

WHAT ABOUT THE LIMITATIONS OF E-COMMERCE

2011-12-13T05:12:00.000-08:00

Isaac Newton’s 3rd Law of Motion, ‘For every action there is an equal and opposite reaction’ suggests that for all the beneﬁts there are limitations to e-commerce. These again will be dealt with according to the three major stakeholders – organizations, consumers and society

Limitations of e-commerce to organizations

Rapidly evolving and changing technology, so there is always a feeling of trying to ‘catch up’ and not be left behind.

Under pressure to innovate and develop business models to exploit the new opportunities which sometimes leads to strategies detrimental to the Organization. The ease with which business models can be copied and emulated over the Internet increase that pressure and curtail longer-term Competitive advantage.

Limitations of e-commerce to consumers

Computing equipment is needed for individuals to participate in the new ‘digital’ economy, which means an initial capital cost to customers.

A basic technical knowledge is required of both computing equipment and navigation of the Internet and the World Wide Web

Lack of security and privacy of personal data. There is no real control of data that is collected over the Web or Internet. Data protection laws are not universal and so websites hosted in different countries may or may not have laws, which protect privacy of personal data.

Electronic processes replace physical contact and relationships. Customers are unable to touch and feel goods being sold on-line or gauge Voices and reactions of human beings

Limitations of e-commerce to society

Breakdown in human interaction. As people become more used to interacting Electronically there could be an erosion of personal and social skills, which Introduction to e-commerce 15 might eventually be detrimental to the world we live in where people are more comfortable interacting with a screen than face to face.

WHAT ARE THE BENEFITS OF E-COMMERCE?

2011-12-13T04:51:00.000-08:00

The previous sections have included discussions about what e-commerce is and its impact, but what are the benefits of e-commerce? What does it offer and why do it? The benefits of e-commerce can be seen to affect three major stakeholders: organizations, consumers and society.

Benefits of e-commerce to organizations

International marketplace. What used to be a single physical marketplace located in a geographical area has now become a borderless marketplace including national and international markets. By becoming e-commerce enabled, businesses now have access to people all around the world. In effect all e-commerce businesses have become virtual multinational corporations

Operational cost savings. The cost of creating, processing, distributing, storing and retrieving paper-based information has decreased (see Intel mini-case).

Mass customization. E-commerce has revolutionized the way consumers buy good and services. The pull-type processing allows for products and services to be customized to the customer’s requirements. In the past when Ford first started making motor cars, customers could have any colors so long as it was black. Now customers can conﬁgure a car according to their speciﬁcations within minutes on-line via the www.ford.com website.

Lower telecommunications cost. The Internet is much cheaper than value added networks (VANs) which were based on leasing telephone lines for the sole use of the organisation and its authorised partners. It is also cheaper to send a fax or e-mail via the Internet than direct dialling.

No more 24-hour-time constraints. Businesses can be contacted by or contact customers or suppliers at any time.

Beneﬁts of e-commerce to consumer

24/7 access. Enables customers to shop or conduct other transactions 24 hours a day, all year round from almost any location. For example, checking balances, making payments, obtaining travel and other information. In one case a pop star set up web cameras in every room in his house, so that he could check the status of his home by logging onto the Internet when he was away from home on tour

More choices. Customers not only have a whole range of products that they can choose from and customize, but also an international selection of supplier

Price comparisons. Customers can ‘shop’ around the world and conduct comparisons either directly by visiting different sites, or by visiting a single site where prices are aggregated from a number of providers and compared

Beneﬁts of e-commerce to society

Enables more ﬂexible working practices, which enhances the quality of life for a whole host of people in society, enabling them to work from home. Not only is this more convenient and provides happier and less stressful working environments, it so potentially reduces environmental pollution as fewer people have to travel to work regularly.

Facilitates delivery of public services. For example, health services available over the Internet (on-line consultation with doctors or nurses), ﬁling taxes over the Internet through the Inland Revenue website

Introduction of Electronic Commerce (E-Commerce)

2011-11-20T21:48:00.000-08:00

Introduction

Electronic commerce, commonly known as e-commerce, eCommerce or e-Comm., refers to

All the activities of purchase and sales of goods or services. Marketing, sales, payment, fulfillment, customer service
Electronic commerce is doing commerce with the use of computers, networks and commerce-enabled software (more than just online shopping)

Brief History

1970s: Electronic Funds Transfer (EFT)

Used by the banking industry to exchange account information over secured networks

Late 1970s and early 1980s: Electronic Data Interchange (EDI) for e-commerce within companies

Used by businesses to transmit data from one business to another

1990s: the World Wide Web on the Internet provides easy-to-use technology for information publishing and dissemination

• Cheaper to do business (economies of scale)

• Enable diverse business activities (economies of scope)

Benefits of Ecommerce

The primary benefits of ecommerce revolve around the fact that it eliminates limitations of time and geographical distance. In the process, ecommerce usually streamlines operations and lowers costs

E-commerce applications

Supply chain management
Video on demand
Remote banking
Procurement and purchasing
Online marketing and advertisement
Home shopping
Auctions

WEB MODELS

Pure-web play model where E-commerce plays only the role of an intermediary between server and buyers.
E-commerce portal combined with their own delivery system, which can be considered a counterpart to the standard store-chains except that points of sale exist only on the Web.
Click-an-mortar business model, where the e-commerce presence is developed as an extension to the physical store (-chain) presence.

Advantages of Electronic Commerce

Increased sales

– Reach narrow market segments in geographically dispersed locations

– Create virtual communities

Decreased costs

– Handling of sales inquiries

– Providing price quotes

– Determining product availability

Being in the space

Disadvantages of Electronic Commerce

Loss of ability to inspect products from remote locations
Rapid developing pace of underlying technologies
Difficult to calculate return on investment
Cultural and legal impediments

Upcoming Articles

2011-10-31T22:26:00.000-07:00

In coming few days we are going to Post articles to discuss all the practical steps needed to build an e-commerce site. Reveals how you can build a fully functional e-commerce site, which will support selling over the Internet, by following the development of an example Web site for a small business.

In the coming few days we will provide articles with excellent demonstration of full-featured e-commerce Web-site construction with the Microsoft suite of development tools.

Topics we are planning to cover in this are
COM and e-commerce object models, product catalog, shopping basket, checkout, order processing, promotions, certificates, pipeline construction, transaction management, deployment, e-mail integration, discussion groups, XML integration, and marketing tips.

So please keep visiting this blog

Calculate time taken in generating Page in the footer.

2011-10-30T06:39:00.000-07:00

Sometime we want to show total time taken by the page to process in the footer. As shown in the below image.

Here is a simple code which helps you to calculate the time taken by ASP page to get generated.

Dim dblStartTime 'Holds the start time for the page process%>

dblStartTime = Timer() 'The Timer function returns the number of seconds, and milliseconds, since 12:00 AM.

Response.Write(" Copyright ©2001-2011 <a href=""http://www.nebula-technology.com"" target=""_blank"">NEBULA TECHNOLOGIES (INDIA) PVT LTD.</a>")

Response.Write (" This page was generated in" & " " & FormatNumber(Timer() - dblStartTime, 3) & " " seconds "")

Components required for using Active Server Pages (ASP)

2011-08-30T05:52:00.000-07:00

This article discusses the components that you must have to use Microsoft Active Server Pages (ASP) technologies with Microsoft Office FrontPage 2003. Before you can view the results of ASP features in FrontPage, you must install the components that are listed in this article.

ASP technology is designed for Web servers that are based on Microsoft Internet Information Services (IIS). The following list shows the operating systems and the Web servers that are supported.

Note You must have IIS installed on the Web server to use ASP pages. If you upgraded to Microsoft Windows 2000, IIS 5.0 is installed by default only if IIS was installed on your earlier version of Windows.

Microsoft Windows XP

Microsoft Windows XP Professional with Microsoft Internet Information Services 5.1or later

Microsoft Windows 2000

Microsoft Windows 2000 Professional with Service Pack 3 (SP3) or later
Microsoft Windows 2000 Server, Advanced Server, or Data Center with Service Pack 3 (SP3) or later

Microsoft Windows Server 2003

Microsoft Windows Server 2003, 64-Bit Datacenter or Enterprise Edition
Microsoft Windows Server 2003, Datacenter, Enterprise, or Standard Edition
Microsoft Windows Server 2003, Web Edition

How to install IIS on your Web server

To install IIS on a Windows Server 2003-based computer, follow these steps.

Note You must have your Windows Server 2003 CD-ROM to follow these steps.

Click Start, click Control Panel, and then click Add or Remove Programs.
Click Add/Remove Windows Components to start the Windows Components Wizard.
Click Application Server, and then click Details to open the Application Server dialog box.
Click Internet Information Services (IIS), and then click Details to open the Internet Information Services (IIS) dialog box.
Click World Wide Web Services, and then click Details to open the World Wide Web Services dialog box.
Click to select the Active Server Pages check box to turn on ASP and IIS.
Click OK three times.
Click Next, and then click Finish

To install IIS on a computer that is running Microsoft Windows 2000 or Microsoft Windows XP Professional, see the IIS Help files. On Windows 2000, the IIS Help files are typically located in the following folder:

C:\WINNT\Help\IIS.CHM

On Windows XP Professional, the IIS Help files are typically located in the following folder:

C:\WINDOWS\Help\IIS.CHM

FrontPage Server Extensions

With FrontPage Server Extensions, the FrontPage client can communicate with a Web server, and you can author remotely. If you are running Windows Server 2003, do not download the server extensions. Instead, install the extensions by using the Add/Remove Programs tool in Control Panel. To do so, follow these steps:

Click Start, click Control Panel, and then double-click Add/Remove Programs
Click Add/Remove Windows Components, click Application Server, and then click Internet Information Services.
Click Next.
Follow the instructions on the remaining pages of the Windows Components Wizard.
After IIS is installed, start IIS, and then click Web Server Extensions.
Click Active Server Pages, and then click Allow
Click Front Page Server Extensions, and then click Allow

To install FrontPage Server Extensions 2000 on Windows XP or on Windows 2000, use the Windows installation CD. The steps resemble the steps for Windows Server 2003 that are described in the previous procedure

VBScript/ASP User-Defined Class Objects

2011-04-07T03:33:00.000-07:00

To define a user-defined Class Object, you use the Class statement to declare a class. The End Class statement defines the termination of the Class. Together, these statements form a Class construct, or Class block. E.g.

Class objName

‘ Place the Class variables, Properties and Methods here

End Class

In this syntax, objName is the name given to the Class Object. The class object name must follow standard VBScript variable naming conventions. Class Objects are usually declared in the variable definition sections. You can have multiple Class blocks in a single VBScript file, but each block must contain the Class …End Class statements. Classes cannot be nested.

Once you have defined the Class Object, you need to create an instance of the Class, similar to how other objects are created. When the Class Object is instantiated, memory is allocated for the Class Object. The Set statement is used with the New keyword to assign an instance of the class to a variable. With VBScript, this is the only time the New keyword is used (i.e. to instantiate a user-defined Class). E.g.

Dim MyObj

Set MyObj = New objName

The Object name MyObj is the Object variable name, and must follow standard VBScript variable naming conventions. The Object variable name is a reference (address) of the Object stored in memory, it is not the Object itself.

Inside the Class block, any Class variables, Properties, Methods and Events can be defined by the developer. The developer does not have to use all of the capabilities of the Class construct, i.e. Classes can be created without Methods or Properties. The design of the Class Object is completely up to the developer.

Class variables are created within the Class structure by using the Dim, Public, or Private statements. Variables defined within the Class structure by any of these statements must follow the standard VBScript variable naming conventions. Variables can be simple variables or arrays. E.g.

Class className

Dim var1, var2

Public var3, var4

Private var5, var6

End Class

The choice of the Dim, Public, or Private statements determine whether the variable is accessible outside of the Class Object. Variables are public by default, i.e. they are accessible outside of the Class Object. Both the Dim and the Public statements create public variables, while the Private statement creates variables that are not public. As a general rule, it is good programming practice to make all Class variables private, since the developer will want to tightly control when these variables are changed.

VBScript does not support Class-level Constants, i.e. named constants declared at the Class level. You cannot use the Const statement at the Class-level so that a constant can be used throughout a Class, but you can use the Const statement within a Property or Method. However, the constant will only have local scope within the Property or Method.

Class Object variables are accessible to VBScript code outside the Class through Class Properties. Class Properties “wrap” the Private variables of a Class. Inside the Class block, the Properties are defined by Property Get [|Let|Set] … End Property statement(s). For VBScript code outside the Class, the Property is accessed by referencing the Object Name.Property.

There are different types of Class Properties, depending on whether the Class variable is to be read, written to, or the Class variable is itself a Class Object. These Properties can be declared Public or Private.

Property Get

The Property Get procedure is used to access (return) private variables inside of the Class structure that are used as a read-only Property, or the read portion of a read-write Property. For VBScript code outside the Class, this type of Class Object Property is generally assigned to a variable or used in a conditional expression. The Property Get procedure returns a value to the calling code, and is general not used with any arguments. [Note: VBScript will let you add arguments to the Property Get procedure, but if you do so you must add the additional argument to the corresponding Property Let or Property Set procedure, since Property Let/Property Set must have one more argument than the corresponding Property Get procedure. It is generally considered bad programming form to have arguments in the Property Get procedure].

Property Let

The Property Let procedure is used to access (assign) private variables inside of the Class structure that are used as a write-only Property or are the write portion of a read-write Property. For VBScript code outside of the Class, this type of Class Object Property is usually assigned by a variable or a constant.

Property Set

The Property Set procedure is exclusively used when the Class Object needs to store

Properties that are object-based instead of numeric, date, boolean or string subtype variables. Property Set replaces the Property Let procedure. While Property Set and Property Let are functionally similar, there are two key differences:

With the Property Set procedure, in the VBScript code segment (outside the Class block) you must use the syntax

Set Object1.Property = Object2

This is because VBScript does not let you use the assignment operator (=) to assign objects without the Set command.

The Property Set procedure makes it clear that the Property is an object-based Property

Example:

Class FileSpec ‘ Define a Class block

Private master_file

Private master_FSO

Public Property Let FileName(strName) ‘ Define a Public Property to assign the file name

master_file = strName

End Property

Public Property Get FileName ‘Define a Public Property to retrieve a file name

FileName = master_file

End Property

Public Property Set FSO(m_FSO) ‘ Define a Public Property for an object

Set master_FSO = m_FSO

End Property

End Class

Rem Below is the VBScript code

Dim objFSO ‘ Declare variables and objects

Dim objFilePointer, cur_file

Set objFSO = CreateObject(“Scripting.FileSystemObject”)

Set objFilePointer = New FileSpec

objFilePointer.FileName = “Myfile.mdb”

cur_file = objFilePointer.FileName

Set objFilePointer.FSO = objFSO ‘ Assigns an Object to the Property

Set objFilePointer = Nothing ‘ Keyword Nothing releases the object memory

A couple notes on the example above. The CreateObject command is used to instantiate an Object that is known at the system level (e.g. a COM object). Also, so far this example only shows how to assign and retrieve property values. It is generally the Method(s) that control the action an object performs, not the properties.

A Property can be made read-only by only providing a Property Get procedure, or by declaring the Property Let procedure as Private instead of Public. A Property can be made write-only by only providing the Property Let procedure, or by declaring the Property Get procedure as Private instead of Public.

Class Methods are really just Functions and Subroutines inside of a Class block. These functions and subroutines can be either Private or Public. If they are public, they will be accessible to a VBScript code segment outside of the Class block by referencing the obj.Method. If they are private, they will only be available to code within the Class block.

An example of Class Methods is as follows:

Class FileSpec

Private master_file

Private master_FSO Private master_file

Private Sub Class_Initialize ‘ Class Object initialization code

‘ code goes here

End Sub

Private Sub Class_Terminate ‘ Class Object termination code

‘ code goes here

End Sub

Public Property Let FileName(strName) ‘ Define a Public Property to assign the file name

master_file = strName

End Property

Public Property Get FileName ‘ Define a Public Property to retrieve a file name

FileName = master_file

End Property

Public Property Set FSO(m_FSO) ‘ Define a Public Property for an object

Set master_FSO = m_FSO

End Property

Public Sub Delete ‘Method to delete the master file

master_FSO.DeleteFile (master_file)

End Sub

End Class

Rem Below is the VBScript code

Dim objFSO ‘ Declare variables and objects

Dim objFilePointer, cur_file

Set objFSO = CreateObject(“Scripting.FileSystemObject”) Set objFilePointer = New FileSpec ‘ Instantiate the Class Object

objFilePointer.FileName = “Myfile.mdb”

cur_file = objFilePointer.FileName

Set objFilePointer.FSO = objFSO ‘ Assigns an Object to the Property

objFilePointer.Delete ‘ Executes a Method to delete a file

Set objFilePointer = Nothing ‘ Keyword Nothing releases the object memory

VBScript Class Objects automatically supports two type of Class Events; Class_Initialize and Class_Terminate Events. The code inside the Class_Initialize event executes once when an Object based on the Class is first instantiated. Any code put in this event is optional, and is typically used for initialization. Code inside the Class_Terminate event executes once just before the Object based on the

Class is destroyed (i.e. Set to Nothing, or the Object goes out of scope). Usage is as follows:

Class FileSpec

Private master_file

Private master_FSO Private master_file

Private Sub Class_Initialize ‘ Class Object initialization code

‘ code goes here

End Sub

Private Sub Class_Terminate ‘ Class Object termination code

‘ code goes here

End Sub

Public Property Let FileName(strName) ‘ Define a Public Property to assign the file name

master_file = strName

End Property

Public Property Get FileName ‘ Define a Public Property to retrieve a file name

FileName = master_file

End Property

Public Property Set FSO(m_FSO) ‘ Define a Public Property for an object

Set master_FSO = m_FSO

End Property

End Class

VBScript Object Commands

2011-04-07T00:36:00.000-07:00

VBScript includes several Functions and Statements that can be used to access objects, including their methods and properties. There are a large variety of objects available to VBSript, including user defined objects, intrinsic objects and extrinsic objects.

VBScript Object Functions

CreateObject Creates and returns a reference to an Automation object

GetObject Returns a reference to an Automation object from a file

IsObject Returns a Boolean value indicating whether an expression references a valid Automation object.

Object Statements

Class Declares the name of a class, as well as a definition of the variables, properties, and methods that comprise the class

Exit Property Forces an exit from inside a Property Set function.

For each…Next repeats a group of statements for each element in an array or a collection.

Property Get Declares, in a Class block, the name, arguments, and code that form the body of a Property procedure that gets (returns) the value of a property

Property Let Declares, in a Class block, the name, arguments, and code that form the body of a Property procedure that assigns (sets) the value of a property

Property Set Sets a reference to an object

Set Assigns an object reference to a variable or property, or associates a procedure reference with an event. Usually used to instantiate an object.

Error Handling Statements

On Error Enables or disables error-handling

Object & Collection Summary

Debug The Debug object is an intrinsic global object that can send an output to a script debugger, such as the Microsoft Script Debugger.

Dictionary An associative array that can store any type of data. Data is accessed by a key.

Drives A collection of Drive objects.

Err Contains information about the last run-time error. Accepts the Raise and Clear
methods for generating and clearing run-time errors.

File An object that refers to a specific File

Files A collection of File objects.

FileSystemObject An object model used to access the Windows file system

Folder An object that refers to a specific Folder

Folders A collection of Folder objects.

Match Provides access to the read-only properties of a regular expression match.

Matches Collection of regular expression Match objects.

RegExp Provides simple regular expression support.

Submatches A collection of regular expression submatch strings.

TextStream An object that refers to a text File

Objects and Classes

2011-04-06T21:15:00.000-07:00

Traditional programming is made up of a collection of subroutines and functions that are typically processed in a sequential or looping manner. In contrast, object oriented programming is a different programming methodology where a program is viewed as being composed of a collection of individual objects. These objects process data and can interact with other objects directly without having to be explicitly programmed to do so. The advantages claimed by object-oriented program include code reusability, rapid deployment of large-scale complex tasks, and ease of use/debugging. Today, objectoriented programming is widely used and is supported with both programming languages (e.g. VB.NET, C++, Visual C++) and operating systems (e.g. Microsoft’s .NET architecture). Object-oriented programming has also become popular within scripting languages, such as VBScript. Beginning with VBScript 5.0, developers have been able to use user-defined Classes.

The key concepts with object-oriented programming include:

• Class

The class is the highest level that defines a unit (set) of data and its behavior. Classes form the basis for modularity and structure in an object-oriented program. The class should sufficiently describe the set of data, and the code for a class should be contained within it and be selfsufficient (except for operating system support). While the terms classes and objects often get used interchangeably, classes describe the structure of objects. One way to think of a class is that it is a container for code. It can also be viewed as a template for an object. When a class is declared (instantiated) by the Set statement, it then becomes an object and memory is allocated for it.

• Object

An object is an in-memory instance of a class. In computer science terms, it is a run-time manifestation (instantiation) of a particular exemplar of a class. Each object has its own data, but the code within a class can be shared (for efficiency). Programs generally have multiple objects. Multiple copies (objects) of a given class can be created. Objects are temporary, i.e. they can be created and removed at will, depending on the programming needs.

• Encapsulation

Encapsulation wraps the data and functions into a single unit, ensuring that the object can be changed only through established interfaces. Encapsulation is sometimes referred to as information hiding. Some of these common interfaces are:

o Fields

Fields are simply public variables stored within the object, as defined by the class. These variables store items of information about an object.

o Properties

Properties, like fields, also store items of information on an object. But Properties use Property procedures to control how values are set or returned. VBScript has two primary Property procedures; Let and Get. The Get property procedure retrieves a Property value, while the Let Property procedure assigns a value to the property value. A third Property procedure Set is used with an Object inside of the Class block.

o Methods

Methods are a collection of subroutines (Sub) and function procedures (Function) declared within a class.

o Events

An event is a message sent by an object announcing that something important has happened. followed by a period, then the particular method, property or field of interest. E.g.

Object.Method

Object.Property

Object.Property.Item

• Dynamism

Dynamism relates to the method of allocating computer resources and definition resources required to run an object-oriented program. There are different types, but VBScript used latebound (late-binding) dynamic typing. This means that the VBScript engine will make the object type determination at runtime and allocate sufficient memory at that time. Note that VBScript and VB.NET are slightly different in their approach to dynamism, and therefore they can declare some variables and objects in different manners (although many forms of declaration are the same).

• Outlet Connections

At times, Objects will connect together and this connection needs to be defined. With IWS, an example of a connection would be between a VBScript object (e.g. ADODB) and a Database Provider (a Provider is a front-end to a database). This connection needs to be defined, and then the connection string (of parameters) between the objects gets defined. When the need for the connection is finished, the connection should be closed.

While a full treatment of object-oriented programming is beyond the scope of these materials, the fundamental concepts of Objects and Classes are important to understand. VBScript supports COMbased Objects (Component Object Module, a Microsoft standard) such as the ActiveX controls, ADO.NET, FileSystemObject, and Microsoft Office Automation objects. VBScript also supports userdefined classes, or Class Objects. VBScript COM objects and VBScript Class objects differ from each other in several important respects. These differences lead to each type of object having its unique strengths:

• VBScript classes are more flexible than VBScript COM objects. Class Objects have an abstract subtype that encapsulates the data you want and the functions you need to work with that data. VBScript COM objects have only basic subtypes (integer or string).

• VBScript classes are slightly more efficient than COM objects. The VBScript parser can execute the classes' code directly instead of asking the COM object to execute a method.

• COM objects are binary modules. VBScript classes are ASCII files.

• You can use any scripting language to write COM objects. You can only use VBScript to write VBScript classes.

• You can use COM objects from within any development environment that supports COM automation. VBScript classes can only be used within development and runtime environments that support VBScript (e.g IWS and Microsoft Internet Explorer).