Microsoft Windows Services & Microsoft Worker Services

Windows Services y Worker Services son dos formas de crear procesos de larga duración en el ecosistema de Microsoft.

Windows Services pertenecen al .NET Framework y se ejecutan como servicios del sistema en Windows. Worker Services son la evolución moderna en .NET (Core/5+) y permiten procesos en segundo plano multiplataforma, usando el modelo de hospedaje de .NET.

¿Qué es un Windows Service? es una aplicación de larga duración que se ejecuta en su propia sesión, sin interfaz de usuario, iniciándose con el sistema operativo y administrándose desde el administrador de servicios de Windows. Históricamente se conocen como NT services y están pensados para tareas en segundo plano exclusivamente en Windows

¿Qué es .NET Worker Services? es una aplicación de fondo basada en el host genérico de .NET (IHostedService/BackgroundService). Permite procesar colas, tareas programadas o trabajos intensivos sin UI, y puede ejecutarse en Windows, Linux y macOS. Es la alternativa moderna a los servicios de Windows, con plantillas oficiales y soporte de extensiones de .NET para configuración, DI y logging.

Windows Services

• Modelo clásico, ligado a Windows. 
• Pensado para .NET Framework. 
• Difícil de portar, instalar y mantener en entornos modernos o cloud.

Worker Services

• Modelo moderno basado en el Generic Host de .NET. 
• Funciona en Windows, Linux y macOS. 
• Se integra nativamente con DI, logging, configuración, health checks, contenedores y DevOps. 
• Puede ejecutarse como servicio de Windows, como systemd en Linux o dentro de Docker.

Similitudes:

• Larga duración: Ambos modelos ejecutan tareas persistentes en segundo plano sin interfaz gráfica. 
• Automatización de procesos: Son adecuados para trabajos programados, procesamiento de colas y servicios que requieren estar activos continuamente.

Diferencias clave:

• Plataforma: Windows Services solo en Windows; Worker Services son multiplataforma. 
• Modelo de hospedaje: Windows Services usan el modelo del SO y ServiceController; Worker Services usan el host genérico de .NET con IHostedService/BackgroundService. 
• Desarrollo y despliegue: Windows Services requieren instalación y registro como servicio del sistema; Worker Services se hospedan como consola, servicio de Windows, systemd en Linux o contenedor. 
• Ecosistema moderno: Worker Services integran DI, configuración y logging de .NET; Windows Services carecen de estas integraciones nativas en .NET Framework.

¿Cuándo usar cada uno?

• Elige Windows Services: Cuando estás atado a Windows Server y a la administración nativa de servicios del sistema, o mantienes una solución existente en .NET Framework. 
• Elige Worker Services: Cuando buscas portabilidad, contenedores, despliegues cloud/devops, integración con DI y observabilidad moderna en .NET.

Comparativa entre Windows Services y Worker Services

He aquí una tabla comparativa:

Aspecto	Windows Services (.NET Framework)	Worker Services (.NET moderno)
Plataforma	Solo Windows	Multiplataforma (Windows, Linux, macOS)
Modelo de ejecución	Servicio del sistema administrado por SCM (Service Control Manager)	Host genérico de .NET (IHostedService/BackgroundService)
Instalación	Registro como servicio (sc.exe, instaladores, herramientas de administración)	Ejecutable de consola, servicio de Windows, systemd, contenedor
Integraciones	Limitadas; sin DI/Logging nativo del host de .NET	DI, configuración, logging, health checks, extensiones de .NET
Casos típicos	Procesos en background en entornos Windows/legacy	Trabajos en background portables, cloud-native, contenedores
Plantillas oficiales	Enfoque clásico de .NET Framework	Plantilla “Worker Service” en .NET
Mantenimiento	Dependiente de Windows y SCM	Observabilidad moderna, despliegues flexibles

Worker Services son la evolución moderna de Windows Services.

Creando un Worker Service

Para crear un Worker Service usaremos la herramienta dotnet. Ese servicio se ejecuatrá cada 5 segundos y mostrará un mensaje.

1. Crear el proyecto Worker:

$ dotnet new worker -n MiWorkerService

2. Nos ubicamos en el directorio creado:

$ cd MiWorkerService

