Métodos en C# || Back to Basics

Un método, también conocido como función, es un módulo de código que nosotros como  programador podemos crear y luego llamar más adelante en el programa. Ya existen muchos métodos en lenguajes de programación como C# pero  nosotros también podemos hacer los propios. Un método generalmente realizará una única tarea. Muchos métodos pueden trabajar juntos para lograr un objetivo.

Los métodos deben tener nombres descriptivos (deben representar una acción y generalmente tienen la forma de un verbo). Los espacios no se pueden usar en nombres de métodos y siempre se debe evitar el uso de caracteres especiales, por ej. $% ^! @.

Los nombres de los métodos deben seguir una convención de nomenclatura consistente en todo nuestro código,  Entre los ejemplos de nombres de métodos adecuados se incluyen CalculateScore, AddNumbers, MultiplyNumbers, GetUserDetails, etc.

Descomponiendo la estructura de un método.

¿Qué es un modificador de acceso?

Los modificadores de acceso incluyen públicos y privados (o simplemente se dejan vacíos). Público significa que otras partes del programa pueden ver y usar este método. Si no queremos eso, usamos el modificador privado de acceso.

¿Qué es un return type?

Los métodos pueden devolver una variable al código que la llamó conocida como el tipo de devolución. Si un método devuelve un valor entero, entonces el tipo de devolución es un int y si un método devuelve un valor verdadero o falso, el tipo de devolución es un bool. Incluso si el método no devuelve ningún valor, todavía tiene un tipo de devolución. Si el método no devuelve un valor, su tipo de devolución es nulo (lo que no significa nada).

¿Qué son los parámetros?

Estas variables se conocen como parámetros. Las variables que se pasan al método se identifican en la parte lista de parámetros del método (dentro de los corchetes). Cuando especifica un parámetro, debe especificar el tipo de variable y el nombre. Si no hay parámetros, entonces los corchetes se dejan vacíos.

A continuacion un ejemplo

public static string GetFullName(string name, string lastname)
 {
   string fullname = name + lastname;
   return fullname;
 }

La palabra static significa que este método particular está asociado con la clase, no una instancia específica (objeto) de esa clase. Lo que esto significa es que puede llamar a un método estático sin crear realmente un objeto de la clase.

Muchos métodos tienen la palabra void en su declaración. La palabra void básicamente significa que el método no devolverá ningún valor a la parte del programa que lo llamó.

Usando métodos

Una vez que hayamos  creado un método, lo próximo que debemos hacer es usarlo. El uso de un método se conoce como llamar o invocar un método. Para llamar a un método que se llamó AddNames, deberíamos escribir:


AddNames();

Código de ejemplo
Aquí  un ejemplo usando parámetros y un tipo de retorno de void. El método AddNames se llama desde el método Main.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
          AddNames ("Yhorby", "Matias");
    }
    public static void AddNames (string name, string  lastname)
    {
     string fullname = name +" " + lastname;
      Console.WriteLine("El nombre completo es  " + fullname);
    }
  }
}

Esto es todo si tienes alguna pregunta no dudes en escribirme.

Microsoft Azure Storage Queues ( Colas de almacenamiento ) + C# Primera parte

Como todos sabemos Microsoft Azure ofrece un sin número de servicios  en esta entrada vamos a aprender sobre Microsoft Azure Storage Queues.

¿Que son colas?

En simples palabras es  un sistema de almacenamiento FIFO (First In First Out) donde podemos guardar mensajes que deben ser procesadas en segundo plano o en un momento concreto y diferente del proceso principal.

¿Que Ofrece Queue Storage?

Ofrece almacenamiento en cola de mensajes asincrónicos para la comunicación entre componentes de aplicaciones, que pueden estar ejecutándose en la nube, en el escritorio, en el sistema local o en dispositivos móviles.

Que necesitamos antes de empezar

  • Necesitamos una cuenta en el  Azure portal
  • Visual Studio 2015 +

Si no sabes como crear el recurso de almacenamiento en el portal de Azure les dejo este video para aprender cómo hacerlo.

¿Ahora que hago?

Para trabajar con Azure necesitamos agregar a nuestro proyecto los siguientes paquetes mediante nuget:

Microsoft Azure Storage Client Library for .NET

Microsoft Azure Configuration Manager library for .NET

El proceso se indica paso a paso en el siguiente video:

  • Si estas en Windows sigue estos pasos para agregar los paquetes de nuget a la solución

Lo siguiente que debemos hacer es configurar la cadena de conexión de nuestro desarrollo el proceso se explica en el siguiente video.

 

