Curso de Visual Basic para tu equipo — Desarrollo y productividad

Declarar variables mediante `Dim` y comprender alcance, duración y asignación.

Utilizar constantes con `Const` y valores de solo lectura cuando corresponda.

Trabajar con tipos numéricos enteros, decimales y de coma flotante.

Utilizar `Boolean`, `Char`, `String`, `Date`, `Object` y tipos definidos por el usuario.

Diferenciar tipos por valor, tipos por referencia, boxing y unboxing.

Comprender valores predeterminados, `Nothing` y tipos de valor anulables.

Aplicar inferencia de tipos con `Option Infer`.

Configurar `Option Explicit`, `Option Strict` y `Option Compare`.

Realizar conversiones con `CType`, `DirectCast`, `TryCast` y funciones de conversión.

Utilizar operadores aritméticos, relacionales, lógicos, de concatenación y asignación.

Diferenciar `And`, `Or`, `AndAlso` y `OrElse` mediante evaluación en cortocircuito.

Trabajar con `Is`, `IsNot`, `Like`, precedencia, desbordamiento y precisión numérica.

Construir decisiones con `If`, `ElseIf`, `Else` y operadores condicionales.

Utilizar `Select Case` para organizar múltiples alternativas y rangos de valores.

Crear bucles con `For`, `For Each`, `While`, `Do While` y `Do Until`.

Controlar iteraciones mediante `Exit`, `Continue` y condiciones de parada seguras.

Evitar bucles infinitos, condiciones redundantes y estructuras difíciles de mantener.

Crear procedimientos `Sub` y funciones `Function` con responsabilidades claras.

Definir parámetros obligatorios, opcionales y matrices de parámetros con `ParamArray`.

Diferenciar paso por valor con `ByVal` y paso por referencia con `ByRef`.

Aplicar sobrecarga de métodos y argumentos con nombre.

Comprender ámbito de bloque, procedimiento, módulo, clase, ensamblado y namespace.

Organizar código mediante módulos, namespaces, archivos y proyectos.

Utilizar directivas de compilación condicional y constantes de compilación cuando proceda.

Manipular cadenas mediante interpolación, concatenación, formato, búsqueda y reemplazo.

Usar `StringBuilder` cuando existen numerosas modificaciones sucesivas de texto.

Trabajar con caracteres, codificación, comparación, cultura y mayúsculas o minúsculas.

Aplicar expresiones regulares para validación, extracción y transformación de texto.

Gestionar fechas, horas, intervalos, zonas horarias y formatos culturales.

Crear arrays unidimensionales, multidimensionales, escalonados y dinámicos.

Recorrer, ordenar, buscar, copiar y redimensionar arrays con criterio.

Utilizar `List`, `Dictionary`, `HashSet`, `Queue`, `Stack` y colecciones relacionadas.

Elegir la estructura de datos adecuada según acceso, orden, unicidad y rendimiento.

Trabajar con `IEnumerable`, enumeradores y ejecución diferida.

Crear iteradores personalizados mediante `Iterator Function` y `Yield`.

Utilizar tuplas, enumeraciones y estructuras para modelar agrupaciones de datos.

Comprender clase, objeto, instancia, estado, comportamiento e identidad.

Crear clases con campos, métodos, propiedades y constructores.

Usar propiedades automáticas y propiedades con validación personalizada.

Controlar acceso mediante `Public`, `Private`, `Protected`, `Friend` y sus combinaciones.

Aplicar encapsulación para proteger invariantes y evitar estados inválidos.

Diferenciar miembros de instancia y miembros compartidos con `Shared`.

Crear constructores sobrecargados y encadenar inicialización.

Utilizar `Me`, inicializadores de objetos y expresiones `With`.

Modelar datos mediante clases, estructuras, enumeraciones y objetos inmutables.

Aplicar composición y agregación para relacionar objetos.

Utilizar clases parciales para distribuir definiciones entre varios archivos.

Gestionar recursos mediante `IDisposable`, `Using` y el patrón de disposición.

Aplicar herencia para especializar comportamiento sin duplicar código.

Utilizar `Inherits`, `MyBase`, `MyClass`, `MustInherit` y `NotInheritable`.

Sobrescribir miembros mediante `Overrides`, `Overridable` y `MustOverride`.

Comprender polimorfismo, sustitución y despacho dinámico.

Diseñar interfaces mediante `Interface` e `Implements`.

Elegir entre herencia, interfaces y composición según el problema.

Crear clases, métodos e interfaces genéricas.

Aplicar restricciones genéricas y consumir restricciones modernas de .NET.

Comprender delegados como referencias tipadas a métodos.

Crear, publicar y gestionar eventos con `Event`, `RaiseEvent`, `Handles` y `AddHandler`.

