Estado de .Net para el 2018

diciembre 6, 2017 1 comentario

Nota importante este articulo esta basado en el articulo publicado por Telerik “The State of .NET in 2018” 

La siguiente gráfica podemos observar el estado  de las tecnologías, plataformas y herramientas de desarrollo que tenemos a disposición en .Net y que tendremos para el próximo año:

2017-12-05_1658

Como vemos en la gráfica tenemos 3 grandes bloques para construir aplicaciones basadas en las .NET Standard library  las librerías base con todos los componentes de .Net, y en herramientas ahora con aclamado Visual Code multiplaforma que se ha convertido en el favorito de los desarrolladores.

.Net Standard Library juega un papel muy importante en el presente y futuro de .net ya que este evita que se genere la fragmentación que se tenia por las diferentes plataformas, especialmente por la ultima que adquirida por Microsoft que fue Xamarin.

2017-12-05_1708

La Standard Library es la librería base de todos los proyectos en .Net independiente de la plataforma utilizada y estas se complementan usando Nugets y librerías especificas para cada una. 2017-12-05_1715

El gráfica anterior podemos ver las diferentes versiones de .Net Standard y  la compatibilidad con las diferentes versiones de cada una de las plataformas existentes, como podemos ver UWP no tiene soporte aun pero se espera que pronto lo tenga.

.Net Core 2.0 ultima versión lanzada de esta plataforma tiene muchas mejoras de compatibilidad con respecto a las APIs que solíamos usar en .Net Framework,  de momento solo 43 APIs no están soportadas en .NET core así que la posibilidad de migrarse se facilita mucho:

2017-12-05_1745

XAML es utilizado en tecnologias Microsoft para el diseño de interfaces en WPF, UWP y Xamarin sin embargo tiene un fragmentación latente en cada una de ellas por ejemplo podemos ver en UWP vs Xamarin lo siguiente:

UWP              -      Xamarin

StackPanel      vs     StackLayout

TextBlock        vs      Label

Esto provoca que se haga dificil reutilizar este código de lado a lado de manera fácil.

XAML Standard llega como la solución a este problema como una especificación única para todas tecnologías que usen XAML

Aun no se tiene una fecha exacta de la primera versión de XAML  Standard pero ya se tienen los repositorios para tal fin  https://github.com/Microsoft/xaml-standard

Angular y React ahora son mas fáciles de utilizar para los .Net developers puesto que con .Net core tenemos 2 templetes que nos permiten utilizar un proyecto base conectado directamente a un Web Api. Tenemos las opciones de Angular, React.js y React.Js and Redux

2017-12-06_1515

Un C# fortalecido en las versiones 7.X y una futura versión 8.0.  Este lenguaje de programación sigue creciendo con nuevas funcionalidades que ya tienen algunos otros lenguajes y alejándose de estigma de ser una copia barata de Java

En el siguiente link puedes encontrar un post anterior con todos los cambios de C#:

https://mteheran.wordpress.com/2017/12/01/features-c-7-0-7-1-7-2/

 

UWP ha logrado unificar todos los dispositivos Microsoft en torno a un único sistema operativo que es Windows 10. Obviamente las capacidades de un dispositivo de Iot son diferentes a las de un PC o Xbox pero afortunadamente con las Extensions SDK podemos extender las funcionalidades de la App que estemos desarrollando para cada uno de las plataformas.

2017-12-06_1541

 

La conclusión al final es que se pinta un 2018 con muchas cosas interesantes por de Microsoft y sus tecnologías. Y si a todo esto agregamos los servicios de Azure tenemos todo un ecosistema robusto para trabajar con nuestras aplicaciones incluyendo tecnologías no creadas por Microsoft.

Sin embargo para todos los developers se hace necesario estar actualizado de los cambios que se presentan y empezar ha utilizar tecnologías como .Net Core desde este momento para sacarle provecho.

 

Anuncios

XML The complete guide

diciembre 4, 2017 Deja un comentario

Tips (Consejos y trucos en visual studio)

diciembre 31, 2017 Deja un comentario

Cuando se usa Super() y Super(props) en React.js

diciembre 31, 2017 Deja un comentario

Cuando trabajamos con React.js  muchas veces tenemos errores en el contructor por no declarar el método  Super  vamos a ver algunos ejemplo de cuando es necesario:

