Archivo

Archive for the ‘C#’ Category

BenchMark: Performance Analysis

Anuncios

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

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

 

 

 

Features C# 7.0, 7.1, 7.2

diciembre 1, 2017 3 comentarios

Métodos útiles en Enumerable

noviembre 26, 2017 Deja un comentario

Enumerable es una clase en .Net que hace parte del paquete o namespace de Linq ( System.Linq) y que ofrece métodos muy útiles para el manejo de colecciones y listas, que en ciertas ocasiones dejamos pasar o no los usamos adecuadamente.

Supongamos que tenemos la siguiente lista para el ejemplo:

 List<Movie> lmovies = new List<Movie>();
 lmovies.Add(new Movie() { Tittle = "Titanic", Genre = "Drama", Year = 1998 });
 lmovies.Add(new Movie() { Tittle = "Avengers", Genre = "Action", Year = 2012 });
 lmovies.Add(new Movie() { Tittle = "Annabelle", Genre = "Terror", Year = 2014 });

Max

el método Max permite encontrar el máximo de una lista de registro de cualquier tipo numérico (decimal, float, int etc…)

 //Get the max value on the list by a numeric field
 var maxmovie = Enumerable.Max<Movie>(lmovies, c => c.Year);
 Console.WriteLine("Demo Max");
 Console.WriteLine(maxmovie); //Result 2014

Min

el método Min permite encontrar el mínimo de una lista de registro de cualquier tipo numérico (decimal, float, int etc…)

 //Get the min value on the list by a numeric field
 var minmovie = Enumerable.Min<Movie>(lmovies, c => c.Year);
 Console.WriteLine("Demo Min");
 Console.WriteLine(minmovie); //result 1988

Repeat 

Repeat nos permite crear una copia de cualquier tipo de dato que le digamos, facilitandonos el proceso de pruebas.

// create N numbers of copy of an object 
 var listmovies = Enumerable.Repeat<Movie>(new Movie() { Tittle = "Movie Example" }, 5);
 Console.WriteLine("Demo Repeat");
 
 foreach (var item in listmovies)
 {
 Console.WriteLine(item.Tittle); 
 }

 

Sum

El método Sum permite sumer todos los datos de una colección de tipo numérico

 // sum a collections of numbers on a field
 var sumMovie = Enumerable.Sum<Movie>(lmovies, c => c.Year);
 Console.WriteLine("Demo Sum");
 Console.WriteLine(sumMovie);

 

Concat

Permite funcionar o concatenar 2 listas en una sola, es una opción muy útil ya que podemos omitir hacer ciclos e insertar los datos uno a uno.

// mix 2 colecction of the same type in only one collection 
 var lstconcat = Enumerable.Concat<Movie>(lmovies, listmovies);
 Console.WriteLine("Demo Concat");

foreach (var item in lstconcat) 
 Console.WriteLine(item.Tittle);

Average

Calcula un promedio de una lista de datos numéricos

// caculate an average from a collection of numbers
 var averageMovie = Enumerable.Average<Movie>(lmovies, c => c.Year);
 Console.WriteLine("Demo Average");
 Console.WriteLine(averageMovie);

Except

Permite devolver una lista omitiendo una lista de elementos contenidos en una segunda lista

 //return a list except the elements on the exception
 var lstExcept = Enumerable.Except<Movie>(lstconcat, listmovies);
 Console.WriteLine("Demo Except");
 foreach (var item in lstExcept)
 Console.WriteLine(item.Tittle);

 

La lista completa de métodos esta en a documentación oficial de microsoft

https://msdn.microsoft.com/en-us/library/system.linq.enumerable_methods(v=vs.110).aspx

 

DEMOS:

https://github.com/Mteheran/EnumerableDemos

Linq bases y ejemplos

noviembre 22, 2017 Deja un comentario