3. Editamos la clase Worker.cs

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace MiWorkerService;

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker ejecutándose a las: {time}", DateTimeOffset.Now);
            await Task.Delay(5000, stoppingToken);
        }
    }
}

4. Editamos el programa principal Program.cs

using MiWorkerService;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddHostedService<Worker>();
    })
    .Build();

await host.RunAsync();

5. Ejecutar proyecto:

$ dotnet build
$ dotnet run

Salida:

info: MiWorkerService.Worker[0]          
Worker ejecutándose a las: 12/03/2025 21:10:34 -06:00                        
info: MiWorkerService.Worker[0]                                                          
      Worker ejecutándose a las: 12/03/2025 21:10:39 -06:00                        
info: MiWorkerService.Worker[0]                                                          
      Worker ejecutándose a las: 12/03/2025 21:10:44 -06:00

Podríamos implementarlo como un Servicio, pero será en otra ocasión.

Conclusión: un Worker Service es como un Windows Service modernizado que funciona en cualquier plataforma y listo para ser implementado en la Nube y/o Docker.

Enlaces:

https://learn.microsoft.com/es-es/dotnet/core/extensions/workers
https://medium.com/@adebanjoemmanuel01/running-a-worker-service-as-a-windows-service-c1d12a28a73c
https://web.valuesite.cl/index.php/2024/11/25/la-utilizacion-de-worker-service-para-servicios-automaticos-vs-frameworks/
https://learn.microsoft.com/es-es/dotnet/core/extensions/windows-service

Entity Framework: un ORM para .NET

Para los programadores Java que han usado Hibernate o cualquier otro ORM sabrán que son herramientas muy útiles para el mapeo de tablas y clases Java. Pues ahorran una gran cantidad de código y horas de esfuerzo.

.NET tiene un ORM llamado EntityFramework (EF), el cual es:

"... un mapeador objeto-relacional (ORM) de Microsoft para .NET que permite a los desarrolladores interactuar con bases de datos relacionales usando objetos de C# en lugar de escribir consultas SQL".

Un ORM nos permite manipular la información de las tablas como objetos. Esto nos evita tener que lidiar con SQL nativo.

Al usar EntityFramework podemos:

• Mapear las tablas de nuestra base de datos como si fueran clases. 
• Manipular la información de las tablas sin necesidad de sentencias SQL. 
• Contar con las operaciones CRUD ya "integradas". 
• Compatibilidad con LINQ (un lenguaje para realizar consultas con C#). 
• Permitir conectarnos distintas fuentes de datos como MS SQL Server, MySQL, PostgreSQL, etc. 
• Simplificar nuestro código.

También debemos tener cuidado de:

1. Observar el rendimiento de las consultas. 
2. Entender cómo se usa LINQ.

Al usar un ORM debemos entender:

1. Qué base de datos vamos a usar. 
2. Qué es lo que queremos mapear (tablas). 
3. Convertir la estructura de las tablas a objetos (mapeo). 
4. Qué operaciones vamos a realizar sobre esos objetos (operaciones CRUD).

Comenzando con EntityFramework

Crearemos una sencilla aplicación C# usando el ORM EntityFramework.

Requisitos:

• Contar con la herramienta dotnet instalada. 
• Contar con MariaDB instalado. 
• Tener nociones de C#.

1. Es necesario contar con una base de datos ("cursomariadb") y al menos una tabla en la misma (persons).

CREATE OR REPLACE TABLE persons(
personid int, 
lastname varchar(255), 
firstname varchar(255), 
address varchar(255), 
city varchar(255)
);

3. Crearemos el proyecto con la herramienta dotnet y nos ubicaremos en el directorio creado:

$ dotnet new console -n DemoEFMariaDB
$ cd DemoEFMariaDB

4. Instalar los paquetes nugets necesarios:

$ dotnet add package Microsoft.EntityFrameworkCore --version 8.0.0
$ dotnet add package Pomelo.EntityFrameworkCore.MySql --version 8.0.0

Con estos instalamos EntityFramework y el conector a MariaDB (recordar que es un fork de MySQL).

5. Dentro del directorio del proyecto crearemos una carpeta llamada Model y dentro una clase C# que homologue a la tabla.

Person.cs

namespace Model
{
    public class Person
    {
        public int PersonId { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string Address { get; set; }

        public string City { get; set; }

        public Person()
        {
            PersonId = 0;
            LastName = string.Empty;
            FirstName = string.Empty;
            Address = string.Empty;
            City = string.Empty;
        }

    }

}

6. Ahora crearemos una clase contexto para la conexión a la base de datos.

AppDbContext.cs

using Microsoft.EntityFrameworkCore;
using Model;


public class AppDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseMySql(
            "server=localhost;database=cursomariadb;user=root;password=secreta",
            new MySqlServerVersion(new Version(10, 11, 2)) 
        );
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Person>().ToTable("persons"); 
        modelBuilder.Entity<Person>().HasKey(p => p.PersonId);
    }
}

