Programación Visual

Estrategia de Desarrollo y Codificación

Autor: Lic. Marcos Brito, MCE
Revisión
Historial de cambios

Fecha Autor Versión Cambios

11/01/2010 Marcos Brito 1.0 Presentación inicial del documento.

Revisores

Nombre Versión Aprobada Posición Fecha

Distribución

Nombre Posición

Propiedades del Documento

Elemento Detalle

Titulo Estrategia de desarrollo y codificación.

Autor Marcos Brito
Fecha Creación
Ultima Actualización
Table of Contents
Objetivos del documento ................................................................................................................ 4
Beneficios ....................................................................................................................................... 4
ARQUITECTURA Y COMPONENTES ....................................................................................... 5
La capa de presentación .............................................................................................................. 5
Pantallas. ..................................................................................................................................... 5
La capa de Negocios. .................................................................................................................. 6
La capa de Datos ......................................................................................................................... 6
Imagen de la estructura ............................................................................................................... 6
Consideraciones especificas en el diseño y programación del sistema .......................................... 7
Procesamiento de Peticiones. .................................................................................................. 7
Autenticación y Autorización. ................................................................................................ 8
Encriptación de Claves (HASH) ........................................................................................... 10
Gestión de Excepciones y Página General de Mensajes. ...................................................... 11
Validaciones. ......................................................................................................................... 12
Estándares de Codificación y generales para el desarrollo. .......................................................... 12
Conclusión. ................................................................................................................................... 14
Objetivos del documento
- Unificar la visión de trabajo.
- Proveer al (los) programadores de una guía de codificación sólida basada en las mejores
prácticas para producir un código de alta calidad, armonioso y de buen rendimiento (Best
Performance).
- Utilizar las mejores prácticas de desarrollo

Beneficios
1. Facilidad en la lectura del código, reduciendo la complejidad del mismo.
2. La mantenibilidad del código, donde se pueda modificar fácilmente y agregarle nuevas
características.
ARQUITECTURA Y COMPONENTES
La arquitectura de desarrollo a utilizar para el proyecto SIGOB-SIMAT es la de tres capas, la cual
describimos a continuación:

- Capa de Presentación o Aplicación

- Capa de negocios
- Capa de acceso a datos

La capa de presentación
Contiene el código que define lo que el usuario debe ver en la pantalla, incluyendo los campos con
formato y los menús de navegación. A continuación presentamos la matriz de controles a utilizar,
cualquier otra opción debe ser consultada con el equipo completo del proyecto.

OPERACION COMPONENTE FABRICANTE COMENTARIO

Entrada de Datos TextBox Microsoft

Selección de Datos en Listas con Listbox Microsoft

más de 10 Registros
Selección de Datos en Listas con Combobox Microsoft
menos de 10 Registros
Despliegue General de Datos Listview Microsoft Control que viene en la instalación por
defecto del Visual Studio. La cantidad de
líneas a desplegar por defecto para estos
controles debe ser trabajada como un
parámetro que se colocara en el
WEB.CONFIG.
Ayuda en línea para cada control ToolTip Microsoft
El menú general del portal Menu Microsoft
Los tabs en las ventanas del TabStrip Microsoft
portal
Cualquier otro control a usar que no esté especificado en el cuadro debe ser consultada con el equipo.

Pantallas.
 Realizacion de un plantilla para las pantallas.
 Todos los labels de la pantalla se colocarán encima de los textboxs.
La capa de Negocios.
El código buscado, insertado o actualizado por la capa de datos es expuesto a la capa de presentación
usando esta capa.

La capa de Datos
Para conectarnos a la base de datos vamos a utilizar los componentes nativos de Microsoft.

Imagen de la estructura
Consideraciones especificas en el diseño
y programación del sistema

En el desarrollo del sistema en general debemos tomar estos puntos en consideración:

Procesamiento de Peticiones.
El procesamiento de las peticiones al servidor deben ser las necesarias, es decir, cada control en donde
no se necesite hacer postback debe tener esta opción deshabilitada (False) y para cada página en donde
las peticiones sean necesarias vamos a tener una funcionalidad para poder medir el tiempo de las
mismas, esta rutina será colocada en el archivo Global.asax, y es la siguiente:
Sub Application_BeginRequest(ByVal sender As Object, ByVal e As EventArgs)
Context.Items.Add("FechaHoraCarga", DateTime.Now)
End Sub

Sub Application_EndRequest(ByVal sender As Object, ByVal e As EventArgs)

Dim tDuracion As TimeSpan

tDuracion = DateTime.Now.Subtract(Context.Items("FechaHoraCarga"))
End Sub

En las pruebas de calidad, que se deben hacer en ambientes parecidos a los de producción, debemos de
medir este tiempo para poder tener una métrica del tiempo de duración entre las peticiones de las
páginas más usadas en el portal, garantizando así la calidad de las respuestas una vez puesta en punto la
aplicación en producción.

Los tiempos de respuestas tienen factores importantes que se deben tomar en cuenta:

1. Los servidores donde estén descansando la base de datos y la aplicación, potencia de

procesamiento, memoria, velocidad en de los discos y sus arreglos, entre otros.
2. La configuración y la optimización de la base de datos, sus índices, llaves primarias.
3. La optimización de los querys
4. El ancho de banda usado
5. El manejo de la aplicación de los datos recuperados desde la base de datos.
Autenticación y Autorización.

La autenticación en el sistema se debe hacer contra los usuarios definidos en las tablas para estos fines.

PARA EL PORTAL.
La forma de manejar la seguridad de entrada al portal es la autenticación mediante un WEB FORM, para
esto en el WEB.CONFIG pondremos:
<authentication mode="Forms">
<forms name=".BANCO" loginUrl="Login.aspx" protection="All" timeout="10" path="/">
</forms>
</authentication>

Las páginas del portal que requieran autenticación se van a definir en el WEB.CONFIG, la rutina para
hacer esto la detallamos a continuación (la página especificada es un ejemplo):

<location path="frmNuevoCliente.aspx">
<system.web>
<authorization>
<deny users="?"/>
</authorization>
</system.web>
</location>

El rol de cada usuario, después de ser autenticado en el portal se manejara en el evento LOAD de cada
página con las rutinas siguiente.

- Rutina para verificar si el usuario esta autenticado en el portal

If Not HttpContext.Current.User.Identity.IsAuthenticated() Then

Response.Redirect(Me.ResolveUrl("frmMensajes.aspx?id=mensaje"))
Exit Sub
End If

- Rutina para verificar si el usuario pertenece al rol defino y puede usar esta página, Autorización,
(Utilizamos el rol de supervisor como ejemplo, esto puede cambiar y es configurable.)

Dim InRol As Boolean = HttpContext.Current.User.IsInRole("Supervisor")

If InRol = False Then
Response.Redirect(Me.ResolveUrl("frmMensajes.aspx?id=36"))
Exit Sub
End If
En el Global.asx del portal esta rutina se colocara:
Sub Application_AuthenticateRequest(ByVal sender As Object, ByVal e As EventArgs)
If Not (Context.User Is Nothing) Then
If Context.User.Identity.IsAuthenticated Then
Dim oSeg As New NombreDeLaClaseDeSeguridad
Dim username As String = Context.User.Identity.Name
Dim UserRol() As String = oSeg.BuscarRol(username)
Dim UserIdentity As New System.Security.Principal.GenericIdentity(username)
Dim UserPrincipal As New System.Security.Principal.GenericPrincipal(UserIdentity, UserRol)
Context.User = UserPrincipal
End If
End If
End Sub

En combinación con la clase de seguridad, donde tendremos un método llamado BuscaRol :

Public Function BuscarRol(ByVal strUserName As String) As String()

'Configurando mi variable con el string de conexion.

'La conexión a base de datos se trabajara con el componente universal entregado por el
personal del PNUD.

Dim strRole() As String

Dim strConn As String
Dim objConnectionStringSettings As ConnectionStringSettings =
ConfigurationManager.ConnectionStrings("Banco")
strConn = objConnectionStringSettings.ConnectionString

'Creando la conexion

