<p>El patr&oacute;n Factory Method es uno de los patrones de dise&ntilde;o m&aacute;s conocidos en el mundo de desarrollo de software 🏭. Sin embargo, la mayor&iacute;a de los ejemplos disponibles se limitan a aplicaciones de consola b&aacute;sicas 🤢, lo que puede resultar desalentador para aquellos que buscan implementarlo en aplicaciones m&aacute;s complejas.&nbsp;</p>
<p>En este art&iacute;culo, exploraremos una implementaci&oacute;n avanzada del patr&oacute;n Factory Method en el contexto de Asp NET Core, mostrando c&oacute;mo puede ser aplicado de manera efectiva en situaciones m&aacute;s desafiantes.🤯</p>
<h2>Inspiraci&oacute;n</h2>
<p>La inspiraci&oacute;n para este art&iacute;culo proviene de un recurso que descubr&iacute; hace aproximadamente dos a&ntilde;os, titulado "<a href="https://medium.com/swlh/factory-pattern-without-switch-this-is-how-it-should-be-done-cd895e356f44" target="_blank" rel="noopener">Factory Pattern Without Switch and If-Else</a>". Desafortunadamente, no tengo acceso para volver a leerlo ni compartirlo con otros desarrolladores 😥. Por lo tanto, he decidido escribir mi propia versi&oacute;n de este contenido, con la esperanza de proporcionar una referencia &uacute;til y accesible para aquellos interesados en este tema.✨</p>
<h2>&iquest;En qu&eacute; consiste el patr&oacute;n Factory Method?</h2>
<p>Si deseas un resumen r&aacute;pido sobre este patr&oacute;n, sus problemas resueltos y cu&aacute;ndo utilizarlo, te recomiendo consultar la explicaci&oacute;n detallada y los ejemplos en <a href="https://refactoring.guru/es/design-patterns/factory-method" target="_new">Refactoring Guru</a>. En este art&iacute;culo, utilizaremos el ejemplo de una empresa de log&iacute;stica inspirado en el sitio web mencionado.</p>
<h2>Implementando Factory Method con C#</h2>
<p>Para nuestra aventura, nos sumergiremos en el mundo de una empresa de log&iacute;stica que realiza env&iacute;os por tierra y mar. Cuando la empresa necesita enviar un producto, requiere un tipo espec&iacute;fico de transporte: ya sea un cami&oacute;n para rutas terrestres o un barco para rutas mar&iacute;timas. Nuestra implementaci&oacute;n del Factory Method se centrar&aacute; en la creaci&oacute;n de estos transportes a medida. 🚚⛴️</p>
<p><img src="https://refactoring.guru/images/patterns/diagrams/factory-method/solution1.png?id=fc756d2af296b5b4d482e548214d08ef" alt="La estructura de las clases creadoras" width="547" height="238"></p>
<p><img src="https://refactoring.guru/images/patterns/diagrams/factory-method/solution2-es.png?id=a8ba5847ee9e34e57c6090afce86673a" alt="La estructura de la jerarqu&iacute;a de productos"></p>
<p>Comenzaremos creando una interfaz llamada <code>ITransport</code> que define el comportamiento de los transportes.</p>
<pre class="language-csharp"><code>public interface ITransport
{
    void Deliver();
}</code></pre>
<p>Luego, agregaremos dos clases concretas: <code>Truck</code> y <code>Ship</code>, ambas implementando la interfaz <code>ITransport</code>.</p>
<pre class="language-csharp"><code>public class Truck : ITransport
{
    public void Deliver()
    {
         // Realizar acciones de entrega por carretera
    }
}

public class Ship : ITransport
{
    public void Deliver()
    {
         // Realizar acciones de entrega mar&iacute;tima
    }
}</code></pre>
<p>Ahora, crearemos la clase m&aacute;s importante, <code>TransportFactory</code>, que se encargar&aacute; de instanciar estas clases cuando sea necesario.</p>
<p>Primero, definiremos un enumerado para identificar los tipos de transporte.</p>
<pre class="language-csharp"><code>public enum TransportType
{
     Road,
     Sea
}</code></pre>
<p>A continuaci&oacute;n, crearemos la interfaz <code>ITransportFactory</code> y la clase <code>TransportFactory</code> junto con su diccionario para registrar los tipos de transporte y las f&aacute;bricas correspondientes.</p>
<pre class="language-csharp"><code>public interface ITransportFactory
{
     void RegisterTransport(TransportType transportType, Func&lt;ITransport&gt; factoryMethod);

     ITransport CreateTransport(TransportType transportType);
}</code></pre>
<pre class="language-csharp"><code>public class TransportFactory : ITransportFactory
{
     private readonly Dictionary&lt;TransportType, Func&lt;ITransport&gt;&gt; transports;

     public TransportFactory()
     {
         transports = new();
     }

     public ITransport CreateTransport(TransportType transportType)
     {
         Func&lt;ITransport&gt; funcion = transports[transportType];

         ITransport transport = funcion();

         return transport;
     }


     public void RegisterTransport(TransportType transportType, Func&lt;ITransport&gt; factoryMethod)
     {
         transports.Add(transportType, factoryMethod);
     }
}</code></pre>
<h2>Funcionamiento de la Implementaci&oacute;n de la Clase TransportFactory</h2>
<p>La clave del funcionamiento de esta implementaci&oacute;n es la utilizaci&oacute;n de un diccionario (<code>Dictionary</code>) llamado <code>transports</code> para almacenar las f&aacute;bricas de transporte registradas.</p>
<p>El diccionario asocia tipos de transporte (<code>TransportType</code>) con funciones (<code>Func&lt;ITransport&gt;</code>) que se encargan de crear las instancias correspondientes de objetos <code>ITransport</code>.</p>
<h2>Usar TransportFactory en Asp NET Core</h2>
<p>Sin modificar los archivos anteriores, vamos a implementar la integraci&oacute;n de este patr&oacute;n en Asp NET Core. Lo haremos utilizando la clase <code>TransportFactoryBuilder</code> y sus extensiones. Esta implementaci&oacute;n est&aacute; inspirada en <a href="https://github.com/dotnet/aspnetcore/tree/main/src/Mvc/Mvc.Core/src/DependencyInjection" target="_new">IMVCBuilder</a>. 🤩</p>
<p>Primero, crearemos la clase <code>TransportFactoryBuilder</code> y su interfaz asociada.</p>
<pre class="language-csharp"><code>public interface ITransportFactoryBuilder
{
     IServiceCollection Services { get; }
}

public class TransportFactoryBuilder : ITransportFactoryBuilder
{
     public TransportFactoryBuilder(IServiceCollection services)
     {
         Services = services;
     }