7. Modificaremos el programa principal del proyecto para agregar las operaciones CRUD. Comenzaremos con la operación INSERT INTO .

Program.cs

using System;
using System.Linq;
using Model;

class Program
{
    static void Main()
    {
        using var db = new AppDbContext();

        // INSERT
        var newPerson = new Person
        {
            PersonId = 4,
            FirstName = "Juan",
            LastName = "Pérez",
            Address = "Calle Falsa 123",
            City = "CDMX"
        };
        db.Persons.Add(newPerson);
        db.SaveChanges();
        Console.WriteLine("Insertado correctamente.");
    }

}

Seguiremos con la instrucción SELECT:

// SELECT
        var persons = db.Persons.ToList();
        Console.WriteLine("Listado de personas:");
        foreach (var p in persons)
        {
            Console.WriteLine($"{p.PersonId} - {p.FirstName} {p.LastName} - {p.City}");
        }

Ahora con la instrucción UPDATE:

 // UPDATE
        var personToUpdate = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToUpdate != null)
        {
            personToUpdate.City = "Guadalajara";
            db.SaveChanges();
            Console.WriteLine("Actualizado correctamente.");
        }

Finalmente con la instrucción DELETE:

// DELETE
        var personToDelete = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToDelete != null)
        {
            db.Persons.Remove(personToDelete);
            db.SaveChanges();
            Console.WriteLine("Eliminado correctamente.");
        }

Código completo:

using System;
using System.Linq;
using Model;

class Program
{
    static void Main()
    {
        using var db = new AppDbContext();

        // INSERT
        var newPerson = new Person
        {
            PersonId = 4,
            FirstName = "Juan",
            LastName = "Pérez",
            Address = "Calle Falsa 123",
            City = "CDMX"
        };
        db.Persons.Add(newPerson);
        db.SaveChanges();
        Console.WriteLine("Insertado correctamente.");

        // SELECT
        var persons = db.Persons.ToList();
        Console.WriteLine("Listado de personas:");
        foreach (var p in persons)
        {
            Console.WriteLine($"{p.PersonId} - {p.FirstName} {p.LastName} - {p.City}");
        }

        // UPDATE
        var personToUpdate = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToUpdate != null)
        {
            personToUpdate.City = "Guadalajara";
            db.SaveChanges();
            Console.WriteLine("Actualizado correctamente.");
        }

        // DELETE
        var personToDelete = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToDelete != null)
        {
            db.Persons.Remove(personToDelete);
            db.SaveChanges();
            Console.WriteLine("Eliminado correctamente.");
        }
    }
}

8. Ejecutamos la aplicación:

$ dotnet run

Salida:

Insertado correctamente.
Listado de personas:
1 - Carmen Moreno - EDOMEX
2 - Jimena Torres - Toluca
3 - Torres Manuel - Cuajimalpa
4 - Juan Pérez - CDMX
Actualizado correctamente.

¡Hemos creado una aplicación C# con EntityFramework !

Conclusiones:

• EntityFramework es una herramienta poderosa que nos ahorra tiempo de desarrollo simplificando el acceso datos y su manipulación. 
• LINQ hace que las operaciones sobre las tablas sea más sencillo.
• Su soporte a varias fuentes de datos es muy útil y no nos limita a usar una sola.
• La complejidad de código se reduce abruptamente, ¡parece magia!
• Aunque tiene muchas ventajas hay que considerar el rendimiento cuando existe una gran cantidad de datos.

