Mostrando las entradas con la etiqueta Servicios. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Servicios. Mostrar todas las entradas

martes, 31 de mayo de 2022

Programa Virtual Online de Desarrollo de Aplicaciones en Python

Contenido del Programa

Modulo 1 - Aplicaciones Comerciales con Python

Mes 1 - Aplicaciones Windows con PyQT

Mes 2 - Aplicaciones Web con Django

Mes 3 - Servicios Web & Web Sockets

Modulo 2 - Aplicaciones Científicas con Python

Mes 4 - Procesamiento de Datos con Pandas, NumPy, Matplotlib

Mes 5 - Machine Learning con SckitLearn, TensorFlow, PyTorch

Mes 6 - Deep Learning con Keras, TensorFlow, PyTorch


Datos del Programa

Duración: 6 meses

Costo Mensual: 250 soles (USD 70)

Horario: Martes y Jueves de 7:00 pm a 11:00 pm

Inicio: Martes 5 de Julio del 2022


Registro en el Programa

Los interesados deberán enviar un mail a Luis.duenash@gmail.com:

Asunto: Curso de Python

Nombre Completo: XXXXXXXXXXXXX

Documento de Identidad: XXXXXX

Lugar de Procedencia: Ciudad/Pais

Ha llevado Cursos antes con Lduenas: Si/No

Si es nuevo como se entero: Blog/LinkedIn/Facebook/UnAlumno


Poster



martes, 17 de agosto de 2021

Entrenamiento - Curso Virtual Online de Python

Curso Virtual Online de Python

Para todos los interesados les comunico que el Sábado 4 de Setiembre iniciamos el Cuarto Curso de Python que se desarrollara de manera virtual online. Este curso tiene un nivel Intermedio-Avanzado y esta enfocado en Desarrollar Aplicaciones Comerciales usando Python.

*****************************************************************************

Parte 1: Contenido del Curso

*****************************************************************************

Mes 1: Programando con Python usando Librerías Estándar y PyQT

1. Introducción a Python

1.1. Instalar Python

1.2. El Lenguaje Python

1.3. Librerías Estándar

1.4. Librerías No Estándar

2. Uso de Librerías Estándar

2.1. Manejo de Archivos con os y shutil

2.2. Web Scrapping con urllib.request y json

2.3. Acceso a Datos con PyOdbc y Pandas

2.4. Compresión de datos y archivos usando zlib y zipfile

2.5. Cifrado de datos con base64, hmac, hashlib y secrets

3. Introducción a PyQT

3.1. Instalar PyQt5 y PyQt5Designer

3.2. Clasificación de QTWidgets

3.3. Crear el diseño de la aplicación

3.4. Programar la aplicación Windows en PyQT

4. Trabajando con Diálogos en PyQT

4.1. Ventana de Dialogo con QDialog

4.2. Cuadro de Mensaje con QMessageBox

4.3. Dialogo de Archivos y Directorios con QFileDialog

Mes 2: Desarrollo de Aplicaciones Windows en Python con PyQT

1. Usando Controles Basados en Items (Item Widgets)

1.1. Mostrar una Columna con QListWidget

1.2. Mostrar varias Columnas con QTableWidget

1.3. Ver Jerarquía de Varias Columnas con QTreeWidget

2. Usando Controles Basados en Modelos (Model Widgets)

2.1. Mostrar una Columna con QListView y QStringListModel

2.2. Mostrar Varios QListView con QColumnView y QDirModel

2.3. Mostrar Vista Jerarquica con QTreeView y QFileSystemModel

2.4. Mostrar Varias Columnas con QTableView, QStandardItemModel y QAbstractTableModel

2.5. Combos Independientes y Dependientes con QComboBox

3. Personalizando el Control QTableView

3.1. Formatear Columnas

3.2. Mostrar Imágenes en Columnas

3.3. Ordenar usando QSortFilterProxyModel

3.4. Filtrar usando QSortFilterProxyModel

4. Mantenimiento de Datos con Pandas usando QTableView 

4.1. Exportar a CSV, Excel, HTML, JSON con Pandas y a PDF (nativo)

4.2. Importar de CSV, Excel, HTML, JSON con Pandas

4.3. Mantenimiento de una Tabla

5. Reportes y Gráficos de Datos en PyQT

5.1. Reporte de Productos usando QPainter y QtPrintSupport

5.2. Grafico de Barras con PIL

5.3. Grafico de Columnas con QPainter

5.4. Grafico de Pie con matplotlib plt y FigureCanvas

6. Cabecera Detalles y Sistema Completo

6.1. Crear una Orden (Cabecera Detalle), Imprimir, Enviar Mail

6.2. Consultar una Orden (Cabecera Detalle), Imprimir, Enviar Mail

6.3. Sistema con Login, MDI y Formularios Dinámicos

7. Programación Asíncrona en PyQT con QThread

7.1. Ejecutando Bucles Asíncronos con Threads y Progreso

7.2. Consulta Asíncrona de una BD con Threads

7.3. Consulta Asíncrona de un Servicio Web con Threads

7.4. Envío de Correos Asíncrono con Threads y Progreso

7.5. Consultar Gran Cantidad de Datos y Exportación Asíncrona con Threads y Progreso

Mes 3: Desarrollo de Aplicaciones Web en Python con Django

1. Introducción a Django

1.1. Instalar Django

1.2. Crear un Sitio Web

1.3. Crear una Aplicación Web

1.4. Iniciar el Servidor Django

2. Creando Aplicaciones de Consultas

2.1. Devolver una Simple Respuesta de Texto

2.2. Devolver una Simple Pagina HTML

2.3. Consultar una Tabla y Exportar a Excel, Pdf y Word

2.4. Consultar Varias Tablas usando Tabs

3. Creando una Librería de JavaScript con Controles Básicos

3.1. Control Grilla con Checks

3.2. Filtro Conectado usando Combo con Grilla

3.3. Filtro Desconectado usando Combo con Grilla

3.4. Control TextList

4. Creando una Librería de JavaScript con Controles Avanzados

4.1. TreeView Jerárquico con Checks

4.2. Tablas Jerárquicas de 2 Niveles

4.3. Grid Jerárquico de 2 Niveles

4.4. Grilla con Columnas de Links para Descarga de Archivos

5. Creando Aplicaciones Web Completas

5.1. Mantenimiento de una Tabla con Imagen en Popups (SPA)

5.2. Sistema con Login, TreeView, iFrame con Código Genérico

5.3. Carrito de Compras con Login, Imágenes y Seguridad

5.4. Trabajar con miles de registros: Consultar y Grabar

Mes 4: Integración de Aplicaciones en Python con Servicios Web y WebSockets

1. Creando y usando Servicios Web en Django

1.1. Servicio de Consulta de Datos

1.2. Servicio de Mantenimiento de Datos (CRUD)

1.3. Servicio de Manejo de Archivos por Bloques

2. Creando y usando WebSockets en Django

2.1. Creando un Servidor WebSocket en Python con websock.WebSocketServer

2.2. Creando un Cliente WebSocket en PyQT con QtWebSockets

2.3. Creando un Cliente Web en JavaScript con WebSocket

2.4. Creando un Cliente Windows en .NET con WebSocketClient

3. Creando Aplicaciones Completas con Clientes Python, .NET y Android

3.1. Manejo de Documentos en Tiempo Real

3.2. Registro de Asistencia de Empleados en Tiempo Real

3.3. Registro de Incidentes en Tiempo Real con Mapas

Mes 5: Computer Vision en Python con OpenCV, dlib y face_recognition

1. Introducción a Computer Vision (CV)

1.1. Revisión e Historia de CV

1.2. Principales Librerías en CV

1.3. Libros y Universidades en CV

1.4. Científicos y Laboratorios en CV

1.5. Conferencias y Competiciones en CV

2. Introducción a OpenCV

2.1. Historia de OpenCV

2.2. Características Generales de OpenCV

2.3. Clasificación de Módulos en OpenCV

2.4. Instalación de OpenCV: opencv-python y opencv-contrib-python

3. Trabajando con Características de la GUI

3.1. Leer, Mostrar, Crear una Imagen con OpenCV

3.2. Leer y Mostrar un Video de Disco

3.3. Leer y Mostrar un Video en PyQT con OpenCV

3.4. Capturar Video de WebCam en Tiempo Real

3.5. Manipular Imagen del Video de WebCam y Grabar

3.6. Dibujar Textos y Figuras

4. Procesamiento de Imágenes con OpenCV

4.1. Transformación Afín: Trasladar la imagen

4.2. Transformación Afín: Rotando una imagen

4.3. Suavizado de Imágenes: Filtros de Paso Bajo

4.4. Transformaciones morfológicas

4.5. Detección de Bordes

5. Detección de Rostros usando Haarcascade

5.1. Detectar Rostros en un Imagen

5.2. Detectar Rostros en un Video en Tiempo Real

5.3. Detectar Rostros y Ojos en un Video en Tiempo Real

6. Reconocimiento de Objetos usando Haarcascade

6.1. Reconocimiento de Objetos en una Imagen con YOLO

6.2. Reconocimiento de Objetos en un Video en Tiempo Real con YOLO

7. Detección de Marcas Faciales con OpenCV

7.1. Detección de Marcas Faciales en una Imagen

7.2. Detección de Marcas Faciales en un Directorio de Imágenes

7.3. Detección de Marcas Faciales en un Video en Tiempo Real

8. Detección de Marcas Faciales usando Dlib

8.1. Detección de Marcas Faciales en una Imagen con Dlib

8.2. Detección de Marcas Faciales en un Video en Tiempo Real con Dlib

9. Reconocimiento de Rostros usando face_recognition

9.1. Comparar 2 rostros para ver sin son la misma persona

9.2. Buscar un rostro en un directorio de fotos

9.3. Reconocer un rostro en un Video en Tiempo Real


*****************************************************************************

Parte 2: Datos del Curso

*****************************************************************************

1. Horario y Fecha de Inicio

- Horario: Sábados de 4:00 pm a 11:00 pm (Hora Perú)

- Fecha de Inicio: Sábado 04 de Setiembre del 2021