     public IServiceCollection Services { get; }
}</code></pre>
<p>Luego, agregaremos la clase <code>TransportFactoryBuilderExtensions</code>, que contiene dos m&eacute;todos de extensi&oacute;n para construir el Factory y registrar transportes.</p>
<p><em><strong>Comentario aparte:</strong> Me cost&oacute; construir este c&oacute;digo para que funcione correctamente, pero vali&oacute; totalmente la pena 😊</em></p>
<pre class="language-csharp"><code>public static class TransportFactoryBuilderExtensions
{
     public static ITransportFactoryBuilder AddTransportFactory(this IServiceCollection services)
     {

         TransportFactoryBuilder builder = new(services);

         services.AddSingleton&lt;ITransportFactory, TransportFactory&gt;();

         return builder;
     }

     public static ITransportFactoryBuilder AddTransport&lt;T&gt;(this ITransportFactoryBuilder builder, TransportType transport) where T : class, ITransport
     {
         builder.Services.AddScoped&lt;T&gt;();

         var provider = builder.Services.BuildServiceProvider();

         var factory = provider.GetRequiredService&lt;ITransportFactory&gt;();

         factory.RegisterTransport(transport, () =&gt; provider.GetRequiredService&lt;T&gt;());


         builder.Services.Replace(ServiceDescriptor.Singleton(factory));

         return builder;
     }
}</code></pre>
<h2><strong>Uso de TransportFactory en una WebApi de Asp NET Core</strong></h2>
<p>&iexcl;Ahora s&iacute;! Ya tenemos todas las clases, todas las interfaces y un enum. Todo lo necesario para que el equipo de desarrollo pueda utilizar esta implementaci&oacute;n del patr&oacute;n Factory Method.</p>
<p>No pueden negar que se ve muy prolijo el c&oacute;digo as&iacute; y respeta el principio de Open/Closed de SOLID 😍</p>
<pre class="language-csharp"><code>var builder = WebApplication.CreateBuilder(args);

builder.Services.AddTransportFactory()
         .AddTransport&lt;Truck&gt;(TransportType.Road)
         .AddTransport&lt;Ship&gt;(TransportType.Sea);</code></pre>
<p>Para utilizar la clase <code>TransportFactory</code> en nuestra l&oacute;gica de negocio, simplemente inyectamos la interfaz <code>ITransportFactory</code> donde sea necesario.</p>
<p>A continuaci&oacute;n, se muestra un ejemplo de un controlador en Asp NET Core que utiliza esta implementaci&oacute;n.</p>
<pre class="language-csharp"><code>[ApiController]
[Route("[controller]")]
public class TransportsController : ControllerBase
{
     private readonly ITransportFactory _factory;

     public TransportsController(ITransportFactory factory)
     {
         _factory = factory;
     }

     [HttpGet]
     public IActionResult Get(TransportType trasportType)
     {
         ITransport transport = _factory.CreateTransport(trasportType);

         return Ok(transport);
     }
}</code></pre>
<p>&nbsp;</p>
<h2>Conclusi&oacute;n</h2>
<p>En este art&iacute;culo, vimos c&oacute;mo implementar el patr&oacute;n Factory Method de manera avanzada en Asp NET Core 😉. Esta implementaci&oacute;n te permite construir una f&aacute;brica de objetos de manera flexible y escalable.</p>
<p>Si te interesa explorar m&aacute;s a fondo esta implementaci&oacute;n, puedes encontrar el&nbsp;<a href="https://github.com/lauchacarro/LogisticTransports-FactoryMethod-DI" target="_new">repositorio de GitHub</a> con el proyecto completo.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>
<p>Recuerda que la implementaci&oacute;n avanzada del Factory Method en Asp NET Core puede ser una herramienta valiosa para la construcci&oacute;n de aplicaciones escalables y mantenibles de aca a 10 a&ntilde;os.💪</p>

Descubre cómo el Factory Method en Asp NET Core impulsa aplicaciones escalables y fáciles de mantener. Optimiza tu desarrollo ahora.

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-6-min.jpg

Como implementar Factory Method en Asp NET Core