Una vez configurada la cadena de conexión lo que debemos de hacer es obtener la cadena de conexión de nuestro app.config en el siguiente video se muestra como.

Una vez que ya tenemos sabemos como obtener nuestra cadena de conexión vamos a crear nuestra cola para lo cual seguimos los pasos del siguiente video.

Ya que tenemos nuestra cola creada vamos a agregar un mensaje a nuestra cola, para ello seguimos los pasos del siguiente video.

Y listo eso es todo en la primera parte en una segunda parte veremos cómo enviar múltiples mensajes en la cola y a leer dichos mensajes.

Referencia —-> https://docs.microsoft.com/en-us/dotnet/api/overview/azure/storage?view=azure-dotnet

Si te gusto o tienes algún comentario no dudes en escribirme.

 

Programación Asíncrona | Trabajando con Delegados Asincronos C#

Se ha venido hablando mucho en los últimos años sobre la programación Asíncrona, ya que este esquema de programación puede mejorar mucho nuestros programas claro está si lo aplicamos correctamente.

En ocasiones nuestros programas nos dan la notificación de que el programa no responde o se congela  cuando el usuario interactúa con ellos. Esto ocurre porque hay algunas tareas pesadas que se están ejecutando detrás, y como sólo hay un hilo de ejecución,  entonces no le queda otra opción  que esperar a que termine dicha tarea para estar nuevamente disponible. Mejorar este tipo de comportamientos les da un toque de profesionalidad a nuestro trabajo algo  que siempre es importante.

En esta entrada veremos cómo aplicar la programación asíncrona usando delegados asíncronos, en otra ocasión hace tiempo escribí una entra sobre los delegados la puede leer en el siguiente enlace aquí y otro aquí.

Si con los enlaces no basta para comprender, a continuación haremos un pequeño ejemplo de cómo funcionan los delegados.

¿Qué es un Delegado?

Un delegado es la implementación de .NET de los punteros a funciones.

Ahora vamos al ejemplo “suuuuper” sencillo de un delegado.

Primero declaramos un delegado:

  delegate int delegadoProducto(int a, int b);

A continuación creamos una función con la misma estructura del delegado:

public class DelegadoProducto
    {
        public int Producto(int x, int y)
        {
            Console.WriteLine();
            Console.WriteLine("DelegadoProducto.Producto: Calculando el producto de {0} por {1}", x.ToString(), y.ToString());
            Console.WriteLine();
            return x * y;
        }
    }

Ahora instanciamos un objeto de nuestro delegado:

  public static void Main(string[] args)
        {
            // Instanciamos un delegado
            var objDelegado = new DelegadoProducto();
 
            // Asignamos el objeto recién creado a la función que creamos en la clase de apoyo
            delegadoProducto variableDelegadoProducto = new delegadoProducto(objDelegado.Producto);
 
            // Llamamos a la función a través del delegado
            var resultado = variableDelegadoProducto(4, 4);
 
            // Imprimimos el resultado de la ejecución
            Console.WriteLine("Resultado del producto es: {0}", resultado.ToString());
            Console.ReadLine();
        }

Si se fijan Sólo se puede asignar funciones a objetos que tienen la misma estructura que su delegado.

Esta es la salida de nuestro programa en consola en mi caso terminal puesto que estoy usando Mac OS.

Aplicando la programación Asíncrona a nuestros delegados.

Vamos con un ejemplo un poco más elaborado para entender mejor el concepto de llamada síncrona.

Para este ejemplo voy a usar a dos de mis amigas  Naiomi y Maria. Ellas harán un viaje hacia la ciudad de NEW YORK que demora 15 segundos aproximadamente. ( es solo un ejemplo)

El codigo el siguiente:

sing System;
using System.Diagnostics;
 
namespace ProgramacionAsincrona.Delegados
{
    class Program
    {
        delegate int DelegadoViajeNYC(string NombreViajero, Stopwatch temporizador);
 
        static void Main(string[] args)
        {
            // Se instancia un temporizador para calcular el tiempo de ejecución.
            var temporizador = Stopwatch.StartNew();
            
            // Se instancia la clase de apoyo
            var objViaje = new Viaje();
 
            // Se crea el primer delegado, que representará el primer viaje.
            DelegadoViajeNYC viajeNaiomi = new DelegadoViajeNYC(objViaje.ViajeNYC);
 
            // Se crea el segundo delegado, que representará el segundo viaje.
            DelegadoViajeNYC viajeMaria = new DelegadoViajeNYC(objViaje.ViajeNYC);
 
            // Ahora ejecutamos los delegados que harán los viajes
            viajeNaiomi("Naiomi", temporizador);
            viajeMaria("Maria", temporizador);
 
            // Hacemos una pequeña pausa y luego mostramos el mensaje de fin de viajes
            System.Threading.Thread.Sleep(1500);
            Console.WriteLine();
            Console.WriteLine("=> Finalizó las llamadas a los viajes, a los {0} segundos.", temporizador.Elapsed.TotalSeconds.ToString());
            Console.WriteLine();
 
            Console.ReadLine();
        }
    }
 
