Definición

Una expresion lambda es:

Una función anónima que se usa para crear delegados.

Esto es importante resaltarlo ya que mucha gente desconoce la relación entre un delegado y una expresión lambda.

Su estructura es:

Parametros => Implementación

• Donde => es el símbolo lambda.

Ejemplo

Tomemos nuestro ejemplo de Funcion Anónima usado en el post del mismo nombre:

Add = delegate(float elNumeroA, float elNumeroB) { return elNumeroA + elNumeroB };

Este seria reescrito como:

Add = (float elNumeroA, float elNumeroB) => elNumeroA + elNumeroB;

Donde float elNumeroA y float elNumeroB serían los parámetros de entrada y elNumeroA + elNumeroB serían nuestra implementación.

Algo que debemos tener presente con estas expresiones es que el TipoDeValorDevuelto se infiere o “adivina” dependiendo de la forma en que se escribe.

En este caso los tipos son float + float = float por lo que Add tendrá la firma < float,float,float >. (Recuerden leer el post inicial de delegados para ver lo que son las firmas)

Más ejemplos

Comencemos con un ejemplo usando una funcion anónima.

public class Algo
{
    // Definimos un tipo suma
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Le asignamos una implementacion mediante una funcion anonima
        Add = delegate(float elNumeroA, float elNumeroB) { return elNumeroA + elNumeroB };
        //La usamos
        double res = Add(3.0f,5.0f)
    }
}

Reemplacemos el delegado con una expresión lambda.

public class Algo
{
    // Definimos un tipo suma
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Usamos la expresion lambda.
        Add = (float elNumeroA, float elNumeroB => elNumeroA + elNumeroB;
        //La usamos
        double res = Add(3.0f,5.0f)
    }
}

Ahora usemos el tipo Generico Func recordando que la firma de suma es < float, float, float >

public class Algo
{
    // Borramos el tipo

    public Algo(){
        // Creamos variable del tipo generico
        //TipoDeVariable         NombreDeVariable
        Func<float,float,float>        Add;
        //Usamos la expresion lambda.
        Add = (float elNumeroA, float elNumeroB) => elNumeroA + elNumeroB;
        //La usamos
        double res = Add(3.0f,5.0f)
    }
}

Importante: si la firma de la expresion lambda no coincide con la firma esperada tendremos errores a la hora de compilar.

Delegados como parámetros

En el siguiente ejemplo vamos a crear una función que reciba como parametros un delegado que tendra la implementacion de una operación matemática y dos numeros con los que se realizara la operación matemática.

public class Algo
{
    public double Ejecuta(Func<float,float,float> op, float numA, float numB){
        return op(numA, numB);
    }

    public Algo(){
        // Creamos variable del tipo generico
        //TipoDeVariable         NombreDeVariable
        Func<float,float,float>        Add;
        //Usamos la expresion lambda.
        Add = (float elNumeroA, float elNumeroB) => elNumeroA + elNumeroB;
        //La usamos
        double res = Ejecuta(Add, 3.0f, 5.0f);
    }
}

Y lo divertido es que podemos poner la expresion lambda directamente en la función Ejecuta

public class Algo
{
    public double Ejecuta(Func<float,float,float> op, float numA, float numB){
        return op(numA, numB);
    }

    public Algo(){
        //La usamos
        double res = Ejecuta((elNumeroA, elNumeroB) => elNumeroA + elNumeroB, 3.0f, 5.0f);
    }
}

Como podrán ver escribimos la expresion lambda sin definir los tipos de los parametros, esto lo podemos hacer gracias a que el método Ejecuta ya define la firma del delegado por lo que el compilador infiere los tipos y valida que sean los correctos, si nosotros cambiaramos el 3.0f o el 5.0f por una cadena de texto el compilador marcaria un error.

Otro punto que se ve claramente es que ahora tenemos todo en una sola linea de código, el uso de lambdas nos ayuda a tener expresiones mas poderosas que optimizan el código.

Expresiones Lambda sin parametros

Para este caso se debe de seguir esta sintaxis:

() => Implementación

El paréntesis a la izquierda es solo para indicar que nuestro delegado no tendrá parametros. Un ejemplo práctico seria:

() => (3 * 6) - 10 ;

Este delegado es un método que regresa un 8 siempre.

Expresiones Lambda con bloques de código