<p class="MsoNormal">Azure Open AI es un servicio que ofrece Microsoft Azure para acceder a <strong>los potentes modelos de lenguaje de OpenAI</strong>, como GPT-4, GPT-3, Codex y Embeddings. Estos modelos pueden aplicarse a una variedad de casos de uso, como la generaci&oacute;n de contenido, el resumen, la b&uacute;squeda sem&aacute;ntica y la traducci&oacute;n de lenguaje natural a c&oacute;digo. Los usuarios pueden acceder al servicio a trav&eacute;s de API REST, SDK de Python o la interfaz web en el <strong>Azure OpenAI Studio</strong>.</p>
<p class="MsoNormal">Azure OpenAI es una colaboraci&oacute;n entre Microsoft y OpenAI para <strong>desarrollar conjuntamente las API</strong> que permiten acceder a los modelos de lenguaje generativos m&aacute;s avanzados del mundo. Estos modelos han sido preentrenados con billones de palabras y tienen una comprensi&oacute;n profunda del lenguaje y el c&oacute;digo. Con Azure OpenAI, los clientes pueden aprovechar estas capacidades para crear aplicaciones innovadoras y de vanguardia.</p>
<h2>&iquest;Qu&eacute; diferencia a Azure OpenAI de los servicios tradicionales de OpenAI?</h2>
<p>Los servicios tradicionales de OpenAI ofrecen una serie de servicios de IA, como GPT-3, un modelo de lenguaje natural capaz de generar textos coherentes y creativos a partir de palabras clave o frases.</p>
<p>Sin embargo, estos servicios tienen algunas limitaciones, como el costo, la disponibilidad y la escalabilidad. Por ejemplo, para acceder a GPT-3 se necesita una invitaci&oacute;n y un pago por uso, y el modelo tiene un l&iacute;mite de 45.000 tokens por solicitud.</p>
<p><strong>Azure Open AI ofrece una soluci&oacute;n a estas limitaciones</strong>, al permitir a los desarrolladores acceder a los servicios de OpenAI a trav&eacute;s de la nube de Microsoft, con mayor flexibilidad, seguridad y eficiencia. Adem&aacute;s, Azure OpenAI ofrece la posibilidad de entrenar y personalizar los modelos de OpenAI con los propios datos y objetivos de cada usuario, lo que aumenta la calidad y la relevancia de las aplicaciones de IA.</p>
<h2>&iquest;Qu&eacute; ventajas tiene Azure OpenAI?</h2>
<p>Azure Open AI tiene varias ventajas para los usuarios que quieren crear y ejecutar aplicaciones de IA de alto nivel, como:</p>
<ul>
<li><strong>Acceso ilimitado y exclusivo</strong> a los servicios de OpenAI, como GPT-3 y Codex, un modelo de generaci&oacute;n de c&oacute;digo a partir de lenguaje natural.</li>
<li><strong>Capacidad para entrenar y personalizar</strong> los modelos de OpenAI con los propios datos y objetivos, usando las herramientas y el soporte t&eacute;cnico de Microsoft.</li>
<li><strong>Escalabilidad y rendimiento &oacute;ptimos</strong>, al aprovechar la infraestructura y los recursos de computaci&oacute;n en la nube de Microsoft, como Azure Machine Learning y Azure Cognitive Services.</li>
<li><strong>Seguridad y privacidad garantizadas</strong>, al cumplir con los est&aacute;ndares y regulaciones m&aacute;s exigentes del sector.<br>Integraci&oacute;n f&aacute;cil y r&aacute;pida con otras plataformas y servicios de Microsoft, como GitHub, Visual Studio Code, Power BI y Microsoft 365.</li>
</ul>
<h2>&iquest;Como crear un recurso de Azure OpenAI?</h2>
<p>Buscar en el portal de Azure el servicio de Azure OpenAI</p>
<h2><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/217c1e2c-446f-4ad8-8efb-66dff98ed7b3.png"></h2>
<p>&nbsp;</p>
<p>Accedemos al listado de los recursos y le damos a <strong>Crear.</strong></p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/66fd25e4-bb26-4f71-b50b-d46ea4456be5.png"></p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>Para crear el recurso, primero vamos a tener que indicarle un nombre al recurso y seleccionar el &uacute;nico&nbsp;plan de tarifa disponible hoy en d&iacute;a,&nbsp;<strong>Standard S0.</strong></p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/b638a739-0314-4a71-bb49-a88de72c96c3.png"></p>
<p>Ahora tenemos que seleccionar mediante que redes se podr&aacute; acceder a este recurso. Para iniciar, recomiendo seleccionar <strong>Todas las redes</strong>.</p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/9005d3c5-2a7e-4054-9307-513a802065be.png"></p>
<p>Ya una vez, todo el formulario completo, pasamos directamente a la revisi&oacute;n para que el portal de Azure valide que todo est&aacute; en orden. Una vez que nos aparezca el mensaje de <strong>Validaci&oacute;n Superada</strong>, le damos a <strong>Crear.</strong></p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/52554483-b03c-4fb4-a974-919705db6f03.png"></p>
<p>Nos toca esperar a que la implementaci&oacute;n del recurso finalice.</p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/828265ec-1356-4d72-9421-764512ab62c9.png"></p>
<p>Una vez completa, vamos a poder acceder al recurso.</p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/7f626e57-7c1a-4619-b52f-274c6280d883.png"></p>
<p>&nbsp;</p>
<p>Ya podemos acceder al recurso, aunque no hay mucho que hacer ac&aacute;, desde esta pantalla es donde uno puede obtener las claves y punto de conexi&oacute;n. Informaci&oacute;n muy &uacute;til cuando queremos usar el recurso desde nuestro c&oacute;digo.</p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/dacc1c76-ba40-4872-aeed-df8dd5a6967d.png"></p>
<p>Para comenzar a trabajar con los modelos de AI como GPT. Es necesario ingresar al Azure OpenAI Studio. En esta aplicaci&oacute;n web es donde vamos a poder crear implementaciones y adem&aacute;s tenemos un Playground (&Aacute;rea&nbsp;de juegos) para poder probar estos modelos.</p>
<p><img src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/e6b9d911-7bd6-404e-a50b-fc4e6fabb844.png"></p>
<h2>Conclusi&oacute;n</h2>
<p>Azure OpenAI es una plataforma de inteligencia artificial que ofrece una oportunidad &uacute;nica para crear y ejecutar aplicaciones de IA innovadoras y potentes. Al combinar lo mejor de OpenAI y Microsoft, Azure Open AI ofrece acceso ilimitado y exclusivo a los servicios de OpenAI, capacidad para entrenar y personalizar los modelos con los propios datos y objetivos, escalabilidad y rendimiento &oacute;ptimos, seguridad y privacidad garantizadas e integraci&oacute;n f&aacute;cil y r&aacute;pida con otras plataformas y servicios. Si quieres saber m&aacute;s sobre Azure Open AI o solicitar una invitaci&oacute;n para probarlo, visita <a href="https://azure.microsoft.com/es-es/services/openai/">https://azure.microsoft.com/es-es/services/openai/</a>.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-5-2.jpg

¿Qué es Azure OpenAI?

<p>Una pr&aacute;ctica com&uacute;n en la programaci&oacute;n es utilizar un bucle "foreach" para iterar sobre una colecci&oacute;n de elementos. Sin embargo, cuando se trata de trabajar con Entity Framework, es importante tener en cuenta que no es recomendable colocar c&oacute;digo de Entity Framework directamente dentro de un bucle "foreach". ❌</p>
<p>En este art&iacute;culo veremos el porqu&eacute; ten&eacute;s que dejar de usar Entity Framework dentro de bucles y te voy a mostrar ejemplos de situaciones reales y mejorar tu c&oacute;digo. 🙌</p>
<h2>El problema de usar EFCore en bucles</h2>
<p>La raz&oacute;n principal radica en el rendimiento y la eficiencia de nuestras consultas a la base de datos. Cada vez que se ejecuta una consulta de Entity Framework, se establece una conexi&oacute;n con la base de datos y se realiza una solicitud para recuperar los datos. Si colocamos ese c&oacute;digo dentro de un bucle "foreach", se generar&aacute; una nueva consulta para cada iteraci&oacute;n del bucle. Esto puede tener un impacto significativo en el rendimiento, especialmente cuando se trabaja con grandes conjuntos de datos.</p>
<p>En lugar de eso, se recomienda realizar una consulta &uacute;nica para recuperar todos los datos necesarios antes de entrar al bucle "foreach". De esta manera, minimizamos el n&uacute;mero de consultas a la base de datos y aprovechamos la capacidad de Entity Framework para recuperar datos de manera eficiente. Adem&aacute;s, podemos almacenar los datos en una estructura de datos local, como una lista o un diccionario, y luego iterar sobre ellos con el bucle "foreach". Esto reduce la carga en la base de datos y mejora el rendimiento general de nuestra aplicaci&oacute;n.</p>
<h2>Situaciones Reales</h2>
<p>A continuaci&oacute;n voy a mostrar distintas situaciones que pueden evitar y les muestro como hacerlo. 👌</p>
<p>Utilizar&eacute; los m&eacute;todos Async para hacer referencia a m&eacute;todos de EFCore y aquellos m&eacute;todos Sync para hacer referencia a los m&eacute;todos comunes de Linq.</p>
<h3>Usar AddRange en vez de Add</h3>
<h4>Antes ❌</h4>
<p>El c&oacute;digo recorre una lista de objetos <code>personDto</code> y para cada elemento, se convierte a un objeto <code>person</code> utilizando el m&eacute;todo <code>ConvertToEntity()</code>. Luego, se agrega cada objeto <code>person</code> al contexto de la base de datos utilizando <code>context.People.Add(person)</code>. Finalmente, se guardan los cambios en la base de datos utilizando <code>context.SaveChanges()</code>.</p>
<pre class="language-csharp"><code>foreach (var personDto in peopleDto)
{
      var person = personDto.ConvertToEntity();
      await context.People.AddAsync(person);
}

