Hasta ahora no me había dado cuenta.
No me funcionaban los comentarios del blog!!!
Esto creo que suele pasar porque hay plantillas en los que no funcionan correctamente los comentarios incrustados.
Hay 3 opciones:
Retocar la plantilla
Esta opción la dejo para usuarios valientes.
Se trata de entrar al código y ajustar la plantilla para que funcione.
http://vagabundia.blogspot.com/2008/06/blogger-fenix-el-formulario-de.html
http://vagabundia.blogspot.com/2008/06/solucin-para-algunos-problemas-al.html
Cambiar de plantilla
Si no van los comentarios incrustados en nuestra plantilla, ¿por qué no cambiarnos a una plantilla en la que funcionen?
Cambiar el formato de los comentarios
Esta opción es algo más facilita.
Como se dan los problemas con los comentarios incrustados, los cambiaremos por ventanas emergentes.
En el interfaz nuevo no he conseguido encontrar el formato de los comentarios, por lo que debemos de cambiar al formato antiguo.
Una vez en el formato antiguo, nos vamos a la pestaña "Comentarios"
y cambiamos la opción a "Ventanas emergentes"
y YA FUNCIONAN LOS COMENTARIOS!!!!
Blog con tutoriales y comentarios acerca de las tecnologías .Net en particular y de la informática en general.
sábado, 8 de octubre de 2011
domingo, 2 de octubre de 2011
Expresiones lambda para torpes
Creo que somos muchos (me incluyo) los que usamos las expresiones lambda por inercia y sin saber de dónde salen y cómo sarles su jugo.
Recordemos que una expresión lambda es algo así:
static void main()
{
int resultado=multiplica(5,2); // ejecutamos la función
}
static int multiplica(int a, int b)
{
return a * b;
}
Pues bien, compliquemos un poco esto.
static void main()
{
miDelegado deleg = multiplica; // asignamos la función al delegado
int resultado = deleg(5, 2); // ejecutamos el delegado
}
static int multiplica(int a, int b)
{
return a * b;
}
Podemos simplificar un poco esta función llamando a Func<>, que es una nueva forma genérica de crear delegados. (apareció en el Framework 3.5)
static void main()
{
Func<int,int,int> miMetodo = multiplica; // asignamos la función al delegado
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
static int multiplica(int a, int b)
{
return a * b;
}
Ahora declaremos la función dentro del método Main
static void main()
{
Func<int, int, int> miMetodo = delegate(int a, int b) { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
Esto se puede traducir a una expresión lambda.
static void main()
{
Func<int, int, int> miMetodo = (a, b)=> { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
{
Func<int, int, int> miMetodo = (a, b)=> a * b ;
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
Uso de expresiones lambda
Expresiones lambda como parámetros
{
Func<int, int, int> suma = (x, y) => x + y;
Func<int, int, int> rest = (x, y) => x - y;
Func<int, int, int> mult = (x, y) => x * y;
Func<int, int, int> divi = (x, y) => x / y;
int result=opera(5, 2, mult);
int result2=opera(5, 2, (x,y)=>x*y);
}
static int opera(int x, int y, Func<int, int, int> operacion)
{
return operacion(x, y);
}
{
int[] numeros = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int divisiblesx3 = numeros.Count(x =>x % 3 == 0);
IEnumerable<int> lista = numeros.Where(x => x % 3 == 0);
}
Nos dice que devuelve un entero, que Count cuelga de un IEnumerable<int> (array números) y que admite una función que probará cada elemento. Esta función admite un int y devuelve un bool, que si cumple la condición, será un count acertado.
Expresión lambda de una función sin parámetros de entrada
{
Func<string> saludo= () => string.Format("Hola");
string result = saludo();
}
Func<string> ObtieneNombre = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
return nombre;
};
Console.WriteLine("Hola, " + ObtieneNombre());
}
Action Saludo = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
Console.WriteLine("Hola, " + nombre);
};
Saludo();
}
Espero que este artículo os ayude a que entendáis un poco más las expresiones lambda
Libro C# 3.0 y LINQ, de Octavio Hernández.
http://www.campusmvp.com/catalogo/Product-C-3.0-y-LINQ_1.aspx
Ctx.articulos.where(art=>art.codigo==’40’)
Pues bien, las expresiones lambda no son más que funciones empaquetadas como un parámetro de una función.
En este ejemplo estamos diciendo que del ienumerable artículos, por cada artículo, devuelva una lista con los elementos que la ejecución de la función "art.codigo=='40'" sea True.
¿De dónde salen las expresiones lambda?
Seguro que este caso os es muy familiar:
static void main()
{
int resultado=multiplica(5,2); // ejecutamos la función
}
static int multiplica(int a, int b)
{
return a * b;
}
Pues bien, compliquemos un poco esto.
Un delegado es un puntero a una función; es decir, a una
variable de tipo “delegado” le asignamos una función.
El delegado debe de tener los mismos parámetros tanto de entrada como de
retorno.
Vamos a usar un delegado para llamar a la función “multiplica”.
delegate int miDelegado(int a, int b); //declaramos el delegado
static void main()
{
miDelegado deleg = multiplica; // asignamos la función al delegado
int resultado = deleg(5, 2); // ejecutamos el delegado
}
static int multiplica(int a, int b)
{
return a * b;
}
Podemos simplificar un poco esta función llamando a Func<>, que es una nueva forma genérica de crear delegados. (apareció en el Framework 3.5)
static void main()
{
Func<int,int,int> miMetodo = multiplica; // asignamos la función al delegado
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
static int multiplica(int a, int b)
{
return a * b;
}
En la función Func<int,int,int>, el 1er y el 2º int corresponden a los parámetros de entrada de la función Multiplica, y el último int es la variable de retorno.
Ahora declaremos la función dentro del método Main
{
Func<int, int, int> miMetodo = delegate(int a, int b) { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
Esto se puede traducir a una expresión lambda.
static void main()
{
Func<int, int, int> miMetodo = (a, b)=> { return a * b; };
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
Y como el cuerpo de la función es sencillo, podríamos
incluso resumirlo de esta manera:
static void main(){
Func<int, int, int> miMetodo = (a, b)=> a * b ;
int resultado = miMetodo(5, 2); // ejecutamos el delegado
}
Uso de expresiones lambda
Expresiones lambda como parámetros
En este ejemplo tenemos 4 funciones de operaciones básicas,
y en la función “opera” le pasamos una expresión lambda como parámetro, tanto
declarada como “al vuelo”
static void main(){
Func<int, int, int> suma = (x, y) => x + y;
Func<int, int, int> rest = (x, y) => x - y;
Func<int, int, int> mult = (x, y) => x * y;
Func<int, int, int> divi = (x, y) => x / y;
int result=opera(5, 2, mult);
int result2=opera(5, 2, (x,y)=>x*y);
}
static int opera(int x, int y, Func<int, int, int> operacion)
{
return operacion(x, y);
}
Otro ejemplo: contamos y obtenemos los múltipos de 3
static void main(){
int[] numeros = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int divisiblesx3 = numeros.Count(x =>x % 3 == 0);
IEnumerable<int> lista = numeros.Where(x => x % 3 == 0);
}
Aquí fijémonos en el intellisense de la función Count.
Nos dice que devuelve un entero, que Count cuelga de un IEnumerable<int> (array números) y que admite una función que probará cada elemento. Esta función admite un int y devuelve un bool, que si cumple la condición, será un count acertado.
El where lo mismo; nos devolverá una lista con los múltiplos
de 3.
Expresión lambda de una función sin parámetros de entrada
Aunque no hayan parámetros de entrada, debemos de poner los
paréntesis.
static void main(){
Func<string> saludo= () => string.Format("Hola");
string result = saludo();
}
Expresión
lambda de una function compleja
En este ejemplo, vemos
cómo la función no debe de ser una simple operación, sino que puede ser de
cualquier tamaño
static void main()
{Func<string> ObtieneNombre = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
return nombre;
};
Console.WriteLine("Hola, " + ObtieneNombre());
}
Expresión
lambda de una función que no devuelve datos
Para este caso, sustituyamos
la instrucción “func” por “action”
static void main()
{Action Saludo = () =>
{
Console.WriteLine("Dime tu nombre");
string nombre = Console.ReadLine();
Console.WriteLine("Hola, " + nombre);
};
Saludo();
}
Espero que este artículo os ayude a que entendáis un poco más las expresiones lambda
Enlaces
http://msdn.microsoft.com/es-es/library/bb397687.aspx
Desmitificando las expresiones lambda, por el Maestro Jose María Aguilar.
http://www.variablenotfound.com/2009/03/c-desmitificando-las-expresiones-lambda.html
Expresiones lambdahttp://www.variablenotfound.com/2009/03/c-desmitificando-las-expresiones-lambda.html
Libro C# 3.0 y LINQ, de Octavio Hernández.
http://www.campusmvp.com/catalogo/Product-C-3.0-y-LINQ_1.aspx
Publicado por
Juan Manuel Fenoll
a las
22:31
0
comentarios


Enviar por correo electrónicoEscribe un blogCompartir en XCompartir con FacebookCompartir en Pinterest
Etiquetas:
c#
Suscribirse a:
Entradas (Atom)