A veces necesitamos que la implementación de nuestro delegado sea algo mas complejo que una simple suma. Para esos casos podemos utilizar un bloque de codigo delimitado por un contexto.

Un contexto es definido por dos llaves, una que abre “{“ y otra que cierra “}“. Las usamos en todas partes y nos sirven para delimitar bloques.

En el caso de las expresiones lambda los contextos se usan para crear algo asi:

(int numA, int numB, int numC) => { 
        int x = numA + numB; 
        return x / numC; 
}

Podemos notar que ya se usan los “;“ para separar las líneas y la palabra return para enviar el valor de retorno, esto es por que al agregar las llaves la implementacion se escribe como lo hariamos con cualquier método siguiendo las mismas reglas.

Notas finales

Lo mas recomendable es usar las lambdas para generar funciones anónimas y los tipos genericos Action y Func en caso que necesitemos usarlos como parametros.

Espero que estos posts ayuden a comprender mejor el uso y evolución de los delegados en la plataforma.net

Ahora vamos a utilizar un par de tipos que nos facilitarán la vida.

Ya sabemos que un delegado lo podemos crear así:

// Definimos el nuevo tipo
delegate double Suma ( float numeroA, float numeroB );

Pero resulta tedioso el estar creando delegados una y otra cuando tenemos muchas funciones con muchas diferentes firmas, por eso el .Net Framework tiene dos tipos de datos maravillosos que nos ayudaran a evitar realizar esa tarea.

Action<> y Func<>

Son dos tipos de datos Genericos dentro del namespace System.Collection.Generics que pueden almacenar funciones.

Action < T >

Este tipo puede guardar funciones que no regresen valores, por ejemplo tenemos esta función:

void Operacion(string dato){
    Console.WriteLine(dato);
}

ahora la vamos a guardar en un tipo genérico Action de la siguiente forma

Action<string> GuardarOperacion;

GuardarOperacion = Operacion;

Es importante remarcar que Action puede tener uno o mas tipos de datos declarados en su definición ( Action < Tipo1, Tipo2, Tipo3, TipoEtc > ) y deben de coincidir con los de la funcion por ejemplo:

// Tenemos tres tipos en la firma del metodo
void OperacionMultiple(string data, int A, float B){
    // Hace algo ...
}

public static void Main(){
    // Creamos un Action con los tres tipos
    Action<string,int,float> GuardaOperacionMultiple;

    // Como la firma coincide podemos hacer operaciones
    GuardaOperacionMultiple = OperacionMultiple;
}

En este ejemplo vimos como un metodo con tres parametros de entrada con diferentes tipos puede ser referenciado por una variable de tipo Action con la misma firma.

¿Y qué sucede si necesito que mi funcion regrese un valor?

Func < T, TResult >

En ese caso utilizamos Func, tomemos el clásico ejemplo de la suma:

float Suma(int a, int b){
    return a + b;
}

Esta función puede ser guardada en una variable de la siguiente manera:

Func<int,int,float> GuardaSuma;

GuardaSuma = Suma;

Nota: Es importante remarcar que el último tipo declarado en Func es el tipo del valor de retorno.

Otra punto a considerar es cuando tenemos una función que no recibe parametros y regresa un valor como:

int Dato(){
    return 300;
}

En este caso nuestro genérico Func deberá ser declarado asi:

Func<int> GuardaDato;

GuardaDato = Dato;

Entran las funciones anónimas

Conociendo Action y Func ahora podemos darnos vuelo con los delegados de una forma mas limpia, la primer idea que viene a mi mente es una serie de Fibonacci.

using System;

public class Program
{
    public static void Main()
    {
        // Declaramos el Generic
        Func<int,int,int> Fibo = null;

        // Le asignamos la implementacion
        Fibo = delegate (int a, int b){
            Console.WriteLine(a);
            if (a >= 144){
                return a;
            } else {
                // Nos volvemos locos y hacemos recursiidad.
                return Fibo(a + b, a);
            }
        };

        // Iniciamos la ejecucion.
        Fibo(0,1);
    }
}

En este pequeño ejemplo de Fibonacci creamos un Func y después le asignamos mediante un delegado la implementación y dentro de la misma implementacion hacemos que se mande llamar a si mismo.

Al final solo necesitamos iniciar el ciclo recursivo llamando Func.