'Definiendo el Objeto Conexion

Dim objConn As New System.Data.SqlClient.SqlConnection(strConn)
'Abriendo la conexion definida
objConn.Open()
Dim CollRole As New StringCollection

Dim rdr As SqlDataReader

Dim strSQL = "exec up_roles '" & Trim(strUserName) & "'" (ESTO DEBE SER CAMBIADO POR EL
COMPONENTE DE CONEXION)
Dim oCmd = New SqlCommand(strSQL, objConn)
oCmd.CommandType = CommandType.Text

Try
If objConn.State = ConnectionState.Closed Then
objConn.Open()
End If
rdr = oCmd.ExecuteReader()
CollRole.Clear()
Do While rdr.Read
CollRole.Add(Trim(rdr("Rol")))
Loop
objConn.Close()
'Copiando al String De Retorno los valores devueltos
ReDim strRole(CollRole.Count - 1)
CollRole.CopyTo(strRole, 0)
Return strRole
Catch oErr As Exception
EventLog(oErr)
End Try

Return strRole

End Function
Encriptación de Claves (HASH)

Las claves de los usuarios deben ser guardado mediante un hash, propios del framework de Microsoft
.NET son los que vamos a usar:

Las rutinas son las siguientes:

'Función para Encriptar usando MD5

Public Function EncryptMD5(ByVal cleanString As String) As String
Dim clearBytes As [Byte]()
clearBytes = New UnicodeEncoding().GetBytes(cleanString)
Dim hashedBytes As [Byte]() = CType(CryptoConfig.CreateFromName("MD5"),
HashAlgorithm).ComputeHash(clearBytes)
Dim hashedText As String = BitConverter.ToString(hashedBytes)
Return hashedText
End Function

'Función para Encriptar usando SHA-1

Public Function EncryptSHA1(ByVal strSource As String) As String
Dim bytHash As Byte()
Dim uEncode As New UnicodeEncoding
'Almacenamos la cadena original en una Matriz de bytes
Dim bySource() As Byte = uEncode.GetBytes(strSource)
Dim sha1 As New SHA1CryptoServiceProvider
'Crear el Hash
bytHash = sha1.ComputeHash(bySource)
'Devolver como una cadena codificada en base64
Return Convert.ToBase64String(bytHash)

End Function
Gestión de Excepciones y Página General de Mensajes.

El manejo de las excepciones se trabajarán basadas en mensajes, los mismos ubicados en un archivo
XML y se desplegaran, para algunos, en una página llamada “frmMensajes”, la misma recibirá como
parámetro el ID del mensaje vía URL.

La estructura del archivo XML es:

<Mensajes>
<Mensaje>
<idMensaje>1</idMensaje>
<Titulo>Acceso no Autorizado para esta página</Titulo>
<CuerpoMensaje>No tiene autorización para autilizar este recurso,favor verificar o
contactar a uno de los administradores</CuerpoMensaje>
<ImagenMensaje>Imagenes/fail.jpg</ImagenMensaje>
<TituloPrimeraAccion>Reintentar Operación</TituloPrimeraAccion>
<TituloSegundaAccion>Enviar Correo a Soporte Técnico</TituloSegundaAccion>
<PaginaPrimeraAccion>VolverALaPaginaOriginal.aspx</PaginaPrimeraAccion>
<PaginaSegundaAccion>HelpDesk.Aspx</PaginaSegundaAccion>
<EnviarCorreo>S</EnviarCorreo>
</Mensaje>

</Mensajes>

Para los mensajes que ameriten enviar un correo al personal técnico, en el archivo WEB.CONFIG
definiremos el o los mismos.

El código en nuestra aplicación para manejar los errores es:

Try

Catch ex As Exception

End Try

Nota : La aplicacion debe grabar el log, subir el formato del log en este
documento.

Alguno de sus usos obligatorios es:

o Antes de invocar un objeto de base de datos
o Antes de acceder a un recurso externo, por ej. Un archivo XML

Cualquier otra operación que el programador considere pertinente, siempre y cuando no altere la
secuencia del programa. Ej. Disparar excepciones para romper el flujo.
Validaciones.

