Estándar de Programación en el Proyecto Middleware

Estándar de Programación en el
Proyecto Middleware

1
Estándar de Programación en el Proyecto Middleware

Índice General

Introducción .............................................................................................................................. 4
1 CREAR UN NUEVO WEB SERVICE en C# ..................................................................... 5
1.1. Definir LA UBICACION del web service..................................................................... 5
1.2. Definir el nombre del web service ................................................................................. 5
1.3. Definir la ubicación del interface ................................................................................... 6
1.4. Definir la ubicación de las entidades ............................................................................. 7
1.5. declaracion de atributos de una clase entidad ................................................................ 9
Para nombrar a los atributos, utilizar mayúscula para la primera letra y también mayúscula
para la primera letra de la/s siguiente/s palabra/s y asignar un nombre que permita
relacionarlo claramente a su funcionalidad. ......................................................................... 9
1.6. Definir la ubicación de la capa de datos ........................................................................ 9
1.7. Declaración de un método en la capa de datos ............................................................ 11
Para nombrar a los métodos, utilizar mayúscula para la primera letra y también mayúscula
para la primera letra de la/s siguiente/s palabra/s. De igual forma, a la hora de pasar
parámetros de entrada, se tiene que empezar el nombre de la variable con la letra “p” y en
minúscula. También describir mediante un summary la descripción del método. ........... 12
Para poder implementar el contenido del método, se tiene que respetar ciertas reglas:..... 12
Para nombrar a los métodos, utilizar mayúscula para la primera letra y también mayúscula
para la primera letra de la/s siguiente/s palabra/s. De igual forma, a la hora de pasar
parámetros de entrada, se tiene que empezar el nombre de la variable con la letra “p” y en
minúscula. También describir mediante un summary la descripción del método. ........... 14
Para poder implementar el contenido del método, se tiene que respetar ciertas reglas:..... 14
1.8 Definir la ubicación de la capa de negocio .................................................................. 15
1.9 Declaración de un método en la capa de negocio ........................................................ 15
1.9 Declaración de métodos en una interface ......................................................................... 16
2.0 implementacion de metodos de una interface................................................................... 17
2.1 Utilitarios .......................................................................................................................... 17

2
Estándar de Programación en el Proyecto Middleware

HISTORIAL DE REVISIONES

Fecha Versión Descripción Autor

19/02/18 1.0 Estándar de Programación en el Proyecto Middleware Edwin Mantilla

3
Estándar de Programación en el Proyecto Middleware

Introducción

Estándar de Creación de Nuevos Objetos en el Proyecto Middleware

- Programación en lenguaje C#

Este documento describe el estándar que adoptaremos para la creación de

nuevos objetos en el proyecto Middleware, el entorno de desarrollo está
bajo el IDE Visual Studio y lenguaje C#.
Para que un software posea alta performance, debe ser escrito con un
estilo de programación bien definido. Esto lo hace fácilmente mantenible,
extensible, predecible y robusto.
Cuando agreguemos nuevos objetos, los cambios producidos deben seguir
el estilo de programación original y no debemos intentar introducir uno
nuevo o modificar la estructura del código, ya que generaría cierta
dificultad en la comprensión del mismo.

Todo software por desarrollar debe ser:

Simple: En la construcción de clases y métodos.

Claro: Asegurarse que las clases, interfaces, objetos y variables

posean un rol bien definido en el código.

Detallado: Proveer la documentación de todas las funcionalidades

que brinde el código para todos aquellos que deban usarlo
y mantenerlo; es decir, una breve descripción de la
funcionalidad que cumplen.

Consistente: Referido a que entidades semejantes deben presentar un

mismo comportamiento.

Robusto: Manejar excepciones, no ocultar los errores ni forzar al

cliente a detectarlos.

4
Estándar de Programación en el Proyecto Middleware

1 CREAR UN NUEVO WEB SERVICE EN C#

1.1. DEFINIR LA UBICACION DEL WEB SERVICE

Para poder definir la ubicación del web service, se tiene que agregar en la
capa donde se encuentra los demás servicios.

Ubicación:
5. Servicios  WS.Integrador.PeruRail, ahí se creará el nuevo servicio.

1.2. DEFINIR EL NOMBRE DEL WEB SERVICE

