DEV Community: Verónica Guamán

Invocar un flujo dentro de otro flujo en Azure Logic Apps

Verónica Guamán — Tue, 26 Mar 2024 14:48:05 +0000

En este corto artículo te mostraré cómo puedes llamar a un flujo de Logic apps dentro de un flujo en el mismo recurso.

Aquí te cuento mi pequeña hazaña, era relativamente nueva en Azure Logic Apps y necesitaba invocar a un flujo dentro de otro flujo, los dos estaban en el mismo recurso, conocía la acción de HTTP y traté de conectarme mediante el URL que general el flujo de Logic apps pero no funcionaba, leí investigué pero no encontré la solución, hasta que encontré un componente que me sonaba "Invoke a workflow in this workflow app"

¡Eureka! Fue la solución a mi problema.

A continuación, te muestro como usarlo:
Agrega una acción a tu flujo actual.

Al seleccionar "Agregar una acción" te mostrará las diferentes acciones disponibles, puedes colocar "invoke" en el buscador para encontrarlo fácilmente

Lo seleccionas, y ya podemos utilizarlo, en la sección de Workflow Name se muestra la lista de todos los flujos que tienes actualmente en tu recurso de Logic Apps, debes elegir el que necesitas.

En el caso de que se requiera algo adicional podemos seleccionar las siguientes opciones en Parametros avanzados:

Y colocar la información que requiera, ejemplo:

Y con esto, concluimos. Aunque pueda parecer básico, este artículo está diseñado para ser de ayuda a aquellos que están empezando con Logic Apps y se encuentran en situaciones similares a las que yo enfrenté en su momento

Si tienes alguna pregunta o quieres compartir tus propias experiencias, no dudes en dejarla en la sección de comentarios. ¡Me encantaría leerlos!

Saludos, y nos encontramos en el próximo artículo ;)

Explorando el Operador ?? en C#

Verónica Guamán — Mon, 25 Mar 2024 00:54:04 +0000

En el mundo de la programación, uno de los desafíos más comunes al que nos enfrentamos es la gestión o manejo de los valores nulos.
En C# como en otros lenguajes, nos encontramos con diversas formas para manejar este problema. Específicamente en C# tenemos una opción que nos permite gestionar los valores nulos de forma concisa, y este es el operador de fusión o coalición nula (??).

En este breve artículo, vamos a entender cómo podemos simplificar y mejorar nuestro código cuando tratamos con valores nulos.

¿Qué es el Operador “??”?
El operador ?? en C# se utiliza para proporcionar un valor de respaldo en caso de que una expresión sea nula. A continuación te muestro su sintaxis, que es bastante simple:

var resultado = expresion1 ?? expresion2;

Aquí, expresion1 es la expresión cuyo valor se evalúa, y expresion2 es el valor de respaldo que se utiliza si expresion1 es nula.

A continuación te muestro dos ejemplos prácticos en los que podemos utilizar este operador.

Asignar un valor por defecto si un valor es nulo:

string nombre = ObtenerNombre() ?? "Nombre Predeterminado";

int longitud = array?.Length ?? 0;

Evitar excepciones NullReferenceException.

Para eso podemos desencadenar una excepción si el resultado es nulo:

string respuesta = ObtenerUsuario() ?? throw new Exception("El usuario no existe");

Al explorar estos ejemplos vemos el poder que tiene este operador al permitirnos manejar los valores nulos que a menudo pueden ser un dolor de cabeza en nuestras aplicaciones.

Espero que estos ejemplos hayan sido de gran ayuda para comprender cómo funciona el operador de fusión nula ( ??) en C#. ¡Nos vemos en el próximo artículo o en twitter :).

Validación de nulos con el operador ?? en C#

Verónica Guamán — Tue, 29 Aug 2023 18:03:37 +0000

En nuestro día a día como programadores, nos encontramos de esas situaciones en las que tenemos que validar si una variable es nula y, si lo es, asignarle un valor por defecto.

En el mundo de la programación cada lenguaje tiene sus operadores y símbolos que hacen que esta tarea sea más fácil y eficiente.

En C# tenemos al operador ??(Coalescencia nula) uno de los varios operadores que tiene este lenguaje de programación, este operador se encuentra dentro de los operadores de comparación simplificados.

En este artículo aprenderemos que es, como utilizar este operador y como puede ayudarnos a simplificar nuestro código en los proyectos en los que trabajemos. Vamos a ello.

¿Qué es el operador de coalescencia nula (??)?
Veamos la definición técnica:
El operador de coalescencia nula (??) es un operador de C# que permite asignar un valor predeterminado a una variable si su valor actual es nulo. Proporciona una forma concisa de manejar valores nulos sin tener que escribir varias líneas de código condicional.