En el siguiente post veremos que es una expresión lambda y como se usa en frameworks como LinQ.

Ahora veremos el concepto de funciones anonimas

Funciones con nombre

La vez anterior nos quedamos con el siguiente codigo:

public class Algo
{
    // Definimos el nuevo tipo
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Le asignamos una implementacion 
        Add = ImplementacionDeLaSuma;
        //La usamos
        double res = Add(3.0f,5.0f)
    }

    double ImplementacionDeLaSuma ( float elNumeroA, float elNumeroB ){
        return elNumeroA + elNumeroB;
    }
}

En este ejemplo creamos un delegado llamado Suma y con ese delegado creamos una “variable” llamada Add.
Para poder utilizar nuestra variable Add le asignamos la funcion ImplementacionDeLaSuma, va a parecer redundante pero ImplementacionDeLaSuma es el nombre de una funcion, mediante ese nombre podemos hacer referencia a ella ya sea para mandarla llamar como funcion ImplementacionDeLaSuma() o utilizarla como “variable” y pasar la referencia de su implementacion a otra “variable” que tenga la misma firma.

Como vimos en el post anterior, el delegado y la función ImplementacionDeLaSuma comparten la misma firma lo que hace posible la igualacion (redundo por que es importante).

¿Y si pudieramos asignar la pura implementacion sin tener que crear una nueva función?

Eso es posible usando delegate de la siguiente forma:

delegate(parametros) { implementacion };

Los parametros: Que como en cualquier función son las variables con las que vamos a trabajar.
La implementacion: Es donde vamos a implementar, escribir, poner, el codigo a ejecutar.

Un ejemplo rápido seria el reescribir la funcion ImplementacionDeLaSuma con esta sintaxis de delegado, el resultado seria el siguiente.

delegate(float elNumeroA, float elNumeroB) { return elNumeroA + elNumeroB };

Como veran en vez de darle un nombre a la funcion utilizamos la palabra reservada delegate como “nombre” de la funcion, y despues solo lo asignamos a nuestro delegado Add. A esto se le conoce como una.

Funcion Anonima

Una funcion anonima consiste en la pura implementacion sin un nombre con el cual se pueda hacer referencia a ella, es por eso que se asigna a una variable de tipo delegate para poder guardarla y utilizarla como vemos en el siguiente ejemplo.

Add = delegate(float elNumeroA, float elNumeroB) { return elNumeroA + elNumeroB };

Esto hace cambiar nuestro ejemplo original y quedaria de la siguiente forma.

public class Algo
{
    // Definimos el nuevo tipo
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Le asignamos una implementacion mediante una funcion anonima
        Add = delegate(float elNumeroA, float elNumeroB) { return elNumeroA + elNumeroB };
        //La usamos
        double res = Add(3.0f,5.0f)
    }

    // ya no necesitamos el metodo ImplementacionDeLaSuma
}

Las funciones anónimas son bastante utiles y poderosas ya que nos permiten asignar implementaciones de una forma rápida y practica además de que es una caracteristica muy usada en Linq, Asyncronos y otras características avanzadas de C#.

En el siguiente post hablaremos de un par de tipos de dato generico que nos sera muy util manipular delegados y funciones anonimas.

¿Que es un delegado?

La respuesta mas sencilla para quien viene de C es

Un delegado es un puntero a una función o método.

Una segunda definición ya basada en C# es

Un Tipo de dato que hace referencia a una función o método.

Ambas definiciones son en escencia lo mismo pero vamos dividiendola en partes, tenemos dos elementos principales, el Tipo de dato y la Función o Mètodo.

Función o Mètodo

Una función o método es un bloque de codigo que contiene una serie de sentencias, la hemos utilizado hasta el cansancio desde que aprendimos a programar y que es como esto:

double Suma(float numeroA, float numeroB){
    return numeroA + numeroB;
}

este método lo dividiria en dos partes, la declaración int Suma(int numeroA, int numeroB) y la implementación { return numeroA + numeroB; }. En este momento lo que a nosotros nos importa es la declaración que se divide en tres partes:

TipoDelValorDevueltoNombreDelMetodo (Parametros);

Aqui voy a introducir un nuevo concepto llamado:
Firma

La firma de un método es la combinación de los tipos de los parametros y el TipoDelValorDevuelto, en pocas palabras:

Firma = Parametros + TipoDelValorDevuelto

Por ejemplo la firma de nuestro ejemplo anterior seria < float, float, double >. En casos donde la declaración sea:

void HazAlgo(int numA, int numB);

La firma seria algo como < int, int > debido a que el TipoDeValorDevuelto es void y por lo tanto no hay.

La firma es bastante importante por que es la huella digital del método y es la caracteristica que hace compatible a un método con unos delegados e incompatible con otros.

Tipo de dato

Como ya sabemos, los tipos definen el tipo de dato que van a guardar las variables, tenemos tipos por valor como los son int, float, bool, byte y tipos por referencia como lo son la mayoria de las clases en .Net.

En .Net nosotros podemos definir nuevos tipos como usando class para crear clases, enum para crear enumeraciones, struct para estructuras entre otras; esto les sera muy familiar ya que despues de definir mediante estas palabras un nuevo tipo pueden crear una nueva variable, por ejemplo.

// Definimos el nuevo tipo
public class Prueba{
    public int Numero { get; set; }
}

public class Consumir{
    public Consumir(){
        // Creamos variable de tipo Prueba
        Prueba LaPrueba;
        // Le asignamos una instancia
        LaPrueba = new Prueba();
        // La usamos
        LaPrueba.Numero = 10;
    }
}

Volviendo al delegado

Con los delegados pasa lo mismo como veremos a continuacion, tomemos la siguiente declaración:

delegate double Suma ( float numeroA, float numeroB );

Como podemos ver es muy parecido a lo que vimos anteriormente, las diferencias son dos, la primera es la palabra delegate al comienzo de la declaración y la segunda es el ; al final lo que nos indica que no habra implementacion.

Lo que se ha hecho en este lugar es definir un nuevo Tipo para apuntar a métodos, cuyo nombre sera Suma y cuya firma sera < float, float, double > de acuerdo a las reglas que hemos estado viendo.

Esto me permite entonces crear una nueva variable usando el nuevo tipo de la siguiente forma:

public class Algo
{
    // Definimos el nuevo tipo
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
    }
}

Aqui podemos ver claramente que creamos una nueva variable de nombre Add del tipo Suma. Como es una variable por referencia, el valor de Add es null de la misma forma que cualquier otro tipo por referencia que no ha sido inicializado.

Ahora vamos a crear este método en nuestra clase:

double ImplementacionDeLaSuma ( float elNumeroA, float elNumeroB ){
    return elNumeroA + elNumeroB;
}

¿Pueden decir cual es la firma de este método? . . . . si, es < float, float, double >.
¿Es esta firma igual a la firma de nuestro delegado? . . . . . . si, son iguales.

Entonces aqui viene el truco de magia.

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Le asignamos una implementacion 
        Add = ImplementacionDeLaSuma;
    }

Como el método tiene la misma forma que nuestro nuevo tipo, podemos a nuestra nueva variable Add asignarle la implementación de nuestro método debido a que podemos obtener la referencia del metodo mediante su NombreDelMetodo quitando los parametros.

A partir de este momento nosotros podemos utilizar nuestra variable Add como un método debido a que ya esta haciendo referencia al metodo ImplementacionDeLaSuma usandolo de la siguiente forma:

public class Algo
{
    // Definimos el nuevo tipo
    delegate double Suma ( float numeroA, float numeroB );

    public Algo(){
        // Creamos variable del tipo Suma
        //TipoDeVariable NombreDeVariable
        Suma              Add;
        //Le asignamos una implementacion 
        Add = ImplementacionDeLaSuma;
        //La usamos
        double res = Add(3.0f,5.0f)
    }

    double ImplementacionDeLaSuma ( float elNumeroA, float elNumeroB ){
        return elNumeroA + elNumeroB;
    }
}

Hasta este punto descubrimos lo que es crear delegados y usar Funciones con Nombre para interactuar con ellos tambien utilizamos la palabra reservada delegate para crear tipos, descubrimos que era la firma de un método, cual es su declaración y cual es su implementacion.

Para el siguiente post seguiremos con Funciones Anonimas y las cosas se pondran divertidas.

Si tienen dudas preguntas o comentarios pueden dejarlos en los comentarios o buscarme por Twitter.