Para poder definir el nombre de un Web Service, se tiene que verificar el

esquema de los que ya existen y crear en base a ellos.

Por ejemplo, quiero crear un nuevo web service, cuyo módulo que me toca
desarrollar es de seguridad.
Me dirijo a la capa donde se encuentran los servicios y agrego el nuevo. Sin
embargo, si no se crea uno nuevo, se debe de implementar en el servicio
correspondiente con todas las capas que las vincula.

Ubicación:
5. Servicios  WS.Integrador.PeruRail, ahí se creará el nuevo servicio.

El nombre de un nuevo servicio, debe de tener el siguiente estándar:

Srv[NuevoServicio]PeruRail.svc

SrvIntegradorPeruRail.svc --- Web Service existente

SrvSeguridadPeruRail.svc --- Web Service nuevo

5
Estándar de Programación en el Proyecto Middleware

Paso 1 - Seleccionar

Paso 2 – Digitar correctamente el nombre

He creado un nuevo web service (WCF) y he seguido el estándar existente,

de igual forma cuando se agreguen nuevos servicios se tiene que respetar
los estándares de creación.

Servicio creado con el estándar

1.3. DEFINIR LA UBICACIÓN DEL INTERFACE

Cuando un servicio web se crea, lo hace junto a su interface. En este caso,

vamos a ubicar la interface del web service SrvSeguridadPeruRail, en la
capa que lo corresponde.

6
Estándar de Programación en el Proyecto Middleware

Ubicación:
4. Interface  WS.IntegradorServicios.Interface, ahí pasaremos el
interface del servicio en mención, que se encuentra en la capa de servicios.
Cuando se creó, se ubicaba en WS.Integrador.PeruRail.

Interface creado inicialmente en el proyecto

WS.Integrador.PeruRail

Cuando se movió, se ubica en WS.IntegradorServicios.Interfaces.

Interface ubicada en el proyecto de Interfaces

WS.IntegradorServicios.Interfaces

1.4. DEFINIR LA UBICACIÓN DE LAS ENTIDADES

1. Entidades  WS.IntegradorServicios.Entidades, si el módulo de

trabajo es nuevo, hay que crear una nueva carpeta, por ejemplo:

ModSeguridad – se crea de esa manera ya que el módulo de desarrollo es

de seguridad, si fuera otro Mod[Nombre], donde [Nombre] es el estándar
que se debe seguir para crear una nueva carpeta.

7
Estándar de Programación en el Proyecto Middleware

Proyecto WS.IntegradorServicios.Entidades

Carpeta creada correctamente

Luego de crear la carpeta con el nombre correspondiente (ModSeguridad),

tenemos que crear las entidades que utilizará el módulo de Seguridad, para
eso se tiene que crear con la siguiente estructura:

BE[NombreEntidad], el nombre debe ser entendible, no tan largo y en

castellano. Por ejemplo:

- BEUsuarioIn
- BEUsuarioOut

Se han creado 2 entidades que tienen relación BEUsuarioIn y

BEUsuarioOut.
BEUsuarioIn, va a contener los atributos (parámetros) de entrada.
BEUsuarioOut, va a contener los atributos (parámetros) de salida.

Entidades creadas dentro de

la carpeta ModSeguridad

Dentro de la capa de Entidades encontramos una carpeta de nombre

Clases, en él se encuentra una clase llamada Enumeradores, ahí se debe de
crear solamente estructuras de enumeración y clases u constantes que
sean utilizadas netamente por las entidades.

Clase Enumeradores de la
carpeta Clases

8
Estándar de Programación en el Proyecto Middleware

1.5. DECLARACION DE ATRIBUTOS DE UNA CLASE ENTIDAD

Cuando se crea un atributo, se tiene que crear con el siguiente estándar:

Para nombrar a los atributos, utilizar mayúscula para la primera letra y también
mayúscula para la primera letra de la/s siguiente/s palabra/s y asignar un nombre que
permita relacionarlo claramente a su funcionalidad.

1.6. DEFINIR LA UBICACIÓN DE LA CAPA DE DATOS

2. Datos  existen dos proyectos en esta capa:

- WS.IntegradorServicios.SQLServer:
En este proyecto, hay que crear una carpeta cuyo nombre es
ModSeguridad, al igual que en entidades el estándar para crear una
nueva carpeta siempre va la palabra Mod[Nombre].

Proyecto WS.IntegradorServicios.SQLServer

Carpeta creada correctamente

Luego de crear la carpeta con el nombre correspondiente

(ModSeguridad), tenemos que crear las clases que utilizará el módulo
de Seguridad, para eso se tiene que crear con la siguiente estructura:

BD[NombreClase], el nombre debe ser entendible, no tan largo y en

castellano. Por ejemplo:

- BDUsuario

9
Estándar de Programación en el Proyecto Middleware

Clases creadas dentro de la

carpeta ModSeguridad

Dentro de esta capa, encontramos una carpeta de nombre Helper. En

él se encuentran clases compartidas para llamadas a base de datos; y
de agregarse algún nuevo método personalizado, debería ser descrita
la función y valor de cada parámetro, con la finalidad que otro
usuario pueda reutilizarlo, en caso así se requiera.

Clases de Helper

Se puede crear un Summary, para poder saber la finalidad del

método creado.

///<summary>
///
///
///
/// </summary>

- WS.IntegradorServicios.TS
Si vamos a consumir los servicios Travel Studio, de igual forma,
crearemos una carpeta con el nombre Mod[Nombre].
En este proyecto se encuentran las referencias de servicios de Travel
Studio.

10
Estándar de Programación en el Proyecto Middleware

Proyecto WS.IntegradorServicios.TS

Carpeta creada correctamente

Luego de crear la carpeta con el nombre correspondiente (ModSeguridad),

tenemos que crear las clases que utilizará el módulo de Seguridad, para
eso se tiene que crear con la siguiente estructura:

BW[NombreClase], el nombre debe ser entendible, no tan largo y en

castellano. Por ejemplo:

- BWUsuario

Clases creadas dentro de la

carpeta ModSeguridad

1.7. DECLARACIÓN DE UN MÉTODO EN LA CAPA DE DATOS

Para poder crear nuevos métodos en esta capa, primero se tiene que
importar los proyectos a utilizar y seguir los estándares necesarios.

1. Proyecto WS.IntegradorServicios.SQLServer

Este proyecto contiene las entidades a utilizar

using WS.IntegradorServicios.Entidades;
using WS.IntegradorServicios.SQLServer.Helper; Conexión de base de datos y extensiones

11
Estándar de Programación en el Proyecto Middleware

Para nombrar a los métodos, utilizar mayúscula para la primera letra y también
mayúscula para la primera letra de la/s siguiente/s palabra/s. De igual forma, a la hora
de pasar parámetros de entrada, se tiene que empezar el nombre de la variable con la
letra “p” y en minúscula. También describir mediante un summary la descripción del
método.

/// <summary>
/// Metodo : ValidarUsuario Equivalente validar un usuario y traer sus datos
/// </summary>
/// <param name="pBEUsuarioIn"></param>
/// <returns></returns>

Public BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn)

{
}

Para poder implementar el contenido del método, se tiene que respetar ciertas
reglas:

- Todas las declaraciones de variables dentro de un método, se tienen que

declarar al inicio del mismo.

Public BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn)

{
BEUsuarioOut getDatosUsuario = null; Declaración de variable

List<Parametro> parametros = new List<Parametro> {

new Parametro("@cod_usuario", SqlDbType.VarChar, 0, pBEUsuarioIn.cod_usuario),
new Parametro("@des_contrasenia", SqlDbType.VarChar, 0, pBEUsuarioIn.des_contrasenia),
new Parametro("@cod_aplicacion", SqlDbType.Int, 0, pBEUsuarioIn.cod_aplicacion),
new Parametro("@cod_empresa", SqlDbType.Int, 0, pBEUsuarioIn.cod_empresa)};

Declaración de los parámetros de entrada.

}

- Usar un try catch para poder controlar el error.

Public BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn)

