Este documento describe la arquitectura Box, que proporciona una programación basada en información. El BoxDictionary mapea la información entre las capas de presentación, negocio y datos. El BoxBusiness implementa la lógica de negocio. El log de datos facilita la comunicación entre desarrolladores y la automatización de pruebas al proporcionar información sobre los datos de entrada, salida y cambiados.

1. Box
(Programación basada en la información)
Arquitectura del Box
Desarrollar con Box
Testear con Box
Información está más allá de los datos, también implica visibilidades, tipos de controles asociados a la
información, sus cambios en todo el proceso de ejecución, asociación de datos con entidades de la base de datos,
nombre de los labels, objetos asociados al control, modos de presentación de la información, estados de los
controles, estados de la aplicación, del servidor, y algo mas.

2. BoxDictionary
Presentación (Servidor)
Presentación (Cliente)
Servicios (Consumidor)
Servicios (Proveedor)
BoxDictionary
Negocio
BoxDictionary
Datos .
API
FCL
Docu
men
tacio
n
Boxing (BoxDictionary)
Entity (data)
HTTP
SOAPREST
Linq to DataSet
REQUEST RESPONSE
Unboxing (BoxDictionary)
Boxing (entity)
Arquitectura

3. BoxDictionary
BoxBaseDictionary
KeyChild
KeyParent
IBoxObject BoxControlUserControl
BoxControlWebControl
BoxControlProfile
BoxControlViewState
BoxControlSession
BoxControlAplication
BoxControlHtmlControl
BoxControlConfiguration
Types.BoxKey.eKeyParent
Types.BoxKey.eKeyChild
Types.BoxTypes
Types.ValueTypes
Arquitectura : BoxDictionary

4. Arquitectura : Business UML
BoxBusinessBase
---------------------------------------------------------------------------------------------------------------
lstErrorsValidate: Dictionary(Of String, String)
oBoxBaseDictionary: BoxDictionaryBase
---------------------------------------------------------------------------------------------------------------
Ini()
NewData()
GetData()
EditData()
SaveData()
BoxDictionary(): Dictionary(Of String, Dictionary(Of String, BoxDictionaryObjects))
BoxDictionaryParent(string): Dictionary(Of String, BoxDictionaryObjects)
BoxDictionaryChild(string): BoxDictionaryObjects
BoxBusinessExample
--------------------------------------
--------------------------------------
EditDataBox(): Boolean
GetDataBox(): Boolean
IniBox(): Boolean
NewDataBox(): Boolean
SaveDataBox(): Boolean
ValidateDataBox(): Boolean
VisibilityForMode()
IBoxBusiness
--------------------------------------
--------------------------------------
EditDataBox(): Boolean
GetDataBox(): Boolean
IniBox(): Boolean
NewDataBox(): Boolean
SaveDataBox(): Boolean
ValidateDataBox(): Boolean
VisibilityForMode()
BoxDictionaryObjects
--------------------------------------------------------------
id: String
type: Types.BoxType.TypeItem
AttributeId: String
Value: String
Text: String
mode: String
oObjectToPresentation: Object
dAttributesExtra: Dictionary(Of String, Object)
--------------------------------------------------------------
1..*
TypeItem
------------------------------------------------
name: String
type: enum eTypeItemClass {..}
------------------------------------------------
Operator =(..): Boolean
Operator <>(..): Boolean
BoxDictionaryBase
--------------------------------------------------------------
Layer: Types.ValueType.eLayer

5. Tiempo de Desarrollo
• Programar con el Box
• Programar con el BoxDictionary
• Programar con el BoxBusiness
• Depuración por módulos
• Log de Datos
• Trazabilidad con el log de error
• Estructura del Log de datos
• Programación con el log de datos como herramienta auxiliar
• Comunicación entre programadores backend y frontend en tiempo de desarrollo (modo requisitos)
• Comunicación entre programadores backend y frontend en tiempo de desarrollo (modo debug)
• Programación con el log de datos como herramienta principal
• Consola de desarrollo

6. Presentación (.vb)
Negocio
Datos
BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)
Enlace lógico : “[TABLA]#[COLUMNA]”
oBox.BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)
BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)
APPLICATION: State de la aplicación
SESSION: State de la sesión
PROFILE: Config. del usuario de la aplic.
CONFIGURATION: Keys del web.config
VIEWSTATE: UIState del control
ENTITIES: Referencia a bases de datos
ACTION: Controles que generan eventos
CONTROL: Controles de presentación
Programación: Programar con el Box : BoxDictionary
Boxing/Unboxing