Seguiremos con esta serie sobre C#.

Enlaces:

https://andresledo.es/csharp/entity-framework-core/
https://medium.com/@ravipatel.it/a-beginners-guide-to-entity-framework-core-ef-core-5cde48fc7f7a
https://codemonkeyjunior.blogspot.com/2025/08/programando-en-c-no-9-usando-nuget.html
https://codemonkeyjunior.blogspot.com/2019/06/instalar-paquetes-nuget-con-dotnet.html
https://es.wikipedia.org/wiki/Language_Integrated_Query
https://blog.georgekosmidis.net/using-mariadb-in-an-aspnet-core-api-with-entity-framework-core.html
https://www.entityframeworktutorial.net/
https://www.learnentityframeworkcore.com/
https://learn.microsoft.com/es-es/ef/

Programando en C# no. 7 (uso de genéricos)

En el mundo de la programación un genérico nos permite escribir código que trabaja con cualquier tipo de datos sin perder la seguridad de tipos. Es una forma de crear clases, interfaces y métodos que pueden operar sobre varios tipos de datos sin duplicar código. Esto evita castings innecesarios y errores en tiempo de ejecución, ofreciendo reutilización y robustez.

Suponiendo que tenemos esta clase:

public class Caja<T> {
    private T contenido;

    public void Guardar(T elemento) {
        contenido = elemento;
    }

    public T Obtener() {
        return contenido;
    }
}

Lo usaríamos de la siguiente forma:

Caja<int> cajaDeEnteros = new Caja<int>();
cajaDeEnteros.Guardar(42);
Console.WriteLine(cajaDeEnteros.Obtener());  

El tipo T se puede cambiar por cualquier clase o tipo primitivo, lo que lo vuelve extremadamente flexible. Si hacer ninuna conversión o casteo (cast). Veamos otro uso:

var myTypeFloat = new Caja<float>();
myTypeFloat.Guardar(232.0f);
Console.WriteLine("Float: {}", myTypeFloat.Obtener());

var myTypeString = new Caja<string>();
myTypeString.Guardar("232");
Console.WriteLine("String: {}", myTypeString.Obtener());

Usar genéricos nos ahorra tener que hacer conversiones, casteos o incluso crear clases por tipos. ¿Se podrá usar con interfaces? La respuesta es sí.

public interface MyInterface<T> {
        T suma(T num1, T num2);
}

Podríamos crear una clase que lo implemente, además específicamos el tipo a usar, en este caso será un BigInteger.

public class MyInterfaceImpl : MyInterface<BigInteger>
    {
        public BigInteger suma(BigInteger x, BigInteger y)
        {
            return x + y;
        }
    }

Creamos unas variables tipo ``BigInteger`` y se las pasamos al método de suma:

BigInteger x = new BigInteger(23);
var y = new BigInteger(45);
var myInterface = new MyInterfaceImpl();
var resultSuma = myInterface.suma(x, y);
Console.WriteLine("Suma: {}", resultSuma); 

Al final mostramos el resultado de la suma.

Este solo es un ejemplo del uso de clases e interfaces genéricas. Continuaremos con esta serie sobre C# en próximas entregas.

Enlaces:

https://emanuelpeg.blogspot.com/search/label/C%23
Aprender a programar con C# (Libro)

F#: un lenguaje funcional

F# (Efe sharp) es un lenguaje de paradigma funcional desarrollado por (la malévola empresa) Microsoft.

Presume de una simplicidad y facilidad para ser aprendido (y usado).

A primera vista nos recuerda a lenguajes como Powershell, Javascript, Perl, Python o Ruby.

F# tiene una sintaxis ligera que requiere muy poco código para compilar software.

Está respaldado por un sistema de tipos eficaz, una biblioteca estándar cómoda y un entorno de ejecución de .NET en el que puede confiar para crear software crítico que sea correcto, rápido y confiable.

La extensión de un programa en F# puede ser *.fs o *.fsx.

Si no tienes instalado Dotnet ve este sitio:

https://dotnet.microsoft.com/en-us/download

Al tenerlo ya instalado, te permitirá crear programas y aplicaciones F#.

Escribamos el clásico "Hola, mundo" en este lenguaje:

holamundo.fsx

printfn "Hola, mundo!!"