await context.SaveChangesAsync();</code></pre>
<h4>Ahora ✔</h4>
<p>Creamos una lista auxiliar de personas (<code>people</code>) y recorremos la otra lista de objetos <code>personDto</code>. En cada iteraci&oacute;n, se convierte cada <code>personDto</code> a un objeto <code>person</code>, que luego se agrega a la lista <code>people</code>. Luego, se agrega toda la lista <code>people</code> a la base de datos utilizando Entity Framework Core.</p>
<pre class="language-csharp"><code>List&lt;Person&gt; people = new();

foreach (var personDto in peopleDto)
{
      var person = personDto.ConvertToEntity();
      people.Add(person);
}

await context.AddRangeAsync(people);
await context.SaveChangesAsync();</code></pre>
<p>Este primer caso es muy b&aacute;sico y haciendo este cambio no ganamos casi nada de rendimiento. Pero lo que s&iacute; ganamos es un mont&oacute;n de calidad. Ahora nuestro&nbsp; <code>foreach</code> no est&aacute; acoplado a c&oacute;digo de EFCore ganando as&iacute; mucha m&aacute;s escalabilidad y mantenibilidad.</p>
<h3>FirstOrDefault dentro de bucles</h3>
<h4>Antes ❌</h4>
<p>Este c&oacute;digo busca productos en la base de datos utilizando una lista de IDs proporcionada. Para cada ID, se realiza una b&uacute;squeda asincr&oacute;nica utilizando Entity Framework.</p>
<pre class="language-csharp"><code>int[] ids = { 1, 2, 3, 4, 5 }; // Array de IDs

foreach (int id in ids)
{
     Product product = await context.Products.FirstOrDefaultAsync(p =&gt; p.Id == id);

     if (producto != null)
     {
            Console.WriteLine($"Producto encontrado - ID: {producto.Id}, Nombre: {producto.Nombre}");
     }
}</code></pre>
<h4>Ahora ✔</h4>
<p>Este c&oacute;digo busca productos en la base de datos utilizando una lista de IDs proporcionada. Primero, se realiza una consulta asincr&oacute;nica para obtener, con una &uacute;nica&nbsp;consulta, los productos con los IDs deseados. Luego, se recorre la lista de IDs y se busca cada producto correspondiente en la lista obtenida previamente.</p>
<pre class="language-csharp"><code>int[] ids = { 1, 2, 3, 4, 5 }; // Array de IDs

List&lt;Product&gt; products = await context.Products.Where(p =&gt; ids.Contains(p.Id)).ToListAsync();

foreach (int id in ids)
{
     Product product = products.FirstOrDefault(p =&gt; p.Id == id);

     if (producto != null)
     {
            Console.WriteLine($"Producto encontrado - ID: {producto.Id}, Nombre: {producto.Nombre}");
     }
}</code></pre>
<p>A continuaci&oacute;n, les muestro el SQL que genera EFCore con esta nueva estrategia.</p>
<pre class="language-csharp"><code>SELECT *
FROM Products
WHERE Id IN (1, 2, 3, 4, 5)</code></pre>
<h3>Validaciones dentro de bucles</h3>
<h4>Antes ❌</h4>
<p>Este c&oacute;digo valida la existencia de los productos en la base de datos utilizando una lista de IDs proporcionada. Para cada ID, se realiza una b&uacute;squeda asincr&oacute;nica utilizando Entity Framework.</p>
<pre class="language-csharp"><code>int[] ids = { 1, 2, 3, 4, 5 }; // Array de IDs

foreach (int id in ids)
{
     var productExists = await context.Products.AnyAsync(p =&gt; p.Id == id);

     if (productExists)
     {
            Console.WriteLine($"Producto encontrado - ID: {id}");
     }
}</code></pre>
<h4>Ahora ✔</h4>
<p>Este c&oacute;digo busca productos en la base de datos utilizando una lista de IDs proporcionada. Primero, se realiza una consulta asincr&oacute;nica para obtener, con una &uacute;nica consulta, <strong>solamente </strong>los IDs de los productos deseados. Luego, se recorre la lista de IDs original y se v&aacute;lida cada ID con la lista&nbsp;<code>existingProductIds</code> obtenida&nbsp; previamente.</p>
<pre class="language-csharp"><code>int[] ids = { 1, 2, 3, 4, 5 }; // Array de IDs

List&lt;int&gt; existingProductIds = await context.Products.Where(p =&gt; ids.Contains(p.Id)).Select(p =&gt; p.Id).ToListAsync();

foreach (int id in ids)
{
     bool productExists = existingProductId.Any(x =&gt; x == id);

     if (productExists)
     {
            Console.WriteLine($"Producto encontrado - ID: {id}");
     }
}</code></pre>
<p>A continuaci&oacute;n, les muestro el SQL que genera EFCore con esta nueva estrategia.</p>
<pre class="language-csharp"><code>SELECT Id
FROM Products
WHERE Id IN (1, 2, 3, 4, 5)</code></pre>
<h2>Bonus Track: Evitar usar metodos Async dentro de bucles</h2>
<p>As&iacute; como venimos explicando el porqu&eacute; hay que evitar usar Entity Framework dentro de bucles, pues las razones son las mismas si fuera usar HttpClient.</p>
<p>As&iacute; que tambi&eacute;n te dejo una situaci&oacute;n (hoy ser&aacute; una sola 😉) de c&oacute;mo evitar usar m&eacute;todos Async dentro de bucles.</p>
<h4>Antes ❌</h4>
<p>Este c&oacute;digo obtiene una lista de productos. Cada producto tiene un precio en una moneda espec&iacute;fica (ARS, USD, EUR). Por cada producto, hay que obtener cuanto vale actualmente la moneda establecida.</p>
<p>El problema est&aacute; en que el foreach puede llegar a hacer 10 iteraciones en las cuales las 10 veces va a consultar a un m&eacute;todo async el valor de USD. &iquest;Es necesario buscar 10 veces el mismo valor? No lo creo.</p>
<pre class="language-csharp"><code>List&lt;Product&gt; products = await context.Products.ToListAsync(); // Podemos llegar a tener 10 productos