2. Duración del Curso

- Duración: 112 horas

- Tiempo: 5 meses

- Frecuencia: 7 horas semanales (28 horas mensuales)

3. Inversión y Forma de Pago

- Mensual: 200 nuevos soles para Peruanos y USD 60 para extranjeros

- Total 5 meses: 1000 nuevos soles o USD 300

- Forma de Pago: En efectivo, al inicio de cada mes (200 soles o USD 60)

- La cuenta del Banco en Perú se enviará a los seleccionados

- Para los alumnos de otros países será por Western Union

4. Registro

- Los interesados deberán enviar un mail a: Luis.duenash@gmail.com con los sgtes datos:

Titulo del mail:

- Cuarto Curso Virtual Online de Python

Contenido del mail:

- Nombre Completo: Apellido Paterno, Apellido Materno y Nombres

- Documento de Identidad: DNI, Cédula, etc.

- Lugar de Procedencia: Ciudad y País

- Ha llevado Cursos antes conmigo: (No / Si), si es Si en donde

- Nivel de Experiencia en Desarrollo: Básico / Intermedio / Avanzado

- Conoce Python: Si/No

- Comentario: Breve resumen de porque quiere llevar el curso.

5. Advertencia

- Solo deberán enviar correo los que estén bien informados de como son mis cursos, mi metodología y arquitectura.

- No se aceptan personas susceptibles o sensibles a fuertes comentarios

- No hay ningún tipo de certificación o diploma de participación (por el momento)

- Habrá un filtro de ingreso y se enviará el mail con el número de cuenta a pagar solo a los seleccionados.

lunes, 13 de mayo de 2019

Entrenamiento - Segundo Curso de C# WinForms

Segundo Curso de C# WinForms con Arquitectura Sin Capas con Cadenas

Contenido del Curso
Parte 1: Estructuras de Datos y Algoritmos en .NET
01. Introducción a .NET Framework: BCL y CLR
02. El Lenguaje C#: Estructuras de Control de Flujo
03. Estructuras de Datos en .NET 1: Arreglos, Listas, Pilas y Colas
04. Estructuras de Datos en .NET 2: Enumeraciones, Diccionarios, Arboles
05. Algoritmos en .NET Parte 1: Búsqueda y Ordenación de Datos
06. Algoritmos en .NET Parte 2: Cifrado y Compresión de Datos
Parte 2: Acceso a Datos con ADO.NET en WinForms
07. ADO.NET: Conexión, Comandos y Readers
08. Consultas de Datos: Filtros y Búsquedas
09. Mantenimiento de Datos y Cabecera-Detalle
10. Reportes, Gráficos, Impresiones, Exportaciones (Texto, Word, Excel y PDF)
11. Creación de Librerías de Controles WinForms
Parte 3: Programación Distribuida en .NET
12. Creando un Servicio WCF y Clientes WinForms
13. Creando un Servicio MVC (HTTP) y Clientes WinForms
14. Creando un Servidor Web Sockets y Clientes WinForms
15. Creando un Servidor HTTP y Clientes WinForms
16. Creando un Servidor TCP y Clientes WinForms

Materiales del Curso
- Documentación en PDFs de Microsoft Docs
- Libros en PDF de C# y .NET
- Videos de Cursos y Eventos de Microsoft
- Demos y Videos del Curso

Horario
- Miércoles y Viernes de 7:00 pm a 10:00 pm

Fecha de Inicio
- Miércoles 22 de Mayo del 2019

Duración del Curso
- Total: 72 horas
- Tiempo: 3 meses
- Frecuencia: 6 horas semanales (24 horas mensuales)

Inversión
- Alumnos: 250 nuevos soles el mes
- Alumnos que actualmente estan llevando Sábados y/o Domingos: 200 soles el mes

Forma de Pago
- Depósito en el Banco BCP (se enviará el número de cuenta a los que envíen su correo)

Contacto
Los interesados enviar un mail a Luis.duenash@gmail.com con los siguientes datos:
Asunto: Curso C# Winforms Miércoles y Viernes
Contenido del Mail:
- Nombre Completo
- Lugar de Trabajo o Estudio
- Tipo de Alumno: Nuevo / Antiguo ISIL / Antiguo Talleres

Forma de Registro
- Enviar su mail indicando los datos solicitados
- Se le enviará el número de cuenta BCP
- Realizar el depósito del mes y enviar constancia (foto o voucher)
- Se le enviará la dirección exacta

Lugar del Curso
Será cerca a la Av Canada con Av Rosa Toro, se le enviará la dirección exacta a todos los registrados una vez realizado el pago al Banco.

Entrenamiento - Primer Curso de Android

Primer Curso de Android con Arquitectura Sin Capas con Cadenas

Contenido del Curso
01. Arquitectura y Componentes
02. Actividades y Navegación
03. Crear la Interface de Usuario
04. Graficos, Imagenes, Animaciones
05. Manejo de Audio y Video
06. Programación Asíncrona
07. Manejo de Datos y Archivos (grandes)
08. Ubicación del Usuario y Mapas
09. Manejo de Entrada, Toques y Gestos
10. Manejo de Camara y Sensores
11. Conectividad: Bluetooth, NFC, WiFi, USB
12. Programación de Redes: Servicios y Sockets
13. Performance y Seguridad

Materiales del Curso
- Manuales en PDF del sitio web de Android Developers de Google
- Libros en PDF de Android y Java
- Videos de Cursos y Eventos de Google
- Demos y Videos del Curso

Horario
- Martes y Jueves de 7:00 pm a 10:00 pm

Fecha de Inicio
- Martes 21 de Mayo del 2019

Duración del Curso
Total: 48 horas
Tiempo: 2 meses
Frecuencia: 6 horas semanales (24 horas mensuales)

Inversión
- Alumnos nuevos o regulares: 250 nuevos soles el mes
- Alumnos que actualmente están llevando Sábados y/o Domingos: 200 soles el mes

Forma de Pago
- Depósito en el Banco BCP (se enviará el número de cuenta a los que envien su correo)

Contacto
Los interesados enviar un mail a Luis.duenash@gmail.com con los siguientes datos:
Asunto: Curso Android Martes y Jueves
Contenido del Mail:
- Nombre Completo
- Lugar de Trabajo o Estudio
- Tipo de Alumno: Nuevo / Antiguo ISIL / Antiguo Talleres

Forma de Registro
- Enviar su mail indicando los datos solicitados
- Se le enviará el número de cuenta BCP
- Realizar el depósito del mes y enviar constancia (foto o voucher)
- Se le enviará la dirección exacta

Lugar del Curso
Será cerca a la Av Canada con Av Rosa Toro, se le enviará la dirección exacta a todos los registrados una vez realizado el pago al Banco.

jueves, 7 de diciembre de 2017

El Manual del Día: Windows Workflow Foundation

MSDN - Manual de Windows Workflow Foundation

Titulo: Manual de Windows Workflow Foundation
Fuente Original: Microsoft Developer Network (MSDN)
Compilado Por: Luis Dueñas Huaroto (Lduenas)
Año de Compilación: 2008
Número de Páginas: 226

Indice del Manual de Windows Workflow Foundation

1. Información General de Windows Workflow Foundation
  1.1. Información general de flujos de trabajo
  1.2. Información general de actividades
  1.3. Información general sobre servicios
  1.4. Información general de compensación
  1.5. Información general de comunicación local y correlación
  1.6. Información general de persistencia
  1.7. Información general del seguimiento
  1.8. Información general de serialización
  1.9. Información general de cambios en el flujo de trabajo
  1.10. Visión general de reglas y condiciones
  1.11. Información general de control de errores
  1.12. Información general sobre el marcado de flujo de trabajo