class MyComponent extends Component {
    constructor(){
        super();
        this.state = {
            name: ''; 
        };
    }
    render () {
        return (
            <p> Name: { this.state.name }</p>
        );
    }
}

Para el caso anterior es necesario usar Super para poder usar la clausula “this” dentro del constructor y definir la variable de estado name.

Si suponemos que el valor viene en una propiedad recibida desde el componente padre tendríamos el siguiente código:

class MyComponent extends Component {
    constructor(props){
        super(props);
        this.state = {
            name: this.props.name; 
        };
    }
    render () {
        return (
            <p> Name: { this.state.name }</p>
        );
    }
}

Para este ultimo caso es necesario pasar por el método Super las props que se están recibiendo pues si esta linea no existe tendremos una excepción.

Para resumir:

Super -> habilita this dentro del constructor del componente

Super(props) -> habilita this.props dentro del constructor  del componente

Jenkins con .Net – guía completa

diciembre 30, 2017 Deja un comentario

Jenkins es un servidor opensource de integración y automatización hecho en java que soporta Java, Node.js y .Net entre otros.

En esta guía vamos a ver como configurar desde 0 Jenkins para .Net

Primero vamos a ir a la pagina de Jenkins realizar la descarga para windows y seguir el paso a paso

https://jenkins.io/download/

1

2

3

4

En este punto debería aparecer una nueva ventana en el navegador en http://localhost:8080/,  si al principio no carga no te preocupes espera un minuto y vuelve a recargar que seguro se esta levantando el servicio.

5

Para iniciar Jenkins nos pide una contraseña que se encuentra en la ruta indicada en rojo solo es copiar y pegarla.6

Al instalar podemos seleccionar la opción personalizada para seleccionar el plug-in MSBuild inmediatamente.

7

8

Creamos el primer usuario admin con los datos requeridos.

9

Después de completar la instalación así luce la aplicación la primera vez que entramos, los Jobs van hacer las herramientas que vamos a utilizar para automatizar un proceso

10

Debemos inmediatamente ir “Manage Jenkins” a configurar nuestro plugin MSBuild, ingresamos la ruta donde se encuentra el .exe de MSBuild.

MsbuildConfig.png

Debemos llenar los campos “Project name” y dentro de “Source Code Management”, Repository URL y luego en la seccion Build debemos usar la opcion Ad Build Step y agregar 2:

MsbuildConfigProject.png

Primero debemos ejecutar el Batch para restaurar los paquetes de la aplicación, este es un ejemplo con mi proyecto que se llama “WebApiDemoJenkins” es necesario descargar Nuget.exe

https://www.nuget.org/downloads

En mi caso lo tengo almacenado en la carpeta “C:\Users\MTEHERAN\Downloads”

Y lanzo el comando restore para restaurar los paquetes en el proyecto y el proyecto de pruebas relacionado

cd "%WORKSPACE%\WebApiDemoJenkins\"
C:\Users\MTEHERAN\Downloads\nuget.exe restore "%WORKSPACE%\WebApiDemoJenkins\WebApiDemoJenkins.csproj" -PackagesDirectory ..\packages
C:\Users\MTEHERAN\Downloads\nuget.exe restore "%WORKSPACE%\WebApiDemoJenkins.Tests\WebApiDemoJenkins.Tests.csproj" -PackagesDirectory ..\packages

En la sección de Build a Visual Studio project solo seleccionamos la versión de Build que configuramos previamente, debe quedarnos algo como esto:

MsbuildConfigProject2.png

Luego podemos ir al proyecto y ejecutar el build, si este es exitoso nos va marcar un icono azul, sino se verá un icono Rojo donde podemos dar click para ver el detalle de la ejecución

projectBuild.png

Para la pruebas Automatizadas vamos a usar el plugin MSTestRunner plugin

vamos a “Manage Jenkins” -> “Manage Plugins” y vamos buscar e instalar MSTestRunner

Debemos reiniciar el servicio de Jenkis y luego de esto y vamos directo a “Global Tool” para configurar el Plugin

MSTestGuide

Editamos el proyecto y agregamos en la sección de build una sección para la ejecución de las pruebas

MSTestGuide2

En este caso no podemos usar la variable de entorno %WORKSPACE% debemos usar la ruta completa, es una buena practica cambiar la ruta del workspace a una por fuera de Program Files. El archivo Output.trx veremos el resultado de la ejecución de las pruebas