Utilizar expresiones lambda, closures y funciones anónimas.

Crear métodos de extensión, atributos personalizados y operaciones básicas de reflexión.

Comprender LINQ como lenguaje común para consultar objetos, datos y XML.

Crear consultas mediante sintaxis declarativa y sintaxis de métodos.

Utilizar `From`, `Where`, `Select`, `Order By`, `Group By`, `Join` y `Aggregate`.

Filtrar, ordenar, proyectar, agrupar y combinar colecciones.

Trabajar con `Any`, `All`, `First`, `Single`, `Count`, `Sum`, `Average` y operaciones relacionadas.

Comprender ejecución diferida, materialización y evaluación múltiple.

Evitar enumeraciones repetidas, consultas costosas y excepciones por secuencias vacías.

Crear proyecciones anónimas, tuplas y objetos de resultado.

Integrar LINQ con colecciones genéricas y fuentes de datos.

Utilizar literales XML, XML axis properties y expresiones embebidas propias de Visual Basic.

Consultar, crear, modificar y guardar documentos XML.

Analizar costes, legibilidad y situaciones donde un bucle resulta más apropiado que LINQ.

Comprender errores de compilación, excepciones, fallos lógicos y problemas de entorno.

Gestionar excepciones con `Try`, `Catch`, `Finally` y filtros `When`.

Lanzar errores mediante `Throw` conservando correctamente la traza original.

Crear excepciones personalizadas solo cuando aportan significado al dominio.

Evitar capturas genéricas que ocultan errores o dejan el sistema en estado inconsistente.

Aplicar validación de entradas, precondiciones, invariantes y comprobaciones de salida.

Utilizar breakpoints, breakpoints condicionales, watches, locals, call stack e Immediate Window.

Depurar recorridos, excepciones, procesos, hilos y aplicaciones en ejecución.

Interpretar stack traces y localizar la causa raíz de un fallo.

Incorporar logging estructurado con niveles, categorías, contexto y correlación.

Utilizar `Debug`, `Trace`, assertions y diagnósticos sin exponer información sensible.

Reemplazar el antiguo `On Error` por manejo estructurado de excepciones en código moderno.

Leer y escribir archivos de texto de forma síncrona y asíncrona.

Trabajar con rutas, directorios, archivos temporales y metadatos del sistema.

Utilizar streams, readers, writers, buffers y codificaciones.

Gestionar recursos mediante bloques `Using` y liberación determinista.

Procesar archivos grandes sin cargarlos completamente en memoria.

Serializar y deserializar datos JSON con las bibliotecas actuales de .NET.

Leer y generar XML mediante APIs y literales propios del lenguaje.

Diseñar DTOs para intercambiar información entre capas y sistemas.

Gestionar configuración mediante archivos, variables de entorno y proveedores de configuración.

Proteger secretos, cadenas de conexión, tokens y credenciales.

Consumir servicios REST mediante `HttpClient`, métodos HTTP, headers y contenido JSON.

Gestionar respuestas, errores, timeouts, reintentos y cancelación en integraciones externas.

Comprender diferencias entre ejecución síncrona, asíncrona, concurrente y paralela.

Utilizar `Async` y `Await` para operaciones no bloqueantes.

Trabajar con `Task`, `Task(Of T)` y tipos de resultado asíncrono.

Evitar bloqueos provocados por `.Result`, `.Wait()` y mezclas incorrectas de modelos.

Propagar errores correctamente a través de cadenas asíncronas.

Gestionar cancelación mediante `CancellationToken`.

Aplicar timeouts, progreso y coordinación de múltiples tareas.

Utilizar `Task.WhenAll` y `Task.WhenAny` para combinar operaciones.

Proteger estado compartido y comprender condiciones de carrera.

Usar locks, colecciones concurrentes y primitivas de sincronización cuando sean necesarias.

Aplicar paralelismo de datos con prudencia y medir su impacto.

Mantener interfaces de usuario responsivas durante operaciones largas.

Comprender bases de datos relacionales, tablas, claves, relaciones, índices y restricciones.

Diseñar consultas SQL de lectura y modificación desde aplicaciones Visual Basic.

Utilizar proveedores ADO.NET, conexiones, comandos, parámetros y lectores de datos.

Evitar inyección SQL mediante consultas parametrizadas.

Gestionar apertura, cierre y pooling de conexiones.

Trabajar con `DataReader`, `DataTable`, `DataSet` y adaptadores según el escenario.

Ejecutar operaciones asíncronas de acceso a datos.

Gestionar transacciones, commit, rollback y niveles de aislamiento.

Mapear registros a objetos de dominio y separar persistencia de lógica de negocio.

Crear repositorios y servicios de datos testeables.

Consumir bibliotecas de acceso modernas de .NET, incluido Entity Framework Core cuando encaje con el proyecto.