7. Programación: Programar con el Box : BoxDictionary
BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)
APPLICATION: State de la aplicación
SESSION: State de la sesión
PROFILE: Config. del usuario de la aplic.
CONFIGURATION: Keys del web.config
VIEWSTATE: UIState del control
ENTITIES: Referencia a bases de datos
ACTION: Controles que generan eventos
CONTROL: Controles de presentación
Namespace Box.BoxDictionary.Types.BoxKey
Structure eKeyChild
Structure KeyAPPLICATION
Structure KeySESSION
Structure KeyPROFILE
Structure KeyCONFIGURATION
Structure KeyVIEWSTATE
Public Const ControlMode As String = "VIEWSTATE#HCONTROLMODE"
Structure KeyENTITY
Public Structure COMPANY
Public Const NAME As String = "ENTITIES#COMPANY#NAME"
End Structure
Structure KeyACTION
Public Const OK As String = "ACTION#OK"
Public Const CANCEL As String = "ACTION#CANCEL“
Structure KeyCONTROL
Public Structure PANEL_DIALOG
Public Const DialogMsg As String = "CONTROL#DIALOGMSG"
Public Const LabelHeader As String = "CONTROL#LABELHEADER"
Public Const MultiView As String = "CONTROL#MULTIVIEW"
End Structure