2. Guía de Programación de Windows Workflow Foundation
  2.1. Introducción a la programación de Windows Workflow Foundation
  2.2. Desarrollo de flujos de trabajo
    2.2.1. Estilos de autorización de flujo de trabajo
      2.2.1.1. Flujos de trabajo secuenciales
      2.2.1.2. Flujos de trabajo de equipo de estado
    2.2.2. Modos de creación de flujos de trabajo
    2.2.3. Utilización de actividades para controlar el flujo
    2.2.4. Uso de condiciones en flujos de trabajo
      2.2.4.1. Cómo usar condiciones mediante código
      2.2.4.2. Cómo: utilizar condiciones de regla en flujos de trabajo
      2.2.4.3. Cambios de flujo de trabajo para condiciones de regla
    2.2.5. Utilización de RuleSets en flujos de trabajo
      2.2.5.1. Evaluación de reglas en RuleSets
      2.2.5.2. Ejecución basada en prioridad de RuleSets
      2.2.5.3. Procesamiento de colecciones en reglas
      2.2.5.4. Encadenamiento hacia delante de reglas
      2.2.5.5. Control de encadenamiento hacia delante
      2.2.5.6. Ejecución programática de RuleSets
      2.2.5.7. Información de seguimiento y de traza de RuleSet
      2.2.5.8. RuleSets declarativo
      2.2.5.9. Programación de consideraciones para las reglas
    2.2.6. Uso de transacciones en flujos de trabajo
    2.2.7. Información de estado de procesamiento por lotes en flujos de trabajo
    2.2.8. Control del error en flujos de trabajo
    2.2.9. Uso de la compensación en flujos de trabajo
    2.2.10. Uso de cambios de flujo de trabajo en flujos de trabajo
    2.2.11. Intercambio de datos en flujos de trabajo
    2.2.12. Utilización de funciones en los flujos de trabajo
    2.2.13. Cómo compilar flujos de trabajo
    2.2.14. Ejecución de flujos de trabajo
    2.2.15. Cómo serializar flujos de trabajo
      2.2.15.1. Utilización de actividades personalizadas con marcado de flujo de trabajo
      2.2.15.2. Uso de reglas con el marcado de flujo de trabajo
    2.2.16. Uso del marcado de flujo de trabajo
      2.2.16.1. Estructura básica
      2.2.16.2. Elementos y atributos
  2.3. Actividades de Windows Workflow Foundation
    2.3.1. Comprensión del contexto de ejecución de la actividad
    2.3.2. Comprensión del modelo de estado de actividad
    2.3.3. Uso de la actividad CallExternalMethodActivity
    2.3.4. Uso de la actividad CancellationHandlerActivity
    2.3.5. Utilización de la actividad CodeActivity
    2.3.6. Utilización de la actividad CompensatableSequenceActivity
    2.3.7. Uso de la actividad CompensatableTransactionScopeActivity
    2.3.8. Uso de la actividad CompensateActivity
    2.3.9. Utilización de la actividad CompensationHandlerActivity
    2.3.10. Utilización de la actividad ConditionedActivityGroup
    2.3.11. Uso de la actividad DelayActivity
    2.3.12. Uso de la actividad EventDrivenActivity
    2.3.13. Uso de la actividad EventHandlersActivity
    2.3.14. Uso de la actividad EventHandlingScopeActivity
    2.3.15. Uso de la actividad FaultHandlerActivity
    2.3.16. Utilización de la actividad FaultHandlersActivity
    2.3.17. Uso de la actividad HandleExternalEventActivity
    2.3.18. Uso de la actividad IfElseActivity
    2.3.19. Uso de la actividad IfElseBranchActivity
    2.3.20. Uso de la actividad InvokeWebServiceActivity
    2.3.21. Uso de la actividad InvokeWorkflowActivity
    2.3.22. Uso de la actividad ListenActivity
    2.3.23. Uso de la actividad ParallelActivity
    2.3.24. Utilización de la actividad PolicyActivity
      2.3.24.1. Condiciones del conjunto de reglas y acciones
      2.3.24.2. Clases PolicyActivity y RuleSet
    2.3.25. Uso de la actividad ReplicatorActivity
    2.3.26. Uso de la actividad SequenceActivity
    2.3.27. Uso de la actividad SetStateActivity
    2.3.28. Uso de la actividad StateActivity
    2.3.29. Utilización de la actividad StateFinalizationActivity
    2.3.30. Utilización de la actividad StateInitializationActivity
    2.3.31. Uso de la actividad SuspendActivity
    2.3.32. Utilización de la actividad SynchronizationScopeActivity
    2.3.33. Utilización de la actividad TerminateActivity
    2.3.34. Uso de la actividad ThrowActivity
    2.3.35. Utilización de la actividad TransactionScopeActivity
    2.3.36. Uso de la actividad WebServiceFaultActivity
    2.3.37. Uso de la actividad WebServiceInputActivity
    2.3.38. Uso de la actividad WebServiceOutputActivity
    2.3.39. Uso de la actividad WhileActivity
  2.4. Desarrollo de actividades de flujo de trabajo
    2.4.1. Creación de actividades personalizadas
      2.4.1.1. Propiedades
      2.4.1.2. Lógica de ejecución
      2.4.1.3. Atributos
      2.4.1.4. Creación de actividades personalizada a partir de actividades de Windows Workflow Foundation predeterminadas
      2.4.1.5. Actividades de personalización
    2.4.2. Información general de lógica de validación de actividad
    2.4.3. Creación de un diseñador de actividad personalizado
  2.5. Servicios de Windows Workflow Foundation
    2.5.1. Servicios de programación de Windows Workflow
    2.5.2. Servicios CommitWorkBatch de Windows Workflow
      2.5.2.1. Uso de DefaultWorkflowCommitWorkBatchService
      2.5.2.2. Utilización de SharedConnectionWorkflowCommitWorkBatchService
        2.5.2.2.1. Utilización de los archivos de configuración de aplicación
    2.5.3. Servicios de persistencia de Windows Workflow
      2.5.3.1. Creación de servicios de persistencia
      2.5.3.2. Bloqueo de información de estado de flujo de trabajo
      2.5.3.3. Comportamiento por lotes del servicio de persistencia
      2.5.3.4. Escenarios de hospedaje complejos
    2.5.4. Servicios de seguimiento de flujo de trabajo de Windows
      2.5.4.1. Características de seguimiento en Windows Workflow Foundation
      2.5.4.2. Perfiles de seguimiento
      2.5.4.3. Seguimiento de tipos de evento
      2.5.4.4. Seguimiento explítico de nivel de código
      2.5.4.5. Seguimiento de flujos de trabajo de solo marcado   
      2.5.4.6. Reglas de seguimiento
        2.5.4.6.1. Servicios de seguimiento personalizados
  2.6. Desarrollo de servicios de Windows Workflow Foundation
    2.6.1. Extender servicios base
    2.6.2. Creación de nuevos servicios personalizados
  2.7. Desarrollo de aplicaciones con flujo de trabajo habilitado
    2.7.1. Creación de una aplicación host de flujo de trabajo
      2.7.1.1. Responsabilidades de la aplicación host
      2.7.1.2. Tareas que la aplicación host debe realizar
    2.7.2. Cómo agregar y quitar servicios de flujo de trabajo
      2.7.2.1. Agregar servicios al motor de tiempo de ejecución del flujo de trabajo
      2.7.2.2. Quitar servicios del motor de tiempo de ejecución del flujo de trabajo
    2.7.3. Cómo aplicar cambios de flujo de trabajo a los flujos de trabajo
      2.7.3.1. Creación dentro de un flujo de trabajo
      2.7.3.2. Creación desde el entorno del host
      2.7.3.3. Cambios de flujo de trabajo y propiedades de actividad
    2.7.4. Hospedaje de diseñadores de flujo de trabajo
      2.7.4.1. Agregar la funcionalidad de comandos de menú
    2.7.5. Consideraciones de implementación para las aplicaciones de flujo de trabajo
    2.7.6. Consideraciones de seguridad para aplicaciones con flujo de trabajo habilitado
  2.8. Desarrollo de aplicaciones de flujo de trabajo ASP .NET
    2.8.1. Uso de flujos de trabajo con ASP .NET
      2.8.1.1. Creación del objeto WorkflowRuntime
      2.8.1.2. Iniciar los flujos de trabajo en Web Forms ASP .NET
    2.8.2. Invocación de servicios web en un flujo de trabajo
    2.8.3. Implementación de un flujo de trabajo como un servicio web
      2.8.3.1. Hospedaje web del flujo de trabajo
      2.8.3.2. Limitaciones de los flujos de trabajo expuestos como servicios web
      2.8.3.3. Para habilitar las cookies e invocar un servicio web de flujo de trabajo
    2.8.4. Errores y excepciones en flujos de trabajo de ASP .NET
  2.9. Flujo de trabajo y comunicación de la aplicación
    2.9.1. Uso de servicios locales en flujos de trabajo
      2.9.1.1. Servicios de comunicación de flujo de trabajo
      2.9.1.2. Clase de servicio
    2.9.2. Uso de correlación en flujos de trabajo
      2.9.2.1. Atributos de interfaz
      2.9.2.2. Utilizar atributos de correlación
    2.9.3. Generación de actividades de comunicación
    2.9.4. Creación de actividades de comunicación personalizadas
      2.9.4.1. Exposición de una clase de servicio como una actividad
      2.9.4.2. Implementación de una actividad de comunicación personalizada
    2.9.5. Comunicación con otros flujos de trabajo
  2.10. Supervisión del rendimiento del flujo de trabajo
  2.11. Consideraciones de seguridad para los flujos de trabajo
  2.12. Consideraciones de control de versiones para flujos de trabajo
  2.13. Creación de servicios de flujo de trabajo y de servicios duraderos
    2.13.1. Información general de Workflow Services y de servicios duraderos
      2.13.1.1 Workflow Services
      2.13.1.2. Servicios duraderos
    2.13.2. Escenarios compatibles de intercambio de mensajes
      2.13.2.1. Intercambio de contexto
      2.13.2.2. Obtener y establecer el contexto
    2.13.3. Estilos de creación de servicio de flujo de trabajo
      2.13.3.1. Servicios de flujo de trabajo de contrato primero
        2.13.3.1.1. Definición de un servicio de contrato en un proyecto de flujo de trabajo
      2.13.3.2. Servicios de flujo de trabajo de flujo de trabajo primero
    2.13.4. Cómo configurar un servicio de flujo de trabajo
    2.13.5. Cómo: Habilitar la persistencia para un servicio duradero
      2.13.5.1. Configuración de servicios duraderos
    2.13.6. Cómo: Hospedar un servicio de flujo de trabajo en IIS
      2.13.6.1. Para hospedar una definición de flujo de trabajo precompilada como un servicio en IIS
      2.13.6.2. Para hospedar una definición de flujo de trabajo declarativa como un servicio en IIS
      2.13.6.3. Para hospedar una definición de flujo de trabajo declarativa como un servicio con un archivo .svc
    2.13.7. Consideraciones de seguridad para servicios de flujo de trabajo y servicios duraderos
      2.13.7.1. Consejos preceptivos de seguridad para Workflow Services
      2.13.7.2. Consejos preceptivos de seguridad para servicios duraderos
    2.13.8. Conversaciones con servicios de flujo de trabajo
    2.13.9. Comportamiento de actualización dinámico para Workflow Services
