Tecnocrata

Como saber si estoy conectado a Internet desde Windows Phone

Un requisito importante para poder brindarle al usuario de Windows Phone, una experiencia agradable, es determinar si su dispositivo esta conectado o no a Internet, hay variados articulos en la red que pueden probar, uno de ellos es este que incluso viene acompanado de un proyecto, es un ejemplo utilizado por Nokia, lamentablemente no funciona o al menos no pude hacer que funcione correctamente y si observan el codigo es bastante ‘elaborado’ para una tarea que es bastante sencilla.

Entonces decidi usar mi propia aproximacion, debo decir que en mi aplicacion actualmente publicada en internet usa la version de codigo que mostrare mas adelante, por lo que puedo garantizar con certeza de que si funciona, ademas de que este articulo es una continuacion prometida de un articulo anterior, en el que explico como detectar internet en aplicaciones Windows y Web.

La idea se centra nuevamente en usar el NCSI de Microsoft, para la tarea y el codigo es el siguiente:

public void IsNCSIConnected(Action<bool> connected)
{
    try
    {
        var x = (HttpWebRequest)WebRequest.Create("http://www.msftncsi.com/ncsi.txt");
        x.BeginGetResponse((resp) =>
                               {
                                   try
                                   {
                                       var response = (HttpWebResponse) x.EndGetResponse(resp);
                                       connected(response.StatusCode == HttpStatusCode.OK);
                                   }
                                   catch
                                   {
                                       connected(false);
                                   }
                               }, null);
    }
    catch (Exception)
    {
        connected(false);
    }
}

Como pueden observar el codigo se basa en la utilizacion de un Delegado Action que devolvera el estado de la conexion. Este metodo me resulto muy util pero se complica cuando manejamos escenarios asincronos, porque quierase o no, bloqueara el hilo de ejecucion de la UI. Entonces pense en una variante mas ‘interesante’.

public async Task<bool> IsNCSIConnected()
{
    var req = (HttpWebRequest)HttpWebRequest.Create("http://www.msftncsi.com/ncsi.txt");
    Task<HttpWebResponse> requestTask = Task.Factory.FromAsync(
        req.BeginGetResponse, result =>
                                  {
                                      try
                                      {
                                          return (HttpWebResponse) req.EndGetResponse(result);
                                      }
                                      catch (Exception)
                                      {

                                          return null;
                                      }
                                      
                                  },
        TaskCreationOptions.None);

    return await requestTask.ContinueWith(responseTask =>
                                                           {
                                                               if (responseTask.Result == null) return false;
                                                               return responseTask.Result.StatusCode ==
                                                                      HttpStatusCode.OK;
                                                           });
}

El codigo puede parecer algo mas complicado, sin embargo la utilizacion es mucho mas simple.

Un Saludo

Posted: 19/8/2013 1:09 por Enrique Ortuño | con no comments
Archivado en: ,
Usando await en un metodo NO asincrono

He recibido varias preguntas relacionadas a este tema, especialmente desde que se popularizo el uso de await y async, muchas personas creen que es algun tipo de caracteristica ‘magica’, cuando en realidad es una consecuencia logica de varias caracteristicas introducidas en la version 4.o del .NET Framework, especialmente de la clase Task. Una duda recurrente es: Como usar await con un metodo NO asincrono.

Supongamos que disponemos de un metodo NO asincrono como el siguiente, que realiza un proceso que puede bloquear el hilo de la interface de usuario, en caso de llamarse desde ahi.

        /// <summary>
        /// This is a blocking call
        /// </summary>
        /// <returns></returns>
        private NetworkInterfaceType GetNetworkInterfaceType()
        {
            var interfaceType = NetworkInterface.NetworkInterfaceType;
            return interfaceType;
        }

Puede haber muchas soluciones, pero la mas simple que puedo recomendar, no necesariamente la mejor es usar el siguiente codigo:

    var interfaceType =await Task.Run(()=>{returnGetNetworkInterfaceType(); });

Obviamente el metodo donde se introduzca la anterior linea, necesariamente debe tener la palabra reservada async.

Un saludo.

Posted: 25/7/2013 1:19 por Enrique Ortuño | con no comments
Archivado en: ,
Descargar una imagen y codificarla en Base64

Durante el Diplomado de Windows Phone 8, hubo la necesidad de descargar un grupo de imagenes desde una URL y guardarlas, inicialmente la idea podia pasar por guardarlas en una BD pero solo con fines de experimentacion decidi guardar las imagenes en un archivo de texto codificada (encoded) en base64.

Aqui les comparto el metodo asyncrono que utilice para tal finalidad:

        public Task<string> DownloadImageAsync(string url)
        {
            HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(url);
            Task<WebResponse> requestTask = Task.Factory.FromAsync(
                req.BeginGetResponse, result => req.EndGetResponse(result),
                TaskCreationOptions.None);

            Task<string> resultTask = requestTask.ContinueWith(responseTask =>
            {
                using (
                    var stream =
                        responseTask.Result.GetResponseStream())
                {
                    int len = (int)stream.Length;
                    byte[] byt = new Byte[len];
                    stream.Read(byt, 0, len);
                    var b64 = System.Convert.ToBase64String(byt);
                    return b64;
                }
            });
            return resultTask;
        }

Como estuve trabajando intensivamente con MVVM, me vi en la necesidad de usar un Convertidor, que aqui se los paso in-extenso:

    public class ImageBase64Converter : IValueConverter
    {

        #region IValueConverter Members
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            string b64Value = (string)value;
            BitmapImage bi = null;
            if (!String.IsNullOrEmpty(b64Value))
            {
                byte[] imageBytes = System.Convert.FromBase64String(b64Value);
                bi = new BitmapImage();
                bi.SetSource(new MemoryStream(imageBytes));
            }
            return bi;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            BitmapImage bi = (BitmapImage) value;

            using (MemoryStream ms = new MemoryStream())
            {
                WriteableBitmap btmMap = new WriteableBitmap(bi.PixelWidth, bi.PixelHeight);
                // write an image into the stream
                Extensions.SaveJpeg(btmMap, ms, bi.PixelWidth, bi.PixelHeight, 0, 100);

                int len = (int)ms.Length;
                byte[] byt = new Byte[len];
                ms.Read(byt, 0, len);
                var b64 = System.Convert.ToBase64String(byt);
                return b64;
            }
        }
        #endregion
    }
Saludos
Posted: 22/7/2013 23:47 por Enrique Ortuño | con no comments
Archivado en: ,
Simplificando las cosas con Events, EventHandlers & EventArgs

Los eventos son una parte importante dentro del framework .NET, recuerdese que son la implementacion del patron observador, por cierto la implementacion mas elegante que puede hacerse. Sin embargo cuando usamos eventos necesitamos pasar o mas exactamente, informar con ciertos parametros hacia el manejador de eventos, observece los siguientes trozos de codigo:

Supongamos que tenemos una situacion en la que queremos informar del cambio de nombre, algo simple es el siguiente codigo, con este codigo lo maximo que se puede hacer es saber si se ha cambiado el nombre o no

public event EventHandler NombreCambiado;

public void OnNombreCambiado(EventArgs e)
        {
            EventHandler handler = NombreCambiado;
            if (handler != null) handler(this, e);
        }

Que ocurre si queremos informar cual es el nuevo nombre?, las cosas se empiezan a complicar pues quiza queremos usar el siguiente codigo:

        public event EventHandler<EventArgs> NombreCambiado;

        public void OnNombreCambiado(EventArgs e)
        {
            EventHandler<EventArgs> handler = NombreCambiado;
            if (handler != null) handler(this, e);
        }