La computadora lo hara cada vez que decidas correr la prueba o si tienes un Continuous Integration Server puedes agregar las pruebas para que cada que compiles te avise cuando lo rompas al estar reparando un bug o implementando otra funcionalidad.

Lo hermoso de esto es que es tan facil como hacer una macro de Excel:

1. Grabas la “macro” con Selenium IDE.
2. La exportas a código C#.
3. La ejecutas como un TestUnit cada que te de la gana.

Pero primero hay que configurar nuestro ambiente.

Instalando Selenium Server

Lo primero que hay que hacer es bajar del sitio de Selenium el servidor que podras encontrar en su seccion de descargas lo podras encontrar bajo el nombre de Selenium Standalone Server.

Despues tendras que decidir donde instalarlo y como es una aplicacion Java tendras que instalar el Java Runtime previamente, para fines practicos lo instalaremos en la misma maquina en la que vamos a desarrollar.

Nota: Es recomendable en un equipo de desarrollo el correr el servidor Selenium en un servidor o maquina virtual con direccion ip fija (o una direccion en el DNS) que sea dedicado a pruebas solamente.

Como siguiente hay que instalar los navegadores que usaremos para correr nuestras pruebas automaticas.

Nota: Puedes tener diferentes maquinas virtuales con diferentes versiones de sistemas operativos y navegadores para ampliar tu capacidad de validar en diferentes configuraciones

Ya que tenemos instalado el servidor y conocemos su ubicacion el siguiente paso es preparar un Firefox para grabar las pruebas cual macro de Excel, para eso utilizaremos un plugin llamado Selenium IDE que podemos descargar de la misma página en la que encontramos el server.

Configurando Xamarin Studio (MonoDevelop)

Vamos a crear una nueva solucion del tipo NUnit (New Solution -> .Net -> NUnit Library Project) y le pondremos SeleniumAuto.Test, después lo que tenemos que hacer es agregar mediante NuGet el assembly Selenium WebDriver y Selenium WebDriver Support Classes, esto lo podras realizar haciendo click derecho en Packages, Seleccionar Add Packages… y despues buscar Selenium WebDriver, repetir todo para Selenium WebDriver Support Classes.

Ahora estamos listos paraponer manos a la obra.

1) Grabando la “macro” con Selenium IDE

En Firefox nos iremos al menu Tools -> Selenium IDE y debermos ver una nueva ventana como la imagen de abajo

Lo primero que hay que hacer es definir la Base Url en la parte de arriba que nos indicara desde donde se iniciara la prueba, despues tendremos que ir a Firefox, abrir una nueva pestaña y navegar hasta la url que definimos como base, en este punto estamos listos para grabar la prueba.

El siguiente paso es presionar el circulo rojo o boton de grabar a la derecha para iniciar a grabar y despues regresar a nuestra pestaña previamente preparada de Firefox para comenzar a realizar las acciones que vamos a automatizar, conforme vayamos realizandolas apareceran en el Selenium IDE.

Para terminar solo hay que volver a presionar el boton de grabar.

2) Exportando a código C#

Este paso es sencillo, solo volvemos al Selenium IDE y nos vamos al menu File -> Export Test Case -> C# / Nunit / WebDriver y guardaremos el archivo con la extension .cs

Tenemos dos tipos diferentes a exportar, el WebDriver y el Remote Control, la recomendacion aqui es usar el WebDriver ya que es la version mas nueva mientras que el Remote Control es de versiones anteriores de Selenium.

Nota: Como podran ver se puede exportar a diferentes lenguajes como Ruby, Python, Java y C#, esto se debe a que Selenium Server expone una API que puede ser consumida por diferentes clientes y que se puede crear un cliente en el lenguaje que tu quieras.

Exportaremos el codigo como NewTest.cs.

3) Ejecutando el código como un TestUnit cada que te de la gana

El siguiente paso es abrir nuestro proyecto Test en Xamarin Studio e importar el archivo que genero Selenium IDE y podremos ver un UnitTest ya programado como el de abajo.

Para correr nuestra prueba tendremos que ir al menu View -> Pads -> Unit Test y en el panel que aparezca presionaremos Run All

En este punto veremos que se abre una ventana de Firefox y comienza a correr la prueba de forma automatica, esto esta muy bien para crear el script pero cuando queremos hacerlo automatico necesitamos enviarlo al servidor con estos dos cambios:

1) Agregaremos el assembly OpenQA.Selenium.Remote; en los using
2) Cambiaremos la linea

csharp driver = new FirefoxDriver(); ==

por

DesiredCapabilities cap = DesiredCapabilities.Firefox ();
driver = RemoteWebDriver(new url("server",cap));

Donde DesiredCapabilities nos sirve para definir el browser sobre el que vamos a probar y RemoteWebDriver es la conexion con nuestro servidor previamente configurado donde server es la URL del server.
Notas Finales
Como pudimos ver no es estrictamente necesario el server para realizar las pruebas automaticas ya que las podemos correr desde nuestra IDE pero pensando en automatizar todo el proceso, un servidor sera necesario.
Si tienen dudas preguntas o comentarios pueden dejarlos en los comentarios o buscarme por Twitter.
]]>
					
					https://www.binamedia.net/2015/07/pruebas-automaticas-de-ui-con-selenium-y-csharp/feed/
			1
		
		
			
		
		
		https://www.binamedia.net/2014/08/asp-net-vnext-alpha-3-agosto-2014/
					https://www.binamedia.net/2014/08/asp-net-vnext-alpha-3-agosto-2014/#respond
		
		
		Fri, 29 Aug 2014 14:38:14 +0000
				
		
		
		http://www.binamedia.net/?p=494

					
										

Si has estado ocupado en tus proyectos y este 2014 te ha pasado desapercibido, es bueno que te vayas enterando de lo que viene en el mundo del .Net y uno de los proyectos mas importantes que se encuentra actualmente en desarrollo es vNext que es la siguiente version de ASP.Net
Entre las nuevas características se encuentran algunas como:

Es Open Source y corre en Windows (.Net Framework), Mac y Linux (Mono Framework)
No compila, leíste bien NO COMPILA, todo esto gracias al nuevo compilador Open Source Roslyn que corre en memoria.
Optimización opcional para la nube gracias al CoreCLR(^1) que corre muy bien en Azure.
Puedes usar una Mac y Sublime Text en vez de Windows y Visual Studio.
Sin dependencias a System.Net(^2).
Inyección de dependencias en todos lados.
Multiples runtimes corriendo lado a lado sin interferir uno con otro(^3).
Administrado por paquetes NuGet y un nuevo archivo de configuración estilo Node.js (o Ruby o Laravel) llamado project.json.

Si deseas probar todas estas novedades lo puedes hacer con el Community Technology Preview de Visual Studio 14 (Visual Studio “14” CTP 3 para hacerlo corto) que ya incluye el intellisence para el Project.json y otras novedades.
Se que hay algunos términos y novedades que tal vez no conozcan por lo que aquí unas pequeñas notas a pie de pagin… post.
(^1) CoreCLR Como parte de las novedades en vNext Microsoft retomo el CoreCLR que es una selección de assemblies mínimos necesarios para realizar la mayor cantidad de tareas, en el caso de vNext se esta partiendo el .Net Framework en pedacitos optimizados para la nube, de esta forma mediante el archivo Project.json se podrán seleccionar los elementos del CLR que estrictamente se necesitan en la aplicación que estas desarrollando, esto permite que las aplicaciones sean más pequeñas y consuman menos memoria, algo que para entornos de nube genera muchos beneficios.
(^2) System.Net Uno de los problemas que Mono y la comunidad Open Source tuvieron y discutieron fue la dependencia de MVC y ASP.Net al assembly propietario de Microsoft System.Net, el problema raiz es que al ser propietaria, Microsoft podría demandar a cualquiera que hiciera una implementación de la misma para ejecutarla en Mono. Lo divertido del asunto es que este assembly es ya tan complejo y tan dependiente de IIS que ni los encargados del .Net Framework han podido crear una version deslindada del IIS de allí un inicio desde cero open source libre de estos problemas.
(^3) Normalmente cuando tienes un servidor IIS en el que ejecutas aplicaciones de Asp.Net tienes instalado el .Net Framework o varias versiones del .Net Framework, el problema reside en que todas tus aplicaciones que corren por ejemplo en el framework 4.0 serán afectadas por cualquier cambio en la configuración de ese framework. Con vNext podrás tener Frameworks modulares (gracias a CoreCLR y Project.json) que correrán en paralelo, así podrás tener una app de framework 5.0(nombre no definitivo) corriendo junto a otra que corra el mismo framework y cada con sus propias configuraciones.
Se vienen cosas interesantes en el mundo del .Net y todavía es buen tiempo para seguir estas novedades.
Dudas preguntas y comentarios los pueden hacer aquí o por twitter en @binamonk
 