Y ahora la definición menos técnica:
El operador ?? valida si un valor es nulo y nos ayuda a asignarle un valor en caso de serlo, vamos a entenderlo mejor con un ejemplo.

CASO DE USO
Tenemos una aplicación donde los usuarios pueden ingresar su nombre. Si no ingresan nada (nulo) vamos a mostrar la palabra "Invitado".

Código tradicional

string nombreUsuario = ObtenerNombreUsuario();

string mensaje;

if (nombreUsuario != null)
{
    mensaje = nombreUsuario;
}
else
{
    mensaje = "Invitado";
}

Como ves esto nos lleva a una serie de comprobaciones y asignaciones.

Ahora veámoslo con el operador ??

string nombreUsuario = ObtenerNombreUsuario();
string mensaje = nombreUsuario ?? "Invitado";

¿Un cambio radical verdad? En lugar de varios bloques if-else para manejar valores nulos, ahora solo necesitamos una línea.
Si nombreUsuario no es nulo, ¡tendrás su nombre! Y si es nulo, no hay problema, "Invitado" es tu plan B.

Veamos unos ejemplos más:

Aquí tenemos una variable del precio de un producto, en lugar de que recibir un valor vacío vamos a asignarle un valor por defecto.

double precioProducto = ObtenerPrecioProducto();
double precioMostrar = precioProducto ?? 0.00;

Escapando de las Excepciones
También debes haber enfrentado el desafío de las excepciones cuando intentas acceder a un objeto nulo. Aquí nuevamente, el operador ?? viene a tu rescate:

string mensajeBienvenida = ObtenerMensajeBienvenida();
string mensajeMostrar = mensajeBienvenida ?? "¡Bienvenido a bordo!";

O Enviar una excepción personalizada.

Usuario usuario = ObtenerUsuario() ?? throw new NotFoundException("Usuario no encontrado");

Ahora ya sabes como validar valores nulos con nuestro super operador ??, ya no tienes que perder tiempo en verificaciones tediosas ni enfrentarte a excepciones inesperadas.

Nos vemos en Twitter

¡Hasta la próxima línea de código y que tus códigos siempre estén libres de nulos! 🚀

Operador Ternario en C#

Verónica Guamán — Fri, 17 Feb 2023 19:17:36 +0000

El operador ternario en C# es una herramienta útil para simplificar el código y tomar decisiones basadas en una condición booleana.

los operadores ternarios son utilizado en muchos lenguajes de programación y puede resultar confuso si no comprendes adecuadamente su sintaxis y funcionamiento.
En este artículo, vamos a explorar cómo funciona el operador ternario simple en C# y cómo puedes utilizarlo en tus proyectos.

En su forma más básica, el operador ternario(?) es una forma abreviada de escribir una sentencia if,else.
Nos permite establecer un valor o una expresión basada en una condición booleana. La sintaxis del operador ternario es la siguiente:



condición ? valorSiVerdadero : valorSiFalso

En esta sintaxis, condición es la expresión booleana que se evalúa. Si la condición es verdadera, la expresión valorSiVerdadero se evalúa y se devuelve como resultado. Si la condición es falsa, se evalúa la expresión valorSiFalso y se devuelve como resultado. En otras palabras, el operador ternario funciona como una expresión que devuelve un valor u otro dependiendo de la evaluación de la condición.

Aquí hay un ejemplo de cómo se puede utilizar el operador ternario en C#:



int edad = 23;
string comprobacionEdad = edad > 18 ? "Mayor de edad" : "Menor de edad";
Console.WriteLine($"El usuario es {comprobacionEdad}");

En este ejemplo, la variable edad se evalúa para ver si es mayor de edad. Si es así, la expresión "Mayor de edad" se devuelve como resultado y se asigna a la variable comprobacionEdad. Si edad es menor o igual a 18, la expresión "Menor de edad" se devuelve como resultado y se asigna a la variable comprobacionEdad.

Una de las ventajas de utilizar el operador ternario en lugar de una sentencia if-else es que puede ayudar a simplificar el código y hacerlo más fácil de leer. También puede ser más eficiente en términos de rendimiento, ya que evita la necesidad de ejecutar una sentencia if-else completa.

Es importante entender que el operador ternario no es adecuado para todas las situaciones. Si tienes una condición compleja o necesitas ejecutar varias instrucciones en cada rama de la sentencia if-else, es posible que sea más adecuado utilizar una sentencia if-else completa en lugar del operador ternario. Además, no abuses del operador ternario ya que el código puede volverse difícil de leer si se utilizan demasiadas expresiones complejas u operadores ternarios anidados.