Sin embargo EventArgs no soporta el paso de parametros, lo recomendado es crear una clase derivada de EventArgs, en el caso del ejemplo la clase se llama NombreEventArgs, como se muestra en el siguiente codigo:

    public class NombreEventArgs: EventArgs
    {
        public string Nombre { get; set; }
        public NombreEventArgs(string nombre)
        {
            Nombre = nombre;
        }
    }
        public event EventHandler<NombreEventArgs> NombreCambiado;

        public void OnNombreCambiado(string nombre)
        {
            EventHandler<NombreEventArgs> handler = NombreCambiado;
            if (handler != null) handler(this, new NombreEventArgs(nombre));
        }

Aqui surge el punto que cada vez que querramos pasar/devolver un parametro de algun tipo, debemos crear una nueva clase? En un principio puede parecer que si, pero a medida que va creciendo una aplicacion podemos encontrarnos con muchas clases que son innecesarias, entonces cual puede ser la solucion?

Crear una clase generica de EventArgs, el resultado, una clase llamada DataEventArgs<T> que la utilizo practicamente en todo proyecto que tengo:

    public class DataEventArgs<T>: EventArgs
    {
        public T Data { get; set; }

        public DataEventArgs(T data)
        {
            Data = data;
        }
    }

La utilizacion?, utilizando el anterior ejemplo:

        public event EventHandler<DataEventArgs<string>> NombreCambiado;

        public void OnNombreCambiado(string nombre)
        {
            EventHandler<DataEventArgs<string>> handler = NombreCambiado;
            if (handler != null) handler(this, new DataEventArgs<string>(nombre));
        }
Saludos.
Posted: 20/7/2013 18:39 por Enrique Ortuño | con no comments
Archivado en: ,
Remover HTML tags

A raiz de un requerimiento, en el Diplomado de Windows Phone 8, que nos pedia consumir un servicio, que devolvia HTML y colocar el contenido recuperado del servicio, como texto plano, en la aplicacion Windows Phone, tuve que buscar la mejor manera de eliminar los tags HTML, encontre este excelente articulo, y el codigo que pongo a continuacion:

/// <summary>
    /// Methods to remove HTML from strings.
    /// </summary>
    public static class HtmlRemoval
    {
        /// <summary>
        /// Remove HTML from string with Regex.
        /// </summary>
        public static string StripTagsRegex(string source)
        {
            return Regex.Replace(source, "<.*?>", string.Empty);
        }

        /// <summary>
        /// Compiled regular expression for performance.
        /// </summary>
        static Regex _htmlRegex = new Regex("<.*?>", RegexOptions.Compiled);

        /// <summary>
        /// Remove HTML from string with compiled Regex.
        /// </summary>
        public static string StripTagsRegexCompiled(string source)
        {
            return _htmlRegex.Replace(source, string.Empty);
        }

        /// <summary>
        /// Remove HTML tags from string using char array.
        /// </summary>
        public static string StripTagsCharArray(string source)
        {
            char[] array = new char[source.Length];
            int arrayIndex = 0;
            bool inside = false;

            for (int i = 0; i < source.Length; i++)
            {
                char let = source[i];
                if (let == '<')
                {
                    inside = true;
                    continue;
                }
                if (let == '>')
                {
                    inside = false;
                    continue;
                }
                if (!inside)
                {
                    array[arrayIndex] = let;
                    arrayIndex++;
                }
            }
            return new string(array, 0, arrayIndex);
        }
    }

El detalle no termina en copiar y usar el codigo, sino en la necesidad de usar esta clase en un Portable Library, lo que me hizo caer en cuenta que la opcion de compilar las expresiones regulares no estan soportadas en este tipo de librerias de clase (por eso pueden ver que el enumerador tiene un color un tanto diferente en el codigo anterior)

En fin, el metodo utilizado fue: StripTagsCharArray.

Un saludo.

Json Serializacion/Deserializacion

Durante las ultimas cuatro semans estuve participando del Diplomado de Windows Phone 8 que se organizo desde Mexico, con la indispensable presencia de Rodrigo Diaz Concha. Demas esta decir que estuvo genial, la cantidad de cosas recibidas y es mi intencion devolver a la comunidad algunas cosas aprendidas.

Existen situaciones donde es necesario serializar o deserializar un objeto a JSON. Se que existen librerias que lo hacen mas eficientemente, aqui pueden encontrar una comparativa muy interesante de ellas. Pero mi intencion es mantenerlo simple y no necesariamente eficiente (por ahora)

public class JsonHelper { /// <summary> /// JSON Serialization /// </summary> public static string JsonSerializer<T>(T t) { string result = string.Empty; using (MemoryStream stream = new MemoryStream()) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T)); serializer.WriteObject(stream, t); stream.Position = 0; using (StreamReader sr = new StreamReader(stream)) { result = sr.ReadToEnd(); } } return result; } /// <summary> /// JSON Deserialization /// </summary> public static T JsonDeserialize<T>(string jsonString) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T)); MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)); T obj = (T)serializer.ReadObject(ms); return obj; } }
Saludos
Posted: 19/7/2013 23:58 por Enrique Ortuño | con no comments
Archivado en: ,
Episodio 6 – Arquitectos.NET Podcast

Las múltiples ocupaciones retrasaron su publicación pero lo prometido es deuda, en esta ocasión, les entregamos la segunda parte de la grabación acerca del tema Bases de Datos NoSQL, conversamos acerca de:

  • Una recapitulación rápida de lo hablado anteriormente
  • Revisión de los Modelos distribuidos
  • Normalización/Des normalización
  • Patrones de Diseño
  • Map/Reduce
  • Persistencia Poliglota (CQRS)

Para aquellas personas que deseen bajar el mp3, aquí se encuentra el enlace.

Esperamos que les haya agradado y quisiéramos escuchar sus comentarios y sugerencias, es perfectamente valido hacerlo de manera privada a nuestros email (dnimrevo@gmail.com y enrique@ortuno.net).

Saludos.

Usando async/await en programas de consola

Hoy intentando preparar algunos ejemplos de entrenamiento me tope con una interesante curiosidad de asyn/await y es que usarlo en un programa de consola, probablemente la solucion que muestre es evidente para los con mas experiencia pero como siempre vale aclararlo, esto lo escribo para los que estamos metiendonos mas con async y await.

La idea es que tengo este bloque de codigo que contiene un metodo asincrono que quiero invocar usando await, pero como saben para usar await el metodo que lo contiene tiene que estar marcado con async, entonces se me ocurrio hacer esto:

   1:  class Program
   2:      {
   3:          static async void Main(string[] args)
   4:          {
   5:              var client = new RestClient("https://qrng.anu.edu.au");
   6:              // client.Authenticator = new HttpBasicAuthenticator(username, password);
   7:   
   8:              var request = new RestRequest("/API/jsonI.php", Method.GET);
   9:              request.AddParameter("length", "1"); 
  10:              request.AddParameter("size", "1"); 
  11:              request.AddParameter("time", "1365981445598"); 
  12:              request.AddParameter("type", "uint8");
  13:             
  14:   
  15:              var rx = await ExecuteTaskAsync(client, request, new CancellationToken());
  16:              Console.WriteLine("Showing content...");
  17:              Console.WriteLine(rx.Content);
  18:   
  19:              Console.ReadKey();
  20:          }
  21:   
  22:          private static async Task<IRestResponse> ExecuteTaskAsync(RestClient _restClient, RestRequest request, CancellationToken cancellationToken)
  23:          {
  24:              var taskCompletionSource = new TaskCompletionSource<IRestResponse>();
  25:   
  26:              var asyncHandle = _restClient.ExecuteAsync(request, r => taskCompletionSource.SetResult(r));
  27:   
  28:              using (cancellationToken.Register(() => asyncHandle.Abort()))
  29:              {
  30:                  return await taskCompletionSource.Task;
  31:              }
  32:          }
  33:      }

Pero al intentar colocar el async en la linea 3 se obtiene un error de compilacion que dice:

“an entry point cannot be marked with the 'async' modifier “

Para solucionar esto simplemente cambie el codigo agregando un metodo adicionar que realiza la llamada asincrona, removiendo la palabra reservada async y usando el WaitAll, tal como se muestra a continuacion:

   1:  class Program
   2:      {
   3:          static void Main(string[] args)
   4:          {
   5:              var task = OnlyCaller();
   6:              Task.WaitAll(task);
   7:              Console.ReadKey();
   8:          }
   9:   
  10:          private static async Task OnlyCaller()
  11:          {
  12:              var client = new RestClient("https://qrng.anu.edu.au");
  13:              // client.Authenticator = new HttpBasicAuthenticator(username, password);
  14:   
  15:              var request = new RestRequest("/API/jsonI.php", Method.GET);
  16:              request.AddParameter("length", "1"); 
  17:              request.AddParameter("size", "1"); 
  18:              request.AddParameter("time", "1365981445598"); 
  19:              request.AddParameter("type", "uint8"); 
  20:   
  21:              var rx = await ExecuteTaskAsync(client, request, new CancellationToken());
  22:              Console.WriteLine("Showing content...");
  23:              Console.WriteLine(rx.Content);
  24:          }
  25:   
  26:          private static async Task<IRestResponse> ExecuteTaskAsync(RestClient _restClient, RestRequest request, CancellationToken cancellationToken)
  27:          {
  28:              var taskCompletionSource = new TaskCompletionSource<IRestResponse>();
  29:   
  30:              var asyncHandle = _restClient.ExecuteAsync(request, r => taskCompletionSource.SetResult(r));
  31:   
  32:              using (cancellationToken.Register(() => asyncHandle.Abort()))
  33:              {
  34:                  return await taskCompletionSource.Task;
  35:              }
  36:          }
  37:      }

 

Espero que les sea util,

 

Saludos

Episodio 5 – Arquitectos.NET Podcast

Luego de varios meses de ausencia, me uno una vez más con Andrés Gonzales, para brindarles a ustedes, un nuevo episodio de la serie de podcast que hemos denominado Arquitectos.Net. El tema que nos trae en esta ocasión, es conversar sobre las bases de datos NoSql, como el tema es bastante amplio decidimos dividirlo en dos episodios, el primer episodio tiene el siguiente temario:

  • Historia
  • Definiciones importantes
  • Clasificación de las Bases de datos NoSQL:
  • Key-Value
  • Documentales
  • Familias de columnas
  • Grafos
  • Modelo de Agregación – Sharding
  • Modelación NoSQL

Para aquellas personas que deseen bajar el mp3, aquí se encuentra el enlace.

Algunos links de utilidad e interés:

Muy pronto estará disponible la segunda parte de nuestra conversación acerca de las bases de datos NoSQL, espero que les haya gustado esta primera introducción.

Saludos

Usando Log4Net, una manera rapida

En algunas situaciones, necesitamos implementar rapidamente un mecanismo de trazabilidad o instrumentacion que escriba en un archivo, en otras palabras un log, en mi caso uso bastante Log4Net y varias personas de tiempo en tiempo me preguntan como usarlo en proyectos we. Aunque hay varios ejemplos, articulos y codigo en internet para tal fin, muchos de ellos dan muchas vueltas sobre el tema antes de mostrarlo concretamente, es mi objetivo en este post mostrar como habilitar log4net en unos sencillos pasos a seguir:

Pasos a seguir

1. Descarga Log4Net, preferiblemente usando Nuget

2. Modificar el archivo web.config, agregando las secciones que muestro en las siguientes capturas de pantalla, he utilizado dos capturas en un archivo bastante lago, para que al ver la captura sepan donde insertalas.

Log4Net-1

En la segunda captura de pantalla que muestro a continuacion, he señalado dos puntos importantes de la configuracion. El primero es el nivel de trazabilidad que se requiere, esto se refiere a cuanta informacion queremos obtener en el log, hare un post separado para este tema y el segundo es el nombre del archivo de log que se generara.

Log4Net-2

3. Para utilizar Log4Net, yo utilizo una variacion mas elaborada de esta clase (Logger). La funcion de esta clase es dar acceso a metodos de Log4Net, formateando previamente el texto y tambien instanciar de manera simple el logger.

public static class Logger
    {
        #region Fields

        private static readonly ILog mLog = LogManager.GetLogger(typeof(Logger));

        #endregion Fields

        #region Constructor

        static Logger()
        {
            Debug.WriteLine("Server Logger initializing...");

            log4net.Config.XmlConfigurator.Configure();

            if (mLog != null)
            {
                Debug.WriteLine("Server Logger initialized");
                Debug.WriteLine(string.Format("Debug: {0}, Error: {1}, Info: {2}, Warning {3}", 
mLog.IsDebugEnabled, mLog.IsErrorEnabled, mLog.IsInfoEnabled, mLog.IsWarnEnabled));
            }
            else
            {
                Debug.WriteLine("Failed initializing Server Logger");
            }

        }

        #endregion Constructor

        #region Public Methods

        public static void PublishException(Exception exception)
        {
            if (mLog != null)
                mLog.Error("Exception", exception);
        }

        public static void WriteVerbose(string category, string message)
        {
            if (mLog != null)
                mLog.Debug(FormatMessage(category, message));
        }

        public static void WriteInfo(string category, string message)
        {
            if (mLog != null)
                mLog.Info(FormatMessage(category, message));
        }

        public static void WriteWarning(string category, string message)
        {
            if (mLog != null)
                mLog.Warn(FormatMessage(category, message));
        }

        public static void TraceError(string category, string message)
        {
            if (mLog != null)
                mLog.Error(FormatMessage(category, message));
        }

        public static void Write(TraceLevel level, string category, string message)
        {
            switch (level)
            {
                case TraceLevel.Verbose:
                    WriteVerbose(category, message);
                    break;
                case TraceLevel.Info:
                    WriteInfo(category, message);
                    break;
                case TraceLevel.Warning:
                    WriteWarning(category, message);
                    break;
                case TraceLevel.Error:
                    TraceError(category, message);
                    break;
            }
        }

        #endregion Public Methods

        #region Private Methods

        private const string MessageFormat = "{0} | {1}";
        private const int MaxCategoryNameLength = 25;

        private static string FormatMessage(string category, string message)
        {
            string output = string.Format(MessageFormat, FormatName(category, 
MaxCategoryNameLength), message);
            return output;
        }

        private static string FormatName(string name, int minLength)
        {
            string result;
            string trimName = name != null ? name.Trim() : string.Empty;
            if (trimName.Length >= minLength)
                result = trimName;
            else
                result = trimName.PadRight(minLength);
            return result;
        }
        #endregion Private Methods
    }

4. Finalmente para utilizar la clase, simplemente realizamos invocaciones a los metodos estaticos de la clase Logger, por ejemplo:

Logger.WriteInfo (“Categoria”,”Mensaje…..”);

 

Consideraciones