{
BEUsuarioOut getDatosUsuario = null;

List<Parametro> parametros = new List<Parametro> {

new Parametro("@cod_usuario", SqlDbType.VarChar, 0, pBEUsuarioIn.cod_usuario),
new Parametro("@des_contrasenia", SqlDbType.VarChar, 0, pBEUsuarioIn.des_contrasenia),
new Parametro("@cod_aplicacion", SqlDbType.Int, 0, pBEUsuarioIn.cod_aplicacion),
new Parametro("@cod_empresa", SqlDbType.Int, 0, pBEUsuarioIn.cod_empresa)};

try
{
//code Controlador de error
}
catch (Exception ex)
{
//code
}

12
Estándar de Programación en el Proyecto Middleware

- Hacer uso de la clase HelperSQL

/// <summary>
/// Metodo : ValidarUsuario Equivalente validar un usuario y traer sus datos
/// </summary>
/// <param name="pBEUsuarioIn"></param>
/// <returns></returns>

public BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn)

{
BEUsuarioOut getDatosUsuario = null;
List<Parametro> parametros = new List<Parametro> {
new Parametro("@cod_usuario", SqlDbType.VarChar, 0, pBEUsuarioIn.cod_usuario),
new Parametro("@des_contrasenia", SqlDbType.VarChar, 0,
pBEUsuarioIn.des_contrasenia),
new Parametro("@cod_aplicacion", SqlDbType.Int, 0, pBEUsuarioIn.cod_aplicacion),
new Parametro("@cod_empresa", SqlDbType.Int, 0, pBEUsuarioIn.cod_empresa)};
Se instancia la clase HelperSQL para la
try conexión de base de datos y extensiones
{
using (HelperSQL helper = new HelperSQL(Util.Conexion()))
{
var reader = helper.ExecuteReader("ValidarUsuario", parametros);

if (reader.Read())
{
Nombre Stored Procedure Parámetros de entrada
}
}

catch (Exception ex)

{

}
return getDatosUsuario;

2. Proyecto WS.IntegradorServicios.TS

En este proyecto, se tiene que consumir el servicio de Travel Studio,

por ello los nuevos métodos en esta capa, también se tiene que
importar los proyectos a utilizar y seguir los estándares necesarios.

Servicio TS:

Servicio Travel Studio

13
Estándar de Programación en el Proyecto Middleware

Importar:
using WS.IntegradorServicios.Entidades; Este proyecto contiene las entidades a utilizar

Para nombrar a los métodos, utilizar mayúscula para la primera letra y también
mayúscula para la primera letra de la/s siguiente/s palabra/s. De igual forma, a la
hora de pasar parámetros de entrada, se tiene que empezar el nombre de la
variable con la letra “p” y en minúscula. También describir mediante un
summary la descripción del método.

/// <summary>
/// Metodo : GetListarTrenesNoBAE Equivalente RailServiceSearch
/// </summary>
/// <param name="pBEBusquedaIn"></param>
/// <returns></returns>

public BEBusquedaOut GetListarTrenesNoBAE(BEBusquedaIn pBEBusquedaIn)

{
}

Para poder implementar el contenido del método, se tiene que respetar ciertas
reglas:
- Todas las declaraciones de variables dentro de un método, se tienen que
declarar al inicio del mismo y agregar el try – catch, de igual forma
instanciar el servicio de TS (Travel Studio) para poder llamar al método
requerido.

/// <summary>
/// Metodo : GetListarTrenesNoBAE Equivalente RailServiceSearch
/// </summary>
/// <param name="pBEBusquedaIn"></param>
/// <returns></returns>

public BEBusquedaOut GetListarTrenesNoBAE(BEBusquedaIn pBEBusquedaIn)

{
BEBusquedaOut bEBusquedaOut = new BEBusquedaOut();
List<BEDetalleBusqueda> bEDetalleBusqueda = new List<BEDetalleBusqueda>();
BEDetalleBusqueda Registro;
Instanciamos el servicio TS y buscamos el
métodos que queremos consumir
try
{
WSTS.RailServiceSearchRequest RSSearch = new
WSTS.RailServiceSearchRequest();
List<WSTS.RailSearchRegion> ListRSSearchRegion = new
List<WSTS.RailSearchRegion>();
WSTS.enmConnector Conector = new WSTS.enmConnector();

Enum.TryParse("enmTSHotelAPI", out Conector);

//"58808620-40A7-41FD-8AF4-19D7F30FC663"

RSSearch.Authenticate = new WSTS.AUTHENTICATE {

LICENSEKEY = bEBusquedaIn.Licensekey,
LANGUAGE = bEBusquedaIn.Idioma,
PASSENGERID = bEBusquedaIn.IdPasajero, Connector = Conector };

}
catch (Exception ex)
{
// code
}
}
14
Estándar de Programación en el Proyecto Middleware

1.8 DEFINIR LA UBICACIÓN DE LA CAPA DE NEGOCIO

3. Logica  WS.IntegradorServicios.Logica, si el módulo de trabajo es

nuevo, se debe de crear la clase de negocio con el estándar que se
muestra, por ejemplo:

Antes:

Carpeta de la Lógica de Negocio

Después:

Proyecto WS.IntegradorServicios.Logica

Nueva clase de negocio, creada para Seguridad

1.9 DECLARACIÓN DE UN MÉTODO EN LA CAPA DE NEGOCIO

Para poder crear nuevos métodos en esta capa, primero se tiene que
importar los proyectos a utilizar, referenciar el interface y seguir los
estándares necesarios.

Proyectos importados

Referenciar el Interface creado

Instanciar la capa de datos

000 Digitar el nombre y parámetros, se

tiene que llamar igual al de la capa
000 de datos.

Instanciamos el objeto y llamamos 15

al método de la capa de datos.
Estándar de Programación en el Proyecto Middleware

1.9 DECLARACIÓN DE MÉTODOS EN UNA INTERFACE

Cuando se declara un método en la interface, tiene que ser declarado con

los estándares correctos e importar los proyectos a utilizar.

Seleccionamos y damos doble clic.

Importar referencias y proyectos

a utilizar.

Al crear un método, lo primero se tiene que definir sus operaciones se

servicio, estas se ubican debajo del [OperationContract]:
Nombre del método declarado

[OperationContract]
[WebInvoke (UriTemplate = "ValidarUsuario", Method = "POST", RequestFormat =
WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]

Declaración de método:
Para todo archivo fuente, clase, variable, método, constante, etc., asignar
un nombre que permita relacionarlo claramente a su funcionalidad. Para
nombrar a los métodos, utilizar mayúscula para la primera letra y también
mayúscula para la primera letra de la/s siguiente/s palabra/s. De igual
forma, a la hora de pasar parámetros de entrada, se tiene que empezar el
nombre de la variable con la letra “p” y en minúscula.

Nombre parámetro de entrada

Nombre del método declarado

BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn);

La declaración del método dentro de la interface quedaría:

[ServiceContract]
public interface ISrvSeguridadPeruRail
{
[OperationContract]
[WebInvoke (UriTemplate = "ValidarUsuario", Method = "POST", RequestFormat =
WebMessageFormat.Json, ResponseFormat = WebMessageFormat.Json)]
BEUsuarioOut ValidarUsuario (BEUsuarioIn pBEUsuarioIn);
}

16
Estándar de Programación en el Proyecto Middleware

2.0 IMPLEMENTACION DE METODOS DE UNA INTERFACE

Para poder implementar un método de una interface, nos posicionamos en:

5 Servicios  WS.Integrador.PeruRail  Srv[ServicioCreado]PeruRail.svc
Para el ejemplo:
SrvSeguridadPeruRail.svc

Seleccionamos y damos doble clic.

Importar referencias y proyectos a utilizar.

Referenciar el interface

Instanciar la capa de negocio.

Digitar el nombre y parámetros, se

tiene que llamar igual al de la capa
de negocio.

Esta clase nos indica la propiedad de tiempo

transcurrido de un método. Se ubica en el
proyecto WS.Integrador.Comunes

Instanciamos el objeto y llamamos

al método de la capa de negocio.

2.1 UTILITARIOS

6. Utilitarios  WS.Integrador.Comunes, en esta capa se encuentran

clases como Util.cs, Encriptador.cs, ExecutionTimeLogger.cs y
TimeStampUtil.cs, estas dos últimas hacen referencia al registro de log de
errores. Estas clases se usarán para métodos comunes en todo el proyecto.
Por otro lado, de requerir agregar una clase extensión, se tiene que
17
Estándar de Programación en el Proyecto Middleware

describir brevemente la razón de su creación para que pueda ser

reutilizado, de darse el caso.

Clases del proyecto

WS.Integrador.Comunes

18