En conclusión, el operador ternario es una herramienta útil que puede ayudarte a simplificar el código y tomar decisiones basadas en una condición booleana en C#. Si lo utilizas de forma adecuada, puede mejorar la legibilidad y la eficiencia de tu código. Sin embargo, es importante recordar que no es adecuado para todas las situaciones y que es importante utilizarlo con moderación.

Gracias por leerme, nos vemos en Twitter.

Cambiar el valor NBF del JWT en ASP.NET MVC API - C#

Verónica Guamán — Thu, 29 Sep 2022 03:49:39 +0000

NBF en JWT significa Not Before

Claim Name: "nbf"
Claim Description: Not Before

Obtiene o establece la hora no anterior para el token de seguridad. Este valor debe estar en UTC.
Es decir nbf: Define el tiempo antes del cual el JWT NO DEBE ser aceptado para su procesamiento.

Si por algún motivo tenemos o debemos cambiar el valor de NFB podemos hacerlo de la siguiente forma.

En la configuración para obtener nuestro token vamos a tener algo parecido a esto:

private string generateJwtToken(User user)
        {
            // generate token that is valid for 7 days
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[] { new Claim("id", user.Id.ToString()) }),
                NotBefore = DateTime.UtcNow.AddMinutes(5),
                Expires = DateTime.UtcNow.AddDays(7),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };
            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }

dentro de esta configuración la línea antes de especificar la expiración vamos a colocar la siguiente línea.
NotBefore = DateTime.UtcNow.AddMinutes(5)
Agregamos el tiempo en el que queremos que esté disponible nuestro token, en este caso de ejemplo le estoy agregando 5 minutos a la hora y fecha actual.

Y ya podemos observar los cambios generando el token y probándolo en https://jwt.io/

Eso es todo por hoy, espero que te sirvan de mucho estos recursos.

Puedes seguirme en Twitter, Instagram o Facebook para más contenido técnico, consejos y más.

Cambiar el valor NBF del JWT en ASP.NET MVC API -C#

Verónica Guamán — Thu, 29 Sep 2022 02:14:47 +0000

NBF en JWT significa Not Before

Claim Name: "nbf"
Claim Description: Not Before

Obtiene o establece la hora no anterior para el token de seguridad. Este valor debe estar en UTC.
Es decir nbf: Define el tiempo antes del cual el JWT NO DEBE ser aceptado para su procesamiento.

Si por algún motivo tenemos o debemos cambiar el valor de NFB podemos hacerlo de la siguiente forma.

En la configuración para obtener nuestro token vamos a tener algo parecido a esto:

private string generateJwtToken(User user)
        {
            // generate token that is valid for 7 days
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[] { new Claim("id", user.Id.ToString()) }),
                NotBefore = DateTime.UtcNow.AddMinutes(5),
                Expires = DateTime.UtcNow.AddDays(7),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };
            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }

Y ya podemos observar los cambios generando el token y probándolo en https://jwt.io/

Eso es todo por hoy, espero que te sirvan de mucho estos recursos.

Puedes seguirme en Twitter, Instagram o Facebook para más contenido técnico, consejos y más.

Recursos para prepararte para las certificaciones de Microsoft AZ-900 DP-900. Tips and Tricks

Verónica Guamán — Wed, 21 Sep 2022 04:56:40 +0000

El AZ-900(Azure Fundamentals) y el DP-900(Azure Data Fundamentals) son exámenes de certificación de Microsoft.

¿Pero qué son estas certificaciones?
Las certificaciones de Microsoft son una serie de exámenes que nos permiten demostrar nuestro conocimiento en una área en específico acerca de tecnologías de Microsoft.
Aprobar estas certificaciones nos permiten reafirmar nuestro conocimiento en ciertas tecnologías y "demostrar" que estamos a la vanguardia de las nuevas tecnologías.

Puedes encontrar más información aquí.

Dentro de estas, se encuentran las Certificaciones de Microsoft Azure, es decir de la nube y se dividen en:

Fundamentals
Associate
Expert

El AZ-900 y el DP-900 se encuentran en la categoría de Fundamentals, es decir que son las idóneas si estás iniciando en el mundo de la nube y cabe destacar que son certificaciones sin fecha de expiración, tomando en cuenta que las otras categorías se renuevan cada año.

Ahora si vamos al grano.
Tres de los recursos principales que me sirvieron mucho para aprobar el examen fueron

A continuación voy a detallar cada uno de ellos.