En la entrada de datos tendremos dos niveles de validaciones, los primeros realizados por los controles
propios de .NET, el segundo nivel consiste en validaciones usando Expresiones Regulares.

Todos los campos tendrán como longitud máxima, el valor mayor del mismo en la base de datos, la
validación del tamaño se debe hacer también del lado del servidor, no solamente especificando la
longitud máxima en el control.

Las validaciones que aquí especificamos están del lado de la aplicación, en la base de datos debemos
también contar con los constraints necesarios para mantener los datos íntegros.

Estándares de Codificación y generales

para el desarrollo.
Para conservar recursos debemos ser muy selectivos en la elección del tipo de dato, asegúrese
que el tamaño de una variable no sea excesivamente grande. Por ejemplo en los ciclos for es
mejor, en la mayoría de las veces utilizar un tipo de dato tipo short que int, dependiendo de la
situación
Mantener el tiempo de vida de las variables tan corto como sea posible, esto es muy importante
cuando nos conectamos a la base de datos.
Mantener el scope (alcance) de las variables tan corto como sea posible, esto sirve para evitar
confusiones, mejorar la mantenibilidad y además minimiza la dependencia, es decir si por algún
motivo se comete el error de borrar una variable es más fácil de encontrar el error si esta tiene
un scope más pequeño.
Usar los procedimientos y variables con un solo propósito. Evite crear procedimientos
multipropósito que lleven a cabo una variedad de funciones no relacionadas. (COHESION AL
MAXIMO NIVEL)
Dentro de una clase, EVITAR el uso de variables públicas, en cambio utilice procedimientos y
propiedades que accedan a dichas variables (privadas), así provee una capa de encapsulación y
brinda la posibilidad de validar valores de cambio sobre las mismas, antes de manipularlas
directamente.
Usaremos siempre sentencias Select-Case o Switch en lugar de utilizar sentencias if-then
repetitivas
Siempre que sea posible vamos a sobrecargar los métodos en las clases.
Con respecto a cómo vamos a nombrar las variables, clase, namespace entre otros tenemos:

1. Los nombres de todas las variables, estructuras, clases y namespaces deben ser en español.
2. El nombre de los NameSpaces deben empezar con las siglas, BB (Banco Binario)
3. Los nombres de las clases y del archivo deben ser iguales
4. Los nombres de los formularios deben empezar con el prefijo “frm”
5. Los nombres de los reportes deben empezar con el prefijo “rpt”
6. Los nombres de los labels deben empezar con el prefijo “lbl”
7. Los nombres de los textbox deben empezar con el prefijo “txt”
8. Los nombres de los listview deben empezar con “lv”
9. Los nombres de los formularios que son para consultas o listas deben empezar con “lst”
10. La primera letra de cada Nombre de las clases debe ser Mayuscula, ej. ClsPersona
11. Todas las variables deben empezar con su tipo de datos, ej. sNombreClliente para denotar que
la variable es de tipo string.
12. Los nombre de las variables (atributos) de cada clase deben empezar con un (undescore , _) ,
ej. _NombrePersona
13. Todos los nombres de los parámetros usados en funciones y/o procedimientos deben estar
precedidos de la letra P, en minúscula.
14. Los nombres de las variables y atributos de las clases deben ser en singular.
15. Una clase debe estar definida en orden descendente de la siguiente manera: Variables
Miembro, Constructores, Enumeraciones, Estructuras o Clases anidadas, Propiedades y por
último los Métodos.
16. La secuencia de declaración de acuerdo a los modificadores de acceso debe ser la siguiente:

public
protected
private

Cualquier otro control que no esté especificado de con que prefijo debe iniciar, favor recomendarlo y
agregarlo a este documento después del acuerdo de todo el equipo.

La estructura de la solución en .net la especificaremos en el próximo documento a enviar, el cual va a

contener el diseño conceptual de la aplicación.
Conclusión.
En el presenta documento trazamos las directrices necesarias para que la calidad del desarrollo de la
aplicación sea de un alto nivel y lograr unificar visión en términos de desarrollo y estructura de la
aplicación.