8. Programación: Programar con el Box : BoxBusiness
Namespace Box.BoxBusinessObjects
Negocio
BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)
Presentación (.vb)
oBox.BoxChild(“ENTITIES#PRODUCT#START_AVAILABILITY”)

9. Programación: Depuración por módulos
Objeto
#If DEBUG Then
Dim bDebug As Boolean = True
#End If
Función(){
#If DEBUG Then
BoxDesarrollo.clBoxException.logOut = bDebug
…
}
Función(){
#If DEBUG Then
BoxDesarrollo.clBoxException.logOut = bDebug
…
}
Es posible obtener el log de depuración de todo la trazabilidad del objeto, poniendo:
Dim bDebug As Boolean = True
Pero también es posible obtener el log de depuración de la trazabilidad de una sola función asignando a la
variable el estado de la depuración:
[BoxDesarrollo.clBoxException.logOut] = [True]
Función(){
#If DEBUG Then
BoxDesarrollo.clBoxException.logOut = bDebug
…
}
…
Depuración en positivo: La variable [bDebug] se le asigna el valor [True], y a la función que no interese, asignarle
[BoxDesarrollo.clBoxException.logOut] el valor de [False].
Depuración en negativo: La variable [bDebug] se le asigna el valor [False], y a la función que interese, asignarle
[BoxDesarrollo.clBoxException.logOut] el valor de [True].

10. Programación: Log de datos : Trazabilidad con el Log de error
Error
Log de datos
Abrimos el archivo [C:[Directory][File]] en Visual Studio en la línea [571]
Insertamos un punto de ruptura condicional :
Ejecutamos la aplicación en modo depuración.

11. Programación: Log de Datos : Estructura del Log de datos
Información de entrada
CONTROL# :
control aspx que no está linkado a base de datos
ACTION# :
control aspx de las acciones que provocarán eventos
[TABLA]#[CAMPO] :
control aspx linkado con la base de datos
Información que cambia de
estado en negocio
Información de salida
Muestra los datos que saldrán en pantalla.
Aquí se podrán observar lo cambios realizados

12. Programación: Programación con el log de datos como herramienta auxiliar
Comunicación entre programadores backend y frontend en tiempo de desarrollo (modo requisitos)
Programador
de BackEnd
Programador
de FrontEnd
Log de datos
Log de datos
La sincronización entre programadores
se hace a través del log de datos.

13. Programación: Programación con el log de datos como herramienta auxiliar
Comunicación entre programadores backend y frontend en tiempo de desarrollo (modo debug)
Programador
de BackEnd
Programador
de FrontEnd
Llamadas a
Funciones del
BoxDictionary
Programación
Back-End
Esta programación permite:
La simultaneidad en el desarrollo.

14. Funcional
Programación: Programación con el log de datos como herramienta principal
Programador
de BackEnd
Programador
de FrontEnd
Log de datos
(esperados)
Hará la capa de presentación: diseño y funcional
A través del log de datos, sabe que controles tiene que
poner, que información recogerá de ellas y que
información entregará. Con ello, sabrá a que funciones
llamar de Negocio y que hacer en presentación.
Hará la capa de negocio y datos
A través del log de datos, sabe que información tiene
como entrada y como tiene que variar. El funcional le
especifica como hacerlo.

15. Programación: Consola de desarrollo
Consola de
desarrollo
Winforms**
Boxing
Negocio
Datos
Log de datos
(resultados)
Info de entrada
Info cambiada
Info de salida
Calls
to Business
Data (in)
IIS (ASP.NET)
Data (in/change/out)
Presentación (Servidor)
Presentación (Cliente)
Automatización de
Selenium**
Selenium
Data(in)
to Businness
Data(out)
from Businness
Data (in)

16. Tiempo de Test
• Protocolo de actuación (modelo completo)
• Protocolo de actuación (test de capa de negocio)
• Protocolo de actuación (test de capa de presentación)
• Protocolo de actuación (test exhaustivo)
• Informes de Test
El log de datos es tratado como un script, que se rellena de forma fácil (cualquier usuario puede hacerlo), y que es
introducido en aplicaciones de test para ser tratado. Estas aplicaciones, una vez creadas, podrán ser extensibles a
cualquier arquitectura que implemente el Box y sea compatible con la versión del script del log de datos.
La resolución de incidencias serán tratadas de la misma forma que los protocolos de actuación para test, salvo
que el script es generado en producción cuando haya un error.

17. Testing: Protocolo de actuación (modelo completo)
Automatización de
Selenium**
Selenium
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
SerellenacomosifueraunExcel.
Winforms**
Boxing
** Aun falta por hacer !!!
Presentación (Servidor)
Presentación (Cliente)
Negocio
Datos
Log de datos
(resultados)
Info de entrada
Info cambiada
Info de salida
** Obtener las diferencias entre el
log de datos (esperados) y el log de datos (resultados)
Informe de test
Informe de errores
*
*
1
2
1
2
Test de capa de negocio: se genera un log de datos que puede ser usado
para el test de presentación.
Test de capa de presentación: se utiliza el log de datos salido de negocio.
Test exhaustivo: se accede como si fueras un usuario
Log de datos

18. Testing: Protocolo de actuación (test de capa de negocio)
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
SerellenacomosifueraunExcel.
Winforms**
Boxing
Negocio
Datos
Log de datos
(resultados)
Info de entrada
Info cambiada
Info de salida
** Obtener las diferencias entre el
log de datos (esperados) y el log de datos (resultados)
Informe de test
Informe de errores
*
*
1
1
Test de capa de negocio: se genera un log de datos que puede ser usado
para el test de presentación.
Si hay errores en negocio, ya no se continua el test.
Este test es muy rápido: no carga ni el IIS, ni el ASP.NET, ni el IE, ni
renderiza cada una de las páginas aspx; tampoco precisa del tiempo de
usuario en rellenar información.
Log de datos

19. Testing: Protocolo de actuación (test de capa de presentación)
Automatización de
Selenium**
Selenium
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
SerellenacomosifueraunExcel.
** Aun falta por hacer !!!
Presentación (Servidor)
Presentación (Cliente)
Log de datos
(resultados)
Info de entrada
Info cambiada
Info de salida
** Obtener las diferencias entre el
log de datos (esperados) y el log de datos (resultados)
Informe de test
Informe de errores
*
*
2
2 Test de capa de presentación: se utiliza el log de datos salido de negocio.
Este tipo de test no precisa de capa de negocio, así que se puede probar
aunque la capa de negocio aún no esté echa.
Se usa para presentaciones al cliente.
Log de datos

20. Testing: Protocolo de actuación (test exhaustivo)
Automatización de
Selenium**
Selenium
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
SerellenacomosifueraunExcel.
** Aun falta por hacer !!!
Presentación (Servidor)
Presentación (Cliente)
Negocio
Datos
Log de datos
(resultados)
Info de entrada
Info cambiada
Info de salida
** Obtener las diferencias entre el
log de datos (esperados) y el log de datos (resultados)
Informe de test
Informe de errores
*
*
2
2
Test exhaustivo: se accede como si fueras un usuario

21. Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Log de datos
(esperados)
Info de entrada
Info cambiada
Info de salida
Testing
Informe de test
Informe de errores
Informe de test
Informe de errores
Informe de test
Informe de errores
Informe de test
Informe de errores
El programador, a través del informe
de test, tiene acceso directo al error
de información y que control lo
contiene, también sabe que función
de la capa de negocio a sido a la que
se ha llamado y que no ha
funcionado como se preveía en el
funcional. Y sabe el tipo de error:
error de dato, visibilidad, nombre
del label, …
Acceso directo al error
Todo esto permite al desarrollador ir
directamente al error de
información sin necesidad de
depuración.

23. • Capa Presentación:
• Controles Sheet (jerárquicos)
• También en la solución de visual studio
• Análisis Orgánico
• Controles Shared
• Funcionamiento el atributo [mode]
• Capa FCL
• Capa Documentación
• Funcionamiento de las excepciones por niveles :
aplicación/formulario/función
• Poner los namespace’s con clases
• Programacion por estructuras: poner tb el árbol del BoxDictionary
Mejoras en esta presentación

24. Mejoras para próximas versiones
• Optimizar el unboxing para que solo haga las transformación en objetos que han sido modificados.
• Hay que tener en cuenta, y ahora no lo hace, que en el unboxing hay objetos que han sido creados en
negocio.
• Automatización de estructuras
• Automatización de la creación del Unboxing
• Extender el Boxing/Unboxing a protocolos de transporte: soap, rest, odata.
• Tiempo de desarrollo/incidencias
• Extender el Boxing/Unboxing a un protocolo de script de inserción/salida de datos.
• Crear la estructura de la capa de datos
• Mejoras en la estructura del BoxDictionary, a lo que se refiere a los objetos contenidos:
• Una posibilidad: [oBox.BoxDictionary(KeyChild).Attributes(KeyAttribute)]
• Mejoras en el boxing/unboxing mediante reflection