RECURSOS AZ-900
1. Lectura - Microsoft Learn
En Microsoft Learn podemos encontrar rutas de aprendizaje, desde lo más básico hasta temas avanzados y tenemos una ruta específicamente para prepararnos para cada certificación.
En el caso de AZ-900 podemos encontrar información aquí.
Aquí vamos a encontrar una sección que nos sugiere dos formas de aprendizaje.

Online - Gratis
Con un instructor - Pago

Podemos aprender todos los aspectos que embarca el examen de certificación. Para las personas que gusten de la lectura no será problema pero si no puede parecerte algo largo y aburrido, pero al final es de mucha ayuda.

Cabe recalcar que puedes cambiar el idioma a español o al idioma de tu preferencia todo el contenido de Microsoft Learn.

2. Vídeos - Youtube
También encontramos muchos otros recursos como videos en youtube para poder aprender todo este contenido de forma resumida, personalmente te recomiendo esta serie de videos.

y por último lo que más me sirvió fue.

3. Cuestionarios con Respuestas - ExamTopics

En este link podemos observar un cuestionario, es decir una serie de preguntas muy muy similares a las que vienen en el examen oficial.

Si tienes poco tiempo para prepararte para el examen de certificación te recomiendo que solamente uses este recurso, porque además de darte las respuestas a cada pregunta, te da recursos o fuentes de donde puedes encontrar la información en la que se basó la respuesta y además, algo super importante es que existe una sección de discusión, en la que varias personas que están estudiando para el examen o personas que ya lo dieron.
Aquí puedes "discutir" sobre la respuesta o a su vez notifican que la pregunta vino en el examen y la fecha.

RECURSOS PARA EL DP-900
y para el DP-900 tenemos mismos recursos.
1. Lectura - Microsoft Learn
En este enlace encontramos de igual forma una ruta de aprendizaje y mientras vamos avanzando nos seguirán apareciendo más temas avanzados acerca del tema.

2. Videos - Youtube
En youtube el mejor recurso que encontré fue este, que es una lista de 4 videos que abarcan todos los temas desde lo básico a lo más avanzado. Son temas que realmente debemos conocer y se incluyen en el examen.

3. Cuestionarios con Respuestas - ExamTopics
De igual forma como lo describí en el recurso para el AZ-900, aquí tenemos cuestionarios y en mi experiencia. Gran parte de estas preguntas o similares se incluyen en el examen, a veces solo cambia el orden de las preguntas.

CONSEJOS PARA EL DÍA DEL EXÁMEN*
Finalmente déjame darte algunos consejos adicionales.
Es importante que sepas algo de ingles ya que los supervisores van a hablarte en este idioma, pero si de plano no sabes o conoces muy poco de ingles tienes un chat y al inicio puedes escribirles que te vas a comunicar por el chat porque no entiendes muy bien al escuchar, aunque esto también es en ingles puedes previamente preparar algunas frases antes del examen.

No debes tener abierto nada más que la aplicación del examen.
No debe existir ruido o pueden suspenderte el examen.
Tu espacio debe estar vacío, es decir que no debe haber nada a tu al rededor ya que piensan que puedes tener algún tipo de ayuda escrita o de otro tipo.

Creo que eso es todo, espero que te sirvan de mucho estos recursos, aprende mucho y muchos muchos éxitos en tu examen.

Puedes seguirme en Twitter, Instagram o Facebook para más contenido técnico, consejos y más.

Nos vemos :D

API con ASP.NET MVC 6 y SQL Server mediante Entity Framework core 6 - Code First - Parte 2

Verónica Guamán — Fri, 24 Jun 2022 05:01:59 +0000

En la Primera parte vimos la configuración de Entity Framework en nuestro proyecto, para poder conectarnos con SQL Server. Si ya tienes todo listo podemos continuar, si aún no la tienes puedes volver AQUÍ.

En esta segunda parte vamos a realizar los Métodos CRUD de nuestra API, En este caso vamos a trabajar con un repositorio, interfaz, controlador y finalmente probarlo mediante Swagger. Si bien podríamos hacerlo directamente en el controlador, no es recomendable tener los métodos tan expuestos. y en proyectos reales, lo realizamos en proyectos diferentes (Data, Services, API), en este tutorial lo simularemos en un solo proyecto.

Dicho esto, vamos a ello.

1. Crear la interfaz

Para esto, en nuestra carpeta Models vamos a crear una nueva carpeta llamada Repository, dentro de esta agregamos una interfaz que se llamará IProductRepository.
Aquí vamos a agregar los métodos que tendrá nuestro CRUD.

namespace DemoAPI.Models.Repository
{
    public interface IProductRepository
    {
        Task<Product> CreateProductAsync(Product product);
        Task<bool> DeleteProductAsync(Product product);
        Product GetProductById(int id);
        IEnumerable<Product> GetProducts();
        Task<bool> UpdateProductAsync(Product product);
    }
}