  • El Log del ejemplo que les presento, se escribira en la carpeta raiz de la aplicacion web, no es la mejor practica, lo mas recomendable es crear una carpeta especial para guardar los logs.
  • La carpeta donde se escriban estos logs, deben tener los permisos adecuados para el usuario sobre el que corre el proceso de IIS, en caso de Windows 2008, podria ser “Network Services”, pero puede variar dependiendo de su sistema operativo, es comun tener muchos problemas por este punto.
  • Esta forma de escribir el log es adecuada para una aplicacion aislada pero para aplicaciones distribuidas puede llegar a convertirse en un dolor de cabeza recolectar cientos de archivos dispersos en varias ubicaciones, lo ideal es guardar esta informacion centralizadamente, probablemente en una base de datos, ultimamente estoy experimentando (en un proyecto fuera de la oficina) con MongoDB y es bastante rapido, obviamente lanzo el log en un proceso asincronico que no bloquea la aplicacion, este tambien es tema de una futura entrada.

Espero que esto les haya sido de utilidad.

Usando JSONP con Ajax, de una manera rapida

Aquellos que nos hemos enfrentado varias veces al mensaje de “XMLHttpRequest cannot load http://192.168.1.109/settings/get. Origin http://localhost:8888 is not allowed by Access-Control-Allow-Origin”, pueden reconocer inmediatamente el problema relacionado al Cross-Domain. El problema en terminos simples se relaciona a que un sitio en un dominio X, por razones de seguridad, no puede acceder mediante ajax o incluso sockets a otro dominio Y. En nuestro caso el sitio X es http://localhost:8888 y el sitio Y que contiene el servicio es http://192.168.1.109/settings/get, este es un problema bastante comun y Eduard Tomas lo explica magistralmente en una reciente entrada

Eduard muestra la solucion utilizada en .NET haciendo uso de los MediaTypeFormatters, este mecanismo explicado hace practicamente transparente el procesamiento de las peticiones con jsonp, considero que es una solucion elegante y tambien muestra en el mismo articulo la solucion mas apropiada, que es la utilizacion de CORS.

Entonces que hago yo ‘escribiendo’ sobre JSONP?, pues es solo exponer mi experiencia y un workaround que utilice en algun momento antes de la aparicion de CORS y de decirle adios definitivamente a JSONP, bueno no tan definitivamente :). Empecemos.

Lado del Servidor

El ‘secreto’ de usar JSONP y Ajax, es el famoso callback en el que se encierra los datos retornados por el servidor.

En .NET la idea es tener un metodo en el controlador que devuelva lo siguiente:

image

En NodeJs, se tiene un similar metodo usando Express, debo advertir que con NodeJs se requiere un poco mas de configuracion, me refiero al codigo que anda por alrededor del app.get y seria lo siguiente:

image

Lado del Cliente

Hasta aqui tenemos la mitad del camino recorrido, la otra mitad se encuentra en el cliente/browser, donde se invoca al servicio REST, de la siguiente manera:

image

La url no es un tema muy relevante, porque depende del servicio al que se invoque, los elementos importantes son el datatype, que especifica el parametro jsonp y finalmente el otro atributo llamado jsonpCallback, que debe contener el nombre exacto de la funcion en la que se envolvio el resultante json.

Consideraciones

Este workaround solamente funciona en proyectos MVC y no en MVC WebApi, los proyectos WebApi justamente usan el mecanismo explicado por Eduard ese o CORS.

Este es un mecanismo inseguro, por lo que solamente deben usarlo en caso de tener que necesiten hacer alguna prueba de concepto rapidamete, es util, luego es mejor usar CORS.

Agradecer a un amigo, Yecid que me ayudo a encontrar este mecanismo.

Saludos

Microsoft cuidado, los vientos de cambio ya estan aqui.

Las personas que me conocen, pueden dar testimonio que mi carrera ha estado enmarcada por un apego inquebrantable hacia la filosofia de desarrollo .NET, practicamente todas las soluciones profesionales y personales en las que he participado tienen esa marca. Este post no pretende cambiar aquello ni mucho menos, tan solo son un conjunto de opiniones en un dia feriado en mi pais.

Hace algun tiempo me preguntaba cual era la razon de la popularidad creciente de dispositivos con el sistema operativo Android y no fue hasta que tuve recientemente, en mis manos uno de los buques insignia de google, el Nexus 10, que pude comprender la verdad (desde mi punto de vista). Ya se que habra algunos que estaran diciendo que mi primera eleccion deberia haber sido Surface o similares productos y no miento al decirles que en los primeros dias que tuve la Nexus 10, la tentacion fue grande para reemplazarla, pero no lo hice, pues uno de los objetivos de comprarla fue que planeo desarrollar una aplicacion para esta plataforma. Nuevamente muchos pueden comentar que porque para Android, que si deberia haberlo hecho para Windows 8 primero… etc, la respuesta corta, ya tengo una aplicacion para Windows Phone, tambien para Windows 8 y el siguiente mercado para ella es Android, solo cuestion de negocios.

image

El tema de este post no es cuan complicado o simple es migrar la aplicacion, o quiza las equivalencias en desarrollo entre ambas plataformas, esos temas los tocare en otras entradas, el tema central aqui es una cuestion mas ‘filosofica’, que tiene que ver con la experiencia y el porque de las cosas, comencemos.

imageLa Nexus 10, es de por lejos probablemente la mejor tablet Android, hasta el momento, esta bien….le quitaremos algunos defectos, que algunos le puede ver, no tiene ranura de expansion y el cargado de la bateria es un dolor de cabeza, pues carga leeeeeeeentamente, supongo que sera solucionado en futuras actualizaciones del firmware, espero. Aparte de ellos tiene un procesador A15 de doble nucleo, 2GB de RAM y ni que decir de la calidad de la pantalla, con una resolucion de 2560 x 1600, la calidad es inmejorable, por ahora. Estas caracteristicas la convierte en un hardware envidiable para casi todas las tablets con Windows 8 RT. Pero mas importante que el hardware es como se siente Android, pues es la primera vez que tengo un dispositivo con este sistema operativo y aunque he escuchado muchas opiniones y comentarios, que mejor que vivir la experiencia uno mismo.

image

El sistema operativo es el Android 4.2 Jeally Bean, la ultima version del mismo, no puedo opinar de versiones anteriores, esta es bastante ‘amigable’, no demore ni 5 minutos en entender todos los conceptos, pero ahora vienen las criticas, hasta el momento he tenido que reiniciar la tablet unas 4 o 5 veces en aproximadamente 2 semanas de uso regular, algunas aplicaciones se congelan misteriosamente y aunque el procesador es uno de los mas rapidos del mercado, la fluidez de varias aplicaciones dejan mucho que desear, se nota el odiado retardo al hacer flip o navegar, debo admitir que algunas aplicaciones propias de google son impresionantemente rapidas y fluidas a diferencia de las muchas. Existen todo tipo de aplicaciones, para todos los gustos, casi ninguna de ellas mantiene un estilo ‘look & feel’ uniforme, cada una pone las barras donde les parece, usan colores que les apetece, no existe una consistencia en el entorno y aunque no es complicado ‘descubrir’ como usar una aplicacion cada vez, aqui empiezo extra;ar Windows 8 o Windows Phone. Pero si hay tantos 'reparos’ que un usuario Windows ve, porque Android es tan ampliamente aceptado?

  • Un punto fuerte es la estrategia de distribucion que Google ha adoptado, tiene cientos por no decir miles de socios que fabrican hardware de los mas distintos sabores/precios, en mi pais se puede encontrar una tablet con prestaciones decentes sino suficientes con Android 4.0 por 100 Dolares Americanos!
  • A la amplia aparicion de ‘novedades’ se suma el conformismo de millones de usuarios ante los problemas de congelamiento o reinicio. En las descripciones de muchas aplicaciones, se puede leer descaradas sugerencias como: ‘Si tiene problemas desinstale y vuelva a instalar, existen problemas desconocido ocacionados por las actualizaciones’. Que nos dice esto? que los usuarios de Android ya han aceptado esos problemas como algo ‘natural’
  • Sumemos a esto el descuido de los programadores al momento de pensar en la experiencia del usuario y la practicamente falta de control por parte de google al momento de permitir la subida de aplicaciones al Google Play. Un amigo que es desarrollador de Android y iOS comenta que uno puede subir practicamente lo que quiera al Google Play y nadie te dice nada, es decir las normas por las que Microsoft se ‘pelea’ con el desarrollador, no son obstaculo con Android, a tal punto que amigos ya me han sugerido aplicaciones que increiblemente estan en el GooglePlay y que permiten descargar aplicaciones comerciales pirateadas!!!! Esto demuestra el grado de libertad/libertinaje que existe en esta plataforma.