Podemos ejecutar de nuevo el “Build now” y debería compilar el proyecto y las pruebas

.Net Core

.Net core se facilitan las cosas puesto que a través de comandos podemos restaurar los paquetes y compilar solo teniendo instalado .net, entonces en Jenkins agregamos un build con Add Build Step “Execute windows batch”

cd "%WORKSPACE%\WebApiCore\"
dotnet restore
dotnet build --configuration "Release"

netcoreJenkins.png

Ejemplo del resultado que veremos:

Testcore

Mejoras en C# 6

diciembre 23, 2017 Deja un comentario

C# 6 aparece en julio del 2015 junto con Visual studio 2015 con muchas mejoras significativas que vale la pena revisar y poner en practica

Inicializar propiedades automáticamente

Podemos después de crear un propiedad dentro de una clase asignar un valor, muy util por ejemplo para clases estáticas:

public string MyVar { get; set; } = "Hello World"; //Auto Property Initializer

 

Operador Null

Usando el símbolo la interrogación  ?  podemos peguntar si una propiedad es nula

DateTime? datetime = new DateTime();

var YearOfDate = datetime?.Year; //using ? asking if the value is null

Console.WriteLine(YearOfDate);

var YearOfDateConditional = datetime?.Year ?? 0; //using ? asking if the value is null and if the property Year is null returning 0

 

Interpolación de cadenas 

Podemos fácilmente vincular variables dentro de un string así como también llamados a métodos

Console.WriteLine("----------------------String Interpolation -----------------");

var years = $"YearOfDate:{YearOfDate} - YearOfDateConditional:{YearOfDateConditional}"; //adding vars on the string easily

Console.WriteLine(years);

 

Funciones y propiedades como expresiones

Con esta mejora podemos utilizar expresiones para representar el valor de una propiedad o también el cuerpo de un método:

public string MyVarExpresion => string.Format("Hello World at:{0}", DateTime.Now);
 //Expression-Bodied Function
 public int Sum2Numbers(int x, int y) => (x + y);

 

using static

Using static permite colocar la referencia de una clase como estática para no tener que indicar el namespace de donde proviene en cada llamado

using static System.Console; // using static 

WriteLine("-----------------------------------------------------------");

 

Operador await en catch y finally 

ya es posible utilizar el operador Await dentro de un bloque catch y finally

public async Task AnyMethod()
 {
 try
 {

}
 catch (Exception)
 {

await CatchMethod(); 
 }
 }

private async Task CatchMethod()
 {
 WriteLine("Exception occured");
 }

 

Filtros o condiciones en excepciones

Ahora usando la clausula “when” podemos realizar un condicional o filtro de la declaración de una excepción por ejemplo:

catch (Exception ex) when (ex.Message.Contains("Something"))
 {

await CatchMethod(); 
 }

 

El mejor articulo que he leído para entender todas las mejoras se encuentra en esta pagina incluye algunos vídeos también:

http://www.sharepointcafe.net/2017/09/csharp-6-new-features.html

Todos los demos incluyendo C# 6, 7, 7.1  se encuentran en el siguiente repositorio:

https://github.com/Mteheran/CSharpVersionsDemos

Recuerda revisar también el articulo con las mejoras de 7.0, 7.1 y 7.2

Features C# 7.0, 7.1, 7.2

Introducción a ITIL

diciembre 23, 2017 Deja un comentario

BenchmarkDotNet librería opensource para benchmarking en .Net

diciembre 22, 2017 Deja un comentario

BenchMark en computación se conoce como el acto o proceso para evaluar o realizar auditoria sobre diferentes componentes de la aplicación, como por ejemplo métodos y funciones en el concepto de programación orientada a objetos.

BenchmarkDotNet es un proyecto opensource para .net diseñado para este proceso y facilitar cada una de las pruebas que deseemos hacer.

con banchMarkDotnet tenemos las siguientes ventajas

  • Rutina estándar de  benchmarking: generando un caso aislado en cada proyecto por cada método; auto-selección de la cantidad de iteraciones  y calculo de estadísticas.
  • Soporte de frameworks: Full .NET Framework (4.6+), .NET Core (1.1+), Mono
  • Soporte de lenguajes: C#, F#, and Visual Basic
  • Sistemas operativos : Windows, Linux, MacOS
  • Fácil comparación de ambientes  (x86 vs x64LegacyJit vs RyuJit, and so on; see: Jobs)
  • Reportes: markdown, csv, html, json, xml, plain text and png plots