Para ejecutar podemos usar dotnet:

dotnet fsi holamundo.fsx

Salida:

Hola, mundo!!

Crear un proyecto F#

Para crear un proyecto F# deberás teclear esto:

dotnet new console --language F#
dotnet run

Se generará un proyecto F# y se ejecutará.

Variables en F#

F# es un lenguaje fuertemente tipado que utiliza inferencia de tipos (int, float, string, bool, etc.). Por lo que deberás cuidar el tipo de dato a declarar. Aunque existe la inferencia de tipos en caso de que no quieras definir el tipo.

variables.fs

// Tipos de datos
let numeroEntero = 23
let (numerico: int) = 32
let (cadena: string) = "FERROCARRILERO"
let (isOk: bool) = true
let real = 90.43

Hemos declarado algunas variables y definido sus tipos. Imprimiremos sus valores de la siguiente forma:

printfn "numeroEntero: %i" numeroEntero
printfn "numerico: %i" numerico
printfn "cadena: %s" cadena
printfn "isOk: %b" isOk
printfn "real: %f" real

Tambien podemos introducir datos, usando las liberías de .Net

entrada.fs

open System

printfn "Introduce tu nombre:"
let nombre = Console.ReadLine()
printfn "Hola, %s" nombre

Ejecutamos (dotnet run):

Introduce tu nombre:
Thomas Muller
Hola, Thomas Muller

En F# todas las variables son inmutables, es decir, no cambian de valor. Si requieres que una variable cambie su valor deberás usar la palabra ``mutable``, esto similar a lenguajes como Rust.

// Variables mutables
let mutable contador = 0
printfn "Contador: %i" contador
contador <- 1
printfn "Contador: %i" contador 

Esto es todo por hoy. En próximas entregas continuaremos con este tema.

Enlaces:

https://fsharp.org/
Vídeos sobre F#
https://es.wikipedia.org/wiki/F_Sharp
https://dotnet.microsoft.com/en-us/learn/dotnet/in-browser-tutorial/1

¿Qué es lo que ocasionó el CAOS INFORMATICO MUNDIAL? | CrowdStrike

En este video te explicaré a detalle que es lo que ocasiono el pantallazo azul de Windows a nivel mundial.

Crowdstrike Analysis:

It was a NULL pointer from the memory unsafe C++ language.

Since I am a professional C++ programmer, let me decode this stack trace dump for you. pic.twitter.com/uUkXB2A8rm

— Zach Vorhies / Google Whistleblower (@Perpetualmaniac) July 19, 2024

Ningún SO es infalibre, aunque esto seguro no pasa en SO Linux. Una de las razones por las que Microsoft es un SO tan malo y poco confiable.

Microsoft Azure en un vistazo

Microsoft Azure es una plataforma de servicios en la nube ofrecida por Microsoft. Similar a Google Cloud Platform (GCP) y Amazon Web Services (AWS), Azure proporciona una amplia gama de servicios de computación en la nube, incluyendo almacenamiento, análisis, redes, bases de datos, inteligencia artificial, desarrollo de aplicaciones y más.

Algunos servicios que ofrece:

1. Azure Virtual Machines: Ofrece máquinas virtuales escalables y flexibles para ejecutar aplicaciones en la nube, con soporte para una variedad de sistemas operativos.
2. Azure Blob Storage: Proporciona almacenamiento de objetos seguro y altamente escalable para datos no estructurados, como archivos multimedia y documentos.
3. Azure SQL Database: Es un servicio de base de datos relacional completamente administrado que ofrece escalabilidad, seguridad y alta disponibilidad para aplicaciones críticas.
4. Azure App Service: Permite a los desarrolladores crear, implementar y escalar aplicaciones web y móviles de manera rápida y sencilla, sin preocuparse por la infraestructura subyacente.
5. Azure Kubernetes Service (AKS): Proporciona una plataforma de contenedores administrada basada en Kubernetes para desplegar, gestionar y escalar aplicaciones en contenedores de manera eficiente.
6. Azure Functions: Permite ejecutar código en la nube sin tener que preocuparse por la infraestructura subyacente, lo que facilita la creación de aplicaciones basadas en eventos y sin servidor.
7. Azure Cognitive Services: Ofrece una variedad de servicios de inteligencia artificial preentrenados, como reconocimiento de imágenes, procesamiento de lenguaje natural y análisis de sentimientos, para agregar funcionalidades avanzadas a las aplicaciones.
8. Azure DevOps: Proporciona herramientas para el desarrollo de software, incluyendo control de versiones, seguimiento de problemas, integración continua y entrega continua (CI/CD), para facilitar la colaboración en equipos de desarrollo.

