How can I be a programmer?

1. Think, act later.

You can not wear your shoes before your socks. You must think about the problem
to solve.

2. There are always things you could learn.

There are many programming languages, tools, techniques, skills and strategies
that can always help you.

3. To study is to observe, to learn is to practice.

REPORT THIS AD

Observe how it works, learn how you can do it. Practice every day.

4. Choose your time.

One day, two days, three days … one weekend. Have a work plan.

5. First create steps, then create the code.

Go back to the first step. You can not wear your shoes before your socks. You
must think about the problem to solve.

6. Learn, teach, share.

The magician did not become a magician without having suffered in the process.
Do not be selfish, share your knowledge.

7. Create a code bunker.

Keep your knowledge and allow others to learn from it.
8. Leave the arrogance, ask and ask for help.
Nobody knows everything and nobody knows little to learn from him.

9. Help someone else.

If you can help, help.

10. Keep learning.

Keep learning, nobody knows everything.

C# y .Net Core en Linux Ubuntu

¿Cómo instalamos .NET Core en Linux (Ubuntu)?
1. Registramos la llave de Microsoft en nuestro sistema:
wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-
microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
2. Desde terminal instalamos el núcleo:
sudo add-apt-repository universe
sudo apt-get install apt-transport-https
sudo apt-get update
sudo apt-get install dotnet-sdk-2.2
3. Creamos un directorio y nos ubicamos en el. Si tenemos Visual Studio podemos abrir el
directotio directamente:
$ mkdir proyecto
$ cd proyecto
#Abrir Visual Studio Code
$ code .
4. Creamos proyecto:
#Crear proyecto
$dotnet new console

Creará un programa (Program.cs) y los archivos necesarios para compilar y ejecutarlo.

Program.cs

using System;

namespace proyecto
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Programando en C#");
}
}
}
5. Compilar y ejecutar:

#Listar ayuda
$ dotnet help

#Compilar y ejecutar:
$ dotnet run

Nota: Todo lo anterior también sirve si usas Windows o Mac.

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/

Visualizar variables de un archivo de configuración en proyecto

web ASP .Net

En este post veremos cómo visualizar las variables de un archivo de configuración (en formato
JSON) de de una aplicación web sencilla ASP .NET.

En el anterior post vimos cómo crear un proyecto.

dotnet new webApp -o miwebapp --no-https

cd miwebapp

Creamos dos páginas *.cshtml, amas con nombre Index.cshtml, una de ellas dentro de un
directorio llamado Solange.

 Index.cshtml
 Solange/Index.cshtml

Nuestro directorio:

Nuestro archivo JSON se verá así:

appsettings.json

{
"Logging": {
"LogLevel": {
"Default": "Warning"
}
},
"AllowedHosts": "*",
"Message": "Aqui un saludo desde el archivo de configuracion",
"Email": "[email protected]",
"Author":"Codemonkey Junior",
"NumberOfPostOnHomePage": 10,
"ShowAdsOnHomePage": true,
"PageSize": 10
}

Nuestras páginas *.cshtml:

Index.cshtml
@page
@using Microsoft.Extensions.Configuration
@inject IConfiguration Configuration
<h1 align='center'>Hola, <font color='green'>amigo</font>.</h1>
<p align='center'><b>Estás en la página principal.</b></p>
<p>El curso inicia en <b>@DateTime.Now</b> </p>

<h2>@Configuration["Message"]</h2>
<h2>@Configuration["Author"]</h2>
<h2>@Configuration["Email"]</h2>

<p>Expresiones:</p>
@{
var booleano = 50 > 100;
var operacion = 9+3;
}
<p>50 > 100 es @booleano</p>
<p>9 + 3 es @operacion</p>

Solange/Index.cshtml
@page

<h1>Hola, está página está solita.</h1>

<p>Su ubicación está en /Solange</p>

Ahora nuestras clases principales: Startup.cs y Program.cs Startup.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;

