Obtener Datos Del Servidor Sin PostBack

Obtener datos del servidor sin
PostBack
Obtener datos de forma rápida
Antes que nada un saludo a todos.
En este artículo trate de ser lo más explícito para explicar una solución al
problema que todos hemos tenido algún día ¡PostBack!, cuántas veces hemos
querido recuperar datos del servidor sin hacer un postback como por ejemplo
llenar una lista o validar algún dato.
Imaginen si tienen una página que pesa 65k y en alguna validación nenecita ir
al servidor por un solo dato de no más de 15 caracteres woow esto es un
trabajo difícil no creen y si requiere ir 5 veces estaríamos hablando de algo así
como 325k cuando solo ocuparon la cantidad de 75 caracteres como 0.1k, sin
contar lo molesto que es para el usuario estar viendo cómo se recarga la
página cada vez que se requiere una validación.
Buscando en Internet me he topado con muchas soluciones para esto pero

creo que una de las más elegantes y poderosas ya que puedo ir al servidor si
hacer un refresh de la página y sin perder la sesión. Este artículo se basa en
JavaScript pero mostrare ejemplos en VB.Net y C# de cómo es posible
utilizarlo.
El script es simple:
<SCRIPT LANGUAGE="JavaScript">
var _xmlhttp;
/*@cc_on @*//*@if (@_jscript_version >= 5)
var idAX =
["Msxml2.XMLHTTP.5.0","Msxml2.XMLHTTP.4.0","Msxml2.XMLHTTP.3.0","M
sxml2.XMLHTTP","Microsoft.XMLHTTP"];
for(var i=0; !_xmlhttp && i<idAX.length; i++)
{try{ _xmlhttp = new ActiveXObject(idAX[i]);}
catch(ex) { _xmlhttp = false; }
}@end @*/
if (!_xmlhttp && typeof XMLHttpRequest!='undefined') {
_xmlhttp = new XMLHttpRequest();
}
function xmlRead(url)
{
if(_xmlhttp)
{
/**
onreadystatechange:
evento que se disparara cuando el estado cambia le asignamos un
delegado
*/
_xmlhttp.onreadystatechange = processReqChange;
/**
open:
primer parametro: Se puede especificar distintos comandos como
GET, HEAD, etc.
segundo parametro: Direccion relativa de nuestro sitio.
tercer parametro: sincrono - asincrono
*/
_xmlhttp.open("GET", url, true);
/**
send:
envia la peticion
*/
_xmlhttp.send();
}
}
function processReqChange()
{
/**
readyState:
0 = sin inicializar
1 = cargando
2 = cargado
3 = interactivo
4 = completo
*/
if (_xmlhttp.readyState == 4) {
/**
status:
Numero de respuesta del servidor ejemplo
200 = OK
404 = Not Found
*/
if
(_xmlhttp.status == 200) {
alert(_xmlhttp.responseText);
} else {
alert('Se genero un error:\n' +
_xmlhttp.statusText);
}
}
}
</SCRIPT>
Entender el script es simple está dividido en 3 zonas principales:

La primera es únicamente para IE los demás exploradores no tomaran en
cuenta esta parte.
/*@cc_on @*//*@if (@_jscript_version >= 5)

var idAX =
["Msxml2.XMLHTTP.5.0","Msxml2.XMLHTTP.4.0","Msxml2.XMLHTTP.3.0","M
sxml2.XMLHTTP","Microsoft.XMLHTTP"];
for(var i=0; !_xmlhttp && i<idAX.length; i++)
{try{ _xmlhttp = new ActiveXObject(idAX[i]);}
catch(ex) { _xmlhttp = false; }
}@end @*/
Este código trata de hacer una instancia del objeto XMLHTTP pero según
versiones ha tenido diferentes nombres y tratamos de localizar cual es y crear
la instancia. (Solo aplica para IE) .
La siguiente parte es usada por otros navegadores como Mozilla.
if (!_xmlhttp && typeof XMLHttpRequest!='undefined') {

_xmlhttp = new XMLHttpRequest();
}
Primero valida si el objeto ha sido instanciado y si no trata de crearlo.

Y en la última sección se especifica la función que recibirá la URL relativa de
donde obtendremos la información. El objeto _xmlhttp ya está inicializado y
únicamente le asignamos un delegado que se encargara de utilizar la
información que recibimos del servidor
function xmlRead(url)
{
if(_xmlhttp)
{
/**
onreadystatechange:
evento que se disparara cuando el estado cambia le asignamos un
delegado
*/
_xmlhttp.onreadystatechange = processReqChange;
/**
open:
primer parametro: Se puede especificar distintos comandos como
GET, HEAD, etc.
segundo parametro: Direccion relativa de nuestro sitio.
tercer parametro: sincrono - asincrono
*/
_xmlhttp.open("GET", url, true);
/**
send:
envia la peticion
*/
_xmlhttp.send();
}
}
function processReqChange()
{
/**
readyState:
0 = sin inicializar
1 = cargando
2 = cargado
3 = interactivo
4 = completo
*/
if (_xmlhttp.readyState == 4) {
/**
status:
Nuemero de respuesta del servidor ejemplo
200 = OK
404 = Not Found
*/
if
(_xmlhttp.status == 200) {
alert(_xmlhttp.responseText);
} else {
alert('Se genero un error:\n' +
_xmlhttp.statusText);
}
}
}
Con este script dentro del head de nuestra pagina de donde nesecitamos ir al
servidor por datos ya estaría casi lista para poder hacer esto. Ahora lo
siguiente es crear la página de prueba. Agregamos un botón de html (no
agreguen un botón de .net ya que los botones de .Net realizan un postback.) y
en el evento onclick mandamos llamar la función xmlRead('Nombre de la
pagina? lista de parámetros') un ejemplo:
<INPUT id="PostBack" type="button" value="Button"

onclick="xmlRead('Controladora.aspx?ID=21');">
Aquí observamos una pagina que se llama Controladora.aspx y un parámetro

ID con valor de 21. Es ese ejemplo le estoy pasando un dato fijo pero se podría
tomar de alguna caja de texto por ejemplo:
<asp:TextBox id="txtTemp" runat="server"

width="350px"></asp:TextBox>
<INPUT id="PostBack" type="button" value="Button"
onclick="xmlRead('Controladora.aspx?ID=' +
document.all['txtTemp'].value);">
Con la caja de texto y un botón apuntando a la función xmlRead lo que sigue

es crear la pagina controladora que será la encargada de evaluar y responder
la solicitud enviada. Creamos una nueva pantalla Web con el nombre de
Controladora.aspx estas pantalla será la encargada de evaluar y responder las
peticiones que nesecitemos del servidor. Para ello es necesario ir a la vista
html de la pantalla y borrar todas las líneas excepto la primera para que nos
quede alo así:
Para C#:
<@= Page language="c#" Codebehind="Controladora.aspx.cs"
AutoEventWireup="false" Inherits="Prueba.Controladora" >
Para VB.Net:
<@= Page language="vb.net" Codebehind="Controladora.aspx.vb"
AutoEventWireup="false" Inherits="Prueba.Controladora" >
Ahora nos vamos a su código y en el evento load del formulario de la pantalla

Controladora hacemos una función para que obtenga el valor del ID y nos
regrese un resultado.
Para C#
private void Page_Load(object sender, System.EventArgs e)