3. Tutoriales de Windows Workflow Foundation
  3.1. Tutorial: Creación de un flujo de trabajo secuencial
    3.1.1. Ejercicio 1: Creación del proyecto de informe de gastos simple
      3.1.1.1. Tarea 1: Creación de la aplicación de informe de gastos simple
        3.1.1.1.1. Creación del proyecto SimpleExpenseReport
        3.1.1.1.2. Creación y ejecución de la aplicación Windows Forms
        3.1.1.1.3. Creación y ejecución de la aplicación del informe de gastos simple de Windows Forms
      3.1.1.2. Tarea 2: Creación del flujo de trabajo secuencial
        3.1.1.2.1. Creación del archivo de origen del flujo de trabajo secuencial
        3.1.1.2.2. Definición del flujo de trabajo secuencial
      3.1.1.3. Tarea 3: Hospedaje del flujo de trabajo secuencial
        3.1.1.3.1. Hospedaje del motor en tiempo de ejecución de Windows Workflow
    3.1.2. Ejercicio 2: Creación del servicio de informe de gastos
      3.1.2.1. Tarea 1: Definición de los parámetros de flujo de trabajo
        3.1.2.1.1. Definición de las propiedades del flujo de trabajo
        3.1.2.1.2. Modificación de la aplicación Windows Forms
      3.1.2.2. Tarea 2: Definición de la interfaz IExpenseReportService
        3.1.2.2.1. Definir e implementar la interfaz
        3.1.2.2.2. Implementar la interfaz
  3.2. Tutorial: Creación de un flujo de trabajo de equipo de estado
    3.2.1. Ejercicio 1: Creación del proyecto del formulario de pedido simple
      3.2.1.1. Tarea 1: Creación del archivo de proyecto del formulario de pedido simple
      3.2.1.2. Tarea 2: Creación del formulario de Windows Formulario de pedido simple
        3.2.1.2.1. Creación del archivo de código fuente de Windows Forms
    3.2.2. Ejercicio 2: Creación de la aplicación del formulario de pedido simple
      3.2.2.1. Tarea 1: Creación del flujo de trabajo del formulario de pedido simple
        3.2.2.1.1. Para crear el archivo de código fuente del flujo de trabajo de equipo de estado en Visual Studio
        3.2.2.1.2. Para crear el archivo de código fuente del flujo de trabajo de equipo de estado mediante un editor de texto
        3.2.2.1.3. Para definir el flujo de trabajo de equipo de estado
        3.2.2.1.4. Para crear las actividades de estado
      3.2.2.2. Tarea 2: Definición de la interfaz IorderingService
        3.2.2.2.1. Definición de la clase NewOrderEventArgs
        3.2.2.2.2. Creación de la interfaz
      3.2.2.3. Tarea 3: Implementación de la interfaz IOrderingService
        3.2.2.3.1. Implementación de la interfaz
        3.2.2.3.2. Habilitación de un nuevo procesamiento de pedido
        3.2.2.3.3. Actualización de la interfaz de usuario
      3.2.2.4. Tarea 4: Definición del estado WaitingForOrder
        3.2.2.4.1. Declaración de campos de flujo de trabajo y propiedades
        3.2.2.4.2. Definición de las actividades secundarias y creación del método
      3.2.2.5. Tarea 5: Definición del estado OrderProcessing
        3.2.2.5.1. Declaración de campos requeridos para OrderProcessingState
        3.2.2.5.2. Definición de las actividades secundarias OrderProcessingState
        3.2.2.5.3. Para definir los métodos CallExternalMethod que llaman y finalizan nuevos Pedidos
  3.3. Tutorial: Creación de una actividad personalizada
    3.3.1. Ejercicio 1: Creación del proyecto de actividad personalizado
      3.3.1.1. Tarea 1: Creación del archivo de proyecto de actividad personalizado
      3.3.1.2. Tarea 2: Creación de la aplicación de hospedaje de la actividad personalizada
        3.3.1.2.1. Para crear el archivo de código fuente de Windows Forms en Visual Studio
        3.3.1.2.2. Para crear el archivo de código fuente de Windows Forms mediante un editor de Texto
        3.3.1.2.3. Agregar el código de Windows Forms a la aplicación host
      3.3.1.3. Tarea 3: Creación del flujo de trabajo secuencial de la actividad personalizado
        3.3.1.3.1. Creación del archivo de origen del flujo de trabajo secuencial SimpleExpenseReport
        3.3.1.3.2. Creación de un archivo de origen de flujo de trabajo secuencial mediante un editor de texto
        3.3.1.3.3. Definición del flujo de trabajo secuencial
    3.3.2. Ejercicio 2: Creación de la actividad personalizada y el flujo de trabajo
      3.3.2.1. Tarea 1: Creación de actividad personalizada
        3.3.2.1.1. Para crear el archivo de código fuente de actividad personalizado WebTear en Visual Studio
        3.3.2.1.2. Para crear el archivo de código fuente de actividad personalizado WebTear mediante un editor de texto
        3.3.2.1.3. Para declarar la clase WebTearActivity
        3.3.2.1.4. Para definir el evento PageFinished
        3.3.2.1.5. Para definir DependencyProperty de la dirección URL
        3.3.2.1.6. Para definir el método Execute
      3.3.2.2. Tarea 2: Uso de actividad personalizada en un flujo de trabajo secuencial
        3.3.2.2.1. Definición de las propiedades del flujo de trabajo secuencial
        3.3.2.2.2. Agregar WebTearActivity al flujo de trabajo secuencial
      3.3.2.3. Tarea 3: Modificación de la aplicación de hospedaje de la actividad personalizada
        3.3.2.3.1. Para iniciar el flujo de trabajo secuencial WebTearWorkflow
  3.4. Tutorial: Hospedaje del tiempo de ejecución de Windows Workflow Foundation
    3.4.1. Ejercicio 1: Generación de un host de consola de Windows
      3.4.1.1. Tarea 1: Creación del archivo de proyecto de hospedaje del flujo de trabajo
        3.4.1.1.1. Procedimientos
      3.4.1.2. Tarea 2: Creación de un flujo de trabajo secuencial
        3.4.1.2.1. Creación del flujo de trabajo secuencial
        3.4.1.2.2. Para agregar el archivo de origen HostingWorkflows al proyecto
      3.4.1.3. Tarea 3: Creación de una aplicación de consola de hospedaje de flujo de trabajo
        3.4.1.3.1. Creación de la clase de hospedaje
        3.4.1.3.2. Para agregar el archivo de origen del programa al proyecto
    3.4.2. Ejercicio 2: Ejecución de un flujo de trabajo
      3.4.2.1. Tarea 1: Creación de un flujo de trabajo y parámetros de paso
        3.4.2.1.1. Definición de las propiedades de flujo de trabajo para parámetros
        3.4.2.1.2. Para pasar los parámetros de la aplicación host
    3.4.3. Ejercicio 3: Trabajar con eventos de tiempo de ejecución
      3.4.3.1. Tarea 1: Realización de escuchas y procesamiento de eventos
        3.4.3.1.1. Para agregar controladores de eventos para los eventos WorkflowRuntime.Started y WorkflowRuntime.Stopped
      3.4.3.2. Tarea 2: Suspensión, finalización y reanudación de los flujos de trabajo
        3.4.3.2.1. Para crear controladores de eventos para los eventos
        3.4.3.2.2. Para crear métodos de control de eventos para WorkflowSuspended, WorkflowResumed y eventos WorkflowTerminated
        3.4.3.2.3. Para suspender y finalizar el flujo de trabajo
    3.4.4. Ejercicio 4: Uso de los servicios de tiempo de ejecución
      3.4.4.1. Tarea 1: Configuración de servicios en tiempo de ejecución mediante código
        3.4.4.1.1. Agregar servicios de tiempo de ejecución
      3.4.4.2. Tarea 2: Configuración de servicios de tiempo de ejecución mediante App.Config
        3.4.4.2.1. Para crear el archivo de configuración de la aplicación
        3.4.4.2.2. Para definir el archivo de configuración de la aplicación
        3.4.4.2.3. Para utilizar el archivo de configuración de la aplicación
      3.4.4.3. Tarea 3: Uso del servicio de persistencia de Windows Workflow
        3.4.4.3.1. Para crear la base de datos de persistencia de SQL
        3.4.4.3.2. Modificación de App.config para SqlWorkflowPersistenceService
        3.4.4.3.3. Creación de controladores de eventos de flujo de trabajo adicionales
      3.4.4.4. Tarea 4: Uso del servicio de seguimiento de flujo de trabajo de Windows
        3.4.4.4.1. Para crear la base de datos de seguimiento de SQL
        3.4.4.4.2. Para importar los espacios de nombres SQL
        3.4.4.4.3. Modificar App.config para SqlTrackingService
        3.4.4.4.4. Para realizar el seguimiento de los eventos de flujo de trabajo
        3.4.4.4.5. Para realizar el seguimiento de los eventos de actividad
      3.4.4.5. Tarea 5: Creación de un perfil de seguimiento
        3.4.4.5.1. Importación de espacios de nombres
        3.4.4.5.2. Creación del perfil del seguimiento
        3.4.4.5.3. Grabar el perfil de seguimiento en una base de datos de seguimiento de SQL
  3.5. Tutorial: Reglas de uso y condiciones
    3.5.1. Ejercicio 1: Creación del proyecto de reglas y condiciones
      3.5.1.1. Tarea 1: Creación del archivo de proyecto de las reglas de uso y condiciones
      3.5.1.2. Tarea 2: Creación de la aplicación de reglas de uso y de hospedaje de condiciones
        3.5.1.2.1. Para agregar un formulario Windows Forms a la aplicación
        3.5.1.2.2. Para agregar un punto de entrada de la aplicación
      3.5.1.3. Tarea 3: Creación del flujo de trabajo secuencial de reglas de uso y condiciones
        3.5.1.3.1. Creación del archivo de origen del flujo de trabajo
        3.5.1.3.2. Modificación de la aplicación host
    3.5.2. Ejercicio 2: Uso de reglas y condiciones con IfElseActivity
      3.5.2.1. Tarea 1: Creación de los tipos de reglas de uso y condiciones
        3.5.2.1.1. Creación de las estructuras de datos
        3.5.2.1.2. Creación de campos y propiedades
        3.5.2.1.3. Modificación de la aplicación host
      3.5.2.2. Tarea 2: Utilización de IfElseActivity con CodeCondition
        3.5.2.2.1. Para agregar nuevas variables de miembro de DiscountWorkflow
        3.5.2.2.2. Para construir IfElseActivity
        3.5.2.2.3. Para construir las actividades IfElseBranchActivity
        3.5.2.2.4. Para crear TerminateActivity
      3.5.2.3. Tarea 3: Uso de IfElseActivity con RuleConditionExpression
        3.5.2.3.1. Creación de las actividades CodeActivity
        3.5.2.3.2. Creación de IfElseActivity
        3.5.2.3.3. Creación del archivo de reglas
    3.5.3. Ejercicio 3: Reglas de uso y condiciones con ConditionedActivityGroup
      3.5.3.1. Tarea 1: Creación de la actividad ConditionedActivityGroup
        3.5.3.1.1. Creación de ConditionedActivityGroup
        3.5.3.1.2. Creación de CodeActivity para quitar cupones
        3.5.3.1.3. Creación de la regla CodeActivity When
      3.5.3.2. Tarea 2: Creación de PolicyActivity y RuleSet
        3.5.3.2.1. Para crear PolicyActivity
        3.5.3.2.2. Para crear el cupón RuleSet
        3.5.3.2.3. Para crear la regla getFreeItems
        3.5.3.2.4. Para crear la regla applyPercentageOffHighest
        3.5.3.2.5. Título del procedimiento
        3.5.3.2.6. Para crear la regla applyPercentageOffLowest
        3.5.3.2.7. Para crear la regla applyPercentageOffTotal
  3.6. Tutorial: Creación de una aplicación de flujo de trabajo con ASP .NET
    3.6.1. Ejercicio 1: Creación del proyecto de flujo de trabajo
      3.6.1.1. Tarea 1: Creación del archivo de proyecto del flujo de trabajo
        3.6.1.1.1. Para crear el flujo de trabajo con un archivo de proyecto de ASP .NET
      3.6.1.2. Tarea 2: Creación de las clases en la biblioteca de flujo de trabajo
        3.6.1.2.1. Para crear los archivos de código fuente de la clase
        3.6.1.2.2. Para agregar el código a los archivos
      3.6.1.3. Tarea 3: Creación de la base de datos de seguimiento y persistencia
        3.6.1.3.1. Creación de la base de datos de seguimiento y persistencia
    3.6.2. Ejercicio 2: Creación del sitio web
      3.6.2.1. Tarea 1: Preparación de los archivos de aplicación del sitio web
        3.6.2.1.1. Para preparar el directorio web virtual
        3.6.2.1.2. Para preparar los archivos de aplicación
      3.6.2.2. Tarea 2: Creación de la página predeterminada
        3.6.2.2.1. Para agregar la página predeterminada al sitio web
  3.7. Tutorial: Hospedaje de Windows Workflow Designer
    3.7.1. Ejercicio 1: Creación de un proyecto de hospedaje de Workflow Designer
      3.7.1.1. Tarea 1: Creación del archivo de proyecto de hospedaje de Workflow Designer
        3.7.1.1.1. Para crear el archivo de proyecto de diseñador de alojamiento
      3.7.1.2. Tarea 2: Creación del formulario de hospedaje de Windows Workflow Designer
        3.7.1.2.1. Para crear el archivo de código fuente del formulario de Windows
        3.7.1.2.2. Para agregar el código del formulario de Windows a la aplicación host
        3.7.1.2.3. Para crear el archivo de código fuente del punto de entrada de la aplicación
        3.7.1.2.4. Para agregar el código del punto de entrada de la aplicación
    3.7.2. Ejercicio 2: Integración del diseñador de flujo de trabajo
      3.7.2.1. Tarea 1: Creación del cargador del diseñador de flujo de trabajo
        3.7.2.1.1. Para crear el archivo de código fuente de WorkflowDesignerLoader
        3.7.2.1.2. Para crear la clase WorkflowLoader
        3.7.2.1.3. Para cargar definiciones de flujo de trabajo mediante WorkflowLoader
        3.7.2.1.4. Para agregar las actividades al host del diseñador del flujo de trabajo
        3.7.2.1.5. Para crear una matriz de actividades secundarias anidadas
        3.7.2.1.6. Para quitar actividades del host de diseñador
      3.7.2.2. Tarea 2: Incorporación del diseñador de flujo de trabajo en el formulario de Windows
        3.7.2.2.1. Implementación de la interfaz IServiceProvider
        3.7.2.2.2. Creación de campos y propiedades necesarios para el hospedaje del Diseñador
        3.7.2.2.3. Para cargar una nueva definición de flujo de trabajo
        3.7.2.2.4. Para cargar las definiciones de flujo de trabajo
        3.7.2.2.5. Para descargar una definición de flujo de trabajo
      3.7.2.3. Tarea 3: Creación de WorkflowMenuCommandService
        3.7.2.3.1. Creación del archivo de código fuente de servicios
        3.7.2.3.2. Creación de la clase WorkflowMenuCommandService
        3.7.2.3.3. Creación del método ShowContextMenu
        3.7.2.3.4. Creación del método GetSelectionMenuItems
        3.7.2.3.5. Creación del método OnMenuClicked
        3.7.2.3.6. Agregar WorkflowMenuCommandService a la clase WorkflowLoader
        3.7.2.3.7. Quitar WorkflowMenuCommandService de WorkflowLoader