Toda la documentación del proyecto se encuentra en su pagina oficial  http://benchmarkdotnet.org/index.htm

Para usar BenchMarkDotnet solo tenemos que instalar el nuget correspondiente en el proyecto en que estemos y con eso podemos empezar a utilizarlo facilmente

Benchmark1

El siguiente código muestra un ejemplo sencillo usando BrenchMark en una aplicación de consola de netcore, como vemos lo único que debemos hacer es usar la marca [Benchmark]  sobre el método que queremos  auditar y dentro de la aplicación  utilizamos  BenchmarkRunner.Run();  no tenemos que hacer impresión directamente en consola (osea usar Console.WriteLine), muy importa tener en cuenta que la aplicación debe esta en modo Release

namespace BenchMarkDotnetDemo
{
 class Program
 { 
    static void Main(string[] args)
   {
      var summary = BenchmarkRunner.Run();

      Console.ReadLine();
   }
 }

   public class RandomCustom
   {
    int getRandom()
    {
     int inRandom = 0;
     for (int i = 0; i < 10000; i++)
     {
      inRandom = new Random().Next(i);
     }

     return inRandom;
    }

    [Benchmark]
    public int GetintRandom() => getRandom();
  }
}

vemos el siguiente resultado en la consola con los datos obtenidos

Benchmark2

Dentro del proyecto podemos encontrar también una carpeta llamada BenchmarkDotNet.Artifacts donde se almacenan los resultados

 

Benchmark3

 

Fácilmente con un Tag dentro de la clase podemos indicar en que frameworks se llevará acabo las pruebas:

[ClrJob, CoreJob, MonoJob]  // used to specify the system core (CoreJob), Mono (MonoJob) and dotnet classic (ClrJob)

Usando [AnyCategoriesFilter(“Run”)] podemos filtrar los métodos antes de la ejecución.

Podemos indicar que un atributo será un parámetro y los valores con los que deseamos hacer las pruebas [Params(50, 1000,50000,1000000)]

Muchas otras configuraciones adicionales se pueden hacer y se encuentran dentro de la documentación de BenchmarkDotNet

El siguiente es un ejemplo mas completo usando las opciones antes mencionadas

class Program
 { 
 static void Main(string[] args)
 {
 var summary = BenchmarkRunner.Run<RandomCustom>();

Console.ReadLine();
 }
 }

[CoreJob] // used to specify the system core (CoreJob), Mono (MonoJob) and dotnet classic (ClrJob)
 [AnyCategoriesFilter("Run")] //execute all method with mark NoRun
 public class RandomCustom
 {
 [Params(50, 1000,50000,1000000)]
 public int intlong { get; set; }

int getRandom()
 {
 int inRandom = 0;
 for (int i = 0; i < intlong; i++)
 {
 inRandom = new Random().Next(i);
 }

return inRandom;
 }

[Benchmark]
 [BenchmarkCategory("Run")]
 public int GetintRandom() => getRandom();

[Benchmark]
 [BenchmarkCategory("NoRun")]
 public int GetintRandom2() => (getRandom() *2);
 }

 

podemos ver los resultados con cada una de los valores del parámetro

Benchmark4

 

Código Fuente:

https://github.com/Mteheran/BenchMarkDemo

Cambios en tiempo real en .Net Core

diciembre 21, 2017 Deja un comentario

En .net core sabemos que usando el comando donet run podemos ejecutar la aplicación sea WebApi o sitio Web pero si realizamos cambios debemos detener el proceso y volverlo a ejecutar. Para evitar hacer esto y poder hacer cambios en tiempo real podemos agregar el componente Watch a nuestra solución

Abrimos el archivo *.csproj y agregamos el siguiente ItemGroup:

<ItemGroup>

<DotNetCliToolReferenceInclude="Microsoft.DotNet.Watcher.Tools"Version="2.0.0"/>

</ItemGroup>

Después de agregar ese nuevo nuget debemos usar dotnet restore para resturar los paquetes y finalmente usando “Dotnet Watch Run” vamos a ver los cambios en tiempo real solo con refrescar el sitio o la Api

2017-12-21_1810