    public class Viaje
    {
        public int ViajeNYC(string NombreViajera, Stopwatch temporizador)
        {
            Console.WriteLine();
            Console.WriteLine("Inicio de viaje realizado por {0}.", NombreViajera);
            System.Threading.Thread.Sleep(15000);
            Console.WriteLine("Fin de viaje realizado por {0}, a los {1} segundos.", NombreViajera, temporizador.Elapsed.TotalSeconds.ToString());
            return 0;
        }
    }
 
}

Recapitulando

Si eres observador puedes notar que la ejecución del programa es lineal: se llama al primer viaje, cuando éste termina se llama al segundo viaje y cuando éste segundo termina se muestra el mensaje de fin de llamadas de viajes. Esto sucede porque estamos llamando a los delegados de forma síncrona, que es casi lo mismo que llamar directamente a la función. El tiempo total de ejecución de todo el programa es un poco más de 31 segundos.

Realizando llamada asíncrona a un delegado

Cambiamos las líneas 24 y 25 por llamadas asíncronas a los delegados.

            // Ahora ejecutamos los delegados que harán los viajes  (llamadas asíncronas)
            viajeNaiomi.BeginInvoke("Naiomi", temporizador, null, null);
            viajeMaria.BeginInvoke("Maria", temporizador, null, null);

Si ejecutamos nuestro codigo el resultado seria el siguiente:

El programa principal hace las llamadas (asíncronas) a los delegados y sigue su ejecución sin esperar a que estas llamadas terminen. Internamente la ejecución de dichas llamadas sucede en un hilo diferente al hilo del programa principal. Este manejo de hilos es interno, de forma transparente para nosotros.

Conclusiones

Ya puedes imaginar el potencial de esta técnica, cómo implementar este tipo de llamadas para algunos procesos que demanden muchos recursos y poder reducir los tiempos de ejecución dividiendo las tareas a través de llamadas asíncronas. Espero que la apliquen en sus próximos desarrollos.

 

 

 

 

Paso a Paso: .NET Core y Entity Framework Core

Saludos hoy quiero mostrarles como funciona net core fuera de windows yo estare usando MAC OS , pero antes debemos cumplir con una serie de prerrequisitos los cuales son:

OS Prerrequisitos
Windows Windows: Debemos .NET Core SDK for Windows o ambos Visual Studio 2015 Update 3* y .NET Core 1.0 for Visual Studio installedo.
linux, mac o docker Guia para instalar aca  .NET Core

A codear !

  • Paso 1

Abrimos la terminal y escribimos

mkdir sampleefcore
  • Paso 2

Creamos un nuevo proyecto

cd sampleefcore
dotnet new
  • Paso 3

Creamos el archivo de configuración llamado appsettings.json en el cual indicaremos la conexión a la base de datos para este ejemplo usaremos SQLite.

{
  "ConnectionStrings": {
    "Sample": "Data Source=sample.db"
  }
}
  • Paso 4

Ahora modificamos el archivo de proyecto, el cual es el project.json para agregar las dependencias EntityFrameworkCore que especificamos en el archivo appsettings.json

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true,
    "copyToOutput": {
      "include": "appsettings.json"
    }
  },
  "dependencies": {
    "Microsoft.Extensions.Configuration": "1.0.0",
    "Microsoft.Extensions.Configuration.Json": "1.0.0",
    "Microsoft.EntityFrameworkCore": "1.0.0",
    "Microsoft.EntityFrameworkCore.Sqlite": "1.0.0"
  },
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.1.0"
        }
      },
      "imports": "dnxcore50"
    }
  }
}
  • Paso 5 

Restauramos los paquetes, para ellos ejecutamos el siguiente comando.

dotnet restore
  • Paso 6

Ahora creamos el contexto de EntityFrameworkCore, para ello creamos un archivo y lo llamamos SampleContext.cs y copiamos el siguiente código:

namespace ConsoleApplication
{
    using Microsoft.EntityFrameworkCore;

    /// <summary>
    /// The entity framework context with a Venta DbSet 
    /// </summary>
    public class VentaContext : DbContext
    {
        public VentaContext(DbContextOptions<VentaContext> options)
            : base(options)
        { }