2. Crear el Repositorio

En la misma carpeta, Repository agregaremos una nueva clase y la llamaremos ProductRepository.
El siguiente paso será realizar la implementación de nuestra interfaz IProductRepository. Aquí vamos a realizar nuestro CRUD. En este archivo vamos a realizar la conexión a nuestra base de datos, así no lo tenemos expuesto directamente en nuestro controlador y se verá de la siguiente manera.

using Microsoft.EntityFrameworkCore;

namespace DemoAPI.Models.Repository
{
    public class ProductRepository : IProductRepository
    {
        protected readonly DemoContext _context;
        public ProductRepository(DemoContext context) => _context = context;

        public IEnumerable<Product> GetProducts()
        {
            return _context.Products.ToList();
        }

        public Product GetProductById(int id)
        {
            return _context.Products.Find(id);
        }
        public async Task<Product> CreateProductAsync(Product product)
        {
            await _context.Set<Product>().AddAsync(product);
            await _context.SaveChangesAsync();
            return product;
        }

        public async Task<bool> UpdateProductAsync(Product product)
        {
            _context.Entry(product).State = EntityState.Modified;
            await _context.SaveChangesAsync();
            return true;
        }

        public async Task<bool> DeleteProductAsync(Product product)
        {
            //var entity = await GetByIdAsync(id);
            if (product is null)
            {
                return false;
            }
            _context.Set<Product>().Remove(product);
            await _context.SaveChangesAsync();

            return true;
        }
    }
}

3. Configurar Repository

Para poder usar nuestra interfaz tenemos que realizar la siguiente configuración en el archivo Program.cs, vamos a agregar las siguientes líneas debajo de la configuración de Entity Framework.

builder.Services.AddTransient<IProductRepository, ProductRepository>();

4. Configurar el controlador

Ya tenemos todo listo para crear nuestro controlador.
En la Carpeta Controlador agregamos un nuevo controlador y lo llamaremos ProductController.
Vamos a crear la configuración para poder acceder desde la interfaz al repositorio y poder hacer la llamada a los métodos creados en esta clase.

private IProductRepository _productRepository;

        public ProductController(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

5. Crear los métodos en nuestro controlador

Como se trata de un API, mediante los verbos Http vamos a etiquetar cada método acorde a la acción que va a realizar, HttpGet para obtener Datos, HttpPost para hacer inserts, HttpPut para Editar datos existentes, y HttpDelete para eliminar.
Para crear los métodos de nuestro CRUD, mediante la interfaz llamamos a los métodos ya creados en el repositorio y enviamos los datos recibidos y nuestro controlador quedará de la siguiente forma.

using DemoAPI.Models;
using DemoAPI.Models.Repository;
using Microsoft.AspNetCore.Mvc;

namespace DemoAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        private IProductRepository _productRepository;

        public ProductController(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        [HttpGet]
        [ActionName(nameof(GetProductsAsync))]
        public IEnumerable<Product> GetProductsAsync()
        {
            return _productRepository.GetProducts();
        }

        [HttpGet("{id}")]
        [ActionName(nameof(GetProductById))]
        public ActionResult<Product> GetProductById(int id)
        {
            var productByID = _productRepository.GetProductById(id);
            if (productByID == null)
            {
                return NotFound();
            }
            return productByID;
        }

        [HttpPost]
        [ActionName(nameof(CreateProductAsync))]
        public async Task<ActionResult<Product>> CreateProductAsync(Product product)
        {
            await _productRepository.CreateProductAsync(product);
            return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        [ActionName(nameof(UpdateProduct))]
        public async Task<ActionResult> UpdateProduct(int id, Product product)
        {
            if (id != product.Id)
            {
                return BadRequest();
            }

            await _productRepository.UpdateProductAsync(product);

            return NoContent();

        }

        [HttpDelete("{id}")]
        [ActionName(nameof(DeleteProduct))]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            var product = _productRepository.GetProductById(id);
            if (product == null)
            {
                return NotFound();
            }

            await _productRepository.DeleteProductAsync(product);

            return NoContent();
        }
    }
}

Finalmente vamos a ejecutar nuestra Aplicación y vamos a probar que todo funcione correctamente.
Por defecto al crearse el proyecto, nuestra API viene integrada con Swagger, que es una OPEN API para documentación y viene integrada con una interfaz que nos permite probar nuestros métodos. (Si deseas saber más de Swagger te dejo el siguiente artículo)

Primero vamos a probar nuestro método Post, ingresando un producto, en este caso simularemos el ingreso de un teclado.