namespace miwebapp
{
public class Startup
{
public IConfiguration Configurations{ get; set; }

public Startup(IConfiguration config)

{
Configurations = config;
}

public void ConfigureServices(IServiceCollection services)

{
services.AddMvc();
}

// This method gets called by the runtime. Use this method to

configure the HTTP request pipeline.
 public void Configure(IApplicationBuilder app,
IHostingEnvironment env)
{

if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}

app.UseMvc();

app.Run(async (context) =>

{
await context.Response.WriteAsync("<h1 align
='center'>Programando en <font color='blue'>C#</font> como si fuera en
primero.</h1><hr/>");
});

}
}
}

Program.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace miwebapp
{
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine("Programando en C#");
CreateWebHostBuilder(args).Build().Run();
}

public static IWebHostBuilder CreateWebHostBuilder(string[] args)

=>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>();
}
}

Desde la terminal tecleamos:

dotnet run
Abrimos el navegador en http://localhost:5000

Al abrir http://localhost:5000/Solange obtendremos:

Como hemos visto en anteriores posts crear aplicaciones con C# es muy sencillo. En está ocasión
crearemos un programa que calcule el valor futuro y rédito de una cantidad a una tasa y periodos
definidos.

Necesitaremos:

 Crear una clase llamada Economica.cs

 Una clase principal (Program.cs)
¿Cómo obtenemos los cálculos de valor futuro y rédito?

valor_futuro = valor_presente * pow(1+tasa/100, periodo);

redito = (valor_futuro - valor_presente) / valor_presente;

La clase Economica.cs tendrá tres atributos:

 presente (valor presente)

 tasa (tasa de inversión)
 periodo (periodo de inversión)
Además tendrá dos métodos para calcular valor futuro y rédito
Economica.cs
using System;

namespace clases
{
public class Economica
{
private double presente;
private double tasa;
private int periodo;

public Economica()
{
Console.WriteLine("Objeto Economica creado e inicializado");
}

public Economica(double presente, double tasa, int periodo)

{
this.Presente = presente;
this.Tasa = tasa;
this.Periodo= periodo;
}

public double Presente

{
get; set;
}

public double Tasa

{
get; set;
}

public int Periodo

{
get;set;
}

public double Futuro()

{
return this.Presente * Math.Pow(1+this.Tasa/100,this.Periodo);
 }

public double Redito()

{
return (this.Futuro()-this.Presente)/this.Presente;
}

public override string ToString(){

return string.Format("Economica( presente = {0} , tasa = {1} , periodo
= {2})", this.presente,this.tasa, this.periodo);
}

}
}

Dentro de esta clase principal se creará una lista de tipo Economica:

//Necesitamos para emplear List

using System.Collections.Generic;

//...

List<Economica> listaEconomica = new List<Economica>();

Agregaremos objetos tipo Economica:

listaEconomica.Add(new Economica(2400,5,12));
listaEconomica.Add(new Economica(2800,6,8));
listaEconomica.Add(new Economica(2100,5,10));
listaEconomica.Add(new Economica(1930,10,7));
listaEconomica.Add(new Economica(3400,2,12));

Para recorrer la lista (y mostrar los resultados) emplearemos el método ForEach:

listaEconomica.ForEach(eco =>
{
Console.WriteLine("Presente = {0}, Tasa = {1} , Periodo =
{2}",eco.Presente, eco.Tasa, eco.Periodo);
Console.WriteLine("Futuro = {0} , Tasa =
{1}",eco.Futuro(),eco.Redito());
Console.WriteLine("--------------------------------------
----");
});

Program.cs
using System;
using System.Collections.Generic;
using clases;

namespace proyecto
{
class Program
{
 static void Main(string[] args)
{
List<Economica> listaEconomica = new List<Economica>();
listaEconomica.Add(new Economica(2400,5,12));
listaEconomica.Add(new Economica(2800,6,8));
listaEconomica.Add(new Economica(2100,5,10));
listaEconomica.Add(new Economica(1930,10,7));
listaEconomica.Add(new Economica(3400,2,12));
listaEconomica.ForEach(eco =>
{
Console.WriteLine("Presente = {0}, Tasa = {1} , Periodo =
{2}",eco.Presente, eco.Tasa, eco.Periodo);
Console.WriteLine("Futuro = {0} , Tasa =
{1}",eco.Futuro(),eco.Redito());
Console.WriteLine("--------------------------------------
----");
});
}

}
}

Podemos ejecutarlo desde terminal:

dotnet run

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:

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/