Descarga
Manual_Windows_Workflow_Foundation

miércoles, 29 de noviembre de 2017

Preguntas y Respuestas de Desarrollo Web en ASP.NET & JavaScript

A partir de este momento estaré inaugurando una nueva sección de videos en mi canal de youtube que consistirá en responder las dudas sobre desarrollo web, para lo cual los interesados deberán enviarme un correo con el siguiente formato:

Para: Luis.duenash@gmail.com
Asunto: Preguntas y Respuestas de Desarrollo Web .NET
Nombre Completo: Apellidos y Nombres
Ubicación Geográfica: Ciudad y País
Tipo de Perfil: Estudiante o Profesional
Lugar de: Estudio o Trabajo
Categoria de la Pregunta: Descrita mas abajo
Pregunta:
Lo mas detalla posible.....

Las Categorías pueden ser entre otras:

Lenguajes
- C#
- Visual Basic

.NET Framework
- ADO.NET
- Serialización
- Cifrado
- Reflection
- Programación Asíncrona
- Programación Paralela

ASP.NET
- Web Forms
- MVC

Servicios
- Servicios Web XML
- Servicios WCF
- Servicios Web API

Formatos de Datos
- Binario
- XML
- JSON
- CSV

Manejo de Archivos
- De Texto: TXT, CSV
- Office Open XML: XLSX, DOCX, PPTX
- Contenedores Comprimidos: OpenXPS y PDF
- Imagenes: Mapa de Bits (BMP, PNG, JPG, GIF) y Vectoriales (SVG)

Protocolos
- HTTP
- TCP
- Web Sockets

Front End
- JavaScritpt
- HTML
- CSS

Arquitecturas
- Orientada a Servicios (SOA)
- Distribuida con Capas (LDA)
- Ligera Sin Capas, etc.

Performance
- Lectura y Escritura de Archivos
- Concatenación de gran cantidad de datos
- Presentación en Pantalla de miles de registros o cientos de páginas
- Exportación e Importación de miles de registros
- Velocidad de Carga de una Página Web, etc.

Las preguntas No pueden ser sobre:
- Frameworks, como por ejemplo Entity Framework, LINQ, MyBatis, Hibernate, etc.
- Librerías, como por ejemplo jQuery, Angular, Bootstrap, Ember, React, DevExpress, etc.
En caso de preguntar sobre estos les explicaré porque no se debe usar (desventajas).

lunes, 25 de julio de 2016

Artículo: Temas a Aprender en un Lenguaje de Programación

Temas a Aprender en un Lenguaje de Programación

1. Introducción

Un Lenguaje de Programación es el medio por el cual los programadores dan ordenes al computador y sin importar que tipo de lenguaje estén usando todos ellos sirven para crear aplicaciones. En este artículo quiero compartir mi opinión sobre que temas deben aprenderse al momento de elegir un Lenguaje de Programación.

He tratado de hacer una especie de Syllabus genérico para cualquier Lenguaje de Programación, por ejemplo los temas lo puedes ver en cualquier lenguaje del servidor como C# en .NET, PHP, Phyton, Ruby, C++, etc. Pero también la mayoría de temas se pueden ver en JavaScript.

Este breve artículo servirá para que tanto estudiantes y profesionales sepan los temas que son necesarios y los mas útiles que deben conocer, por lo que se ha divido en 3 partes con 4 capítulos cada una: Básica, Intermedia y Avanzada.

2. Temas o Tópicos a Aprender

Parte Básica

1. Estructuras de Datos
1.1. Simples: Numéricas, Cadenas, Lógicas, Fecha, etc.
1.2. Complejas: Arreglos, Listas, Pilas, Colas, Arboles, etc.
1.2. Objetos: Clases, Intefaces, Propiedades, Métodos, Eventos, etc.

2. Estructuras de Control de Flujo
2.1. Condicionales: if, switch, case, etc.
2.2. Repetitivas o de Bucle: for, while, do..while, etc.
2.3. Control de Errores: try..catch

3. Creando Interfaces de Usuario (IU)
3.1. Formularios
3.2. Controles de Entrada: TextBox, Radio, Check
3.3. Controles de Ejecución: Button, LinkButton
3.4. Controles de Imagen: Image, ImageButton
3.4. Controles de Listas: ListBox, ComboBox
3.5. Controles de Vistas: GridView, TreeView, ListView
3.6. Otros Controles: Calendarios, Banners, Visores, etc.

4. Manejo de Entrada y Salida
4.1. Información del Sistema: Directorios, Rutas y Archivos
4.2. Lectura y Escritura: Archivos Secuenciales y Aleatorios
4.3. Codificación de Datos: Codificar y Decodificar datos
4.4. Manejo de Expresiones Regulares

Parte Intermedia

5. Acceso a Base de Datos (Conectado)
5.1. Conectarse a una Base de Datos
5.2. Ejecutar Comandos SQL: Select, Insert, Update, Delete
5.3. Trabajar con Procedimentos Almacenados

6. Manejo de Datos (Desconectado)
6.1. Consultas: Filtros y Búsquedas
6.2. Ordenación: Ascendente y Descendente
6.3. Paginación: Por Filas y Por Columnas
6.4. Transferencia: Importación y Exportación

7. Presentación o Visualización de Datos
7.1. Vistas: Tablas, Cabecera Detalle, Jerárquicas y Tabla Cruzada
7.1. Reportes: Por Código y Por Herramientas
7.2. Gráficos: Por Código y Por Controles
7.3. Impresiones: Presentación Preliminar, Configurar Pagina, Imprimir

8. Pruebas de la Aplicación
8.1. Pruebas Unitarias: Funcionalidad
8.2. Pruebas de Rendimiento: Velocidad
8.3. Pruebas de Disponibilidad: Continuidad
8.4. Pruebas de Seguridad: Protección