Al darle a Execute tiene que darnos una respuesta, en este caso el código 200 para indicarnos que todo está correcto.

Finalmente vamos a probar nuestro Get y verificar que nuestro insertar funciono correctamente.

Y así hemos completado nuestra API.

Muchas gracias por leerme y Nos vemos en Twitter e Instagram ;)

API con ASP.NET MVC 6 y SQL Server mediante Entity Framework core 6 - Code First - Parte 1

Verónica Guamán — Fri, 24 Jun 2022 04:55:07 +0000

ASP.NET 6 se ha actualizado junto a .NET 6, y una de las actualizaciones más notables ha sido la eliminación del archivo Startup.cs, el cual se ha unificado con el archivo Program.cs

Esto suele crear una confusión de como llevábamos nuestras conexiones con los servicios, por ejemplo la conexión a la Base de datos con Entity Framework entre otras configuraciones que veremos en el tutorial de hoy

En ese sentido, en este tutorial vamos a crear un API con métodos fundamentales, un CRUD y veremos como podemos conectar nuestro proyecto con SQL Server mediante Entity Framework.

En este Artículo en especifico, vamos a ver la parte 1, la cual consiste en realizar toda la configuración de Entity Framework hasta la migración de nuestra entidad hacia la base de datos.
Y vamos a ver como sin tocar SQL ni nuestro gestor SQL Server vamos a crear la base de datos y la tabla Product con sus respectivos campos.

Para la realización de las funciones (CRUD) te dejo la Parte 2

Para este tutorial vamos a necesitar

Visual Studio 2022(ya incluye SDK .NET 6) o SDK .NET 6 y Editor de código de su preferencia
SQL server Management Studio

Teniendo todo esto listo, vamos a empezar.

1. Crear un proyecto API - ASP.NET MVC 6

EL primer paso es crear un proyecto ASP.NET Core Web API

Al crear el proyecto debemos elegir la versión de nuestro proyecto, en este caso .NET 6 y dejamos las opciones que vienen marcadas por defecto

A primera vista podemos observar la estructura de la plantilla con estructura MVC y algo nuevo, desapareció el archivo STARTUP.CS

Aunque el archivo no viene por defecto en la plantilla, nosotros podemos añadirlo manualmente.

2. Agregar la clase "Product"

Para este proyecto vamos a crear un CRUD para productos, entonces, vamos a crearnos una carpeta llamada Models y dentro de esta agregamos una nueva carpeta y la nombraremos Data, añadimos una clase con los atributos de la entidad Product. en este caso solamente va a tener un Id, un nombre y una descripción



namespace DemoAPI.Models
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
    }
}

Hecho esto vamos con el siguiente paso.

3. Instalar paquetes de Entity Framework

Para poder conectarnos con SQL Server vamos a utilizar Entity Framework, entonces para esto necesitamos agregar 3 paquetes a nuestro proyecto.

Entity Framework Core
EF para SQL Server y
Entity Framework Tools

Para esto nos vamos al Administrador de paquetes Nuget, buscamos los paquetes mencionados anteriormente y le damos en instalar

4. Agregar y configurar el DbContext

El siguiente paso será configurar la conexión a la base de datos, para esto en la misma carpeta Models/Data, agregamos una clase que se llamará DemoContext.cs y dentro de esta vamos a agregar la siguiente configuración.



using Microsoft.EntityFrameworkCore;

namespace DemoAPI.Models
{
    public class DemoContext : DbContext
    {
        public DemoContext(DbContextOptions<DemoContext> options) : base(options)
        {
        }
        public DbSet<Product> Products { get; set; }
    }
}

Aqui agregamos a nuestra entidad, Product que es la que vamos a agregar a la base de datos.
La estructura de nuestro proyecto hasta el momento se ve así

5. Agregar nuestra cadena de conexión a la Base de Datos

Desde .NET core las cadenas de conexión o configuraciones que solían ir en el webconfig podemos colocarlos en le archivo appsettings.json, entonces vamos a agregar la cadena de conexión a este archivo y quedará algo así



{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "ConnectionStrings": {
    "DefaultConnection": "server = localhost; database = DemoApi; Trusted_Connection = true"
  },
  "AllowedHosts": "*"
}

Agregamos la cadena de conexión, aquí va el nombre del servidor en el que se encuentra tu base de datos, en este caso el mío es local host, segundo va el nombre de tu base de datos y por ultimo agregamos esta configuración de seguridad, si el nombre de tu servidor es diferente y/o tiene usuario o contraseña debemos agregarla a la cadena de conexión como "user = tuUsuario" y "password = tucontraseña".

Esta configuración nos va a servir en el siguiente punto