foreach (product in products)
{
     Currency currency = await _currencyService.GetByIdAsync(product.CurrencyId); // CurrencyId puede llegar a ser ARS, USD o EUR

     if (currency != null)
     {
            Console.WriteLine($"Moneda encontrada - ID: {currency.Id}, Valor: {currency.Rate}");
     }
}</code></pre>
<h4>Ahora ✔</h4>
<p>Lamentablemente, CurrencyService internamente usa HttpClient para comunicarse con una API externa del cual no tenemos control. Por lo tanto, no podemos evitar que se llame dentro de un foreach, pero si pudimos lograr que en vez de llamar a esa API 10 veces, se llame solamente la cantidad necesaria juntando los IDs de monedas con <code>Distinct()</code>.</p>
<p>Este c&oacute;digo, por m&aacute;s que sea m&aacute;s complejo, escala para que en la lista de productos haya 10, 100 o 1000 &iacute;tems y aun as&iacute; se llame m&aacute;ximo 3 veces a CurrencyService.GetByAsync().</p>
<pre class="language-csharp"><code>List&lt;Product&gt; products = await context.Products.ToListAsync(); // Podemos llegar a tener 10 productos
List&lt;string&gt; currencyIds = products.Select(p =&gt; p.CurrencyId).Distinct();
List&lt;Currency&gt; currencies = new();

foreach(currencyId in currencyIds)
{
     Currency currency = await _currencyService.GetByIdAsync(product.CurrencyId); // CurrencyId puede llegar a ser ARS, USD o EUR
     currencies.Add(currency);
}

foreach (product in products)
{
     Currency currency = currencies.First(c =&gt; c.Id == product.CurrencyId);
     if (currency != null)
     {
            Console.WriteLine($"Moneda encontrada - ID: {currency.Id}, Valor: {currency.Rate}");
     }
}</code></pre>
<h2>Conclusi&oacute;n</h2>
<p>En resumen, evitar colocar c&oacute;digo de Entity Framework dentro de un bucle "foreach" es una pr&aacute;ctica recomendada para optimizar el rendimiento de nuestras consultas y minimizar la carga en la base de datos. Al realizar una consulta &uacute;nica y almacenar los datos localmente antes de iterar sobre ellos, podemos lograr una ejecuci&oacute;n m&aacute;s eficiente y aprovechar al m&aacute;ximo las capacidades de Entity Framework.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>

Es común emplear un bucle "foreach" para recorrer una lista de elementos. No obstante, cuando se trabaja con Entity Framework, es crucial tener en consideración que no es aconsejable incluir código de EF directamente dentro de un bucle "foreach".

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-3.jpg

Como evitar usar Entity Framework dentro de bucles Foreach

<p>En el d&iacute;a de hoy vamos a estar usando HTTP Interceptors en Blazor. Todo lo explicado en los siguientes p&aacute;rrafos sirve tanto para Blazor WebAssembly, para Blazor Server y para cualquier proyecto .NET.</p>
<h2>&iquest;Qu&eacute; son los Interceptors?</h2>
<p>Un interceptor permite que puedas inspeccionar y/o modificar todas las solicitudes HTTP de un HttpClient. Esto significa que antes de realizar cualquier llamado al servidor, podes editar su contenido y tambi&eacute;n la respuesta.</p>
<p>Dicho de un modo bruto, podemos decir que tenemos un <a title="middleware" href="https://lautarocarro.blog/middleware-en-aspnet-core/">middleware</a> del lado del cliente.</p>
<h2>&iquest;C&oacute;mo se lo puede usar?</h2>
<p>Sea con Blazor o JS, los interceptors se los suelen usar para lo mismo:</p>
<ul>
<li>Imprimir en la consola cada solicitud HTTP que se realiza.</li>
<li>Capturar todas respuestas con c&oacute;digo 500 con fines de monitoreo.</li>
<li>Agregar a las solicitudes el encabezado <em>Authorization</em> junto con su token.</li>
<li>Implementar una l&oacute;gica de reintentos.</li>
<li>Mostrar un componente UI de <em>&ldquo;Cargando&hellip;&rdquo; </em>cada vez que se realiza una petici&oacute;n.</li>
</ul>
<p>Y la lista puede tener muchas opciones m&aacute;s.</p>
<h2>Creando Interceptors de Blazor</h2>
<p>En este ejemplo voy a mostrar un caso sencillo donde vamos a crear un interceptor que muestre en la consola del navegador todos los c&oacute;digos de estado de todas las respuesta que recibamos del servidor.</p>
<ul>
<li>Primero vamos a necesitar crear una clase que herede de&nbsp;<a href="https://docs.microsoft.com/dotnet/api/system.net.http.delegatinghandler" target="_blank" rel="noreferrer noopener" aria-label="DelegatingHandler (abre en una nueva pesta&ntilde;a)">DelegatingHandler</a>.</li>
<li>Segundo, simplemente sobrescribimos el m&eacute;todo&nbsp;<em>SendAsync</em>.</li>
<li>Por &uacute;ltimo agregamos en ese m&eacute;todo la implementaci&oacute;n de c&oacute;digo que sea necesaria.</li>
</ul>
<p>Y nos quedar&iacute;a algo similar a la siguiente clase.</p>
<p>[FALTA EL GITHUB GIST]</p>
<pre class="language-csharp"><code>public class StatusCodeHttpMessageHandler : DelegatingHandler
{
     private readonly ILogger&lt;StatusCodeHttpMessageHandler&gt; _logger;
     public StatusCodeHttpMessageHandler(ILogger&lt;StatusCodeHttpMessageHandler&gt; logger)
     {
          _logger = logger;
          InnerHandler = new HttpClientHandler();
     }


     protected override async Task&lt;HttpResponseMessage&gt; SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
     {
         // Antes de enviar la solicitud
         Console.WriteLine("Antes de enviar la solicitud al servidor...");

         // Puedes realizar alguna l&oacute;gica personalizada aqu&iacute;
         // por ejemplo, agregar encabezados adicionales a la solicitud

         // Llama al siguiente delegado en la cadena
         var response = await base.SendAsync(request, cancellationToken);
         _logger.LogInformation($"{(int)response.StatusCode} - {response.StatusCode}");

         // Despu&eacute;s de recibir la respuesta
         Console.WriteLine("Despu&eacute;s de recibir la respuesta del servidor...");

         // Puedes realizar alguna l&oacute;gica personalizada aqu&iacute;
         // por ejemplo, leer o modificar la respuesta antes de devolverla

         return response;
     }
}</code></pre>
<h2>Agregando nuestro Interceptor al HttpClient</h2>
<p>Cuando iniciamos un proyecto de Blazor, nos encontramos con que en la clase Program se crea una nueva instancia de HttpClient y esta instancia se agrega como Scoped en el contenedor de inyecci&oacute;n de dependencias de .NET Core.</p>
<p>Lo que vamos a hacer nosotros es modificar esto para poder pasarle al constructor del HttpClient nuestro nuevo interceptor.</p>
<pre class="language-csharp"><code> builder.Services.AddScoped&lt;StatusCodeHttpMessageHandler&gt;();