Parte Avanzada

9. Programación de la Reusabilidad
9.1. Módulos o Librerías de Clases
9.2. Módulos o Librerías de Controles

10. Programación Asíncrona
10.1. Subprocesamiento: Threads y ThreadPool en una CPU
10.2. Programación Paralela: Tareas en Múltiples CPU

11. Programación de Redes y Distribuida
11.1. Sockets: TCP, UDP
11.2. Web: HTTP (Get, Post, Put, Delete)
11.3. Web Sockets: WS
11.4. Servicios: RPC, SOAP, REST (HTTP)
11.5. Correos: IMAP, POP3, SMTP
11.6. Mensajería: AMQP, MQTT, STOMP
11.7. Archivos: FTP
11.8. Señales: STUN, TURN, ICE, NAT

12. Criptografía o Cifrado de Datos
12.1. Cifrado Simétrico: AES, DES, RC2, Rijndael, Triple DES, etc.
12.2. Cifrado Asimétrico: DSA, ECDiffieHellman, ECDSA, RSA, etc.
12.3. Valores Hash: MD5, RIPEMD160, SHA1, SHA256, SHA512, etc.
12.4. Firmas Digitales y Tokens

3. Comentario Final

Parte Básica

Los Institutos y Universidades que enseñan como curso oficial o electivo en pre-grado un Lenguaje de Programación deberían cubrir la parte básica, pero pasan mucho tiempo en los 3 primeros temas y se olvidan del manejo de entrada y salida, sobre todo del manejo de archivos y después cuando los alumnos son profesionales y trabajan no pueden leer cualquier tipo de archivo, excepto el de Texto: TXT, XML, JSON, CSV, pero no un Binario (DOC, XLS, EXE, DLL, etc)  o uno Comprimido (XLSX, DOCX, PPTX, etc.)

También noto muchos problemas en los programadores en los temas de Codificación de Datos (Encoding), Decodificación de Datos (Decoding) y Búsqueda de Patrones de Texto (Expresiones Regulares). Con una buena base educativa no tendría porque haber ningún tipo de problemas al desarrollar una aplicación en cualquier lenguaje.

Parte Intermedia

La parte intermedia esta dirigida a los profesionales que trabajan desarrollando aplicaciones y necesitan conocer los temas de acceso a datos (conectado) y manejo de datos (desconectado), presentación de datos y pruebas. Aquí la falla está en que se da mucho énfasis a la programación conectada pero No se entiende que ésta es la causante de que en las empresas "Los Sistemas están Lentos" porque "La Red está Lenta" porque "las aplicaciones realizan muchas conexiones" (miles por día), por lo que es "Indispensable" saber el manejo "Desconectado" con los datos.

En cuanto a la presentación de datos la mayoría de programadores solo saben "Herramientas de Reportes", por ejemplo "Crystal Reports" o "Report Viewer" (Reporting Services) o para crear Gráficos usan "Controles", abren instancias de aplicaciones como Word y Excel. Todas estas técnicas descritas son ineficientes ya que consumen mucha memoria y son lentas, hay otras formas de hacer reportes "super rápidos", por ejemplo en .NET para Windows se usa PrintDocument y en Web solo basta con HTML y JavaScript.

En cuanto a las Pruebas, los instructores solo saben enseñar "Pruebas Unitarias" que es lo mínimo que debe pedirse de la aplicación: que cumpla con la funcionalidad pedida, pero hay temas más técnicos como son la Performance o Rendimiento, la Disponibilidad como la tolerancia a Fallas de Red y la Seguridad (privacidad de datos, ataques, robo de información, etc.) que No se toman en cuenta. Es por esto que a cada momento vemos en todas partes "Sistemas Lentos", "Sistemas Caídos por Falta de Red", "Ataques a Sitios Web", "Robo de Datos", etc.

Parte Avanzada

En esta última parte si que estamos peor (según mi experiencia de mas de 25 años como programador e instructor), ya que los 4 últimos temas es poco probable que se enseñe en una capacitación tradicional, excepto Web HTTP (REST) y Servicios SOAP (porque está de moda), pero temas como crear tu propia librería de clases y controles o tu propio módulo de clases y controles Nunca se ve, solo se les enseña a usar lo que ya está hecho sin  siquiera ser selectivo con lo que se usa (solo extraer lo necesario del código o control).

Otro problema de muchos programadores es que No saben el "ABC" de la programación asíncrona, muchos piensan que solo se puede implementar en la web con AJAX, jQuery o cualquier Framework popular, cuando en la web en el lado del cliente puede usarse XHR (nativo) y en el servidor Threads, ThreadPool, Delegados-CallBacks, Tasks, etc. Es mas importante que apliques asíncrono al servidor que al cliente porque la del cliente es para dar una mejor "Experiencia de Usuario" y la del servidor es para que "No se quede Colgado", y al final vas a dar la peor experiencia al usuario.

En cuanto al tema de la programación de redes o distribuida, la mayoría desconoce el poder de los Sockets y Web Sockets para hacer comunicación bidireccional en tiempo real y solo saben la peor (Servicios SOAP: Unidireccional). También es necesario aprender a manejar archivos con FTP, correos con SMTP, colas con STOMP, Señales con STUN, etc.

Finalmente, el tema de la Seguridad es muy importante y parte de esta es el cifrado de datos como claves, contenido, archivos, etc. Es necesario conocer los 4 tipos de tareas criptográficas mas comunes: cifrado simétrico y cifrado asimétrico (bidireccionales), valores hash (unidireccionales) y Firmas Digitales.

En General

En General, el Comentario Final es que si queremos mejorar nuestro nivel sea que somos estudiantes o profesionales debemos saber cuales son los temas mas importantes en nuestra formación, siento que en todos los niveles de la educación: pre-grado (para estudiantes) y especialización (para profesionales) los temas que se enseñan no son los mas importantes para el trabajo. Se da mucho énfasis en patrones y reusabilidad ("Construye Fácil") pero no en lo mas importante: en Producción que sea "Veloz", "Seguro" y "Siempre Disponible".

Mi aporte en estos últimos años ha sido cambiar esa mentalidad de "lo fácil" (reusabilidad) por lo "fácil mas lo eficiente" (performance y si se puede reusabilidad), aunque me hubiese gustado llegar a mas gente (aunque sea en mi país), es por eso, que a través de este Blog y mi Canal de YouTube trato de compensar este déficit.

Espero que con este artículo logre contribuir a que los centros de enseñanza de Lenguajes o Herramientas de Programación tomen en cuenta los temas que son necesarios enseñar para tener mejores profesionales que nunca tengan problemas al momento de trabajar o si los tienen que los resuelvan de la mejor manera y lo mas rápido posible.

viernes, 8 de abril de 2016

Entrenamiento - Cierre Inscripciones Segundo Taller de ASP.NET MVC & JavaScript

Cierre de Inscripciones del Segundo Taller de ASP.NET MVC & JavaScript

A todos los interesados en el Segundo Taller de ASP.NET MVC & JavaScript que se realizará los Domingos de 8:00 am a 2:00 pm se les comunica que solo hasta mañana Sábado se podrán registrar enviando un mail a Luis.duenash@gmail.com

A todos los registrados gracias por su interés, ya que en solo una semana estaba casi lleno. Se estará enviando un mail con la dirección exacta una semana antes del inicio que es el Domingo 1 de Mayo.

Saludos a todos.

viernes, 25 de septiembre de 2015

Entrenamiento - Segundo Modulo del .NET Developer

Segundo Modulo del .NET Developer

Estimados Visitantes del Blog y Alumnos, queria comunicar a los interesados el inicio del Segundo Módulo del Programa .NET Developer que se realiza los días Sábados de 3:00 pm a 10:00 pm, en el cual se ha realizado los siguientes cambios:

Modulo 1: Windows Developer (48 horas en 2 meses)
Curso 01: .NET Framework (18 horas)
Curso 02: ADO .NET (18 horas)
Curso 03: WinForms (18 horas)

Modulo 2: Web Developer (96 horas en 4 meses)
Curso 04: ASP.NET Web Forms + JavaScript (24 horas)
Curso 05: ASP.NET MVC + JavaScript (24 horas)
Curso 06: HTML5 + JavaScript (24 horas)
Curso 07: Servicios (WCF y Web API) (24 horas)

Modulo 3: Mobile Developer (72 horas en 3 meses)
Curso 08: Responsive Web Designe (CSS3+HTML5+MVC) (18 horas)
Curso 09: jQuery Mobile (18 horas)
Curso 10: Xamarin Forms iOS (18 horas)
Curso 11: Xamarin Forms Android (18 horas)

Mañana Sábado 26 de Setiembre estaremos finalizando el primer módulo y el Sábado 10 de Octubre estaremos iniciando el segundo módulo con WebForms pero visto de forma diferente, sin usar Formularios ni Controles WebForms, solo HTML y JavaScript, mediante llamadas asíncronas con XHR y usando Serialización de Cadenas.


Ya saben que el costo es de 360 soles mensuales y los interesados tienen que enviar un mail de confirmación a Luis.duenash@gmail.com para enviarles la dirección exacta.

En la parte Web enseñaremos como optimizar el envio de imagenes, subir archivos grandes al servidor, hacer todas las operaciones con los datos del lado del cliente: filtro, paginación, ordenación, exportación, etc. Además de mostrar cambios en tiempo real usando web sockets, HTML5, etc.

jueves, 4 de junio de 2015

El Demo del Día: Performace entre Serializadores .NET

Performace entre Serializadores .NET

El Problema de la Performance

Uno de los problemas principales de los Sistemas Informáticos Modernos es la Performance, sea Windows o Web la Aplicación, con el crecimiento del uso (aumento de usuarios) dentro (Intranet) y fuera de la empresa (Internet) las aplicaciones cada vez son mas lentas.