6. Configurar mi Program.cs para obtener la cadena de conexión

En este punto vamos a configurar el archivo Program.cs, anteriormente esta configuración la realizábamos en el startup.cs pero no difiere en mucho, debemos agregar las siguientes líneas.



builder.Services.AddDbContext<DemoContext>(
    options =>
    {
        options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
    });

Aquí hacemos uso del paquete EF para SQL Server, y obtenemos la cadena de conexión del appsettings.json para poder conectarnos a nuestro servidor y poder crear y posteriormente interactuar con la base de datos

7. Realizar la migración del ASP.NET MVC a Base de Datos

Hechos todos los pasos anteriores, vamos a la consola de paquetes en visual studio o a la terminal y vamos a ejecutar el siguiente comando Add-Migration InitialMigration en donde InitialMigrations puede ser modificada a tu gusto, es como se llamará está migración en especifico, en este caso yo la llamé así, y acorde vayas migrando puedes especificar que cambios agregas etc.
Si todo está configurado correctamente, se debío crear una carpeta con el nombre especificado en este caso InitalMigration y dentro de esta un archivo con todos los cambios que se van a ir a la base de datos. se verá algo así



using Microsoft.EntityFrameworkCore.Migrations;

#nullable disable

namespace DemoAPI.Migrations
{
    public partial class InitialMigration : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "Products",
                columns: table => new
                {
                    Id = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Name = table.Column<string>(type: "nvarchar(max)", nullable: false),
                    Description = table.Column<string>(type: "nvarchar(max)", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Products", x => x.Id);
                });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "Products");
        }
    }
}

Aquí podemos observar este código generado que contiene toda la información de la migración, en este caso nos dice que vamos a crear una tabla llamada Product con los campos especificados y le asigna por defecto al Id como clave primaria.
El siguiente comando es Update-Database con este comando vamos a enviar todos estos cambios a la base de datos, si todo está correcto podemos ir a nuestro SQL Server Management Studio a verificar que se creo nuestra base de datos DemoApi y la tabla Product

Podremos visualizar esto:

Ahoya ya tenemos todo listo para empezar con nuestro CRUD, te dejo el enlace a la PARTE 2

Muchas gracias por leerme y Nos vemos en Twitter e Instagram ;)

Sesión - APIs con .NET 5 y Documentación con Swagger

Verónica Guamán — Sat, 17 Jul 2021 14:42:23 +0000

Hola a todos :D
En esta ocasión abordamos el tema de como podemos documentar nuestras APIs hechas en ASP.NET 5 con Swagger.

Partiendo desde las bases podemos tratar los temas a breves rasgos para dar un contexto a la parte netamente técnica que se trato en la sesión.

Iniciamos definiendo que es una API(Application Programming Interfaces) en palabras breves, como su nombre lo indica es una Interfaz que permite la comunicación entre aplicaciones.
Las APIs permiten que nuestros productos y servicios se comuniquen con otros, sin necesidad de saber cómo están implementados.

Podemos construir APIs, para el consumo de nuestras aplicaciones privadas(móviles, web), internas de la empresa o podemos consumir APIs públicas(APIs externas).

Por otra parte, si desarrollamos nuestras APIs, un paso super importante y una buena práctica es realizar su documentación, ya que estas APIs van a ser consumidas por terceras personas, ya sea porque es una API pública, o va a ser consumida por el equipo de Frontend.

El documentar ayudará a que las personas que van a consumirla puedan entender que van a consumir, que parámetros deben ingresar, cual va a ser la respuesta que van a obtener
O como paso fundamental para nosotros como desarrolladores la documentación nos ayuda a recordar que hicimos, como lo hicimos y a futuro poder realizar mejoras y nuevas versiones.

En este punto entra el termino de Swagger, que es una herramienta basada en el estándar OpenAPI que nos permite documentar y probar nuestros Web APIs de forma accesibles y entendibles por los usuarios o desarrolladores que pretendan utilizarlos.

Con esta premisa, y entrando ya al tema, en .NET con ASP.NET podemos crear APIs fácilmente, ya que nos proporciona una plantilla basada en MVC(aunque no tenga vistas) para poder crearla rápidamente e ir construyendolas.

También nos proporciona herramientas para realizar la documentación utilizando Swagger, para esto existen paquetes Nugget, Swashbuckle y NSwag (en esta ocasión utilizaremos Swashbuckle).

Podemos agregarla mediante consola o por el administrador de paquetes Nugget y realizar algunas configuraciones en el Startup de nuestro proyecto para poder visualizarlo e iniciar con la documentación(como lo menciono en el video).