Este ultimo punto no les recuerda algo familiar? Pues a mi si, me recuerda a Windows y es que en Windows uno puede hacer practicamente lo que desee. No sabemos si es que es por voluntad propia o por la imposibilidad de ejercer un mayor control, Microsoft ha dejado prosperar su plataforma apoyado en este punto, sea cual sea la respuesta, Google ha tomado muestra y esta creciendo considerablemente sostenido por cientos de miles de programadores que hacen lo que quieren :) (son palabras fuertes), nadie les dice que reglas deben seguir (bueno hay reglas muy minimas), nadie o practicamente nadie controla lo que subes siempre que subas aplicaciones, a nadie parece preocuparle la dichosa fragmentacion de mercado ni tantas cosas que Microsoft pregona como ventajas de sus plataformas Windows. Ojo no estoy diciendo que Microsoft debe dar rienda suelta a semejante libertinaje, pero algo tiene que hacerse, una idea que anda circulando por ahi es comprar el proyecto Mono e integrarlo como una herramienta mas, permitiendo que todos nosotros, otros tantos cientos de miles, podamos tambien programar en Android usando C#, quiza esta ‘cura’ puede ser peor que la enfermedad.

Lo cierto es que los vientos de cambio ya estan aqui y Microsoft debe cuidarse no solo las espaldas, sino los costados, arriba y abajo, tomar desiciones equivocadas puede ser desastrozo pero no tomarlas puede ser aun mas catastrofico, en un horizonte cercano divisamos un mayor crecimiento de Android, tambien asoma su cabeza Chrome OS y aunque oficialmente no hay relacion entre Android y Chrome OS, se imaginan un potencial competidor economico a Windows pero en entornos de escritorio?

image

Microsoft tiene asegurado por un buen tiempo (no sabemos cuanto) el nicho empresarial, donde aun pocos confian en una tablet Android para integrarla en sus soluciones y tambien debido a que la integracion es pobre. Pero os aseguro que Google empezo por las tablets, va por el escritorio y seguramente ya tiene planes para entornos corporativos, sus timidos intentos con Google Doc y Drive, muestran una estrategia inicial, no se cuanto les resultara, dudo que mucho por el momento, pero quien sabe a mediano plazo.

Los desarrolladores por nuestra parte no podemos quedarnos con los brazos cruzados, podemos y debemos tomar cartas en el asunto, como? Primero abrazando estandares abiertos, HTML5 y CSS3 pero por sobre todo empezando un aprendizaje formal y conciencudo de Javascript. Este lenguaje anteriormente menos-preciado, hoy se perfila como la piedra que cimentara muchas grandes aplicaciones. Tampoco debemos despegarle un ojo a iniciativas de Google como Dart, que aunque son timidos intentos de monopolizar el desarrollo, no dejan de ser intentos, que vienen nada menos que de Google.

En resumen manteneos atentos mis amigos, que el futuro nos depara grandes sorpresas y desafios, que Steve Ballmer y Cia. no se equivoquen en sus desiciones pues miren que muchos andamos abordo del barco que guian.

Entrevista con MSExpertos

El dia de ayer la gente de MSExpertos, me invito a compartir la entrevista de audiencia tecnica Latam, que me hicieron y aqui se las dejo en integridad:

1. ¿Quién eres en tus propias palabras?

Soy una persona entusiasta por la tecnología, autodidacta, geek de corazón y por sobre todo alguien a quien le gusta compartir conocimiento.

2. ¿Qué ha sido lo que te ha motivado para trabajar con tecnologías Microsoft?

He trabajado con .NET desde sus primeras versiones, hablamos desde el 2000, como una alternativa a otras plataformas que en ese momento usaba como J2EE o lenguajes como Delphi, PHP y Visual Basic. En .NET encontré una combinación y balance perfecto entre simplicidad y poder y un nicho donde acentar todos mis esfuerzos por lograr ser el mejor en la plataforma.

3. ¿Qué hace que tú seas un excelente evangelist?

Me considero un evangelist, que quiere contagiar su entusiasmo por las nuevas tecnologías, por formas diferentes de pensar y hacer las cosas.

4. ¿Cuál es la mejor cosa que te ha pasado desde que eres evangelist?

Generalmente me encuentro con todo tipo de personas en las charlas que doy, pero hay un tipo en el que me enfoco en particular, son como yo los llamo cariñosamente: ‘los odiadores de Microsoft’ que por mala información o guía no aprecian correctamente las bondades y ventajas que ofrece Microsoft en sus productos. El poder convertir y ver cómo estas personas se apasionan tanto o más que yo con .NET es la mejor de las cosas que me ha pasado.

5. Microsoft ha renovado toda su gama de productos, ¿Qué puedes decirnos de Visual Studio?

Visual Studio es una de las grandes herramientas que Microsoft tiene en su plataforma, hasta el momento no he podido encontrar un entorno que sea tan flexible y versátil, tan simple de usar y a la vez tan lleno de características. En su ultima versión se nota el esfuerzo constante por mejorarlo, se carga mas rápido esta mas ordenado y te permite concentrarte en aquello que tienes que hacer, escribir código. El único detalle que me gustaría ver en un futuro, es probablemente un Visual Studio en la nube.

6. Cuéntanos cuáles crees que son las tres fortalezas del nuevo paquete de desarrollo de la nueva gama de productos Microsoft

La simplicidad, es una de esas tres fortalezas, el saber que Microsoft destina miles de dólares a estudiar la forma más simple de usar un producto es un orgullo; El enfoque en las personas, de todos sus productos lo hacen diferente de otros donde lo importante es la aplicación y finalmente la integración que se comienza a ver más firmemente, entre productos que podrían considerarse diferentes, como por ejemplo la Xbox y un Windows Phone.

7. ¿Qué contiene tu “Computer Bag”?

Definitivamente cosas Microsoft, empezando por el maletín que es uno que me regalaron y dice SQL Server 2012, tengo un Hub USB, que cambia de colores (que no es lo mas importante pero si lo mas notorio) y que también dice SQL Server 2012 y bueno para escuchar música cuando ando algo libre unos parlantes chiquitines, que estos si dicen Visual Studio 2012.

8. ¿Tienes alguna experiencia laboral interesante para contarle a la comunidad de Desarrolladores en Latinoamérica acerca de estos productos?

Claro, mi línea profesional principal ha sido, es y será .NET pero en este ultimo anio se ha notado el advenimiento de grandes tecnologías como bases de datos NoSql u otras como Nodejs, lo interesante de todo ello, es que he debido de involucrarme como arquitecto en la construcción de soluciones mixtas y que todo aquello que aprendí en mi recorrer por la plataforma de Microsoft, me ha preparado perfectamente para enfrentarme a nuevas tecnologías no-Microsoft, obviamente ha existido un proceso y su curva de aprendizaje, pero definitivamente Microsoft y las practicas que uno usa dentro de su plataforma, nos alistan para poder mirar más allá del propio terreno.

9. Nombra 3 recursos indispensables que quieras recomendarle a la comunidad de Desarrolladores sobre el producto