En próximas entregas veremos más de este tema.

Enlaces:

https://azure.microsoft.com/

Regiones en C#

CSharp tiene características muy útiles para los desarrolladores .NET y en este post hablaremos de una de ellas, las regiones. La documentación oficial nos dice que las #region 

Permite especificar un bloque de código que puede expandir o contraer cuando usa la función de esquema del editor de código. En archivos de código más largos, es conveniente poder contraer u ocultar una o más regiones para que pueda concentrarse en la parte del archivo en la que está trabajando actualmente.

Un ejemplo del uso del bloque #region ... #endregion.

#region Tipos anonimos
var entero = 334;
var strNumero = "MX-34455";
var booleano = true;
var real = 123.9;
var flotante = 34.7f;
var caracter = '\u0432';
var listaEnteros = new List<int>();
#endregion

Las regiones forman parte de las directivas del pre-procesador de C#.  Otro ejemplo de estas directivas es #if ... #endif.

#if DEBUGEANDO
  Console.Title = "Debugeando el Code";
  Console.WriteLine("En modo DEBUG");
#endif

Algunos consideran que es muy útil el uso de estas directivas y otros más que es una perdida de tiempo. Que no son nada útiles. Cada quien puede dar su opinión. A mi parecer sino afecta el funcionamiento del código está bien.

 
Links:
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/preprocessor-directives/preprocessor-region
https://geeks.ms/jorge/2018/07/25/el-uso-de-regions-en-c-apesta/

Instalar paquetes Nuget con dotnet

La herramienta dotnet no sólo nos sirve para crear o ejecutar aplicaciones en lenguaje C#, también podemos usarla para agregar paquetes y listarlos.

Sintaxis:

dotnet run [-c|--configuration] [-f|--framework] [--force] [--launch-profile] [--no-build] [--no-dependencies]
    [--no-launch-profile] [--no-restore] [-p|--project] [--runtime] [-v|--verbosity] [[--] [application arguments]]
dotnet run [-h|--help]

¿Qué paquetes podemos instalar?

• Paquetes opensource y gratuitos
• Paquetes comerciales
• Nuestros propios paquetes (aunque puede haber ciertas restricciones) 

Nosotros emplearemos Nuget.