Analizar concurrencia, rendimiento, paginación, índices, errores y consistencia de datos.

Comprender el modelo de programación dirigido por eventos.

Crear ventanas, formularios, controles, menús y cuadros de diálogo.

Diseñar interfaces mediante Visual Studio Designer y código.

Gestionar eventos de usuario, ciclo de vida y navegación entre pantallas.

Validar formularios y mostrar errores de forma comprensible.

Trabajar con controles de listas, tablas, árboles, imágenes y selección.

Aplicar data binding entre controles y objetos.

Separar presentación, lógica de aplicación, dominio y acceso a datos.

Crear controles reutilizables y componentes personalizados.

Desarrollar aplicaciones Windows Forms para utilidades y sistemas empresariales.

Conocer WPF, XAML, binding, comandos, recursos, estilos y fundamentos de MVVM.

Aplicar accesibilidad, localización, escalado DPI, temas y ejecución asíncrona en la interfaz.

Comprender pruebas unitarias, de integración, funcionales y de sistema.

Crear proyectos de pruebas con MSTest, NUnit, xUnit o el framework adoptado por la empresa.

Aplicar Arrange, Act, Assert y nomenclaturas comprensibles.

Probar funciones, clases, servicios, validadores y reglas de negocio.

Utilizar fakes, stubs y mocks sin acoplar las pruebas a detalles internos.

Medir cobertura interpretándola como señal y no como único objetivo.

Aplicar desarrollo guiado por pruebas cuando resulte útil.

Utilizar analizadores, reglas de estilo, formateadores y warnings como errores.

Aplicar SOLID, separación de responsabilidades y dependencia hacia abstracciones.

Conocer patrones como Factory, Strategy, Repository, Adapter, Observer y Dependency Injection.

Organizar soluciones por capas, módulos, responsabilidades y proyectos.

Documentar APIs mediante comentarios XML, README, diagramas y decisiones técnicas.

Gestionar dependencias, versiones y paquetes mediante NuGet.

Crear y consumir bibliotecas escritas en Visual Basic, C# u otros lenguajes .NET.

Comprender assemblies, namespaces, referencias, metadatos y compatibilidad binaria.

Integrar componentes COM, automatización de Office y APIs nativas cuando exista una necesidad justificada.

Analizar código Visual Basic 6, VBA o .NET Framework antes de una migración.

Modernizar aplicaciones legacy de forma incremental, manteniendo pruebas y compatibilidad.

Validar entradas, aplicar mínimos privilegios y proteger datos y secretos.

Evitar inyección, rutas inseguras, deserialización peligrosa y exposición de información interna.

Analizar rendimiento mediante profiler, diagnóstico de CPU, memoria, asignaciones y Garbage Collector.

Optimizar strings, colecciones, LINQ, I/O, recursos y consultas a bases de datos basándose en mediciones.

Utilizar Git con ramas, commits, pull requests, revisiones, merges y resolución de conflictos.

Automatizar compilación, pruebas y publicación mediante MSBuild, CLI de .NET y pipelines CI/CD.

Publicar aplicaciones dependientes del framework o autocontenidas y preparar instaladores Windows.

Gestionar configuración por entorno, versionado, logging, mantenimiento, rollback y soporte de producción.

Diseñar una aplicación empresarial completa utilizando Visual Basic y .NET.

Definir problema, usuarios, requisitos, reglas, restricciones y criterios de aceptación.

Crear una solución organizada en proyectos de presentación, aplicación, dominio, infraestructura y pruebas.

Modelar el dominio mediante clases, estructuras, enumeraciones, interfaces y objetos de valor.

Aplicar encapsulación, composición, herencia y polimorfismo con criterio.

Implementar colecciones, genéricos, delegados, eventos, lambdas y consultas LINQ.

Crear una interfaz Windows Forms o WPF clara, accesible y responsiva.

Incorporar validación, navegación, mensajes de error y operaciones asíncronas.

Persistir información en una base de datos mediante ADO.NET o una biblioteca compatible.

Consumir un servicio REST y procesar respuestas JSON.

Gestionar configuración, conexiones, secretos, archivos y logs.

Implementar excepciones, cancelación, timeouts y recuperación ante fallos.

Crear pruebas unitarias y de integración para los componentes críticos.

Aplicar principios SOLID, patrones apropiados y separación de responsabilidades.

Analizar rendimiento, uso de memoria, consultas, operaciones de I/O y experiencia de usuario.

Documentar arquitectura, instalación, configuración, decisiones y guía de uso.

Versionar la solución con Git mediante ramas, commits y pull request.

Preparar compilación, pruebas y publicación automatizadas.

Generar una versión distribuible con configuración segura y procedimiento de actualización.