Una de las paginas que contiene, artículos, foros e incluso un AppWall es: http://windowsphonegeek.com/

Probablemente otro de los sitios que tienen enormes cantidades de aportes de calidad es DZone: http://dzone.com/mz/dotnet

Finalmente DevProConnections tiene otro tanto de material y también incluye artículos de HTML5, javascript, Nodejs, etc. Todos ellos desde una perspectiva de un desarrollador .NET: http://www.devproconnections.com/

Code Contracts en VS2012 – Parte 2

Se que probablemente he saltado explicaciones detalladas y obviamente necesarias de lo que es Code Contracts, pero pienso subsanarlo a medida que vamos avanzando en esta serie de posts. pero voy a enfocarlo de una perspectiva personal de como lo percibi yo y como lo aplique. Tampoco hare una explicacion detallada de Code Contracts porque ya existen excelentes posts que lo hacen.

Bueno, existen dos razones fundamentales por las que uno quisiera utilizar Code Contracts y mas especificamente su rewriter, porque CodeContracts como tal no es realmente “util” sin el rewriter.

  1. La posibilidad de tener una comprobacion de Precondiciones, PostCondiciones, Invariantes, Aserciones y Supociones en tiempo de ejecucion. Es decir quiero utilizar las capacidades del Rewriter, para que cuando compile mi ensamblado “inyecte” codigo de Contratos dentro de mi codigo.
  2. Otra razon es la posibilidad de tener una verificacion estatica del codigo en tiempo de compilacion, esto quiere decir que gracias a las bondades de Code Contracts, puedo tener advertencias de un posible mal diseño en mi codigo y/o sugerencias que me ayuden a mejorarlo.

Para tomar la desicion de usar o no Code Contracts y su rewriter, esta depende mucho del proyecto, mi proyecto actual, requiere el procesamiento de cientos de miles de registros en un tiempo minimo, y la desicion es usar Code Contracts, pero NO usar el rewriter para generar los ensamblados finales (por temas de performance, basicamente no quiero tener codigo “inyectado” que no controlo circulando por ahi y al que en algun momento le echare la culpa por un bajo rendimiento), pero si utilizar las capacidades de verificacion estatica de code contracts, esta caracteristica es altamente util para los desarrolladores. Sabemos que los desarrolladores trabajaran sobre el ensamblado compilado en Modo Debug y que la version final de los ensamblados sera compilada en modo Release, ya los estoy mareando verdad? pero bueno como podran “ver” hay varias combinaciones y para explicarlo mejor aqui una matriz con mi seleccion

image

Esta combinacion se plasma en las siguientes configuraciones del rewriter.

Configuracion en Modo Debug:

image

Configuracion en Modo Release:

image

Al principio puede parecer confusas estas configuraciones pero luego pueden ir retocando sus valores para tener una mayor granularidad del control del rewriter o del verificador estatico.

En la documentacion oficial de Code Contracts se encuentra un diagrama de flujo bastante explicativo que sirve tambien para elegir como usar esta herramienta, el diagrama es el siguiente:

image

Si se detienen en el anterior diagrama podran observar que la seleccion que yo realice corresponde al Usage 3.

Aun restan varios temas relacionados a Code Contracts, que seguire tocando en las siguientes entradas.

Saludos

Posted: 17/11/2012 8:42 por Enrique Ortuño | con no comments
Archivado en: ,
Diferencias entre OpenID y OAuth

Motivado por el post de Eduard Tomas acerca de “Integrar OAuth en tu aplicacion ASP.NET MVC”, escribo este post. Existe mucha confusion (inicial) en lo que se refiere a OpenID y OAuth y a ella contribuyen autores que las tratan como sinonimos implicitos en cuanto a seguridad se refiere, pero ambas son cosas totalmente diferentes y en este post quiero explicarles esas diferencias con un par de ejemplos:

Escenario con OpenID:

  1. El usuario desea ingresar al sitio dospatitos.com con su cuenta
  2. dospatitos.com, que es la parte que confia (Rely Party), solicita al usuario el identificador OpenID (las credenciales OpenID las pueden crear en cualquiera de muchos sitios gratuitos, yo uso myopenid, al final doy un link a un sitio con un directorio de proveedores de cuentas OpenID)
  3. El usuario ingresa su identificador OpenID
  4. El sitio dospatitos.com redirecciona al usuario al sitio del proveedor de la cuenta OpenID, en mi caso siempre me lleva obviamente a myopenid.com
  5. El usuario se autentifica (autentica o como quieran) dentro del sitio del proveedor de OpenID
  6. Una vez que la autenticacion es exitosa, el proveedor de OpenID redirecciona al usuario de regreso al sitio dospatitos.com
  7. Finalmente dospatitos.com permite al usuario ingresar al sitio y a los datos de su cuenta en el mismo.

Claramente, se muestra que OpenID esta relacionado directamente a delegar la autenticacion.

Escenario con OAuth:

  1. El usuario ya se encuentra autentificado en dospatitos.com, pero desea (por alguna razon extraña) importar algun datos (en este caso fotografias) de un segundo sitio llamados misfotos.com, en este caso debemos observar que el custodio de esos datos/recursos, se llama Site Provider y no entregara esos datos hasta que este seguro a quien se los dara, obviamente el dueño de esos datos.
  2. El sitio dospatitos.com (que en el lenguaje de OAuth se llama Consumer), redirecciona al usuario al Site Provider, en este caso misfotos.com
  3. El usuario, debe autentificarse ante misfotos.com (para autentificarse misfotos.com podria estar usando OpenID u otro mecanismo de autenticacion)
  4. El sitio misfotos.com le presenta una pantalla al usuario informandole que el sitio dospatitos.com desea acceder a sus fotografias.
  5. El usuario hace su seleccion, es decir elige autorizar el proceso.
  6. El sitio misfotos.com, redirecciona al usuario de regreso al sitio dospatitos.com
  7. El sitio dospatitos.com, recupera las fotografias desde misfotos.com
  8. Finalmente el sitio dospatitos.com informa al usuario que la importacion fue exitosa.

En este caso tambien es bastante claro que OAuth se trata de autorizacion, el sitio dospatitos.com accedera a recursos almacenados en misfotos.com sin necesidad de que entre llos fluyan mis credenciales ni de uno ni de otro sitio.

Directorio de proveedores OpenID: http://openiddirectory.com/openid-providers-c-1.html

Espero que esta aclaracion les sea de utilidad.

Un abrazo.

Episodio 4–Arquitectos.NET Podcast

Andrés Gonzales y mi persona nos reunimos, una vez más, con las mismas ganas y entusiasmo, para conversar sobre tecnología, el tema que nos trae en esta ocasión es “Seguridad – Autenticación”. Consideramos que este episodio solo será el inicio de varios en los que tocaremos tópicos de seguridad y en los cuales estaremos invitando a personas reconocidas que compartan con nosotros el micrófono. Bueno aquí les dejo un resumen del temario que contiene el podcast:

  • Definiciones de Términos (Autenticación vs Autorización)
  • Analogías
  • Tipos de autenticación
  • Problemas de la autenticación
  • Ingeniería social
  • Mecanismos de Seguridad Actuales
  • Nuevos mecanismos de autenticación
  • Memorización subconsciente
  • Consejos
  • Técnicas informales para creación de passwords
  • Técnicas formales para creación de passwords
  • Mecanismo de intercambio de passwords
  • Administradores de passwords

Para aquellas personas que deseen bajar el mp3, aquí se encuentra el enlace.

Una errata involuntaria: durante la grabación del podcast, al explicar el algoritmo de Diffie-Hellman, confundimos las llaves publicas y privadas, durante la explicación, por favor sepan disculparnos el error cometido al fragor de la grabación.