        public DbSet<Venta> Ventas { get; set; }
    }

    /// <summary>
    /// A factory to create an instance of the VentaContext 
    /// </summary>
    public static class VentaContextFactory
    {
        public static VentaContext Create(string connectionString)
        {
            var optionsBuilder = new DbContextOptionsBuilder<VentaContext>();
            optionsBuilder.UseSqlite(connectionString);

            var context = new VentaContext(optionsBuilder.Options);
            context.Database.EnsureCreated();

            return context;
        }
    }

/// <summary>
    /// /// A simple class representing a Venta
    /// </summary>
    public class Venta
    {
        public Venta()
        {
        }

        public int Id { get; set; }

        public string Producto { get; set; }

        public string Caracteristic { get; set; }
    }
}
  • Paso 7

Modificamos el Program.cs con el siguiente código

namespace ConsoleApplication
{
    using System;
    using Microsoft.Extensions.Configuration;

    public class Program
    {
        public static void Main(string[] args)
        {
            // Enable to app to read json setting files
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);

            var configuration = builder.Build();

            // Get the connection string
            string connectionString = configuration.GetConnectionString("Sample");

            // Create a Venta instance
            var user = new Venta() { Producto = "Soda", Caracteristic = "Pepsi" };

            // Add and Save the Venta in the database
            using (var context = VentaContextFactory.Create(connectionString))
            {
                context.Add(user);
                context.SaveChanges();
            }

            Console.WriteLine($"Product was saved in the database with id: {user.Id}");
        }
    }
}
  • Paso 8

Compilamos nuestra aplicación con el siguiente comando

dotnet build
  • Paso 9

Si todo está bien estamos listos para correr nuestra aplicación.

dotnet run

Fin

Ahora aqui les dejare un pequeño video de como funciona  la aplicación.

Subete a la nube con los #AzureSkills!

Saludos es hora de aprender Azure y gratis, desarrolla habilidades que te brinden mejores oportunidades laborales y la posibilidad de acceder a salarios más altos de manera flexible y a tu propio ritmo.

Casi el 80% de las empresas ya utilizan la tecnología en la nube. ¡Es el momento perfecto para adquirir habilidades de #AzureSkills y transformarte en el protagonista de la 4ta revolución industrial! Regístrate ahora y entrénate con los cursos gratuitos en línea: https://aka.ms/azureskillsdx

Xamarin y otras especias | Charla

Saludos mi buen amigo Cristopher Junior Vivieca Ramos de  viviecar.com me invito a dar una charla en el Instituto Politécnico Padre Segri en Santiago, Rep. Dominicana. donde estuve hablando sobre “Xamarin y otras especias”

Fotos del evento.

Presentación del evento.

Te gustaria que sea ponente en alguna charla ?

Si te gustaria que diera una charla sobre el mismo tema o otras tecnologías Microsoft no dudes en ponerte en contacto conmigo.

Bug DisplayAlert Xamarin.Forms

Solución para Bug DisplayAlert Xamarin.Forms

Disclaimer: Si alguno considera que no es un bug y es mas una mala práctica por parte de algunos developers dejo aca el link del bug aca.

Bug

Este sucede cuando implementamos DisplayAlert  en Xamarin.Forms  se traduce en dos ventanas emergentes, lo que obviamente no se espera, y este es el bug.

Estoy hablando de este bloque de código:

var resp = await DisplayAlert("","Seguro quieres salir?","Si", "No");
if (resp)
{ 
   //Hacer algo
}

Solucion

Lo que debemos hacer es  invocar el Display Alert  en el hilo de interfaz de usuario principal usando Xamarin.Forms.Device.BeginInvokeOnMainThread. Tenemos que pasar la acción que  ejecutará el DisplayAlert al hilo principal de la UI:

Device.BeginInvokeOnMainThread(new Action(async () =>
  {
       if(await DisplayAlert("", "Seguro quieres salir?", "Si", "No"))
       {
         //Hacer algo
       }
  }));

Que hace la solución?

Esto soluciona el problema, porque ahora estamos invocando el hilo principal de la interfaz de usuario. Nuestra DisplayAlert ahora se ejecuta solo una vez. Así que, sí, por ahora, podemos utilizar esta solución.

Sin embargo, es de esperar, que corrijan el error, por lo que sólo pueden ejecutar sin el método BeginInvokeOnMainThread. Espero que esto les puede ayudar con su desarrollos.

Si tienen algo que añadir, dudas comentarios no duden en escribirme.

Documentacion: https://developer.xamarin.com/api/member/Xamarin.Forms.Device.BeginInvokeOnMainThread/p/System.Action