Esta lentitud es tratada de resolver aumentando Hardware como mas Servidores, mas Memorias, mas CPUs, mas Ancho de Banda, etc. Todo menos hacer una reingeniería del desarrollo que es la principal causa, es decir el problema es la forma cómo se programa (Software) donde lo común es que se realizan muchas conexiones al Servidor de Base de Datos, se usan estructuras de datos pesadas (por ejemplo en .NET los DataSets), se hacen bucles expensivos, etc.

Solución al Problema de la Performance

Aprender las Buenas Prácticas de Programación que permitan consumir la menor cantidad de memoria con el menor tiempo de procesamiento, para lo cual hay diferentes las cuales compartiremos a partir de hoy, empezando por una Comparación de Serializadores para elegir el mejor.

Definición de Serialización

Según Wikipedia, la Serialización (o Marshalling en inglés) es el proceso de codificación de un objeto en un medio de almacenamiento (como puede ser un archivo, o un buffer de memoria) con el fin de transmitirlo a través de una conexión en red como una serie de bytes o en un formato humanamente más legible como XML o JSON, entre otros.

La serie de bytes o el formato pueden ser usados para crear un nuevo objeto que es idéntico en todo al original, incluido su estado interno (por tanto, el nuevo objeto es un clon del original).

La Serialización es un mecanismo ampliamente usado para transportar objetos a través de una red, para hacer persistente un objeto en un archivo o base de datos, o para distribuir objetos idénticos a varias aplicaciones o localizaciones.

Importancia de elegir un Serializador

Es necesario saber elegir adecuadamente un Serializador, ya que cada vez que enviamos datos entre dos procesos se usa la serialización. 

A continuación listamos los Serializadores .NET junto con los tipos de aplicaciones o tecnologías distribuidas que las usan por defecto:

- Serializador Binario: Usado en Sockets y .NET Remoting (dll)
- Serializador SOAP: Usado por Servicios Web XML (asmx)
- Serializador XML: Usado por los Servicios WCF (svc y dll)
- Serializador JSON: Usado en Web API
- Serializador Personalizado: Hay que crearlo uno mismo.

La importancia de seleccionar bien el Serializador es que este es el factor principal de performance al momento de usar un Servicio o una Aplicación Distibuida, es decir, depende de este el tiempo de serialización deserealización y sobre todo el formato y el tamaño de los datos que se pasan por la red.

En este post, comprobaremos cual es el mejor, sin embargo la mayoría siempre usa el peor y después quiere que sus Servicios sean rápidos, es decir, quieren una cosa (Performance) pero hacen otra (Estándar).

Crear una Aplicación Windows Forms en C#

Abrir Visual Studio y crear una aplicación Windows Forms en C# llamada "Comparacion_Serializacion", cambiarle de nombre al formulario por "frmListaProductos" y realizar el diseño similar a la figura mostrada:


Nota: En el diseño hay un DataGridView llamado "dgvProducto", un menú contextual llamado "mnuContextual" con 6 opciones: mnuCargarDatos, mnuBinario, mnuSOAP, mnuXML, mnuJSON y mnuPersonalizado.

Crear el Procedimiento Almacenado en SQL Server

Crear el Procedimiento llamado "uspProductsListar" en SQL Server:

Create Procedure uspProductsListar
As
Select ProductID, ProductName, SupplierID, 
CategoryID,UnitPrice, UnitsInStock
From Products

Crear la Clase Entidad del Negocio

Agregar una clase al proyecto llamada: "beProducto" y escribir el siguiente código:

using System;
using System.Runtime.Serialization;

namespace Comparacion_Serializacion
{
    //[Serializable]
    //[DataContract]
    public class beProducto
    {
        //[DataMember]
        public int IdProducto { get; set; }
        //[DataMember]        
        public string Nombre { get; set; }
        //[DataMember]
        public int IdProveedor { get; set; }
        //[DataMember]
        public int IdCategoria { get; set; }
        //[DataMember]
        public decimal PrecioUnitario { get; set; }
        //[DataMember]
        public short Stock { get; set; }
    }
}

Nota: Los atributos de serialización (Serializable, DataContract y DataMember) han sido comentados inicialmente para ver que sucede cuando se intenta serializar con cada técnica.

Crear la Clase de Acceso a Datos

Agregar una clase al proyecto llamada: "daProducto" y escribir el siguiente código:

using System;
using System.Collections.Generic; //List
using System.Data; //CommandType, CommandBehavior
using System.Data.SqlClient; //SqlConnection, SqlCommand, SqlDataReader

namespace Comparacion_Serializacion
{
    public class daProducto
    {
        public List<beProducto> listar(SqlConnection con)
        {
            List<beProducto> lbeProducto = null;

            SqlCommand cmd = new SqlCommand("uspProductsListar", con);
            cmd.CommandType = CommandType.StoredProcedure;
            SqlDataReader drd = cmd.ExecuteReader(CommandBehavior.SingleResult);
            if (drd != null)
            {
                lbeProducto = new List<beProducto>();
                int posIdProducto = drd.GetOrdinal("ProductID");
                int posNombre = drd.GetOrdinal("ProductName");
                int posIdProveedor = drd.GetOrdinal("SupplierID");
                int posIdCategoria = drd.GetOrdinal("CategoryID");
                int posPrecioUnitario = drd.GetOrdinal("UnitPrice");
                int posStock = drd.GetOrdinal("UnitsInStock");
                beProducto obeProducto;
                while (drd.Read())
                {
                    obeProducto = new beProducto();
                    obeProducto.IdProducto = drd.GetInt32(posIdProducto);
                    obeProducto.Nombre = drd.GetString(posNombre);
                    obeProducto.IdProveedor = drd.GetInt32(posIdProveedor);
                    obeProducto.IdCategoria = drd.GetInt32(posIdCategoria);
                    obeProducto.PrecioUnitario = drd.GetDecimal(posPrecioUnitario);
                    obeProducto.Stock = drd.GetInt16(posStock);
                    lbeProducto.Add(obeProducto);
                }
                drd.Close();
            }

            return (lbeProducto);
        }
    }
}

Crear la Clase de Reglas del Negocio

Agregar una clase al proyecto llamada: "brProducto" y escribir el siguiente código:

using System;
using System.Configuration; //ConfigurationManager
using System.Data.SqlClient; //SqlConnection
using System.Collections.Generic; //List

namespace Comparacion_Serializacion
{
    public class brProducto
    {
        public string CadenaConexion { get; set; }
        private string archivoLog;

        public brProducto()
        {
            CadenaConexion = 
                ConfigurationManager.ConnectionStrings["conNW"].ConnectionString;
        }

        public List<beProducto> listar()
        {
            List<beProducto> lbeProducto = null;
            using (SqlConnection con = new SqlConnection(CadenaConexion))
            {
                try
                {
                    con.Open();
                    daProducto odaProducto = new daProducto();
                    lbeProducto = odaProducto.listar(con);
                }
                catch (SqlException ex)
                {
                    //grabarLog(ex);
                }
                catch (Exception ex)
                {
                    //grabarLog(ex);
                }
            } //con.Close(); con.Dispose();
            return (lbeProducto);
        }
    }
}

Nota: Para usar la clase "ConfigurationManager", primero hay que hacer referencia a la librería "System.Configuration.dll"

Crear una Clase para la Serialización Personalizada de Strings

Agregar una clase al proyecto llamada: "CustomSerializer" y escribir el siguiente código:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.IO;

namespace Comparacion_Serializacion
{
    public class CustomSerializer
    {
        public static void Serializar<T>(List<T> lista, string archivo, char separadorCampo, 
        char separadorRegistro)
        {
            StringBuilder sb = new StringBuilder();
            PropertyInfo[] propiedades = lista[0].GetType().GetProperties();
            for (int i = 0; i < propiedades.Length; i++)
            {
                sb.Append(propiedades[i].Name);
                if (i < propiedades.Length - 1) sb.Append(separadorCampo);
            }
            sb.Append(separadorRegistro);
            for (int j = 0; j < lista.Count; j++)
            {
                propiedades = lista[j].GetType().GetProperties();
                for (int i = 0; i < propiedades.Length; i++)
                {
                    if (propiedades[i].GetValue(lista[j], null) != null) 
                    sb.Append(propiedades[i].GetValue(lista[j], null).ToString());
                    else sb.Append("");
                    if (i < propiedades.Length - 1) sb.Append(separadorCampo);
                }
                if (j < lista.Count - 1) sb.Append(separadorRegistro);
            }
            File.WriteAllText(archivo,sb.ToString());
        }

        public static List<T> Deserializar<T>(string archivo, char separadorCampo, 
        char separadorRegistro)
        {
            List<T> lista = new List<T>();
            if (File.Exists(archivo))
            {
                string contenido = File.ReadAllText(archivo);
                string[] registros = contenido.Split(separadorRegistro);
                string[] campos;
                string[] cabecera = registros[0].Split(separadorCampo);
                string registro;
                Type tipoObj;
                T obj;
                dynamic valor;
                Type tipoCampo;
                for (int i = 1; i < registros.Length; i++)
                {
                    registro = registros[i];
                    tipoObj = typeof(T);
                    obj = (T)Activator.CreateInstance(tipoObj);
                    campos = registro.Split(separadorCampo);
                    for (int j = 0; j < campos.Length; j++)
                    {
                        tipoCampo = obj.GetType().GetProperty(cabecera[j]).PropertyType;
                        valor = Convert.ChangeType(campos[j],tipoCampo);
                        obj.GetType().GetProperty(cabecera[j]).SetValue(obj, valor);
                    }
                    lista.Add(obj);
                }
            }
            return (lista);
        }
    }
}

Nota: Para crear mi propio Serializador uso Reflection y Listas Genéricas. 
Una de las claves para hacer la Deserealización es crear una instancia del objeto dinámicamente con Activator.CreateInstance y luego escribir el valor desde la cadena al objeto para lo cual uso Convert.ChangeType.

Escribir el Código del Formulario frmListaProducto

Antes de escribir el código de los Serializadores hay que hacer las siguientes Referencias:
- System.Runtime.Serialization.Formatters.Soap.dll para la Serialización SOAP
- System.Runtime.Serialization para la Serialización JSON

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO; //FileStream
using System.Linq; //ToList
using System.Diagnostics; //Stopwatch
using System.Runtime.Serialization.Formatters.Binary; //BinaryFormatter
using System.Runtime.Serialization.Formatters.Soap; //SoapFormatter
using System.Xml.Serialization; //XmlSerializer
using System.Runtime.Serialization.Json; //DataContractJsonSerializer