Algunos links de utilidad e interés:

Esperamos que les haya agradado el podcast y nos encontramos en una siguiente edición del mismo.

Saludos.

Posted: 8/11/2012 0:58 por Enrique Ortuño | con no comments
Archivado en: ,
Code Contracts en VS2012 – Parte 1

La utilización de Code Contracts en VS puede ser confusa, antiguamente en las versiones de VS 2008 Code Contracts no estaba incluido en los ensamblados del proyecto y aunque sucedía esto, todo era un poco mas claro, había que bajar el add-in desde la página de Research de Microsoft y asunto arreglado. Pero no a todos nos gustaba la idea de crear una dependencia para el tema de Code COntracts y mas aun la palabra “Research” con la que es catalogado aun el proyecto. Todo cambio con la versión de VS2012 donde las clases de Code Contracts ya vienen incluidas en el NameSpace System.Diagnostic, pero las cosas se complicaron un poco mas, porque aquellos que leen la teoría de Code Contracts y tratan de llevarla a la practica se llevan una alegría inicial, porque podríamos ver que intellisense nos da algo así:

image

Parecería que todo anda normal que ya tengo todo integrado con VS pero al ejecutar el código anterior y pasarle a x un valor de 1, no ocurre nada.

Que tal si le cambiamos a esto:

image

Aquí suceden cosas mas “extrañas”, obtenemos una excepción o mensaje de error como este:

image

Ahhh pero claro tenemos que bajarnos el Rewriter de Code Contracts desde esta pagina:http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx

Tambien existe un excelente documento guia en la misma pagina, lo pueden descargar desde aqui: http://download.microsoft.com/download/C/2/7/C2715F76-F56C-4D37-9231-EF8076B7EC13/userdoc.pdf

Mi principal observación es, porque aun no esta integrado el Rewriter dentro de VS2012? y/o del framework? Esto me obliga a colocar una dependencia adicional dentro de mi servidor de Build, entiendo que no es el gran problema pero, tampoco le veo problema a que todo este integrado.

Saludos

Posted: 1/11/2012 11:46 por Enrique Ortuño | con 1 comment(s)
Archivado en:
Episodio 3–Arquitectos.NET Podcast

En esta ocasión nos volvemos a reunir Andres Gonzales y mi persona para presentarles el tema “ORMs – Mapeo Objeto Relacional”, con la participación especial de un invitado: Rory Vidal un arquitecto de software, que gentilmente nos ayudo a llevar adelante el tema. El temario de esta conversación ha sido el siguiente:

  • ¿Porqué un ORM?
  • Modelacion Database-First, Model-First y Code-First
  • Clasificación de los ORM
  • ORM Tradicionales: NHibernate, Entity Framework, DataObjects.NET y BLToolkit
  • Mini-ORM: Dapper
  • Los ORM y los Reportes
  • Optimizaciones en temas de Bases de Datos
  • Problemas con los ORM
  • Caracteristicas Especiales

Para aquellos que no tengan flash instalado o que deseen guardar este archivo, aqui les dejamos el enlace, también pueden dirigirse a esta página para ver el reproductor online.

Algunos enlaces de utilidad:

Hacemos extensiva la invitación a que cualquiera de Uds., pueda participar con nosotros en un episodio futuro del podcast, lo único requerido es interés y ganas de compartir sus experiencias.

Ante cualquier duda, comentario y/o sugerencia, les solicitamos hacerla llegar aquí: arquitectos.net@outlook.com

Un saludo.

Que trae de nuevo el .NET Framework 4.5?

El siguiente articulo es una traduccion del articulo de Rob Sanders, acerca de sus anotaciones de lo observado en el TechEd-Australia, contiene los elementos nuevos que trae el .NET Framework 4.5.

Introduccion

Arrancamos… un poco de discusion acerca de la historia del .NET Framework, el cual tiene ahora 10 anios. El panorama es bastante breve, los presentadores estan bastante relajados y trabajan fluidamente entre ambos.

  • Cuales son los elementos clave que trae la version 4.5?
  • Mejoras en la funcionalidad asincrona
  • Windows 8 y Windows 8 RT
  • Nuget y paquetes distribuibles
  • Un framework mas ligero con los paquetes Nuget.
  • Rendimiento
  • Usuarios y retroalimentacion de la comunidad

Core Framework

Asynchronous/Waits [Demo]

Mostrando el uso de async/await dentro del contexto de una interface WPF. Se requiere mucho menos codigo que lo que tradicionalmente se requeria, en especial con relacion al UI Thread Marshalling.

Estamos revisando el ensamblado, naturalmente usando .NET Reflector. Cuando utilizamos async/await el compilador genera una gran cantidad de codigo por debajo. Tenga esto en mente cuando piense usar async/await. No es ideal para pequenas aplicaciones.

Las clases base del namespace IO ahora son compatibles con async. Stream/TextReader/Writer/etc. Cambiando de tema…

Identity

Revision de los usos historicos de Iidentity, Iprincipal, etc. Capacidades basicas en membership y roles, ausencia de acceso a mas informacion (por ejemplo el email)

El framework 4.5 se convierte en mas claim-aware. Nueva clase ClaimsIdentity (la cual implementa IIdentity) , la cual permitira el uso de claim-tokens en las aplicaciones. Hay varios metodos helpers que ayudan en la navegabilidad. Otras clases Principals heredan de esta clase. Compatibilidad hacia atras para aplicaciones antiguas.

Active Directory en el Serve 2012 ahora puede exportar claims-tokens. Windows Identity Foundation ahora esta integrado en e. Framework 4.5 (no mas instaladores separados) [N.T: Al fin]

Librerias Portables de Clases

Aunque estoy bastante seguro de que esta caracteristica fue introducida en el Fx .NET 4.0?. Ah, Este fue separado del framework base en su version 4.0

[Demo]

El soporte esta incluido en los proyectos de Visual Studio. Evita la necesidad de definiciones de pre-compilador.

