BEST PRACTICES (BUENAS PRÁCTICAS)

Consiste en lograr un desarrollo eficiente, tanto para la máquina, evitando

flujos innecesarios y con demasiada carga de recursos, como para el
programador que con un código más limpio e intuitivo logra una mayor
facilidad para comprender, seguir y manipular dicho código, logrando mayor
eficiencia y productividad.

Algunas reglas básicas que debe conocer todo programador está

relacionado con el flujo de datos desde una ventana a otra, casos que se
describen a continuación:

1.- Siempre que se acceda a un dato recuperado de una llamada a un

servicio, comprobar siempre que se encuentra en el contexto, ejemplo:

ControlFlujo flujo = NuevoControlFlujo();

flujo.GestorFuncional =
typeof(Telefonica.Hera.Front.T_HAV0004);

flujo.ServicioRequerido =
(int)Telefonica.Hera.Front.T_HAV0004.Servicios.DetallesFacturaci
on;

flujo.Ejecuta();

if (ContextoLocal.ContainsKey("ds1T"))

dsHAFKCPCO ds1T = (dsHAFKCPCO)ContextoLocal["ds1T"];

….

2.- Siempre introducir las transacciones a servicios dentro de un try y catch,

ejemplo:

try

{
Transacciones.com_telefonica_ssnn_ha_HAB1317(ds1317);

}
 catch { }

3.- Siempre que se quiera acceder a un dato de una fila en concreto de un

DataSet asociado a un servicio, comprobar antes que la tabla que debe
contener los datos, tiene filas. Ejemplo:

ControlFlujo CargarDireccion = NuevoControlFlujo();

CargarDireccion.SinContexto = SinContexto;

CargarDireccion.GestorFuncional =
typeof(Telefonica.Hera.Front.T_HAV0004);

CargarDireccion.ServicioRequerido=(int)Telefonica.Hera.Front.T_H
AV0004.Servicios.ConsultaDireccion;

CargarDireccion.Ejecuta();

//JFG poner un valor por defecto

ContextoLocal["NU-CALLE"] = "";

ContextoLocal["CO-PROVINCIA"] = "";

ContextoLocal["NU-ENTIDAD-POBLAC"] = "";

ContextoLocal["NU-FINCA"] = "";

if (ContextoLocal.ContainsKey("Result.ds0B"))

dsHA0BCPCO ds0B = (dsHA0BCPCO)ContextoLocal["Result.ds0B"];

if (ds0B.ENTRADA.Rows.Count > 0)

ContextoLocal["NU-CALLE"] =
ds0B.ENTRADA[0]._NU_CALLE.ToString().TrimEnd();

ContextoLocal["CO-PROVINCIA"] =
ds0B.ENTRADA[0]._CO_PROVINCIA.ToString().TrimEnd();

ContextoLocal["NU-ENTIDAD-POBLAC"] =
ds0B.ENTRADA[0]._NU_ENTIDAD_POBLAC.ToString().TrimEnd();
ContextoLocal["NU-FINCA"] =
ds0B.ENTRADA[0]._NU_FINCA.ToString().TrimEnd();

if (ds0B.SALIDA.Rows.Count > 0)

ContextoLocal["DS-CALLE"] = ds0B.SALIDA[0]._DS_CALLE.TrimEnd();

ContextoLocal["DS-DOMICILIO"] =
ds0B.SALIDA[0]._DS_DOMICILIO_INS.TrimEnd();

ContextoLocal["DS-POBLACION"] =
ds0B.SALIDA[0]._DS_ENTIDAD_POBLAC.TrimEnd();

ContextoLocal["DS-PROVINCIA"] =
ds0B.SALIDA[0]._DS_PROVINCIA.TrimEnd();

ContextoLocal["NU-POSTAL"] =
ds0B.SALIDA[0]._NU_CODIGO_POSTAL.ToString().TrimEnd();

4.- Problemática de los servicios que tienen subgrupos en un subgrupo en

las tablas de salida. (ALBERTO ARIAS RELLENA ESTO).

5.- Siempre que un servicio de el error ‘Error leyendo campo “ ’ (Error

leyendo campo comillas dobles) , es porque en la generación del dataset se
ha pasado o bien utilizar como custom tool, el HeraDataSetGenerator, o
bien después de poner HeraDataSetGeneratos se ha pasado ejecutar “Run
Custom Tool”.

6.- Antes de crear un método nuevo, que se piense que es “genérico”

(eliminación de caracteres extraños, parseo de fechas, movimiento en los
campos para paginar las transacciones de los servicios, obtención de
códigos/descripciones de combos, etc), comprobar si ya existe en la clase
utilidades.

7.- Jamás utilizar componentes de Windows, solo se deben utilizar los de la

arquitectura, es decir, no se debe utilizar la clase TextBox sino la
HeraTextBox. Esto es porque al ejecutar el proyecto en modo release fallará
dicho componente de Windows.
Actualmente se encuentra en desarrollo una importante mejora respecto a
la forma de tratar las ventanas, que implica una reducción de los controles
de flujos y lograr una definición de clases, con sus atributos y entidades, de
esta forma se podría lograr una mayor abstracción y encapsulamiento de
determinados procesos que ya se han realizado, pero por la arquitectura
actual resulta imposible de reutilizar. Ésta solución está pensada para una
programación a futuro para eventuales mejoras de rendimiento de la
aplicación. A continuación se describirán algunas mejoras importantes que
ya es posible de utilizar en el proyecto actual

1.- Transacciones de servicios: Normalmente se realiza en la capa de

negocios de la ventana (T_HAV0XXX.cs) y se encarga de entregar la
entrada de datos al servicio y recibir la salida de éste. Para construir esta
entrada de datos normalmente utilizamos un DataSet al que se le
incorporan los datos de entrada para entregárselo al servicio. A su vez, éste
servicio retorna la salida en este mismo DataSet, Ejemplo:

try
{
Transacciones.HARGCPCO(dsgc);
}
catch { }

Una solución propuesta es en vez de utilizar directamente el nombre del

servicio de la clase Transacciones es utilizar el método EJECUTAR de la clase
Transacciones, que se compone de 4 parámetros:

1.- Nombre del servicio

2.- Nombre del descriptor

3.- Nombre del DataSet definido con la entrada de datos

4.- Un valor Booleano que indica si se desea que la transacción quede en un

caché de datos (true – false)

El ejemplo quedaría, entonces, de la siguiente forma

try
{
Transacciones.Ejecutar("HARGCPCO", "HAF1091", dsgc, false);
}
catch { }

De esta forma se logra una mayor eficiencia en la transacción y además

dispone de un caché (opcional) para la reutilización del proceso.
2.- Lograr el concepto de clases: El definir las clases nos facilita entender
mejor el concepto de objetos, sus atributos y es una alternatva al uso de controles
de flujo. Si tenemos, por ejemplo “cliente” definido como una clase su definición
sería sencilla e intuitiva, ejemplo:

public partial class HAV0160 : HeraForm

{
private Cliente Mi_cliente = new Cliente();
}

Por su parte, un control de flujo sería:

Mi_cliente = ContextoFlujo.ContainsKey("CO-CLIENTE") ?
ContextoFlujo["CO-CLIENTE"].ToString() : "";

3.-