¿Qué es Nuget?
Nuget es un administrador de paquetes muy al estilo de Maven o CPAN para entornos .NET (y obvio para C#).

NuGet is the package manager for .NET. The NuGet client tools provide the ability to produce and consume packages. The NuGet Gallery is the central package repository used by all package authors and consumers.

Traduciendo tendríamos:

NuGet es el administrador de paquetes para .NET. Las herramientas de cliente de NuGet proporcionan la capacidad de producir y consumir paquetes. La Galería NuGet es el repositorio central de paquetes utilizado por todos los autores y consumidores de paquetes.

No es sorpresa para el desarrollador saber que estar peleándose con los repositorios y administración de paquetes en nuestras aplicaciones es el pan de cada día.

¿Por qué debería usar Nuget?
Simplemente porque ahorra un tiempo considerable a la hora de crear paquetes o estar buscando X o Y paquete necesarioen nuestras aplicaciones en C#. Además es la convención habitual.

Por ejemplo, quiero conectar mi aplicación a una BD hecha en MySQL  y necesito las librerías necesarias. ¿Qué debo hacer? Fácil: instalarlas usando dotnet.

Creamos directorio Codemonkey:

mkdir Codemonkey && cd Codemonkey

Creamos una aplicación de consola:

dotnet new console

Nos ubicamos en el directorio creado y procedemos a instalar las librerías o paquetes necesarios para usar MySQL.
Para instalar el paquete MySql para C# necesitamos teclear en terminal:

dotnet add package MySql.Data --version 8.0.16

Una vez instalada podemos listar los paquetes (en algunos casos se debe ejecutar con sudo):

dotnet list package

La salida será:

El proyecto "Codemonkey" tiene las referencias de paquete siguientes
   [netcoreapp2.2]: 
   Paquete de nivel superior         Solicitado   Resuelto
   > Microsoft.NETCore.App     (A)   [2.2.0, )    2.2.0   
   > MySql.Data                      8.0.16       8.0.16  

(A): paquete con referencia automática.

Siempre es bueno contar con la documentación oficial y estar al tanto de la información actual. En posteriores post veremos un ejemplo para conectarnos a una BD MySQL.

Links:
https://www.nuget.org/

Crear una aplicación web con ASP .NET

Vamos a crear nuestra primera página web con ASP.NET siguiendo los pasos de la página: https://dotnet.microsoft.com/learn/web/aspnet-hello-world-tutorial/intro

1. Creamos proyecto y nos ubicamos sobre este.

dotnet new webApp -o myWebApp --no-https
cd myWebApp

2. Tecleamos:

dotnet run

3. Abrimos nuestro navegador en http://localhost:5000/

Tenemos nuestra primera aplicación ASP .Net hecha.
Links:
http://codemonkeyjunior.blogspot.com/2019/05/c-y-net-core-en-linux-ubuntu.html

Microsoft Power Shell ... el MS-DOS mejorado

MPS (Microsoft PowerShell) 

Permite automatizar tareas, algo así como lo que puedes hacer con MS-DOS pero a un mejor nivel.  Es como tener una terminal Linux en Windows.

Algunos comandos son: get-help,get-alias,get-help-dir,ls y dir (para ver una lista de directorios/archivos), clear, date,exit, entre muchos más.

Ejemplos.

1. Usar el comando cd para colocarnos en un directorio (Documents)

PS C:\>cd ./Documents

2. Obtener servicios
PS C:\>get-service

Puedes usar los comandos MS-DOS y combinarlos con los de PS. Los archivos PS se guardan con la extensión *.ps1 



PowerShell  para novatos

0- Comentarios

<#
puedes usar
comentarios multilínea
para tus programas
#>

#comentario simple

1. Hola mundo.

1.1 Usando comillas:

"Hola mundo desde PowerShell"

1.2 Usando echo:

echo "Hola mundo desde PowerShell"

1.3 Usando Write-Host:

Write-Host "Hola mundo desde PowerShell"

2. Definir una variable y mostrarla.

$miVariable="soy una cadena"

2.1 Con write-host:

write-host $mivariable

2.2 Con echo:

echo $miVariable

2.3 Directamente

$miVariable

3. Introducir datos.

$nombre = Read-Host "Tu nombre es: "
$edad= Read-Host "¿Cuántos años tienes?"
write-host "Te llamas $nombre y tienes $edad años"

4. Operaciones básica: suma, resta , producto y división

$a=34
$b=25
$suma= $a+$b
$resta= $a-$b
$producto= $a*$b
$division= $a/$b
write "$a + $b = $suma"
write "$a - $b = $resta"
write "$a * $b = $producto"
write "$a / $b = $division"

5. Operadores aritméticos y booleanos.
-eq (==)
-ne (!=)
-gt (>)
-ge (>=)
-lt (<)
-le (<=)

-and
-or
-not


$a=99
$b=2
Write-Host "a= $a  y b= $b"
$result=($a -lt $b)
write-host "($a -lt $b): $result"
$result=($a -gt $b) -or ($b -lt $a)
write-host "($a -gt $b) -or ($b -lt $a): $result"
$result=($a -eq $a) -and ($b -lt $a)
write-host "($a -eq $b) -and ($b -lt $a): $result"

6. Crear una función.

function mensaje{
 "hola desde una función"
}

#invocar
mensaje

7. Uso de for y foreach.
$lista={3,4,4,5,6}
$plazo=9
for($i=0;$i -lt 5;$i++){
   write-host "$i"
}
write-host ""

foreach ($l in 0..$plazo){
  write-host "$l"
}

Enlaces de interés:
http://elpaladintecnologico.blogspot.mx/2009/02/que-es-powershell-ejemplos-basicos-para.html
http://www.aprendeinformaticaconmigo.com/powershell