Visto, traducido y comentado del blog de Scott Hanselman.
 
]]>
					
					https://www.binamedia.net/2014/08/asp-net-vnext-alpha-3-agosto-2014/feed/
			0
		
		
			
		
		
		https://www.binamedia.net/2014/08/office-dev-center-extendiendo-office-con-el-poder-del-html-5/
					https://www.binamedia.net/2014/08/office-dev-center-extendiendo-office-con-el-poder-del-html-5/#respond
		
		
		Tue, 26 Aug 2014 15:21:46 +0000
				
		
		http://www.binamedia.net/?p=489

					
										

Con la creación de Azure y la consolidación de la nube muchas cosas están cambiando en Microsoft, una de ellas es Office y su iniciativa Office 365 que es una subscripción para contar con varios servicios para oficina que va desde correo hasta toda la suite completa de Office.
Lo mas nuevo en Office 365 es su nuevo portal para desarrolladores en Dev.Office.Com donde podemos aprender com extender las capacidades de esta suite con nuestros propios desarrollos.
¿Cómo hacerlo?
Básicamente con HTML, CSS y Javascript ya que la API de Office 365 es web friendly y los plugins pueden ser creados con estos lenguajes y tu aplicación es un mini sitio que se conecta con office para generar el valor agregado que deseas.
Esta aplicación deberá ser hospedada en un Tenant (un tipo de instancia de servidor web en Azure) permitiendo escalar las instancias para mantener la app funcionando sin que la demanda de usuarios la mate.
¿Por qué desarrollar para office?

Por que puedes integrarlo a tu negocio.
Por que puedes integrarlo a negocios de terceros y vender la integración.
Por que puedes hacer una aplicación como lo hizo PayPal para ayudar a la gente a crear recibos con datos directos de su cuenta de PayPal
Por que corre en Office for Mobile Devices como iOS y Android.
Administración centralizada al ser una aplicación web.

Es una opción interesante que puede funcionar en lugar de hacer macros con VBA o plugins que tienen que ser instalados.
]]>
					
					https://www.binamedia.net/2014/08/office-dev-center-extendiendo-office-con-el-poder-del-html-5/feed/
			0
		
		
			
		
		
		https://www.binamedia.net/2014/07/building-cloud-apps-with-microsoft-azure/
					https://www.binamedia.net/2014/07/building-cloud-apps-with-microsoft-azure/#respond
		
		
		Thu, 31 Jul 2014 19:58:16 +0000
				
		
		http://www.binamedia.net/?p=485

					
										

La creación de aplicaciones en la nube es un tema que ha tomado mucha importancia a la hora de diseñar o modernizar aplicaciones web, para el caso de la plataforma .Net, Azure tiene una serie de servicios poderosos que necesitan de buen conocimiento para obtener de ellos los mejores beneficios.
Microsoft consciente de ello libero este libro de mejores practicas para mejorar nuestro arsenal de soluciones.
Pueden descargar este libro como PDF AQUI
]]>
					
					https://www.binamedia.net/2014/07/building-cloud-apps-with-microsoft-azure/feed/
			0
		
		
			
		
		
		https://www.binamedia.net/2013/06/bug-en-sopitas-para-windows-phone-reparado/
					https://www.binamedia.net/2013/06/bug-en-sopitas-para-windows-phone-reparado/#respond
		
		
		Thu, 06 Jun 2013 16:58:53 +0000
				
		http://www.binamedia.net/?p=473

					
										

 
A partir de la tarde del 5 de Junio apareció un bug en la aplicación de Sopitas para Windows Phone que hace que se cierre de forma repentina sin dejar ver las noticias, afortunadamente ya fue reparado y se encuentra en camino el fix para que puedan seguir disfrutando de sus noticias favoritas.
La tienda de Windows tarda 5 días en publicar las actualizaciones por lo que el proximo Miercoles 6 de Julio ya tendran lista la actualización con el fix.
Saludos
]]>
					
					https://www.binamedia.net/2013/06/bug-en-sopitas-para-windows-phone-reparado/feed/
			0