[N.T.: http://channel9.msdn.com/Shows/Visual-Studio-Toolbox/Visual-Studio-ToolboxPortable-Class-Libraries ]

Otras cosas

  • Optimizaciones del Profile y Multicore JIT
  • Timeout para expresiones regulares (regex) (probablement no es una mala idea)
  • Nuevo namespace para el nuevo soporte de compresion zip, supongo que los problemas de licencias estan resueltos?
  • Referencias debiles - cambios de tipo en caso de que un objeto sea destruido (disposed)
  • Internacionalizacion (cultura) dentro de un app-domain (bueno por unas pocas razones)

Cosas web

  • Modelo de programacion HTTP (lease aplicaciones RESTful)
  • Soporte completo para enrutamiento (MVC?)
  • Negociacion del contenido
  • Composicion de consultas (QueryString)
  • Aplicaciones auto-hospedadas (self hosted)

Las operaciones CRUD pueden ser mapeadas a verbos HTTP (GET/POST/etc). Soporte de programacion HTTP mejorado en el Fx .NET 4.5. Se incluye negociacion de contenido, de manera nativa. Filtrado de contenido al vuelo usando WebAPI [Demo]

Mehesh esta mostrando las peticiones/respuestas HTTP en tiempo real. Estamos viendo el flujo de datos JSON en la respuesta. Ahora esta mostrando como la respuesta puede ser cambiada para retornar un XML basico. Funcionalidad incorporada. Referencia al Sr. Philip Beadle (famoso por DotNet-Nuke)

Agregando un controlador, agrega el codigo de manejo apropiado. Se necesita tener un manejador de excepciones, por lo demas todo esta en su lugar.

HTTP Client

La clase HttpClient puede ser usada para instanciar programaticamente un objeto cliente Http, bastante util para ejecutar peticiones get y evaluar respuestas, etc.

Web Sockets

La tecnica de Polling ha sido usada durante mucho tiempo como una aproximacion de busquedas. Se puede mejorar? Establecer una conexion con una llamada normal. Comunicacion bi-direccional Full-duplex, Soporte para proxies integrado, Soporte binario, UTF-8.

Soporte en IIS 8, ASP.NET 4.5, WinRT, WCF 4.5 sobre Windows 8 y Windows Server 2012.

[Demo - Aplicacion de un chat usando Web-Sockets]

El mensaje es enviado al servidor, el servidor hace un broadcast a los usuarios.

Un poco decepcionante verlo ejecutandose en una sola computadora y con solo dos usuarios. Momento de ver codigo.

El HttpHandler verifica la peticion, se enruta al handler si la peticon es una peticion web-socket. Me gustaria ver que esto se concretase un poco mas.

ASP.NET Web Forms

  • Controles de datos fuertemente tipados (finalmente!)
  • Soporte mejorado para async
  • Minificacion integrada de js/css
  • Controles de servidor actualizados para generar HTML5

MVC

  • Mejoras en Razor
  • Cambios al template por defecto
  • Async, async!
  • Soporte para dispositivos moviles mejorado.

Viendo un demo de ASP.NET . Enlace de datos (Data-bindig) con controles fuertemente tipeados, bye bye eval(). La demostracion muestra validacion, enrutamiento (ya no se observa la extension .aspx en el URL) e interpretacion mejorada del query string. Aun se registran rutas en una forma que no es novedosa para los programadores MVC.

WCF

  • Simple de configurar (finalmente!) Los valores por defecto ahora son mas sensibles
  • Los proxies que se generan, ahora definen metodos async por defecto!
  • Se pueden crear tareas (tasks) basadas en operaciones asincronas.
  • Web-Sockets (como se menciono previamente), se requiere un paquete Nuget.
  • Soporte para el protocolo UDP (datagramas!)
  • Un API de control mejor expuesto a travez de codigo.
  • El uso de la operacion "Configure"para recuperar en tiempo de ejecucion la configuracion definida. (N.T. genial!)
  • Soporte WCF para aplicaciones Windows 8.

[Demo - WCF y una aplicacion Windows 8] Nota: Usando Entity Framework (buenisimo)

Observar que los metodos sync y async son generados en los proxy cliente. Los metodos async no estaban habilitados por defecto en el pasado. Los clientes Windows 8, no soportan operaciones sync - solamente operaciones async (debido a las consideraciones de bloqueo de las UI Metro o como se llamen ahora). No se ven archivos de configuracion para las aplicaciones Windows 8. El demo falla auch!

WPF

  • Los controles Ribbon ahora estan integrados
  • Validacion asincrona
  • El enlace de datos (data-binding) ha cambiado
  • Enlace retrazado - delay binding (tal vez por async)
  • Enlace a propiedades estaticas
  • Extensioes de marcado (XAML) para eventos

[N.T. Me pregunto si todo lo de XAML tambien se aplica a Windows Phone]

WF

  • Expresiones C# soportadas
  • Servicios Workflow con el modelo Contract-First
  • Versionamiento de Workflow (finalmente integrado). Se carga correctamente el workflow con la actividad.
  • Mejoras en los disenadores (de nuevo… finalmente!)
  • Soporte de comentarios y navegacion mejorada.

Otras cosas interesantes (Parte 2)

MEF 2.0

Esto se acerca a un framework IoC para mocking e inyeccion de dependencia.

  • Soporte para abrir partes genericas
  • Registro basado en reglas y convenciones
  • Construccion de reglas para importar/exportar sin declaraciones/atributos.
  • Mejoras de ambito
  • Mejoras en el diagnostico.
  • Pensadas para aplicaciones Web y Metro

Pensamiento rapido: Nada en el compilador en tiempo de ejecucion (Roslyn?)

El TPL (Task Parallel Library)

El Task Parallel Library… se ve bastante bien:

  • Mejoras en el rendimiento
  • Nuevos metodos:
    • Run
    • Delay
    • WhenAny
    • WhenAll
    • FromResult
  • La clase Progess<T>

TPL Data Flow

Mirando a los sistemas reactivos - flujos de datos en memoria, controles basados en agentes. Nueva libreria .Net.

Esto es algo en lo que voy a estar bastante interesado en probar. Para tener mas informacion acerca de TPL data Flow, mantengase atento a la Tecnologia Sanders

  • Conjunto de bloques (primitivas)
  • Queue/buffer/Task
  • EG ActionBlock/TransformBlock/BufferBlock

Demo rapido del nuevo TPL data Flow. Estamos llegando al final brevemente.

Conclusion

No es una version menor, tiene un gran soporte para Windows 8, async y mejoras de rendimiento. Aqui finalizamos.

[N.T.]

El articulo original pueden encontrarlo aqui: 

http://www.sanderstechnology.com/2012/whats-new-in-net-4-5/11488/#.UFUQL42PXiu

En aras de mantener el sentido de la traduccion mantuve algunos terminos en su version en ingles, sepan por favor disculpar esta mezcla Smile

Mi granito de arena: Un inclusion esperada en el Framework 4.5 es Code Contracts, al fin podemos usarlo sin tener que hacer referencias externas.

Gracias por la paciencia de leer hasta aqui.

Un saludo.

Posted: 16/9/2012 22:28 por Enrique Ortuño | con no comments
Archivado en: ,,
Episodio 2–Arquitectos.NET Podcast

Una vez mas, estimados amigos, nos reunimos con Andres Gonzales y grabamos el segundo episodio del podcast que hemos venido a llamar “Arquitectos.NET”, en esta ocasión el tema de nuestra conversación son “Las arquitecturas de Servicios SOA y REST”, hemos querido centrar la charla en nuestras experiencias y recomendaciones y de ahí que surge el siguiente temario básico:

 

  • Definición e historia de las arquitecturas SOA y REST
  • Problemas que se intentan resolver con SOA/REST
  • Protocolos involucrados: WSDL, SOAP / WS-*
  • Peligros y equivocaciones posibles
  • Seguridad
  • Esquemas de n capas
  • Enterprise Service Bus
  • Cuándo aplicar SOA/REST y cuándo no.
  • Menciones a casos reales de uso de SOA/REST

Para aquellos que no tengan flash instalado o que deseen guardar este archivo, aqui les dejamos el enlace, también pueden dirigirse a esta página para ver el reproductor online.

Continuamos con nuestro aprendizaje en esto de hacer podcasts y en esta ocasión, tenemos algunos problemillas en el audio, que espero nos sepan disculpar:

  • Unos cortes de audio producto de la edición post-grabación (les aseguro que no se perdieron algo muy importante)
  • Mi mascota ladra en el fondo, en algunos momentos

Luego de haber recibido buenos comentarios y un excelente “feedback”" de varios amigos escuchas, los invitamos nuevamente a hacernos llegar sus sugerencias e ideas para futuros podcasts. También están abiertas las puertas para recibir participantes invitados que quieran conversar con nosotros acerca de aquello que más nos gusta: la tecnología y el desarrollo de software. Esta invitación no ha caído en saco roto y el siguiente podcast contaremos con un invitado, que muchas personas en nuestro país conocen (es una sorpresa).

Para centralizar todos vuestros contactos pueden hacernos llegar sus correos electrónicos a la dirección arquitectos.net@outlook.com.

Un saludo y hasta la siguiente emisión.

Posted: 28/8/2012 22:58 por Enrique Ortuño | con no comments
Archivado en: ,,
Más artículos Página siguiente >