{
string id = Request.QueryString["ID"];
int reg = 0;
try
{
reg = Int32.Parse(id); //Lo convertimos en numero
}
catch (Exception ex)
{
Response.Write("Respuesta sin PostBack: no es un
numero");
return; //Salimos de la funcion

}
switch (reg)
{
case
1:
Response.Write("Respuesta sin PostBack: Numero
Uno");
break;
case
2:
Dos");
break;
case
3:
Tres");
break;
case
4:
Cuatro");
break;
default:
Response.Write("Respuesta sin PostBack: Otro
Numero");
break;
}
}
Para VB.Net
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles MyBase.Load
Dim id As String =
Request.QueryString.Item("ID").ToString()
Dim reg As Integer = 0
Try
reg = Integer.Parse(id)
Catch ex As Exception
Response.Write("Respuesta sin PostBack: no es un
numero")
Exit Sub 'Salimos de la funcion
End Try
Select Case reg

Case 1
Uno")
Case 2
Dos")
Case 3
Tres")
Case 4
Cuatro")
Case Else
Response.Write("Respuesta sin PostBack: Otro
Numero")
End Select
End Sub
Con este codigo en la pantalla controladora, el script en la pantalla de prueba
lo único que falta es probarlo :). Recuerden que la sesión no se pierde siempre
y cuando hagan referencia a la pagina controladora de forma relativa esto
quiere decir no pongan la ruta completa sino como cuando insertan una
imagen algo así como /Pantallas/Controladora.aspx o ../Controlador/BD.aspx
algo así mucha suerte cualquier duda envíenme un mail.
Espero que este articulo les sirva como a mi me sirvió Gracias.
Working with MSDTC
Introduction
If you tried to search for MSDTC, the first result will describe MSDTC as an acronym for Microsoft
Distributed Transaction Coordinator. As the name says, MSDTC is a Windows service providing
transaction infrastructure for distributed systems. In this case, a transaction means a general way of
structuring the interactions between autonomous agents in a distributed system. However, in my simple
definition, it is a service from Microsoft that you need to deal with whenever you want to do transaction
processing, and it is very hard to identify and troubleshoot any of the problems that you may face while
interacting with it.
Background
Doing transaction processing in your code is a very simple to do task, all that it needs to surround the
part that you want to be executed as one transaction with one Transaction scope and commit it whenever
you finish all parts.
But with the default setup on your machine, most likely you will end up with the below common
MSDTC error:
Hide Copy Code

Network access for Distributed Transaction Manager (MSDTC) has been disabled.
Please enable DTC for network access in the security configuration for MSDTC using the
Component Services Administrative tool.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Inner Exception:
The transaction manager has disabled its support for remote/network transactions.
(Exception from HRESULT: 0x8004D024)
Using the Code

However, because of number of elements inside your and the server environment / network / firewall,
which will interfere with MSTDC, and the lack of clear error reporting from the DTC itself, this task
will become much harder.
Basic Setup
Since the most common scenario is to have Database / Application servers, having your code working
fine on your machine does not means that it work fine once you deploy it on the server. When you
connect to another server or DB server, that server needs to enable Distributed Transaction for network
access on it as well.
Below are some of the basic setups that must you need do first in order for the MSDTC to work fine:
Still Not Working?
If you are trying to connect to another server, and you are getting an error simillar to the below, this
means that its time to start cross machines investigation. follow the below steps to do more investigation
about why it is not working.
Hide Copy Code

Communication with the underlying transaction manager has failed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Inner Exception:
The MSDTC transaction manager was unable to pull the transaction from the source
transaction manager
due to communication problems. Possible causes are: a firewall is present and it doesn't
have an
exception for the MSDTC process, the two machines cannot find each other by their NetBIOS
names,
or the support for network transactions is not enabled for one of the two transaction
managers.
(Exception from HRESULT: 0x8004D02B)
Port 135
MSDTC uses port 135 to connect to other servers; a simple telnet command on port 135 should help you
identify the problem, the command should be executed from both machines, as the port should be
opened for both directions.
In the below example, let's imagine that your server IP address is "10.10.10.1" and your IP address is
"10.10.10.2", both commands below should be working fine.
From your machine:
Hide Copy Code

telnet 10.10.10.1 135
From server:
Hide Copy Code

telnet 10.10.10.2 135
IP Address vs Machine Name
You need to make sure that both machines see each other using the same IP address, this problem
usually occurs due to some domain configuration where they disable IP Address resolving within the
network.
In order to identify this problem, you need to compare the results from running " IPconfig" command
on machine A and a ping to the same Machine. The output IP address should be matching. In case it’s
not, you need to modify the host server on machine B to have the IP corrected.
In the below example, let's imagine that your server IP address / name is " 10.10.10.1 / Server1"
and your IP address / name is "10.10.10.2 / MyMachine".
From Your Machine
Hide Copy Code

C:\>Ipconfig
//you will get results similar to
Ethernet adapter Ethernet:
Connection-specific DNS Suffix . : x.com

IPv4 Address. . . . . . . . . . . : 10.10.10.2
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Default Gateway . . . . . . . . . : 10.10.10.x
From Server
Hide Copy Code

C:\>ping MyMachine
Pinging ENPAYSAFEDEVDB [10.10.10.2] with 32 bytes of data:

Reply from 10.10.10.2: bytes=32 time=1ms TTL=127
Reply from 10.10.10.2: bytes=32 time<1ms TTL=127
The IP address should match, if not, the host file needs to be changed on server.
Hide Copy Code

# localhost name resolution is handled within DNS itself.
# 127.0.0.1 localhost
# ::1 localhost
10.10.10.2 MyMachine
Track Your Transactions
In order to exactly figure out what is happening, you need to track where your transaction is stuck at, the
below methods can help you in this process:
If you are using SQL server, it is very easy to identify if the transaction has reach the database side or
not. To do so, the below SQL command needs to be executed:
Hide Copy Code

SELECT * FROM sys.sysprocesses WHERE open_tran = 1
The output will be something similar to:

The main keys listed below will help you understand this output:
 lastwaittype: Check this reference to show what every waittype exactly means.
 status: Current status for this transaction.
 hostname: The source server/machine of this transaction.
 cmd: The current command for the transaction is as follows:
While Connecting Running
When Connect Completed Sleeping / Awaiting Command
Query e.g. select "1" Running
When select completed Sleeping / Awaiting Command
At your side, you can also see the transactions from Component Services >> local DTC screen as
follows:
This screen also give the option to "Commit", "Abort" and "Forget" this transaction.
DTCPing
DTCPing is very helpfull tool which can be downloaded directly from Microsoft website, this tool can
assist you trhough debugging and diagnosing DTC issues, as it can simulate a DTC between two
machines.
DTCPing can be downloaded from:
https://www.microsoft.com/en-us/download/details.aspx?id=2868
Using LINQ for type Conversion
Introduction
.NET provides several ways to change the type of a value to another type at run-time. Each technique
has its limitations. This article provides (yet) another alternative that works in all instances when the
CLR is capable of performing a type cast.
Background
Two popular solutions to the problem of type conversion are to use System.Convert.ChangeType,
or to obtain System.ComponentModel.TypeConverter and call its ConvertFrom method. The
first method breaks when you try converting a value type T to System.Nullable<T>; the second one
breaks when you try converting different numeric types, for example, float to double. These
limitations appear especially frustrating, because the CLR has built-in capabilities to perform both types
of conversion.
One way of using these type casting capabilities is to build a LINQ lambda expression, compile it into a
Func<object,object>, and then use the compiled delegate every time we need to convert between
two types.
Using the Code

The code below implements this approach, wrapping it into an extension method of System.Type.
Hide Shrink Copy Code

public static class TypeCast {
// This is the method exposing the rest of the functionality
public static object Cast(this Type type, object obj) {
return GetConverter(type, obj)(obj);
}
private static readonly IDictionary<PairOfTypes,Func<object,object>> converters =
new Dictionary<PairOfTypes,Func<object,object>>();
private static readonly ParameterExpression convParameter =
Expression.Parameter(typeof(object), "val");
// This is the method with the "guts" of the implementation
[MethodImpl(MethodImplOptions.Synchronized)]
private static Func<object,object> GetConverter(Type targetType, object val) {
var fromType = val != null ? val.GetType() : typeof(object);
var key = new PairOfTypes(fromType, targetType);
Func<object,object> res;
if (converters.TryGetValue(key, out res)) {
return res;
}
res = (Func<object,object>)Expression.Lambda(
Expression.Convert(
Expression.Convert(
Expression.Convert(
convParameter
, fromType
)
, targetType
)
, typeof(object)
)
, convParameter
).Compile();
converters.Add(key, res);
return res;
}
// This class provides Equals and GetHashCode
// for a pair of System.Type objects.
private class PairOfTypes {
private readonly Type first;
private readonly Type second;
public PairOfTypes(Type first, Type second) {
this.first = first;
this.second = second;
}
public override int GetHashCode() {
return 31*first.GetHashCode() + second.GetHashCode();
}
public override bool Equals(object obj) {
if (obj == this) {
return true;
}
var other = obj as PairOfTypes;
if (other == null) {
return false;
}
return first.Equals(other.first)
&& second.Equals(other.second);
}
}
}
Now, you can use the Cast method like this:

Hide Copy Code
double? x = typeof(double?).Cast(1.0);
int y = typeof(int).Cast(1.2345);
Happy coding!
GridView all in one

Download source code - 21.6 KB
Introduction
I have seen lot of beginners struggle with GridView and it is not working. To solve this to
some extent, I have created an application with most of the events and properties of
GridView. This may be helpful for getting a clear idea about working with GridView. This
application also has a few JavaScript code snippets and stylesheets which may be useful to
add some values to the GridView. Hope this article will be simple and sufficient.
What is a GridView?
The DataGrid or GridView control displays data in tabular form, and it also supports
selecting, sorting, paging, and editing the data inside the grid itself. The DataGrid or
GridView generates a BoundColumn for each field in the data source
(AutoGenerateColumns=true). By directly assigning the data source to the GridView, the
data can be rendered in separate columns, in the order it occurs in the data source. By
default, the field names appear in the grid's column headers, and values are rendered in text
labels. A default format is applied to non-string values and it can be changed.
GridView Fields
Column Name Description
To control the order and rendering

BoundColumn
of columns.
Presents the bound data in

HyperLinkColumn
HyperLink controls
Bubbles a user command from

ButtonColumn within a row to the grid event
handler
TemplateColumn Controls which controls are
Column Name Description
rendered in the column
Displays Edit, Update, and Cancel

links in response to changes in the
CommandField
DataGrid control's
EditItemIndex property.
BoundColumn
By explicitly creating a BoundColumn in the grid's Columns collection, the order and
rendering of each column can be controlled. In the BoundField properties, when the
DataField and the SortExpressions are given, sorting and rendering the data can be
easily done.
HyperLinkColumn
A HyperLinkColumn presents the bound data in HyperLink controls. This is typically used
to navigate from an item in the grid to a Details view on another page by directly assigning
the page URL in NavigationUrl or by rendering it from the database.
TemplateColumn
With a TemplateColumn, the controls which are rendered in the column and the data fields
bound to the controls can be controlled. By using the TemplateColumn, any type of data
control can be inserted.
By clicking the Edit Templates option, it opens the Template field where we can see
controls that can be added like Label, CheckBox, and even a GridView.
CommandField
The EditCommandColumn is a special column type that supports in-place editing of the data
in one row in the grid. EditCommandColumn interacts with another property of the grid:
EditItemIndex. By default, the value of EditItemIndex is -1, meaning none of the rows
(items) in the grid are being edited. If EditItemIndex is -1, an "edit" button is displayed in
the EditCommandColumn for each of the rows in the grid.
When the "edit" button is clicked, the grid's EditCommand event is thrown. It's up to the
programmer to handle this event in the code. The typical logic sets EditItemIndex to the
selected row, and then rebinds the data to the grid.
When EditItemIndex is set to a particular row, the EditCommandColumn displays "update"

and "cancel" buttons for that row ("edit" is still displayed for the other rows). These buttons
cause the UpdateCommand and CancelCommand events to be thrown, respectively.
Different Types of Events
Name Description
Occurs when the server control binds to a data source.

DataBinding
(Inherited from Control.)
Occurs after the server control binds to a data source.

DataBound
(Inherited from BaseDataBoundControl.)
Occurs when a server control is released from memory, which

Disposed is the last stage of the server control lifecycle when an ASP.NET
page is requested. (Inherited from Control.)
Occurs when the server control is initialized, which is the first

Init
step in its lifecycle. (Inherited from Control.)
Occurs when the server control is loaded into the Page object.
Load
Occurs when one of the pager buttons is clicked, but after the
PageIndexChanged
GridView control handles the paging operation.
PageIndexChanging Occurs when one of the pager buttons is clicked, but before the
Name Description
GridView control handles the paging operation.
Occurs after the Control object is loaded but prior to

PreRender
rendering. (Inherited from Control.)
Occurs when the Cancel button of a row in edit mode is

RowCancelingEdit
clicked, but before the row exits edit mode.
RowCommand Occurs when a button is clicked in a GridView control.
RowCreated Occurs when a row is created in a GridView control.
Occurs when a data row is bound to data in a GridView

RowDataBound
control.
Occurs when a row's Delete button is clicked, but after the

RowDeleted
GridView control deletes the row.
Occurs when a row's Delete button is clicked, but before the

RowDeleting
GridView control deletes the row.
Occurs when a row's Edit button is clicked, but before the

RowEditing
GridView control enters edit mode.
Occurs when a row's Update button is clicked, but after the

RowUpdated
GridView control updates the row.
Occurs when a row's Update button is clicked, but before the

RowUpdating
GridView control updates the row.
Occurs when a row's Select button is clicked, but after the

SelectedIndexChanged
GridView control handles the select operation.
Occurs when a row's Select button is clicked, but before the

SelectedIndexChanging
GridView control handles the select operation.
Occurs when the hyperlink to sort a column is clicked, but after

Sorted
the GridView control handles the sort operation.
Occurs when the hyperlink to sort a column is clicked, but

Sorting
before the GridView control handles the sort operation.
Occurs when the server control is unloaded from memory.

Unload
These events are all listed in the MSDN, and here I have given a few events which are
frequently used in our day to day projects:
PageIndexChanging
This event occurs when the property of the grid AllowPaging is set to true, and in the
code behind the PageIndexChanging event is fired.
Paging
The DataGrid provides the means to display a group of records from the data source (for
example, the first 10), and then navigates to the "page" containing the next 10 records, and
so on through the data.
Paging in DataGrid is enabled by setting AllowPaging to true. When enabled, the grid
will display page navigation buttons either as "next/previous" buttons or as numeric
buttons. When a page navigation button is clicked, the PageIndexChanged event is thrown.
It's up to the programmer to handle this event in the code.
Hide Copy Code

//AllowPaging="True"
//fires when the property AllowPaging is set to True

GridView2.PageIndex = e.NewPageIndex;
//Datasource method
TempTable();
RowCommand
The DataGrid fires the RowCommand event when any button is pressed. We can given any
name as command name, and based on that, the check will be done and the loop will be
executed.
Hide Copy Code

//OnRowCommand="GridView6_RowCommand"
//CommandName="view" CommandArgument='<%# Bind("id") %>'
protected void GridView6_RowCommand(object sender,

GridViewCommandEventArgs e)
{
//this will check whether the command name is equal to view. If it is
//equal to view the it will go inside the loop.
if (e.CommandName == "view")
{
//to find which row is clicked
int row = int.Parse(e.CommandArgument.ToString());
StringBuilder sb = new StringBuilder();
sb.Append("<script language="'javascript'">\r\n");
//javascript to navigate to view page.
sb.Append(" window.open('View.aspx?id=" + row + "',
null,'width=350,height=300,scrollbars=yes,left=350,top=200,right=5,bottom
=5');");
sb.Append("</script>");
if (!this.IsClientScriptBlockRegistered("BindScript"))
{
RegisterClientScriptBlock("openScript", sb.ToString());
}
}
}
RowCreated
The DataGrid fires the RowCreate event when a new row is created.
Hide Copy Code

//OnRowCreated="GridView3_RowCreated"
protected void GridView3_RowCreated(object sender, GridViewRowEventArgs

e)
{
//When a child checkbox is unchecked then the header checkbox will also
be unchecked.
if (e.Row.RowType == DataControlRowType.DataRow && (e.Row.RowState ==
DataControlRowState.Normal || e.Row.RowState ==
DataControlRowState.Alternate))
{
CheckBox chkBxSelect =
(CheckBox)e.Row.Cells[1].FindControl("chkselect");
CheckBox chkBxHeader =
(CheckBox)this.GridView3.HeaderRow.FindControl("chkHeader");
chkBxSelect.Attributes["onclick"] =
string.Format("javascript:ChildClick(
this,'{0}');", chkBxHeader.ClientID);
}
}
RowDeleting
The DataGrid fires the RowDeleting event when the command name is given as Delete.
Hide Copy Code

//OnRowDeleting="GridView3_RowDeleting"
//CommandName="delete"
protected void GridView3_RowDeleting(object sender,

GridViewDeleteEventArgs e)
{
//finding the row index of which row is selected.
int row = e.RowIndex;
//deleteing the temp row(or your delete query that will delete the row
from
//the database
Temp.Rows[row].Delete();
//reassigning the datasource
GridView3.DataSource = Temp;
GridView3.DataBind();
}
RowUpdating
The DataGrid fires the RowUpdating event when the command name is given as Update.
Hide Copy Code

//OnRowUpdating="GridView3_RowUpdating"
CommandName="update"
protected void GridView3_RowUpdating(object sender,
GridViewUpdateEventArgs e)
{
//maintaining the row index to intial position
GridView3.EditIndex = e.RowIndex;
}
RowEditing
The DataGrid fires the RowEditing event when the command name is given as Edit.
Hide Copy Code

/OnRowEditing="GridView3_RowEditing"
//CommandName="edit"
protected void GridView3_RowEditing(object sender, GridViewEditEventArgs

e)
{
//changing the index of the grid.
GridView3.EditIndex = e.NewEditIndex - 1;
//finding the row of the grid
int row = e.NewEditIndex;
//updating the rows inside the grid
Temp.Rows[row]["name"] =
((TextBox)GridView3.Rows[e.NewEditIndex].FindControl(
"txtname")).Text;
Temp.Rows[row]["gender"] =
((DropDownList)GridView3.Rows[e.NewEditIndex].FindControl(
"ddlgender")).Text;
Temp.Rows[row]["email"] =
"txtemail")).Text;
Temp.Rows[row]["salary"] =
"txtsalary")).Text;
Temp.AcceptChanges();
//total of the salary and displaying it in footer.
Total = decimal.Parse(Temp.Compute("sum(Salary)",
"Salary>=0").ToString());
//maintaining the total value in the session
Session["Salary"] = Total;
}
RowDatabound
The DataGrid fires the RowDatabound event when a data row is bound to data in a
GridView control.

//OnRowDataBound="GridView4_RowDataBound"
protected void GridView4_RowDataBound(object sender, GridViewRowEventArgs

e)
{
//Example for grid inside a grid
//to find the row index to the selected row.
int index = e.Row.RowIndex;
//check whether the row type is equal
if (e.Row.RowType == DataControlRowType.DataRow)
{
//assiging datasource for the grid inside the grid.
DataTable tempdt = new DataTable();
tempdt.Columns.Add("Id");
tempdt.Columns.Add("Language", typeof(String));
DataRow dr = tempdt.NewRow();
dr["Id"] = 1;
dr["Language"] = "C";
tempdt.Rows.Add(dr);
DataRow dr1 = tempdt.NewRow();
dr1["Id"] = 2;
dr1["Language"] = "C++";
tempdt.Rows.Add(dr1);
GridView gr = (GridView)(e.Row.FindControl("GridView5"));
if (gr != null)
{
gr.DataSource = tempdt;
gr.DataBind();
}
}
}
Sorting
Data in a grid is commonly sorted by clicking the header of the column to sort. Sorting in a
DataGrid can be enabled by setting AllowSorting to true. When enabled, the grid
renders LinkButton controls in the header for each column. When the button is clicked, the
grid's SortCommand event is thrown. It's up to the programmer to handle this event in the
code. Because DataGrid always displays the data in the same order it occurs in the data
source, the typical logic sorts the data source, and then rebinds the data to the grid.
Hide Copy Code

//AllowSorting="True"
//OnSorting="GridView2_Sorting"
//SortExpression="name"
protected void GridView2_Sorting(object sender, GridViewSortEventArgs e)

{
//to check whether to display in ascending order or descending order
if (e.SortExpression.Trim() == this.SortField)
this.SortDirection = (this.SortDirection == "D" ? "A" : "D");
else
this.SortDirection = "A";
this.SortField = e.SortExpression;
TempTable();
}
Header and Footer of the Grid

This is a JavaScript to use when there is a necessity to check all the checkboxes in a column
by checking a single checkbox in the grid header. While we are checking the grid header,
all the checkboxes inside the grid will be selected, and if any child column is unchecked,
then the header will also be unchecked.

<script type="text/javascript">
var TotalChkBx;
var Counter;
window.onload = function()
{
TotalChkBx = parseInt('<%= this.GridView3.Rows.Count %>');
Counter = 0;
}
function SelectAll(CheckBox)
{
var TargetBaseControl = document.getElementById('<%=
this.GridView3.ClientID %>');
var TargetChildControl = "chkselect";
var Inputs = TargetBaseControl.getElementsByTagName("input");
for(var n = 0; n < Inputs.length; ++n)
if(Inputs[n].type == 'checkbox' &&
Inputs[n].id.indexOf(TargetChildControl,0) >= 0)
Inputs[n].checked = CheckBox.checked;
Counter = CheckBox.checked ? TotalChkBx : 0;
}
function ChildClick(CheckBox, HCheckBox)
{
var HeaderCheckBox = document.getElementById(HCheckBox);
if(CheckBox.checked && Counter < TotalChkBx)
Counter++;
else if(Counter > 0)
Counter--;
if(Counter < TotalChkBx)
HeaderCheckBox.checked = false;
else if(Counter == TotalChkBx)
HeaderCheckBox.checked = true;
}
</script>
onclick="javascript:SelectAll(this);"
Maintaining the values in the footer is done by the following code:
Hide Copy Code

protected void GridView3_RowDataBound(object sender, GridViewRowEventArgs
e)
{
//total in the footer
if (e.Row.RowType == DataControlRowType.Footer)
{
e.Row.Cells[4].Text = this.Total.ToString();
}
}
To maintain the grid header in a fixed state, a style sheet is used in the source code:
Hide Copy Code

<style type="text/css">.DataGridFixedHeader {
BACKGROUND: url(Images/grid_header.jpg) repeat-x;
POSITION: relative; TOP: expression(this.offsetParent.scrollTop); HEIGHT:
27px }
</style>
<div style="width:80%; height:250px; overflow:auto;" >
<asp:GridView ID="GridView1" runat="server"
Width="100%" AutoGenerateColumns="False"
CellPadding="4" DataKeyNames="id"
ForeColor="#333333" GridLines="None"
OnRowCreated="GridView1_RowCreated"
AllowPaging="True" AllowSorting="True"
OnPageIndexChanging="GridView1_PageIndexChanging"
OnSorting="GridView1_Sorting"
PageSize="2" OnRowCommand="GridView1_RowCommand"
OnRowDeleting="GridView1_RowDeleting"
OnRowEditing="GridView1_RowEditing">
....
....
<HeaderStyle BackColor="#507CD1" Font-Bold="True" ForeColor="White"
CssClass="gridHeader DataGridFixedHeader" />
.....
.....
</asp:GridView>
</div>
Export GridView to Word, Excel, and PDF

Word
Hide Copy Code

protected void btnword_Click(object sender, EventArgs e)
{
Response.AddHeader("content-disposition",
"attachment;filename=Information.doc");
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.ContentType = "application/vnd.word";
System.IO.StringWriter stringWrite = new System.IO.StringWriter();
System.Web.UI.HtmlTextWriter htmlWrite = new
HtmlTextWriter(stringWrite);
// Create a form to contain the grid
HtmlForm frm = new HtmlForm();
GridView1.Parent.Controls.Add(frm);
frm.Attributes["runat"] = "server";
frm.Controls.Add(GridView1);
frm.RenderControl(htmlWrite);
//GridView1.RenderControl(htw);
Response.Write(stringWrite.ToString());
Response.End();
}
Excel
Hide Copy Code

protected void btnexcel_Click(object sender, EventArgs e)
{
string attachment = "attachment; filename=Information.xls";
Response.ClearContent();
Response.AddHeader("content-disposition", attachment);
Response.ContentType = "application/ms-excel";
StringWriter sw = new StringWriter();
HtmlTextWriter htw = new HtmlTextWriter(sw);
// Create a form to contain the grid
HtmlForm frm = new HtmlForm();
GridView1.Parent.Controls.Add(frm);
frm.Attributes["runat"] = "server";
frm.Controls.Add(GridView1);
frm.RenderControl(htw);
//GridView1.RenderControl(htw);
Response.Write(sw.ToString());
Response.End();
}
PDF
Hide Copy Code

protected void btnpdf_Click(object sender, EventArgs e)
{
Response.Clear();
StringWriter sw = new StringWriter();
HtmlTextWriter htw = new HtmlTextWriter(sw);
GridView1.RenderControl(htw);
Response.ContentType = "application/pdf";
Response.AddHeader("content-disposition",
"attachment; filename=Information.pdf");
Response.Write(sw.ToString());
Response.End();
}
Difference between DataGrid, DataList, and Repeater

A DataGrid, DataList, and Repeater are all ASP.NET data Web controls.
They have many things in common like the DataSource property, the DataBind method,
and the ItemDataBound and ItemCreated events.
When you assign the DataSource property of a DataGrid to a DataSet, each DataRow
present in the DataRow collection of the DataTable is assigned to a corresponding
DataGridItem, and this is the same for the rest of the two controls. But The HTML code
generated for a DataGrid has an HTML TABLE <ROW> element created for the particular
DataRow and it is a table form representation with columns and rows. For a DataList, it is
an array of rows, and based on the template selected and the RepeatColumn property value,
we can specify how many DataSource records should appear per HTML <table> row. In
short, in a DataGrid, we have one record per row, but in a DataList, we can have five or
six rows per row. For a Repeater control, the data records to be displayed depend upon the
templates specified, and the only HTML generated is the due to the templates.
In addition to these, DataGrid has in-built support for sorting, filtering, and paging the
data, which is not possible when using a DataList, and for a Repeater control, we would
require to write explicit code to do paging.
Conclusion
This is my second article, and if you have any questions, you can refer to the project
attached because all the code in the article is from the project. Further questions or
clarifications or mistakes are welcome.
The Truth About HttpHandlers and WebApi
In 2012 when Microsoft introduced the ASP.Net WebAPI, I initially became confused about yet another
way to generate and transmit content across a HttpRequest. After spending some time thinking about
WebAPI over the past week or two and writing a few blocks of sample code, I think I finally have some
clarity around my confusion and these are those lessons I learned the hard way.
Old School API – SOAP and ASMX
When ASP.Net launched, the only framework to create and publish content that was available was
WebForms. Everybody used it, and it worked well. If you wanted to create an interface for machine-to-
machine communications you would create a SOAP service in an ASMX file. You could (and still can)
add web references to projects that reference these services. The web reference gives you a first class
object with a complete API in your project that you can interact with.
Over time, it became less compelling to build the SOAP services as they transmitted a significant
amount of wrapper content around the actual payload you wanted to work with. This extra content was
messy, and other programming languages didn’t have the tooling support to manage them well.
Developers started looking for less complicated alternatives to communicate with connected clients. It
turns out that there was another option available that was overlooked by many: HttpHandlers.
HttpHandlers in ASP.Net
HttpHandlers are the backbone of ASP.Net. An HttpHandler is any class that implements the
IHttpHandler interface, handles an incoming request, and provides a response to webserver
communications. IHttpHandler is a trivial interface with the following signature:
public class TestHandler : IHttpHandler
{
public void ProcessRequest(HttpContext context)
// TODO: Implement this method
throw new NotImplementedException();
public bool IsReusable
get
// TODO: Implement this property getter
throw new NotImplementedException();
Listing 1 – Simple IHttpHandler interface implementation

The ProcessRequest method is where we can insert our code to handle all data being requested of the
handler and all data to respond from the handler. The IsReusable property is often misunderstood, but
has a simple definition: Should an instance of this handler be re-used for other requests to the
webserver? If the return value is false, a new version of the handler class will be instantiated for each
request to the server. If IsReusable returns true, then the same instance will be used for all requests to
the server. A simple implementation that outputs some of my favorite sports teams in XML format
might look like this:
public class MyHandler : IHttpHandler
public readonly static IEnumerable MyTeams = new List
new Team { City = "Philadelphia", Name = "Phillies" },
new Team { City = "Boston", Name = "Red Sox" },
new Team { City = "Cleveland", Name = "Browns" },
new Team { City = "Houston", Name = "Astros" },
new Team { City = "San Diego", Name = "Chargers" }
};
#region IHttpHandler Members
public bool IsReusable
{
get { return true; }
public void ProcessRequest(HttpContext context)
context.Response.ContentType = "text/xml";
context.Response.Write("");
foreach (var t in MyData.MyTeams)
context.Response.Write(t.City);
context.Response.Write(t.Name);
#endregion
Listing 2 – A Sample XML Generating HttpHandler

Some developers get confused about the difference between a class that implements IHttpHandler and an
ASHX file. These are very similar things, but different with their own advantages. An ASHX file is an
IHttpHandler whose end-point is defined by the name of the ASHX file. If you create foo.ashx you can
trigger the ProcessRequest method by navigating to http://localhost/foo.ashx Conversely, a class that
implements IHttpHandler needs to be registered in web.config with a path and file-extension end-point
to answer to. The format of this registration lies within the system.webServer section of web.config:
Listing 3 – Web.Config entries for an HttpHandler
Further instructions on how to configure the HttpHandler is available on MSDN
Both of these types of HttpHandlers are easy to implement, and put you right on the metal. You are
handed and HttpContext and you can do anything you want to handle the incoming request and respond
to it. If you are working with some low-level operations such as inspecting HttpHeaders for responses,
you may choose to go this route.
ASP.Net WebAPI in a nutshell
Scott Guthrie describes ASP.Net WebAPI as a technology that allows developers to build powerful web
based APIs that have the following 9 core capabilities:
 Modern HTTP Programming Model – Directly access the HTTP requests and responses
using a strongly typed HTTP object model
 Content Negotiation – Built in support for content negotiation, which allows the client and
server to work together to determine to correct data format to return from an API
 Query Composition – Easily supports OData URL conventions when you return a type of
IQueryable<T> from a method
 Model Binding and Validation – Supports the same model binding available in WebForms and
MVC
 Routes – You know ’em, you love ’em… they’re all over ASP.Net. Why WOULDN’T you
expect them in WebAPI?
 Filters – You can apply similar filters to those that you create for MVC
 Improved Testability – WebAPI uses two new objects called HttpRequestMessage and
HttpResponseMessage to make unit testing significantly easier.
 IoC Support – The same service locator pattern implemented in ASP.Net MVC is available to
inject dependencies into your API implementations
 Flexible Hosting – Web APIs can be hosted within any type of ASP.Net application. You can
also host it within any process if you don’t want to engage IIS to host your API.
The quick and dirty summary of this list is that WebAPI functions, looks, and feels like developing with
ASP.Net MVC. There are a few simple differences between them, but once you learn them, its very
easy to progress quickly.
The Super-Duper Happy Sample
To implement a simple service that outputs a collection of values when a GET is called with no
arguments (eg: http://localhost/api/Values ) you need to add very little to get started. First, add a
WebAPI controller to your website by selecting the appropriate item in the Add Item dialog box:
The default implementation delivered looks like the following:
public class ValuesController : ApiController
// GET api/<controller>
public IEnumerable<string> Get()
return new string[] { "value1", "value2" };
// GET api/<controller>/5
public string Get(int id)
return "value";
// POST api/<controller>
public void Post([FromBody]string value)
// PUT api/<controller>/5
public void Put(int id, [FromBody]string value)
// DELETE api/<controller>/5
public void Delete(int id)
{
}
Listing 4 – Default API Controller implementation

With this simple implementation you can navigate your browser to http://localhost/api/values and get the
two values “value1” and “value2” returned in XML format. If you programatically request that address
and change your “accept” header to “text/json” you will receive JSON in the response stream. You can
PUT, POST, and DELETE content to this controller and the appropriate action methods will be triggered
based on the HTTP action executed.
The Truth
WebAPI is just another HttpHandler, one that has been wrapped around all sorts of helpful content
management and negotiation technologies as Scott Guthrie suggested. You certainly could cut out all of
those other technologies and benefits and code directly “on the metal” with an HttpHandler, and that was
the only choice you had until 2012 and ASP.Net 4. In today’s web community, its best to use RESTful
methods and use a standard format like XML or JSON to transfer data. HttpHandlers had their place,
but going forward, I’m going to use WebAPI whenever I need to transmit data over HTTP to browsers
or any other connected client.
https://thomasfrank.se/
Creating VB Programs for the Internet

 Working on the Internet
 Making a Simple Program with VBScript
 Using VBScript with Internet Explorer
o Working with HTML Elements
o More on Scripts
o Incorporating VBScript with HTML
o Handling Events with VBScript
 Understanding a DHTML Application
o Programming a Simple DHTML Application
o Rapid Development with DHTML Applications
o Using DHTML with ActiveX Components
o Compiling a DHTML Application
Working on the Internet

Advantages of using VB and VBScript on the Internet
More than likely, you already have a general idea of what the Internet is, and you use it
every day for email, Web browsing, and downloading files. Also, many of you probably
already develop Internet applications with C++ or Java. You can use any document on the
Internet, including spreadsheets and databases, but sometimes you need to do a little
programming to force the application to do what you want it to do. Learning Visual Basic
and VBScript in relation to Internet programming puts you one step ahead, and your Web
pages will work and look much better.
Before you look at how to use Visual Basic to do Internet programming, it's useful to have
a fundamental concept of how the Internet works. In a nutshell, the Internet is a very large
network with millions of users and computers interacting with each other. To expand on
this concept, the entire Internet is nothing more than millions of computers communicating
with each other by means of special documents. These documents are written in special
code that all computers can understand. Some of these documents are interactive, meaning
that any user can change the information that the document contains. One example of this is
the Web page, which is one or many documents in which users can add or change
information.
As complex and unwieldy as the Internet is, its fundamental dynamics concern the
relationship between a client PC and server computer. A client is something that needs a
service, and a server is something that provides a service. In the case of the Internet, the
client is the computer in your home or at your office, and the server is a computer
somewhere on the Web that provides data to the client.
The way by which the client can talk to the server is via protocols. A protocol is a set of
rules by which the client knows how to pass requests for data to the server. Likewise, the
server knows how to send responses back to the calling client. Protocols are useful because
they don't rely on platform specifics. A client doesn't need to know whether a server is an
HP running an operating system such as UNIX or an IBM running OS/2; the server doesn't
need to know whether the client computer is a Macintosh or a Gateway PC.
The protocol used most often on the Internet is HTTP (Hypertext Transfer Protocol).
Another widely used protocol is FTP (File Transfer Protocol), and there are others. Any
computer that can talk HTTP or FTP can communicate with servers on the Internet, and
vice versa.
For a computer to be a server on the Internet, it must have two things: an address by which
other computers can locate it and the capability to understand and process the various
protocols. A server is assigned a unique numeric ID called an IP (Internet Protocol)
address. Normally, however, you don't use the numeric address when calling a server on
the Internet; instead, you use the server's associated domain name. The domain name is the
friendly addressing format, www.domainname.com, that you've come to know from using
the World Wide Web (see Figure 28.1).
FIGURE 28.1 The Internet is based on discrete conversations between a client computer
and an Internet server.
Many ISPs out there
The ISP that you use might depend on your local area. This book doesn't recommend any
particular service because they all provide one basic function--connecting you to the rest of
the world. Each ISP is unique because each has a slightly different format. You might try
several before settling on one. Some services, such as AT&T Worldnet and America
Online, offer trial memberships in which you can "try before you buy."
The software used on the physical computer to make it a server that can speak the protocols
of the Internet and respond accordingly is called Internet server software. The particular
Internet server software manufactured by Microsoft is Internet Information Server (IIS).
For a client computer to be able to communicate with a server on the Internet, it must have
a connection to the Internet. Then, when connected, it must have a way to contact and
receive data from Internet servers through the various protocols. The connection is
accomplished via an Internet service provider (ISP), such as America Online, CompuServe,
MSN, AT&T Worldnet, MCI, or Sprint. The tool to communicate to the server and
decipher the data returned by the Internet server is handled by the Internet browser, such as
Microsoft's Internet Explorer or Netscape Navigator.
Where does Visual Basic fit in all this? Microsoft has positioned Visual Basic to play an
important role on the client side and the server side. On the client side, you can use a
derivative of Visual Basic, VBScript, to create Web page programs that can run from
within Internet Explorer. You also can use Visual Basic to create custom ActiveX
components that you can embed in Web pages and run as any custom ActiveX component
would.
Client side versus server side
If you write a program that resides and executes on a client computer, that program is
called a client-side program. If you create a program that runs on an Internet server, that
program is called a server-side program. Microsoft Word is considered a client-side
program. Yahoo Search, a program that searches for articles on the Web, is a server-side
program.
On the server side, you can use VBScript to create Active Server Pages (ASP) in order to
create logic that enables IIS to respond to various input from client computers. Also, you
can use Visual Basic to create custom ActiveX components designed to work as extensions
and enhancements to the IIS environment. These components are called server-side
components.
You can use VBScript with server-side ActiveX components to access databases connected
to the Internet server to return data to the client. You can keep track of the various activities
of the users accessing your server. You can handle mail and deliver files. You can create
responses custom-tailored to the specific requester. You can transact business.
On the client side, you can use VBScript to make decisions about what information to send
back to the server, to create animation effects, and to interact with other programs on the
client computer, to name a few examples.
Microsoft is very serious about the Internet and is trying to position Visual Basic as the
language by which to program for the Internet, provided that you use Internet Explorer as
the client browser and Internet Information Server as the Internet server software on the
back end. Therefore, using Visual Basic or VBScript within the context of the Internet is a
skill that's more and more expected of programmers.
Making a Simple Program with VBScript

When you install Internet Explorer on your computer, you have access to some benefits of
the Visual Basic programming environment. Although IE isn't a complete programming
environment, you still have a lot of programming potential at your disposal. Most
commands, statements, and functions available to you in Visual Basic are also accessible to
you in Internet Explorer.
Programs versus scripts
Most often you can think of a script as a small program. However, there are subtle
differences between a program and a script. In the traditional sense, you can think of a
script as a set of tasks performed in sequence. On a Web page, a script is a set of tasks that
the page executes as it loads. Programs, on the other hand, are a collection of sets of tasks
that can be performed sequentially or at random. For instance, you can have a program that
runs a set of tasks on startup and another set of tasks when a user clicks a button (event-
driven). As scripting languages such as VBScript become more powerful, however, the
boundary between where a script ends and a program begins becomes more and more
complicated.
When used to its full potential, VBScript is a useful but not really powerful script language
that lets you write programs to control the way things happen on the Internet and in other
environments. There has never been a script language that can compete with a
programming language such as Visual Basic. You could probably achieve the most power
by combining the two environments and using both VBScript and Visual Basic. Other
VBScript limitations include the following:
 VBScript is bound to the interpreter that lives with Internet Explorer.

 VBScript has only one data type, Variant.
Also, you can't do the advanced things that Visual Basic enables you to do, such as create
custom controls and classes or access the Windows API. However, with VBScript you can
access ActiveX controls. The more you use VBScript, the more ways you will discover to
make it work to your benefit.
Because VBScript is a text-based programming language, you don't need to have a copy of
Visual Basic to program in VBScript. All you need is a text editor such as Notepad to
create HTML pages with VBScript embedded in it. Advanced tools such as Visual InterDev
offer the benefit of visual programming enhancements and editing capabilities that enable
you to write VBScript more easily.
VBScript executes as a Web page loads into Internet Explorer. For example, you can use
VBScript to write text to a browser window, thus avoiding the need to write the page in
HTML. Although it's far from being a replacement for HTML, VBScript does most of the
same functions, providing you with a quick solution to some Web programming problems.
Creating an Hello World program in VBScript
1. Open Notepad or another text editor and enter the following text:
<SCRIPT LANGUAGE="VBScript">
document.write "Hello World"
</SCRIPT>
2. Save the text as Test.htm.
3. Open Internet Explorer.
4. Drag the Test.htm file from Windows Explorer to the client area of Internet Explorer
(see Figure 28.2).
FIGURE 28.2 VBScript enables you to control output to Internet Explorer.
Using VBScript with Internet Explorer

You can use VBScript with HTML to make Web pages that appear and behave like Visual
Basic programs. This is possible because, as you read earlier, much of Visual Basic
functionality is built into Internet Explorer. Figure 28.3 shows a simple page of HTML,
28htm01.htm (see Listing 28.1), presented in Internet Explorer. If users enter Fred
Flintstone in the top text box, the bottom text box returns the validation string You are in!.
Any other text produces the response You are out. If you're interested in more information
on HTML programming, look into some of the books on the subject at
http://www.mcp.com.
FIGURE 28.3 You can process data by using VBScript and HTML.
Placing VBScript on a Web page
You place VBScript between the <SCRIPT></SCRIPT> tags on a Web page. As the script
is loaded from the Web page, script is executed as each line is encountered. If you have
script at the top of a page, that script executes even if the page is still loading. If the script is
a procedure, however, it's not executed until it's called from other areas in the page.
Usually, procedures are placed within the <HEAD></HEAD> tags at the beginning of the
page.
LISTING 28.1 28HTM01.HTM--A Simple Page of HTML That Processes Data
01 <HTML>
02 <TITLE>Using VB6: VBScript</TITLE>
03 <HEAD>
04 
05 <SCRIPT LANGUAGE=VBSCRIPT>
06 
22 </SCRIPT>
23 </HEAD>
24
25 <BODY>
26 
28 <CENTER>
29 <H1>Secret Login</H1>
30 </CENTER>
31
32 
36 <P>
37 Name:
38 <BR>
39 <INPUT TYPE=Text Size=40 ID=txtName>
40
41 
45 <P>
46 Authentication:
47 <BR>
48 <INPUT TYPE=Text Size=40 ID=txtValidate>
49
50 
55 <P>
56 <INPUT TYPE=Button Value="Validate" ID=cmdValidate>
57 </BODY>
Download this code
A fully commented, unnumbered version of this code is available from http://www.mcp.

com/info. The code for this chapter is in the file VB6CH28.zip.
What are HTML elements?
Think of HTML elements as controls embedded in the Internet Explorer browser and
accessed via HTML. HTML elements are covered in more detail in the following section.
What's interesting about this program is that although it appears to be using an intrinsic
Visual Basic ActiveX control, it's not; it's made completely from HTML and HTML
elements.
The way the program works is that two HTML <INPUT TYPE=Text> elements (lines 39
and 48) and an <INPUT TYPE=Button> HTML element (line 56) are created. When users
click the button, a click event handler written in VBScript (lines 10-20) processes the data
input into the first text element (line 13). A response is output in line 15 or 18.
Working with HTML Elements
If you don't have a working knowledge of HTML, this code might be difficult to grasp. A
fundamental understanding of HTML and HTML elements is a prerequisite for working
with VBScript on the Internet. HTML, the language of the Internet, is a tagged language,
which means that tags are used to issue instructions to the HTML interpreter about how to
process data sent from the server to the calling client. For instance, the following piece of
HTML instructs the browser to make the words Hello World boldface.
<B>Helllo World</B>
In addition to tags that tell the browser how to handle text are tags that tell the browser
about the structure of the HTML page. Also, some tags create elements very similar to the
intrinsic ActiveX controls. Table 28.1 lists these elements.
TABLE 28.1 HTML Elements Compared to Intrinsic ActiveX Controls
HTML Element ActiveX Intrinsic Control
<INPUT TYPE=CHECKBOX> CheckBox
<SELECT> ComboBox
<INPUT TYPE=BUTTON> CommandButtons
<FRAME> Frame
<INPUT TYPE=IMAGE> Image
<SELECT MULTIPLE> ListBox
<INPUT TYPE=RADIO> OptionButton
<INPUT TYPE=TEXT> TextBox
<TEXTAREA> TextBox with multiple lines and scrollbars
<INPUT TYPE=BUTTON> CommandButton
<SELECT> DropDownCombo or ListBox
HTML elements have properties that you can set at design time, as you would an ActiveX
control. HTML element properties are called arguments. The syntax for these arguments is
a bit different from properties of ActiveX controls. To create an <INPUT TYPE=TEXT>
element with the text Hello World in it, you would use the following:
<INPUT TYPE=TEXT SIZE=40 VALUE="Hello World">
In this syntax,
 INPUT TYPE=TEXT tells the browser to make a text element.

 SIZE=40 tells the browser to make the element 40 characters wide.
 VALUE="Hello World" tells the browser to set Hello World as the text element's string.
The following sections provide a more detailed description of the HTML elements that you
use with VBScript.
The <FORM> element
HTML forms begin with the tag <FORM> and ends with the tag </FORM>. The <FORM>
element takes the following format:
<FORM ACTION = URL METHOD= post|get NAME=aname>

...
</FORM>
In this syntax,
Working with CGI
The common gateway interface (CGI) is a specification that defines a set of standards by
which data consistently and predictably enters and leaves an Internet Server. Originally
developed for the UNIX environment, CGI is used for Internet-based data-processing and
decision-making routines such as queries and lookups. Programs that do this sort of server-
side processing are called CGI scripts and are usually written in a language such as Perl or
C++.
 ACTION is the server-side uniform resource locator to which the form's data will be
passed. Typically, this is a CGI script.
 METHOD is the way that the data is passed. You can choose between the post (moves
everything into the URL) and get (sends behind the scenes, in the background) methods.
These methods evolve from CGI programming.
 NAME is a user-defined ID that identifies the form. This is particularly useful when you
have Web pages that contain more than one form.
Therefore,
<FORM ACTION=http://www.mysite.com/cgi-bin/myscript.exe
METHOD=post NAME-myform>
...
</FORM>
denotes a form that will pass its data to a CGI script, myscript.exe, on the server
www.mysite.com. The form will use the post method. The name of the form is myform.
Forms are parent elements, which means that the information gathered is generated by
other HTML elements living between the <FORM> and </FORM> tags. An element that
lives within a <FORM> is called a child element.
You can think of the <FORM> element as a nongraphical version of a Visual Basic form. A
VB form can contain buttons, text boxes, labels, and a host of other controls. When you
reference a control within a VB form, you do so through the form. For instance, if you had
a CommandButton named Command1 on a form named Form1, you would reference the
CommandButton with the following piece of code:
Form1.Command1.
The Document Object Model (DOM)
The Document Object Model is the hierarchical relationship of data in a Web page. For
example, the window object contains the document object, which can contain a form object.
Modern VB Internet programming is about using the DOM. In earlier versions of HTML,
the DOM was much less complex. Now the DOM has hundreds of objects, attributes, and
methods. For an in-depth look at the DOM, visit Microsoft's Web page at http:// www.
microsoft.com/msdn/sdk/inetsdk/help/ dhtml/references/ domrefs.htm.
The same is true of an HTML <FORM>. You can have <INPUT>, <TEXTAREA>, and
<SELECT> elements that reside with a <FORM>. Therefore, if you have a <FORM
NAME=MyForm> element that contains an <INPUT TYPE=TEXT NAME=MyText>
element, you would reference it with VBScript as
MyForm.MyText
This notion of parent and child elements becomes very important when you work with
VBScript and the Internet Explorer Document Object Model (DOM).
The <INPUT> Element
The <INPUT> elements are what you provide for users to enter in form data and trigger a
submission of the form's data onto a server on the Internet.
HTML has a standard set of <INPUT> types, just as VB has a standard set of controls that
you adapt to a particular purpose. Also, as with VB control properties, each <INPUT>
element has attributes that you configure to accommodate a particular layout need.
The <INPUT> element attributes are as follows:
Attribute Description
NAME Defined name of <INPUT>'s data, similar to a variable name
VALUE <INPUT>'s data, similar to the value of a variable
TYPE Defines the type of <INPUT> element, such as Text, Radio, Checkbox, and so on
MAXLENGTH Specifies the maximum number of characters that may be entered in an <INPUT>
field
SIZE Defines the size (width) of the <INPUT> field, is used for Text or Password
CHECKED Marks a check box or sets a radio button to True
The <INPUT> element types are as follows:
 Text--You use the Text type to enable users to enter textual data:
<INPUT TYPE=Text SIZE=40 NAME=txtName>
 Password--A Password type is similar to a Text <INPUT> element type, but the characters
that users enter are masked with asterisks. Although the type offers some measure of
security, the type's security can be breached with little difficulty if you don't have a secure
transaction.
<INPUT TYPE=Password NAME=pswMain>
 Submit--The Submit button is the <INPUT> type that you use to create a button that, when
clicked, triggers the submission of a form's data to a server on the Internet. The browser
will show the caption of the Submit type to be the string Submit unless the VALUE is
assigned another string.
<INPUT TYPE=Submit Value="Submit Profile"

NAME=Submit>
 Reset--This <INPUT> type creates a button that clears the data from all fields on an HTML
form when clicked:
<INPUT TYPE=Reset Value="Clear Profile"

NAME=Reset>
 Button--This <INPUT> type creates a button that can be referenced with VBScript:
<INPUT TYPE=Button NAME=cmdValidate

Value="Validate>
 Radio--Radio buttons are used to make exclusive choices, very much in the same way that
you use an OptionButton control in VB. The tricky thing is to understand that for a set of
Radio types to be exclusive of one another, all Radio types to be grouped must have the
same value attached to their NAME attribute:
<INPUT TYPE=RADIO NAME=opFlintstones

VALUE="Fred">Fred<BR>
VALUE="Wilma">Wilma<BR>
VALUE="Betty">Betty<BR>
VALUE="Barney">Barney<BR>
 When you submit the form, only the VALUE of the chosen Radio type will be sent to the
server.
 Checkbox--Check boxes are used to make inclusive choices. The value of the NAME
attribute for each check box must be different. When you add the parameter CHECKED,
you put a check mark in the check box.
<INPUT TYPE=CHECKBOX NAME=chkCartoon

VALUE=IsCartoon CHECKED>
 Hidden--Hidden <INPUT> types are never shown on the form. Using hidden types is a good
way to send some data from the form to the server without users knowing about it. It's as
though you have a piece of data embedded in the form, which you can return to the
server on a free-ride basis. For the following code example, I attached this name to a
HIDDEN input type:
<INPUT TYPE=Hidden NAME=hidAuthor

VALUE="Bob Reselman">
 When the data is sent back to the server, my name will also be sent to the server without
users ever having chosen to have such data sent.
 Image--An IMAGE <Input> type displays a GIF image that has the behavior of a SUBMIT
<INPUT> type:
INPUT TYPE=image NAME=imgMain SRC=gifs/gifbut.gif>
The <SELECT> Element
A <SELECT> element is similar to an <INPUT> element in that it enables users to input

data to be submitted to a server on the Internet. The <SELECT> element is a little more
powerful, how-ever, in that it has the behavior of a Visual Basic ListBox or ComboBox.
The tag begins with <SELECT> and ends with </SELECT>. Between the tags, you place
<OPTION> elements:
<SELECT NAME="lstUser">
<OPTION VALUE="Admin">Admin
<OPTION VALUE="Employee">Employee
<OPTION VALUE="Guest">Guest
</SELECT>
If you use the MULTIPLE attribute in the tag definition, the element will appear as a list,
similar to the Visual Basic ListBox. When the element appears as a list, you can submit
multiple <OPTION> elements to the server. If you omit the MULTIPLE attribute, the
element will appear as a drop-down box, similar to a VB ComboBox, from which you can
choose only one <OPTION>.
The <TEXTAREA> Element
Some things in common
Although various HTML elements have common arguments, the behavior associated with
these elements is different. Fortunately, the VB6 IDE has created a way to set HTML
elements just as you would an ActiveX control. This topic is covered later in the section
"Using DHTML with ActiveX Components."
The <TEXTAREA> element is similar to a TEXT <INPUT> type, except that a

<TEXTAREA> element can accept multiple lines of text. The tag definition begins with
<TEXTAREA> and ends with </TEXTAREA>:
<TEXTAREA NAME=txtComments ROWS=5 COLS=30>

</TEXTAREA>
Any text that appears between the tags will show up in the field of the <TEXTAREA>.
These tags will also accept a default value.
The <TEXTAREA> element has three attributes:
Attribute Description
NAME The name of the element (required)
ROWS The number of rows in the <TEXTAREA> field
COLS The width of the field in characters
More on Scripts
From the browser's point of view, the only difference between Web pages that contain a
script and those than don't is the presence of the <SCRIPT> tag in the page's HTML. A
<SCRIPT></SCRIPT> tag indicates that everything between the tags is VBScript or
JavaScript. The syntax of the <SCRIPT> tag is
<SCRIPT LANGUAGE = scripting language>...</SCRIPT>
When a browser sees the <SCRIPT> tag, it says to itself, "I have some script stuff coming
up to consider." When the browser sees the </SCRIPT> tag, it stops that consideration.
Unless the script is code for an event handler, sub, or function, the script will be executed in
the order in which it's encountered.
The <SCRIPT> tag has a LANGUAGE attribute that indicates the scripting language used.
The <SCRIPT> tag supports VBScript, Jscript, and JavaScript.
You code VBScript between the <SCRIPT></SCRIPT> tags just as you would code VB
within the Visual Basic IDE. You Dim variables, write code, and use apostrophes to begin
comment lines. If you declare a variable within a Sub or Function, that variable is local to
the Sub or Function; variables declared outside a Sub or Function are global. As mentioned
earlier, all variables are variants, but you can typecast values by using the conversion
functions of Cint(), CLng(), CStr(), and so forth.
As mentioned earlier, scripts can run from a server on the Internet or from your local hard
drive. The browser considers only the structure of the script, not its source. Therefore, you
load and run client-side scripted HTML as you load any other Web page. This might not be
entirely true in all cases if you're trying to run scripts by using objects that will run on the
client or the server based on where the page resides.
In Listing 28.1, lines 5-22 are the <SCRIPT> portion of the page. The script contains the
code for a click event handler for the Button element cmdValidate. The code for the event
handler starts at line 10 and ends at line 20.
Incorporating VBScript with HTML
Figure 28.4 shows a Web page that contains the <TABLE>, Form, CheckBox, Radio, Text,
<TEXTAREA>, <SELECT>, Password, and Button HTML elements. At the bottom of the
page is a button that, when clicked, displays the Internet Explorer Alert dialog. If users
enter the correct password, the Alert dialog--the HTML equivalent of a MessageBox--
reports back the type of user, any comments from the Comment text area, the selected
Radio elements, and an indication of which check boxes have been selected. The code that
executes this logic is written in the VBScript click event procedure cmdValidate_OnClick.
Listing 28.2 shows the HTML and VBScript for this page.
FIGURE 28.4 The <TABLE> element, part of the HTML 3.0 standard, creates a table that
contains a caption (<CAPTION>) and any number of rows (<TR>). More new tags are
being added to this element every day.
LISTING _28.2 28HTM02.HTM--A Web Page with the HTML elements

01 <html>
02 
04 <head>
05 <title>Using VB6: HTML Elements</title>
06 </head>
07
Commenting HTML
You comment HTML code by putting comments between the characters, . For
example, the code  indicates that the string Created by
Bob Reselman won't be interpreted as HTML; it will be ignored as comments. You can
have as many lines between the begin and end comment characters as you want.
08 <body>
09 <script language="VBScript">
68 </script>
69 
71
72 <H1 align="center">HTML Elements</H1>
73
74 
78 <TABLE BORDER="1">
79 
80 <FORM NAME="frmLogin">
81 <TR>
82 
84 <TD>
85 <SELECT NAME="lstUser" SIZE="1">
86 <OPTION VALUE="Admin">Admin </OPTION>
87 <OPTION VALUE="Employee">Employee </OPTION>
88 <OPTION VALUE ="Guest">Guest </OPTION>
89 </SELECT >
90 </TD>
91 
94 <TD>
95 Password:<BR>
96 <INPUT TYPE="PASSWORD" SIZE="20" NAME="pswMain"><BR>
97 Any Comments?: <BR>
98 <TEXTAREA NAME ="txtComments" ROWS="5" 102:COLS="30">
99 </TEXTAREA >
100 
102 </TD>
103 </TR>
104 </FORM>
105 </TABLE>
106
107 <P>
108 
111 <TABLE BORDER="1">
112 <TR>
113 <TD>
114 
116 <FORM Name="frmFlintstones">
117 
120 <FONT SIZE="4" FACE="ARIAL">Flintstone</FONT><BR>
121 
123 <B>Choose a Character: </B><BR>
124 
Case sensitivity
Because VBScript and HTML aren't case-sensitive languages, <INPUT TYPE=Text> is the
same as <input type=text>. However, JavaScript is case- sensitive.
127 <INPUT TYPE="radio" NAME="opFlintstones"

128 VALUE="Fred">Fred<BR>
130 VALUE="Wilma">Wilma<BR>
132 VALUE="Betty">Betty<BR>
134 VALUE="Barney">Barney<P>
135 
136 <INPUT TYPE="checkbox" CHECKED NAME="chkCartoon"
137 VALUE ="IsCartoon">Cartoon?
138 
139 </FORM>
140 
141 </TD>
142 
144 <TD>
145 
148 <FONT SIZE="4" FACE="ARIAL">Star Trek</FONT><BR>
149 
150 <B>Choose a Character: </B><BR>
151 <INPUT TYPE="radio" NAME="opStarTrek"
152 VALUE="Kirk">Kirk<BR>
154 VALUE="Spock">Spock<BR>
156 VALUE="McCoy">McCoy<BR>
158 VALUE="Scotty">Scotty<P>
159 
160 <INPUT TYPE="checkbox" NAME="chkCartoon"
161 VALUE="IsCartoon">Cartoon?
162 
163 </FORM>
164 </TD>
165 </TR>
166 </TABLE>
167 
169 <P><INPUT TYPE ="button" VALUE="Validate"
170 NAME="cmdValidate">
171 
172 </BODY>
173 </HTML>
This VBScript code shows you how to program the various standard HTML elements.
Notice on line 26 that the code uses the length property of the document.forms element to
determine how many forms are within the HTML document. In HTML, the length property
is similar to the Visual Basic count property for collections. The use of the length property
on line 26 and again on line 29 for the elements collection should give you a sense that an
HTML document is a series of collections within collections (or arrays within arrays, to use
non-language-centric terminology). As you program more with HTML and DOM, you will
find yourself traversing and manipulating the various collections of elements in a
document. Therefore, an understanding of the different collections and parent-child
hierarchies with the DOM is fundamental for developing more complex Web pages with
VBScript. The SideNote titled "The Document Object Model (DOM)" earlier in this
chapter shows you the URL for the Microsoft site that provides documentation for the
DOM.
Static versus dynamic Web pages
A static Web page is one in which the content is hard-coded in HTML and not subject to
quick change. For instance, if you wanted to make a Web page that presents the works of
Shakespeare, you could type up all the plays in a word processor, save the document as
HTML, and put it on a Web site. You probably wouldn't expect the data to change at all
after you posted it on the site. Dynamic data, on the other hand, changes all the time and is
usually written using an HTML script. For instance, if you wanted to have a Web page that
reports the current price of your favorite stock, you would do it by writing a small program
in a scripting language such as VBScript. The program would go to a stock-reporting
server, ask for the current price of your stocks, and then forward those prices to you.
As you can see, making the page in Figure 28.4 (refer to Listing 28.2) is a laborious effort
because of manipulating the HTML elements necessary to organize the page into an
acceptable presentation and writing the VBScript to handle the events and actions within
the page. DHTML is much more difficult and time-consuming in this respect. Before
Visual Basic 6, this sort of scripting was the only way that you could make dynamic Web
pages. Although powerful, scripting of this sort is tedious and exposed. The code that you
write is open for the world to see--not advantageous if you are at all concerned with
protecting your intellectual property. However, Visual Basic 6 lets you write VBScript with
HTML in a way that's less burdensome and more protective of your code--using dynamic
HTML.
Handling Events with VBScript
You write an event procedure for an HTML element or ActiveX control in VBScript by
using the standard Visual Basic syntax. The only difference is that, whereas the Visual
Basic IDE creates the event-procedure code block for you, in VBScript you must create the
code block yourself. Therefore, if you want to write a click event procedure for the element
<INPUT TYPE=BUTTON NAME=MyButton>, you write
<SCRIPT Language=VBScript>
Sub MyButton_OnClick()
`Enter code here.
...
End Sub
</SCRIPT>
Plenty more information on VBScript and ActiveX controls is available. The Internet
contains so much on subjects related to Internet programming that it would probably take a
normal person several thousand years to research only a small percentage of it. I make this
statement with the intention of motivating you to discover how huge the resources are.
Some of these resources can be found at Microsoft's Knowledge Base
(http://www.microsoft.com) and at Netscape (http://www.netscape.com). You also can
refer to http://www.mcp.com, particularly for Java 97 Unleashed, FrontPage 97
Unleashed, and other books on HTML.
FIGURE 28.5 You select a DHTML application project from the New Project dialog.
Understanding a DHTML Application

Working with designers
A designer is a helper application that you load into the Visual Basic IDE. Designers
automate many programming functions that you need for a particular activity or type of
program. VB6 has introduced numerous new designers, including designers for data
projects and add-ins. The DHTML Page Designer provides a visual way to lay out, format,
and code DHTML pages. As of this writing, designers are written in C++.
Visual Basic has a new project type, the DHTML application (see Figure 28.5). A DHTML
application is a program that you design within the DHTML Page Designer in the Visual
Basic IDE (see Figure 28.6) and program in Visual Basic (see Figure 28.7), but it runs as
HTML in Internet Explorer (see Figure 28.8).
FIGURE 28.6 The DHTML Page Designer for a DHTML application is very similar to the
standard Visual Basic IDE.
FIGURE 28.7 You code DHTML applications as you would a standard VB program.
FIGURE 28.8 DHTML applications run within Internet Explorer as HTML.
There's a slight twist, however--the code that you write for your DHTML application is
compiled into a DLL that's embedded in a Web page that the Visual Basic IDE creates as
part of the DHTML project. All the code--event procedures, variables, functions, subs, and
so on--is contained in that DLL. The only thing exposed is the HTML that defines and
positions the HTML elements (see Figure 28.9).
FIGURE _28.9 The DHTML application compiles into a DLL that the Visual Basic IDE
embeds in a Web page and references with a class ID.
Programming a Simple DHTML Application
You create a DHTML program as you would a standard Visual Basic application. The only
difference is that the IDE for a DHTML application contains a Toolbox for HTML
elements. Rather than use intrinsic ActiveX controls on a form, you use HTML elements
within a Web page. For example, rather than call the Text property to find out the contents
of a TextBox control, you call value. This is because DHTML uses the <INPUT
TYPE=Text> element instead of a TextBox. You can use ActiveX controls within a
DHTML application, but you use only those ActiveX controls that ship as an OCX or
ActiveX DLL. You can't use the intrinsic controls in the VB6 runtime DLL.
Using multiple browsers

As of this writing, DHTML applications aren't supported by any browser other than
Internet Explorer. Although Netscape supports a version of DHTML, it's not officially
recognized by the W3C consortium and isn't compatible with Microsoft's Internet Explorer.
Another noteworthy difference between standard VB and a DHTML application is the use
of the property id instead of Name. You use the id property for an element or ActiveX
control in DHTML as you would use the Name property for a control in VB. This use is
particular to Microsoft's enhancement of DHTML as it relates to use under Internet
Explorer. You can use the Name property when scripting standard HTML.
If you're unfamiliar with the DOM and the properties associated with DHTML elements,
you might have a little period of adjustment ahead of you. The Microsoft Web site is an
excellent learning resource. Also, you can use the Books Online reference that comes on
your Visual Basic CD-ROM.
Create a simple DHTML application
Download this project's code
The code for this project is in the file VB6CH28.zip, which you can download from http://
www.mcp.com/info. The project file is DHTMLProject. vbp.
1. Open a New DHTML application project.
2. Double-click the DHTMLPage Designer in the Project window to open the DHTML form
(see Figure 28.10).
FIGURE 28.10 The DHTML Page Designer automates code generation.
3. Double-click the TextField element to add it to the form.
4. Double-click the Button element to add it to the form (see Figure 28.11).
FIGURE 28.11 You can drag and drop HTML elements around a form just as you would
in the standard Visual Basic IDE.
5. Position the TextField and Button elements one on top of the other.
6. Select Button1's value property in the Properties window. Change the value property
from Button1 to Click Me.
7. In the page view pane, double-click the Button1 element to open a code pane to the
Button1_onclick() event procedure.
8. Enter the code shown in Figure 28.12 in the Button1_onclick() event procedure.
9. Save the project and press the F5 key to run the code.
FIGURE 28.12 Notice that the event procedure for a button click is OnClick.
When you run the code for this simple application, Visual Basic compiles the code into a
temporary DLL, generates the HTML around the DLL, and automatically embeds the DLL
on the page. Then the code is run in Internet Explorer. When you look at the source HTML
that loads into the browser, you see no VBScript of any kind--the code is embedded in the
DLL, and your intellectual property is safe.
Rapid Development with DHTML Applications
The capability to quickly create powerful, interactive Web pages is a major benefit of
VB6's DHTML application feature. Figure 28.13 shows a simple login page with a
validation button.
FIGURE 28.13 DHTML applications present the same appearance as HTML pages in a
Web browser.
Listing 28.3 shows the HTML/VBScript code for the login page. Listing 28.4 shows the
same login page, only generated as part of the Visual Basic DHTML application project.
(I've altered the text layout of both listings for the code to be more readable; the syntax of
the code hasn't been altered in any way.)
Download this project's code
The code for this project can be found in the file VB6CH28.zip, which you can download
from the Web site dedicated to this book. The project file is prjSimpleLogin.vbp.
LISTING 28.3 28HTM03.HTM--A Login Screen That Uses VBScript with HTML
01 
03 <HTML>
04 <TITLE>Simple Login in Standard HTML</TITLE>
05 <HEAD>
06 <SCRIPT LANGUAGE=VBScript>
07 
42 </SCRIPT>
43 </HEAD>
44
45 <P>Type your Login Name:</P>
46 <P>
47 <INPUT TYPE=TEXT NAME=txtName></P>
48 <P>Type your password:</P>
49 <P>
50 <INPUT TYPE=PASSWORD NAME=pwdMain></P>
51 <P>Select your role:</P>
52 <P><SELECT NAME=selectMain>
53 <OPTION SELECTED VALUE=Guest>Guest
54 <OPTION VALUE=Employee>Employee
55 <OPTION VALUE=Contractor>Contractor
56 </SELECT>
57
58 </P>
59 <P>Click your status:</P>
60 <P><INPUT NAME=Option1
61 TYPE=RADIO
62 VALUE=Salary CHECKED> Salary</P>
63 <P><INPUT NAME=Option2
64 TYPE=RADIO
65 VALUE=Hourly>Hourly</P>
66
67 <P><INPUT NAME=cmdValidate
68 TYPE=button
69 VALUE=Validate></P>
70 </BODY>
71 </HTML>
Class ID
DHTML references functionality that's created within a DHTML application DLL through
a class ID. A DHTML project compiles into a DLL. When you compile the code, VB
assigns a unique number--a class ID--to the DLL. When you deploy your DHTML
application to Internet Explorer via the Internet, the browser automatically registers the
class ID of the DLL in the Windows Registry. Then, when Internet Explorer encounters the
class ID in the page, it automatically looks up the classid in the Registry to find the location
of the DLL and other particulars.
Notice that lines 6-42 in Listing 28.3 show the script that captures the button click event
procedure, whereas Listing 28.4 shows no script whatsoever. This is because the button
click event procedure for Listing 28.4 is encapsulated within a DLL referenced by the
classid, as shown on line 3.
LISTING 28.4 SIMPLELOGIN.HTM--DHTML Code Generated by a VB DHTML

Application
01 

02 <object id="DHTMLPage1"
03 classid="clsid:9318A4D8-12D7-11D2-A58E-B6A734C6C111"
04 width=0 height=0>
05 </object>
06 
07 <BODY>
08 <P>Type your Login Name:</P>
09 <P>
10 <INPUT id=txtName name=txtName ></P>
11 <P>Type your password:</P>
12 <P>
13 <INPUT id=pwdMain name=PasswordField1 type=password></P>
14 <P>Select your role:</P>
15 <P><SELECT id=selectMain
16 name=selectMain
17 style="HEIGHT: 22px; WIDTH: 161px"
18 value = Select1>
19 <OPTION selected value=Guest>Guest
20 <OPTION value=Employee>Employee
21 <OPTION value=Contractor>Contractor</SELECT>
22 </P>
23 <P>Click your status:</P>
24 <P><INPUT id=Option1
25 name=Option1
26 type=radio
27 value=Salary CHECKED> Salary</P>
28
29 <P><INPUT id=Option2
30 name=Option2
31 type=radio
32 value=Hourly>Hourly</P>
33 <P><INPUT id=cmdValidate
34 name=cmdValidate
35 type=button
36 value=Validate></P>
37 </BODY></HTML>
Making an interactive page like this login page by using HTML with VBScript requires
paying a lot of attention to the detail of HTML and how it interacts with VBScript. The
programming experience isn't at all visual. Everything is character based, thus giving you
ample opportunity to make time-consuming syntax errors. On the other hand, making the
same page as a DHTML application enables you to use your existing VB programming
skills and visually create pages. Also, because you're using the Visual Basic IDE, you can
take advantage of VB's de

Obtener Datos Del Servidor Sin PostBack

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Obtener Datos Del Servidor Sin PostBack

Cargado por

Copyright:

Formatos disponibles

Obtener datos del servidor sin

Buscando en Internet me he topado con muchas soluciones para esto pero

Entender el script es simple está dividido en 3 zonas principales:

/*@cc_on @*//*@if (@_jscript_version >= 5)

if (!_xmlhttp && typeof XMLHttpRequest!='undefined') {

Primero valida si el objeto ha sido instanciado y si no trata de crearlo.

<INPUT id="PostBack" type="button" value="Button"

Aquí observamos una pagina que se llama Controladora.aspx y un parámetro

<asp:TextBox id="txtTemp" runat="server"

Con la caja de texto y un botón apuntando a la función xmlRead lo que sigue

Ahora nos vamos a su código y en el evento load del formulario de la pantalla

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

return; //Salimos de la funcion

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As

Select Case reg

Espero que este articulo les sirva como a mi me sirvió Gracias.

Working with MSDTC

Hide Copy Code

Using the Code

Hide Copy Code

From your machine:

Hide Copy Code

Hide Copy Code

IP Address vs Machine Name

From Your Machine

Hide Copy Code

//you will get results similar to

Ethernet adapter Ethernet:

Connection-specific DNS Suffix . : x.com

Hide Copy Code

Pinging ENPAYSAFEDEVDB [10.10.10.2] with 32 bytes of data:

Hide Copy Code

Track Your Transactions

Hide Copy Code

The output will be something similar to:

When Connect Completed Sleeping / Awaiting Command

Query e.g. select "1" Running

When select completed Sleeping / Awaiting Command

DTCPing can be downloaded from:

Using LINQ for type Conversion

Using the Code

Hide Shrink Copy Code

Now, you can use the Cast method like this:

GridView all in one

To control the order and rendering

Presents the bound data in

Bubbles a user command from

rendered in the column

Displays Edit, Update, and Cancel

When EditItemIndex is set to a particular row, the EditCommandColumn displays "update"

Occurs when the server control binds to a data source.

Occurs after the server control binds to a data source.

Occurs when a server control is released from memory, which

Occurs when the server control is initialized, which is the first

GridView control handles the paging operation.

Occurs after the Control object is loaded but prior to

Occurs when the Cancel button of a row in edit mode is

RowCreated Occurs when a row is created in a GridView control.

Occurs when a data row is bound to data in a GridView

Occurs when a row's Delete button is clicked, but after the

Occurs when a row's Delete button is clicked, but before the

Occurs when a row's Edit button is clicked, but before the

Occurs when a row's Update button is clicked, but after the

/@cc_on @//*@if (@_jscript_version >= 5)