builder.Services.AddScoped(sp =&gt;
{
      var handler = sp.GetRequiredService&lt;StatusCodeHttpMessageHandler&gt;();
      return new HttpClient(handler)
      {
             BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
      };
});</code></pre>
<p>De esta manera cada vez que se inyecte el HttpClient en alg&uacute;n componente se lo utilice para realizar solicitudes al servidor, estas van a pasar por nuestro interceptor sin falta.</p>
<h2>Conclusi&oacute;n</h2>
<p>Los interceptors son muy usados en el desarrollo web y no pueden faltar en Blazor.</p>
<p>Les dej&oacute; el este mismo c&oacute;digo en <a title="Repositorio de GitHub" href="https://github.com/lauchacarro/BlazorHttpInterceptor" target="_blank" rel="noopener">un repositorio de GitHub </a>para que puedan clonarlo y probarlo ustedes mismos.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>

En el día de hoy vamos a estar usando HTTP Interceptors en Blazor. Todo lo explicado en los siguientes párrafos sirve tanto para Blazor WebAssembly, para Blazor Server y para cualquier proyecto .NET.

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-5.jpg

Usando HTTP Interceptors en Blazor

<p>Si eres nuevo en el mundo de la programaci&oacute;n en C#, es posible que hayas o&iacute;do hablar de los t&eacute;rminos "boxing" y "unboxing", pero no sepas exactamente qu&eacute; significan o c&oacute;mo funcionan. En esta gu&iacute;a, te explicaremos qu&eacute; son boxing y unboxing en C# y c&oacute;mo utilizarlos correctamente para evitar errores comunes.</p>
<h2>&iquest;Qu&eacute; es el boxing y unboxing en C#?</h2>
<p>El boxing y unboxing son conceptos relacionados con la conversi&oacute;n de tipos de datos en C#. Cuando se trabaja con tipos de datos primitivos, como enteros y booleanos, a menudo es necesario convertirlos en un objeto para que puedan ser almacenados en una colecci&oacute;n o en una variable de objeto. Esto se conoce como "boxing". Por otro lado, "unboxing" se refiere a la conversi&oacute;n de un objeto en un tipo de datos primitivo.</p>
<h2>Ejemplo de boxing y unboxing en C#</h2>
<p>Veamos un ejemplo de c&oacute;mo funciona el boxing y unboxing en C#. Supongamos que queremos almacenar una lista de enteros en una variable de tipo objeto. En este caso, necesitamos convertir los enteros en objetos antes de poder almacenarlos en la variable.</p>
<pre class="language-csharp"><code>List&lt;int&gt; numeros = new List&lt;int&gt;();
numeros.Add(1);
numeros.Add(2);
numeros.Add(3);
object obj = numeros; // Boxing</code></pre>
<p>&nbsp;</p>
<p>En este ejemplo, estamos convirtiendo la lista de enteros en un objeto para poder almacenarla en la variable <code>obj</code>. Este proceso se conoce como boxing.</p>
<p>Para hacer el proceso inverso, es decir, convertir un objeto en un tipo de datos primitivo, debemos realizar un proceso llamado unboxing. Veamos un ejemplo:</p>
<pre class="language-csharp"><code>int primerNumero = (int)numeros[0]; // Unboxing</code></pre>
<p>&nbsp;</p>
<p>En este caso, estamos convirtiendo el primer elemento de la lista, que es un objeto, en un tipo de datos entero. Este proceso se conoce como unboxing.</p>
<h2>C&oacute;mo evitar errores comunes en boxing y unboxing</h2>
<p>Aunque el boxing y unboxing pueden ser &uacute;tiles en algunas situaciones, es importante tener en cuenta que tambi&eacute;n pueden causar errores si no se utilizan correctamente. Uno de los errores m&aacute;s comunes que se pueden producir es la p&eacute;rdida de rendimiento. El boxing y unboxing pueden ser procesos costosos en t&eacute;rminos de rendimiento, especialmente cuando se utilizan en bucles o en aplicaciones que manejan grandes cantidades de datos.</p>
<p>Para evitar estos errores, es recomendable utilizar tipos de datos gen&eacute;ricos en lugar de objetos en las colecciones siempre que sea posible. De esta manera, se evita la necesidad de realizar el proceso de boxing y unboxing. Adem&aacute;s, es importante utilizar el tipo de datos adecuado para cada variable y evitar la conversi&oacute;n innecesaria de tipos de datos.</p>
<h2>Conclusi&oacute;n</h2>
<p>En resumen, el boxing y unboxing son conceptos importantes en C# que se utilizan para convertir tipos de datos primitivos en objetos y viceversa. Aunque pueden ser &uacute;tiles en algunas situaciones, tambi&eacute;n pueden causar errores y p&eacute;rdida de rendimiento si no se utilizan correctamente. Es importante tener en cuenta estas consideraciones al programar en C# y utilizar tipos de datos gen&eacute;ricos siempre que sea posible para evitar el boxing y unboxing innecesarios.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>

En el artículo, se explica qué es el Boxing y Unboxing y se proporcionan ejemplos simples de cómo se pueden utilizar en código. 

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-2.jpg

Qué es boxing y unboxing en C#: una guía completa para principiantes