namespace Comparacion_Serializacion
{
    public partial class frmListaProducto : Form
    {
        private List<beProducto> lbeProducto;

        public frmListaProducto()
        {
            InitializeComponent();
        }

        private void cargarDatos(object sender, EventArgs e)
        {
            brProducto obrProducto = new brProducto();
            lbeProducto = obrProducto.listar();
            dgvProducto.DataSource = lbeProducto;
        }

        private void medirTiempo(Action metodo)
        {
            Stopwatch cronometro = new Stopwatch();
            cronometro.Start();
            metodo();
            MessageBox.Show(String.Format("Tiempo de Duración: {0:n0} msg", 
            cronometro.Elapsed.TotalMilliseconds));
            cronometro.Stop();
        }

        private void serializarBinario()
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (FileStream fs = new FileStream("Binario.txt",
                FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                bf.Serialize(fs, lbeProducto);
            }
        }

        private void deserializarBinario()
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (FileStream fs = new FileStream("Binario.txt",
                FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                lbeProducto=(List<beProducto>)bf.Deserialize(fs);
            }
        }

        private void serializarSOAP()
        {
            SoapFormatter sf = new SoapFormatter();
            using (FileStream fs = new FileStream("SOAP.txt",
                FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                sf.Serialize(fs, lbeProducto.ToArray());
            }
        }

        private void deserializarSOAP()
        {
            SoapFormatter sf = new SoapFormatter();
            using (FileStream fs = new FileStream("SOAP.txt",
                FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                lbeProducto=((beProducto[])sf.Deserialize(fs)).ToList();
            }
        }

        private void serializarXML()
        {
            XmlSerializer xs = new XmlSerializer(typeof(List<beProducto>));
            using (FileStream fs = new FileStream("XML.txt",
                FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                xs.Serialize(fs, lbeProducto);
            }
        }

        private void deserializarXML()
        {
            XmlSerializer xs = new XmlSerializer(typeof(List<beProducto>));
            using (FileStream fs = new FileStream("XML.txt",
                FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                lbeProducto = (List<beProducto>)xs.Deserialize(fs);
            }
        }

        private void serializarJSON()
        {
            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(List<beProducto>));
            using (FileStream fs = new FileStream("JSON.txt",
                FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
            {
                js.WriteObject(fs, lbeProducto);
            }
        }

        private void deserializarJSON()
        {
            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(List<beProducto>));
            using (FileStream fs = new FileStream("JSON.txt",
                FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                lbeProducto=(List<beProducto>)js.ReadObject(fs);
            }
        }

        private void serializarString()
        {
            CustomSerializer.Serializar(lbeProducto, "Strings.txt", ',', '|');
        }

        private void deserializarString()
        {
            lbeProducto=CustomSerializer.Deserializar<beProducto>("Strings.txt", ',', '|');
        }

        private void mnuSerializarBinario_Click(object sender, EventArgs e)
        {
            medirTiempo(serializarBinario);
        }

        private void mnuDeserializarBinario_Click(object sender, EventArgs e)
        {
            medirTiempo(deserializarBinario);
            dgvProducto.DataSource = lbeProducto;
        }

        private void mnuSerializarSOAP_Click(object sender, EventArgs e)
        {
            medirTiempo(serializarSOAP);
        }

        private void mnuDeserializarSOAP_Click(object sender, EventArgs e)
        {
            medirTiempo(deserializarSOAP);
            dgvProducto.DataSource = lbeProducto;
        }

        private void mnuSerializarXML_Click(object sender, EventArgs e)
        {
            medirTiempo(serializarXML);
        }

        private void mnuDeserializarXML_Click(object sender, EventArgs e)
        {
            medirTiempo(deserializarXML);
            dgvProducto.DataSource = lbeProducto;
        }

        private void mnuSerealizarJSON_Click(object sender, EventArgs e)
        {
            medirTiempo(serializarJSON);
        }

        private void mnuDeserealizarJSON_Click(object sender, EventArgs e)
        {
            medirTiempo(deserializarJSON);
            dgvProducto.DataSource = lbeProducto;
        }

        private void mnuSerializarPersonalizado_Click(object sender, EventArgs e)
        {
            medirTiempo(serializarString);
        }

        private void mnuDeserializarPersonalizado_Click(object sender, EventArgs e)
        {
            medirTiempo(deserializarString);
            dgvProducto.DataSource = lbeProducto;
        }
    }
}

Nota: Todos las funciones manejadoras de eventos llaman a la función "medirTiempo" para ejecutar la Serialización y Deserealización.

Modificar el Archivo de Configuración

Abrir el archivo app.Config y aumentar la cadena de conexión:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="conNW" providerName="SQLServer"
      connectionString="uid=UsuarioNW;pwd=123456;
      server=DSOFT\Sqlexpress;database=Northwind"/>
  </connectionStrings>
  <startup> 
      <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  </startup>
</configuration>

Ejecutar y Probar la Aplicación Windows Forms

Grabar la aplicación y pulsar F5 para ejecutarla. Aparecerá una ventana similar a la siguiente figura:


Clic derecho y se mostrará el menú contextual, del cual seleccionar la primera opción: "Cargar Datos" y se listarán los productos.


Serialización Binaria

Clic derecho y del menú contextual seleccionar la opción "Binario" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 11 msg y se creará un archivo llamado "Binario.txt" con el siguiente contenido:


Notas
- Si se intenta Serializar el archivo a Binario se caerá ya que la Entidad (clase beProducto) no es serializable, proceder a descomentar el atributo [Serializable].
- Observar que el tamaño del archivo Binario.txt es de 5756 bytes (en mi caso).

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Binario" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 8 msg y se cargarán los datos desde el archivo "Binario.txt" en la lista de objetos y se mostrará en la grilla.

Serialización SOAP

Detener la ejecución y probar nuevamente, seleccionando la opción "Cargar Datos", luego del menú contextual seleccionar la opción "SOAP" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 30 msg y se creará un archivo llamado "SOAP.txt" con el siguiente contenido:


Nota: Observar que el tamaño del archivo SOAP.txt es de 73586 bytes (en mi caso)

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Binario" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 51 msg y se cargarán los datos desde el archivo "SOAP.txt" en la lista de objetos y se mostrará en la grilla.

Serialización XML

Detener la ejecución y probar nuevamente, seleccionando la opción "Cargar Datos", luego del menú contextual seleccionar la opción "XML" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 192 msg y se creará un archivo llamado "XML.txt" con el siguiente contenido:


Nota: Observar que el tamaño del archivo XML.txt es de 22270 bytes (en mi caso)

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Binario" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 209 msg y se cargarán los datos desde el archivo "XML.txt" en la lista de objetos y se mostrará en la grilla.

Serialización JSON sin atributos

Detener la ejecución y probar nuevamente, seleccionando la opción "Cargar Datos", luego del menú contextual seleccionar la opción "JSON" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 474 msg y se creará un archivo llamado "JSON.txt" con el siguiente contenido:


Nota: Observar que el tamaño del archivo JSON.txt es de 19716 bytes (en mi caso)

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Binario" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 347 msg y se cargarán los datos desde el archivo "JSON.txt" en la lista de objetos y se mostrará en la grilla.

Serialización JSON con atributos (DataContract y DataMember)

Detener la ejecución, decomentar los atributos [DataContract] y [DataMamber] de la entidad beProducto, además renombrar el archivo JSON.txt por JSON2.txt y probar nuevamente, seleccionando la opción "Cargar Datos", luego del menú contextual seleccionar la opción "JSON" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 27 msg y se creará un archivo llamado "JSON.txt" con el siguiente contenido:



Nota: Observar que el tamaño del archivo JSON.txt es tan solo de 10332 bytes (en mi caso)

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Binario" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 92 msg y se cargarán los datos desde el archivo "JSON.txt" en la lista de objetos y se mostrará en la grilla.

Serialización Personalizada con Strings

Detener la ejecución y probar nuevamente, seleccionando la opción "Cargar Datos", luego del menú contextual seleccionar la opción "Personalizado" y luego "Serializar", se mostrará el tiempo de la serialización, en mi caso 15 msg y se creará un archivo llamado "Strings.txt" con el siguiente contenido:



Nota: Observar que el tamaño del archivo Strings.txt es de 3125 bytes (en mi caso)

Detener la ejecución y probar nuevamente, pero esta vez seleccionar directamente del menú contextual "Personalizado" y "Deserealizar", se mostrará el tiempo de deserealización, en mi caso 53 msg y se cargarán los datos desde el archivo "Strings.txt" en la lista de objetos y se mostrará en la grilla.

Resumen Comparativo

A continuación una figura con un cuadro resumen de tiempos y tamaños por serializador (formato):



Esta resaltado los que mejor rendimiento tienen, es decir el tiempo de Serializado el ganador es el Binario, pero en tamaño (ancho de banda) el ganador es el Strings (Personalizado), además para Servicios Web el Binario no es aplicable por tanto, el mejor Serializador en Performance sería el String.

Sin embrago el comportamiento de los desarrolladores ha sido:
- Web Services XML con SOAP (2002-2007)
- WCF Services con XML (2008-2011)
- Web API con JSON (2012-2015)

Comentario Final

Después de haber tratado detalladamente los Serializadores .NET y analizado su tiempo y tamaño, la recomendación final es que si desean consumir el mínimo ancho de banda, hay que crear su propio serializador (yo le estoy dejando el mio, que poco a poco lo voy a optimizar) ya que es el que mejor rendimiento tiene en velocidad, tamaño e inter-operabilidad.

Claro, muchos dirán que No es Estandar el formato creado, y otros dirán y como hago para consumirlos desde los clientes, es decir como muestro estos datos, así como hay Templates para JSON yo tambien tengo mis propias rutinas que muestran en JavaScript cualquier Strings separados por caracteres, los cuales serán motivos de otros post.

Descarga del Código