N342 ASPx Code Behind

• Basics
• ASP
• ASPx
• Database
  • Permissions
  • Reading
  • Writing
• DataGrid

Basics

We have seen that mixing the user interface (HTML) with the programming logic (JavaScript, etc.) looks bad and is bad; difficult to write and to maintain. We've seen (or will) that the two can be separated using industry standard technologies of XML, XML and JavaScript. Microsoft has developed a technology that is part of what they call .NET, known as the code-behind approach.

The basic idea is to write user interface operations as JavaScript (or other language) functions that are callable from HTML.

ASP

Mixing the user interface (HTML) with the programming logic (JavaScript, etc.) is one approach. Below is a typical ASP example which we'll redo later in ASPX.

When the submit button is clicked, the HTML submits the form to the server ASP program which examines the iceCream radio buttons to determine the input.

The Request is used to examine user inputs.

The Response is used to write to the browser.

On the browser, the above appears as below after submitting.

URL: simple.asp?name=Ray&iceCream=Yes

Name: Do you like ice cream? Yes: No: Ray likes ice cream.

ASPx (from Deitel 3rd ed.)

Redoing the above in ASPX.

User interface (simple.aspx at left) is defined by mixed HTML and <asp> tags referencing user interface controls.

For example, a radio button list named iceCream with Yes/No options are displayed by:

 <asp:RadioButtonList id = "iceCream" runat = "server">
         <asp:ListItem>Yes</asp:ListItem>
         <asp:ListItem>No</asp:ListItem>
</asp:RadioButtonList>

The browser displayed iceCream control can be accessed in the code-behind.

Logic (simple.aspx.js at right) runs on the server. In this case, the only logic is to handle the form submit button click. The iceCream control is accessed to determine

The server translates the <asp> tags into HTML and JavaScript which are sent to the browser.

The server generates and sends to the browser mixed HTML and JavaScript (partial listing at left) to produce the user interface (at right).

For comparison:

Compiling

The code-behind is compiled automatically by the IIS server the first time accessed or compiled by hand below.

To compile the above example using Microsoft Visual Studio .NET 2003:

Open a command prompt. Change the directory to the location of the js (JScript) file. Define the .NET SDK path variables, for Visual Studio 2003 it is done by: C:"\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin\sdkvars.bat"   Compile simple.aspx.js jsc /t:library /out:simple.dll simple.aspx.js

Testing

In the browser address bar enter the location of simple.aspx file containing the HTML and <asp> tags. Assuming the simple.aspx and simple.aspx.js files are located on virtual directory N342 of homepages.ius.edu:

http://homepages.ius.edu/username/n342/simple.aspx

Benefits/Drawbacks

Code-behind appears to be more work, we had to write an ASPX and a JavaScript file that also had to be compiled; so what's the payoff?

1. Separating the GUI (simple.aspx) and logic (simple.aspx.js).
    
2. More abstract and powerful GUI objects. The <asp> tagged objects can be controlled by parameters to produce a variety of functions.
    
3. It is possible to develop your own <asp> objects.
    
4. The resulting HTML produced is reasonably generic, working on most browsers.
    
5. Can use a variety of Microsoft .NET languages (JavaScript, C#, Visual Basic).
    
6. A lot of Web development is done in ASPX.

The main drawbacks are:

1. Whereas the client XML/XSL and server ASP as used in class can be tested independently, the client/server code must be tested together, as a single unit. Harder to split user interface and logic development.
    
2. Code-behind generates code that you do not directly control, debugging can be challenging.
    
3. Microsoft controls the complete package of <asp> objects and languages rather than the industry in general.
    
4. Learning to use Microsoft objects doesn't transfer well to other platforms (e.g. servers other than IIS).

Databases

.NET has changed database use somewhat to distinguish between database server (such as SQL Server or Oracle) and Access-type databases. We will only examine Access database use.

Note that homepages.ius.edu site is configured for use with .NET and Access.

Permissions

To write to the database, ASPNET must be given the necessary level of permission to make changes to the directory where the Access database is located.

Failure to grant sufficient permission for Update, Insert or Delete operations result is "Operation must use an updateable query" error.

To grant permission to ASPNET to change files in a directory:

1. Open My Computer.
2. Locate the directory (e.g. C:\Project).
3. Right click on the directory and select Properties.
4. Click on the Security tab.
5. Add ASPNET.
6. Grant ASPNET Full Control.

Reading

First, ADO can still be used as long as the ASPx file specifies that the page is to be used in ASP compatibility mode, which reduces threading and the performance of the server.

The following displays the ID of all in the Trader table using ADO.

Accessing database records in non-compatibility mode is somewhat different than before.

The following assumes the Project.mdb and ASPx files in the same directory. The code-behind reads each record from the Trader table and prints the ID field value by:

1. Connecting to the Access DB Project.mdb file.
2. Creating a data adapter  and executing an SQL Select on the connected Access DB.
3. Creating a dataset named "simple".
4. Filling a data table with the selected records from the Trader table.
5. Iterating over all data rows in the data table (i.e. dataTable.Rows.Count) and writing out the ID field of each data row.

Writing

Writing database records is simple though ASPNET must have permission to write to the directory containing the Access database file.

The following inserts a record into the Trader table by:

1. Connecting to the Access DB Project.mdb file.
2. Creating a data table as above except, that with only a single table, can reference by index 0 (i.e. ds.Tables[0]).
3. Verifying that ID='Ray' is not in data table.
4. If not already in table, executing an SQL Insert on the connected Access DB.

DataGrid

Tables are often part of the user interface. To automate table generation from a database, the GUI object DataGrid can be used.

Notice that the two files refer to the same dataGrid object. The ASPx defines the object <asp:DataGrid and the code-behind fills from the database.

The following displays the ID and Balance from the Trader table by:

1. Establishing a connection to the Project.mdb Access file in the directory containing the datagrid.aspx file.
2. Executing the SQL on the connected database.
3. Filling the data set from the resulting table(s).
4. Binding the data set to the DataGrid object.