<p>Luego de la salida a producci&oacute;n del blog de Rest Of My Cloud (ROMC) con el art&iacute;culo de <a href="https://restofmycloud.com/blog/3-maneras-de-utilizar-efcore-con-blazor">3 Maneras &uacute;nicas de utilizar Entity Framework con Blazor WebAssembly</a>, me han preguntado mucho <strong>&iquest;Por qu&eacute; eleg&iacute; NextJs sobre Blazor?</strong> para construirlo.</p>
<p>Para responder esta pregunta haremos un peque&ntilde;o viaje al pasado...</p>
<h2>Los comienzos de ROMC</h2>
<p>Cuando comenc&eacute; a analizar con que tecnolog&iacute;a iba a construir este blog que, actualmente se encuentra en producci&oacute;n, ten&iacute;a como opciones: MVC, Blazor y NextJs.</p>
<p>Por opini&oacute;n personal que les contar&eacute; en un futuro art&iacute;culo, no considero buena idea crear nuevos proyectos con Asp NET Core MVC 🤫. Por lo tanto, ya la primera opci&oacute;n quedaba descartada. As&iacute; que el verdadero debate es sobre los &uacute;ltimos 2.&nbsp;</p>
<p>Repasemos de que tratan los frameworks web NextJS y Blazor 👇</p>
<h2>&iquest;Que es NextJS?</h2>
<p>NextJs es un framework de React para la construcci&oacute;n de aplicaciones web que se renderizan del lado del servidor y la generaci&oacute;n de sitios web est&aacute;ticos para aplicaciones web basadas en React.</p>
<h2>&iquest;Que es Blazor Server?</h2>
<p>Blazor es un marco web para compilar componentes de UI web (componentes Razor) que se pueden hospedar de maneras diferentes.&nbsp;</p>
<p>Con el modelo de hospedaje de Blazor Server, la aplicaci&oacute;n se ejecuta en el servidor desde una aplicaci&oacute;n ASP.NET Core. Las actualizaciones de la interfaz de usuario, el control de eventos y las llamadas de JavaScript se controlan mediante una conexi&oacute;n SignalR usando el protocolo WebSockets.</p>
<h2>Ventajas y desventajas de usar NextJs</h2>
<p>Voy a mencionar las ventajas de usar NextJs bas&aacute;ndome en mi experiencia y relaci&oacute;n previa a desarrollar ROMC.</p>
<h3>Ventajas:</h3>
<ul>
<li>La curva de aprendizaje es muy corta</li>
<li>Soporta cualquier librer&iacute;a de React y JS</li>
<li>Soporta Typescript (Esto es muy importante!)</li>
<li>Tiene una gran velocidad de renderizado</li>
<li>Nos otorga varias herramientas para un <strong>SEO </strong>destacable.</li>
</ul>
<h3>Desventajas:</h3>
<p>La mayor desventaja es que no ten&iacute;amos experiencia previa con NextJs 😖</p>
<h2>Ventajas y desventajas de usar Blazor Server</h2>
<h3>Ventajas:</h3>
<ul>
<li>Conozco y uso Blazor desde las versiones preview de NET Core 3.0 (2019).</li>
<li>Para desarrolladores .NET la curva de aprendizaje de Blazor es muy corta.</li>
<li>Tambi&eacute;n tiene una gran velocidad de renderizado y de actualizaci&oacute;n de estado gracias a SignalR.</li>
</ul>
<h3>Desventajas:</h3>
<p>Yo NO soy el &uacute;nico desarrollador de ROMC.</p>
<h2>Hablemos del equipo de desarrollo</h2>
<p>Como menciono, yo no soy el &uacute;nico que desarolla el sistema de Rest Of My Cloud Tambi&eacute;n est&aacute; <a title="Nicole Tevez Linkedin" href="https://www.linkedin.com/in/nicoletevez/" target="_blank" rel="noopener">Nicole Tevez</a>, desarrolladora React, que ha hecho un gran trabajo en el maquetado del sitio web. 💁&zwj;♀️</p>
<p>A la hora de elegir la tecnolog&iacute;a a usar, sab&iacute;a que tanto ella como yo tenemos experiencia en React y con Typescript. Si eleg&iacute;a crear ROMC con Blazor ella deber&iacute;a aprender desde cero C#, Asp NET Core y luego Blazor.🥱</p>
<p>En cambio, si eleg&iacute;a NextJs, ambos simplemente deber&iacute;amos complementar nuestro conocimiento de React con este framework. 😉</p>
<h2>SEO como Atributo de Calidad</h2>
<p>Un atributo de calidad es una <strong>propiedad medible</strong>&nbsp;de un sistema, que indica qu&eacute; tan bien el sistema&nbsp;<strong>satisface&nbsp;</strong>las necesidades de las partes interesadas. 👨&zwj;🏫</p>
<p>En este caso, para el armado de este blog, al atributo de calidad que eleg&iacute; darle mayor prioridad es al SEO para un buen posicionamiento de los art&iacute;culos en los motores de b&uacute;squeda.</p>
<p>Y tal como mencionamos antes, NextJs se lleva el premio por justamente ser su ventaja tener herramientas para la mejora del SEO.💪</p>
<h2>Conclusi&oacute;n</h2>
<p>A pesar de que los que me conocen saben de mi fanatismo con Blazor, esta vez tuve que mirar para otro lado, eligiendo una tecnolog&iacute;a totalmente diferente para que el equipo (Nicole y yo) tenga una experiencia de desarrollo amena y para poder cumplir con los atributos de calidad establecidos en este proyecto.</p>
<p>De todas formas, Blazor me parece un framework web &uacute;nico en el mundo y tal como menciono en los &uacute;ltimos p&aacute;rrafos de <a title="Qu&eacute; es ROMC" href="../../../que-es-romc" target="_blank" rel="noopener">&iquest;Qu&eacute; es ROMC</a>? Rest Of My Cloud comienza ahora como un blog, pero ya estamos desarrollando nuevos sistemas donde React y Blazor WebAssembly tendr&aacute;n un papel, en conjunto, muy importante.</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>
<p>&nbsp;</p>

Luego de la salida a producción de Rest Of My Cloud me han preguntado mucho ¿Por qué elegí NextJs sobre Blazor?. En este artículo cuento mi experiencia al elegir la tecnología a utilizar 

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-1-2.jpg

¿Por qué elegí NextJs sobre Blazor?