Y un punto super importante que podemos mencionar es que a partir de la versión ASP.NET 5 Swagger viene incorporada en la plantilla de nuestras APIs, así que no necesitaremos hacer nada, prácticamente tenemos todo configurado para iniciar a documentar.

En la sesión tratamos estos temas teóricos a detalle, por eso solo menciono lo más reelevante en este post.

Dicho todo esto, adjunto todos los recursos que utilizamos en la sesión:

Te dejo el video de la sesión aqui, en el que revisamos un poco de teoría como introducción, posteriormente realizamos la DEMO con un ejemplo de como podemos documentar nuestra API.

También te adjunto el repositorio en Github aquí, con el código fuente utilizado en la sesión y podrás encontrar también las diapositivas.

Nos vemos en Twitter e Instagram ;)

10 Atajos y Fragmentos de código que nos ahorraran tiempo al programar en Visual Studio

Verónica Guamán — Sat, 12 Jun 2021 20:35:24 +0000

Visual Studio(VS) es un Potente IDE que nos brinda muchas herramientas que facilitan todo el proceso de desarrollo de software.

En esta ocasión veremos fragmentos de código y atajos que nos ahorrará tiempo al codificar en VS, los que uso en mi día a día y creo que te será de gran ayuda

En primer lugar vamos a ver fragmentos de código, estos son pequeños "atajos", basta teclear palabras claves y darles doble tab para que se inserte el código requerido.

1. Crear una clase

                   class + doble tab

Al realizar esta acción se crea una declaración de clase, esta debe ser usada en un namespace. Y se va a visualizar así:

class MyClass
{
}

Ahora tienes que reemplazar el **"MyClass" por el nombre de tu clase y ya puedes utilizarlo

2. Crear un constructor

                   ctor + doble tab

Crea un constructor para la clase contenedora, debemos estar dentro de una clase para poder hacer uso de este, ya que toma el nombre de esta clase y crea su constructor.
Se verá así

class MyClass
{
   public MyClass()
   {
   }
}

3. Crear un atributo

                   prop + doble tab

Crea una declaración de propiedad autoimplementada, es decir que crea una propiedad con los métodos get y set dentro de una clase.

public int MyProperty { get; set; }

solo deberíamos cambiar el tipo de dato y el nombre de la propiedad.

4.Crear un bloque Try - Catch

                   try + doble tab

crea un bloque try - catch dentro de un método

 try
 {
 }
 catch (Exception)
 {
   throw;
 }

ahora solo nos queda insertar el código dentro.

5. Console WriteLine

                cw + doble tab

Console.WriteLine();

como vemos nos ayuda a crear un Console.Writeline rapidamente, ya solo nos queda ingresar lo que queremos mostrar.

Ahora vamos a revisar algunos atajos que podemos realizar desde nuestro teclado.

6. Duplicar la línea

                Ctrl + D

Duplica la línea en donde esta el cursos o las líneas seleccionadas

En los siguientes atajos, mantén presionado el ctrl y posteriormente digita las letras en orden.

7. Formatear el código

                Ctrl + K, Ctrl + F

Formatea el código seleccionado, o el archivo actual.

8. Comentar un fragmento de código

                Ctrl + K, Ctrl + C

Comenta las líneas seleccionadas

9. Descomentar un fragmento de código

                Ctrl + K, Ctrl + U

Descomenta las líneas seleccionadas

10. Mostrar sugerencias

                Ctrl + Barra espaciadora

Completa palabras, muestra sugerencias de código, un ejemplo simple lo podemos observar al usarlo después de "clase." nos muestra su atributos, métodos etc.

Nos vemos en Twitter e Instagram ;)

Sesión - Construyendo una Aplicación Web con ASP.NET 5 y SQL Server

Verónica Guamán — Tue, 18 May 2021 23:12:58 +0000

En esta sesión abarcamos temas básicos, desde la explicación de que es .NET hasta realizar una aplicación web, en sí un CRUD(Create, Read, Update, Delete) de un Producto.

Puedes volver a ver la sesión aquí:

En mi página de Facebook:
o en mi canal de Youtube:

El repositorio del proyecto realizado lo encuentras aquí
y lo más pedido, las presentaciones también la encuentras en el repositorio de GitHub.

Pueden descargar el proyecto y usarlo, pero deben colocar su cadena de conexión en el appsettings.json. y funcionará perfectamente.

Se resolvió la conexión a la DB en el hosting con Soome, actualice el artículo con el paso adicional que me faltaba y ya funciona correctamente.
debí correr la migración, en el artículo anterior no lo necesitaba ya que se ejecutaba un DBSeed y por eso se creaba automaticamente.

Pero ya quedo resuelto :D

Nos vemos en Twitter e Instagram ;)