<p>Utilizar Entity Framework con Blazor WebAssembly es un escenario muy poco com&uacute;n, pero WebAssembly trae todo un abanico de posibilidades para poder ejecutar nuestras herramientas favoritas de .NET en la Web.</p>
<p>En este art&iacute;culo te voy a mostrar 3 maneras que ni te imaginabas que era posible realizar para poder utilizar Entity Framework Core del lado del NAVEGADOR 🤯.</p>
<h2>&iquest;Que es Blazor WebAssembly?</h2>
<p>Para recordar un poco, Blazor WebAssembly (WASM) es una de las formas de crear sitios web con .NET. En este caso, Blazor Wasm tiene la particularidad de ejecutar c&oacute;digo C# en el navegador sin necesitdad de usar un servidor. Literalmente, el sitio web descarga las DLL de .NET y las ejecuta en tu navegador.</p>
<h2>Blazor Wasm y Entity Framework Core</h2>
<p>Ya que Blazor Wasm utiliza las DLL de .NET en el navegador, tranquilamente tambi&eacute;n puede utilizar las de cualquier librer&iacute;a construida con .NET, como por ejemplo: AutoMapper, MediatR, FluentValidation y, por supuesto, Entity Framework Core.</p>
<p>Hasta ahora todo muy lindo y de color de rosa, pero tampoco podemos esperar que algo tan "milagroso" no tenga l&iacute;mites. 🙄</p>
<h2>Blazor Wasm y SQLServer</h2>
<p>Actualmente, desde una sesi&oacute;n del navegador no se puede abrir conexiones de red arbitrarias. Es la raz&oacute;n por la cual no nos podemos conectar directamente a la base de datos con Javascript. ❌</p>
<p>De igual forma, como Blazor WebAssembly se ejecuta en el navegador, tambi&eacute;n es imposible que desde un proyecto de Blazor Wasm nos conectemos a base de datos como SqlServer, MySql, Postgres, MongoDb, etc.</p>
<p>Podemos leer m&aacute;s sobre el asunto en el siguiente link 👉&nbsp;<a href="https://github.com/dotnet/SqlClient/issues/599#issuecomment-799567767" target="_blank" rel="noopener">https://github.com/dotnet/SqlClient/issues/599</a></p>
<h2>Blazor Wasm y Entity Framework Core InMemory</h2>
<p>Entity Framework Core InMemory es la forma m&aacute;s b&aacute;sica de usar nuestro ORM favorito, ya que consta de crear una "base de datos" en memoria, por lo tanto, no realiza ninguna conexi&oacute;n de red. 😴</p>
<p>Esta librer&iacute;a de EFCore es usada normalmente para los UnitTesting, pero tambi&eacute;n puede llegar a ser muy &uacute;til a la hora de desarrollar sitios web para el manejo de estado en arquitecturas frontend complejas como Flux.</p>
<h2>Blazor Wasm y SQLite</h2>
<p>Las aplicaciones Blazor WebAssembly, desde .NET 6, pueden usar dependencias nativas compiladas para ejecutarse en WebAssembly.</p>
<p>Las herramientas de compilaci&oacute;n de WebAssembly de .NET se basan en <a title="Emscripten" href="https://emscripten.org/" target="_blank" rel="noopener">Emscripten</a>, una herramienta que permite compilar c&oacute;digo a WebAssembly. 🔨</p>
<p>SQLite es una base de datos contenida en un archivo, a diferencia de los otros motores de bases de datos, que son software completos.</p>
<p>SQLite est&aacute; desarrollado en C lo que significa que podemos importarlo como dependencia nativa y utilizar SQLite directamente en nuestra aplicaci&oacute;n Blazor. Esto es posible, ya que al compilar, no solo nuestro c&oacute;digo C# se va a compilar a WebAssembly, sino que gracias a la tool Emscripten, tambi&eacute;n se va a compilar SQLite a WebAssembly, permitiendo que lo podamos utilizar directamente en el navegador. 😲</p>
<p>De esta forma se puede usar una base de datos dentro de tu proyecto web y lo m&aacute;s importante, es que pod&eacute;s usar EFCore con SQLite en el navegador.🚀</p>
<figure class="image"><img title="SQL en la consola del navegador al utilizar Entity Framework con Blazor WebAssembly" src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/Captura%20de%20pantalla%202023-01-08%20193548.jpeg" alt="SQL en la consola del navegador al utilizar Entity Framework con Blazor WebAssembly" width="1430" height="992">
<figcaption>SQL en la consola del navegador al utilizar Entity Framework con Blazor WebAssembly</figcaption>
</figure>
<p>&nbsp;</p>
<h2>Blazor Wasm y Remote.Linq</h2>
<p>Remote.Linq es una librer&iacute;a que serializa y deserializa consultas de Linq a JSON. Esto permite que una app de .NET construya una consulta de Linq, la convierte a Json y se la env&iacute;a a otra app de .NET para deserealizarla y ejecutarla, ya sea con una Lista o con EFCore mismo. ⭐</p>
<p>Con Blazor WebAssembly podemos hacer que nuestro sitio web construya las consultas de Linq pidiendo la informaci&oacute;n que el sitio web NECESITA y enviarle el Json de Linq a una WebApi para que resuelva la consulta y le devuelva la informaci&oacute;n solicitada al sitio web. (igualito a GraphQL pero 100% .NET con nuestro ORM favorito) 😉</p>
<figure class="image"><img title="Parte del JSON que es enviado a la WebApi como otra forma de usar Entity Framework con Blazor WebAssembly" src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/Captura%20de%20pantalla%202023-01-08%20194539%20(1).jpeg" alt="Parte del JSON que es enviado a la WebApi como otra forma de usar Entity Framework con Blazor WebAssembly" width="1447" height="337">
<figcaption>Se puede observar parte del JSON, creado con Remote.Linq, que fue enviado a la WebApi para que lo ejecute con EFCore</figcaption>
</figure>
<p>&nbsp;</p>
<p>A continuaci&oacute;n podemos ver el &uacute;nico Controller que tiene la WebApi</p>
<pre class="language-csharp"><code>[ApiController]
[Route("api/[controller]")]
public class QueryController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public QueryController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpPost]
    public DynamicObject Query([FromBody] RemoteQuery query)  
        =&gt; query.Expression.ExecuteWithEntityFrameworkCore(_context);

}</code></pre>
<figure class="image"><img title="El QueryController hace de intermediario para utilizar EntityFramework con Blazor WebAssembly" src="https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/images/Captura%20de%20pantalla%202023-01-08%20201221%20(1).jpeg" alt="El QueryController hace de intermediario para utilizar EntityFramework con Blazor WebAssembly" width="1141" height="185">
<figcaption>La WebApi al recibir el JSON y ejecutarlo en QueryController se resulve la query de Linq como cualquier otra consulta de EFCore</figcaption>
</figure>
<p>&nbsp;</p>
<p>A continuaci&oacute;n les dejo una charla que di hace unos a&ntilde;os para la comunidad NETBaires sobre Blazor WebAssembly y Remote.Linq</p>
<p>&nbsp;</p>
<p><iframe src="https://www.youtube.com/embed/Tli-KBwpC_Q" width="560" height="314" allowfullscreen="allowfullscreen"></iframe></p>
<h2>Conclusi&oacute;n</h2>
<p>En este art&iacute;culo aprendiste 3 maneras de usar Entity Framework Core con Blazor WebAssembly, pero el verdadero mensaje que quiero dejar con este art&iacute;culo es que con WebAssembly tenemos la posibilidad de crear aplicaciones web superiores a cualquier sitio web tradicional. Y todo esto utilizando el lenguaje C#, el framework .NET y las librer&iacute;as que ya conocemos</p>
<p>Si encuentras &uacute;til este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen caf&eacute; ☕.</p>
<p><a title="Buy Me A Coffee" href="https://www.buymeacoffee.com/lauchacarro" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/practicaldev/image/fetch/s--rJvAnNew--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://cdn.buymeacoffee.com/buttons/default-black.png" alt="Buy Me A Coffee"></a></p>
<p>Les dejo un link de GitHub con una app que realiza las 3 maneras de utilizar Entity Framework con Blazor WebAssembly 👉 <a title="3 maneras de utilizar Entity Framework con Blazor WebAssembly" href="https://github.com/lauchacarro/BlazorWasmEFCore" target="_blank" rel="noopener">https://github.com/lauchacarro/BlazorWasmEFCore</a></p>

Este artículo conocerás 3 maneras únicas de utilizar Entity Framework con Blazor en el navegador gracias a la magia de WebAssembly. Te aseguro que te vas a sorprender 😉

https://raw.githubusercontent.com/lauchacarro/Academy-Images/main/feature-images/rest-of-my-cloud-flyers-1.png

Hey, Rest Of My Cloud ya llegó. El blog que necesitas para salir a producción.