Powerful generic class for a generic abstraction of IEqualityComparer.
jueves, 17 de noviembre de 2016
domingo, 6 de noviembre de 2016
Extendiendo LinQ
Como hemos mencionado en otros posts y en otras ocasiones,
la librería principal de LinQ,
System.Linq, está formada por un
conjunto de métodos extensores que en la mayoría de los casos expande la
funcionalidad del tipo
IEnumerable<T>. Por este motivo, y por facilidad de generación
de este tipo de métodos, alargar, dilatar, mejorar o incluso moldear muchos de
ellos, se vuelve una tarea muy simple y en ocasiones bastante gratificante y
útil.
domingo, 30 de octubre de 2016
PLinQ 2
En este nuevo post de PLinQ,
nos vamos a centrar en los métodos más importantes de ParalallelEnumerable, decimos los más importantes, ya que nos
ofrecen una funcionalidad extra para nuestras consultas parametrizadas.
Cabe destacar, como nombramos en el anterior post de PLinQ,
que la clase ParallelEnumerable,
tiene una definición para cada uno de los métodos
extensores (operadores de consulta) de la clase System.LinQ, para hacer completamente transparente su uso, de
modo que pensemos que estamos utilizando una consulta simple a un IEnumerable.
sábado, 22 de octubre de 2016
PlinQ 1
A forma de introducción, PLinQ,
ofrece la capacidad de realizar consultas LinQ
To Objects, de forma paralela, ósea
utilizando todos los cores
(núcleos) de el microprocesador. En un primer vistazo, podemos pensar que esto
es magia, pero como veremos a continuación, no es algo que sea 100%
recomendable en todos los casos, y puede llegar a tener una serie de
consideraciones y fallos, que o bien no conocemos o no estamos acostumbrados en
la programación síncrona.
Una de las ideas que solemos tener en nuestra cabeza acerca
de la programación en paralelo, es que si poseemos una máquina con 4 cores o microprocesadores, un
trabajo que tarda en hacerse 20 segundos, debería de tardar 20/4, solo 5
segundos. Esto no es cierto, hay algunos casos en que la ejecución sobre un
único núcleo es más rápida que sobre n.
La diferencia radica, en que para poder hacer una ejecución en paralelo es
necesario particionar la información en trozos, para que cada uno de estos, sea
tratado por un núcleo y luego volver a fusionar la información. Todo este
trabajo, conlleva un sobrecoste, que en ocasiones no es conveniente.
lunes, 16 de mayo de 2016
Let
Una entrada que pudiera ser no merecedora de un espacio para
ella sola. La cláusula Let,
tiene una serie de virtudes que van desde una mejora notable en la lectura y
comprensión del código, hasta un incremento en el rendimiento por la reducción
de llamadas redundantes.
La única nota negativa, pero no menos importante, es que
esta cláusula, solo puede utilizarse con sintaxis de consulta (azúcar sintáctico), por lo que nuestras queridas Lambdas se quedan fuera.
domingo, 8 de mayo de 2016
Operadores de Conversión
Como su propio nombre indica, los operadores de conversión
realizan transformaciones de datos de un tipo de colecciones a otras.
En este caso tenemos un grupo de operadores de conversión
que son de ejecución instantánea, compuesta por los operadores ToList, ToArray, ToLookUp
y ToDictionary, y otro grupo de carga
perezosa o diferida, compuesta por OffType
y Cast. De este último tipo también
sería el operador AsEnumerable,
pero en éste no pondremos mucho énfasis, ya que es un operador que se utiliza
más en LinqToSql o LinqToEntities, y este curso es de LinqToObjects.
domingo, 1 de mayo de 2016
Operadores de Ordenación
Llegamos al grupo de operadores destinados a realizar el trabajo de ordenación en nuestras colecciones. Dentro de este apartado nos encontramos con un nuevo actor de este teatro, un actor que tiene una importancia mínima pero que forma parte de todo este tinglao, es la interfaz IOrderedEnumerable<TElement> . Es una interfaz super simple, que hereda de IEnumerable<TElement> y de IEnumerable, y que simplemente añade un método CreateOrderedEnumerable, cuya función será la de crear las ordenaciones. Es importante nombrarla ya que será el tipo de devolución que generen nuestros operadores de ordenación OrderBy, OrderByDescending, ThenBy y ThenByDescending.
Llegados a este momento del repaso de LinQ, volveremos a ver las diferencias para estos operadores
entre la sintaxis de consultas
y nuestras queridas Lambdas.
martes, 19 de abril de 2016
Operadores de Agregación
Los Aggregate Operators, nos permiten realizar operaciones matemáticas de una temática simple sobre los elementos que forman una colección. Normalmente el resultado de estos, es un valor numérico, aunque no siempre es obligatorio.
La ejecución de todos estos operadores es inmediata, y se
realiza justo en el momento de realizar la llamada, por lo que ninguno de ellos
tiene ejecución diferida
o perezosa.
En este conjunto de operadores, se diferencian tres tipos.
Un primer tipo muy simple, compuesto por Count
y LongCount. Un segundo grupo también
bastante sencillo compuesto por Max,
Min, Sum y Average
y un tercero compuesto por el operador Aggregate,
más complejo y potente. El primer grupo, posee sobrecargas sin parámetros, para
secuencias numéricas sencillas y sobrecargas con filtrado (parámetro Func<T, bool>), que purifican
la secuencia antes de aplicar el cálculo. Los métodos correspondientes al
segundo grupo, poseen un número bastante considerable de sobrecargas, que van
en concordancia con el tipo de datos sobre el que se aplica el cálculo,
normalmente int, int?, double, doublé?,
decimal, decimal?, long
y long? En afinidad con su delegado genérico
Func<T, int>, Func<T, int?>, Func<T, double> …
jueves, 24 de marzo de 2016
Autonuméricos, EntityFramework Sql y Oracle
El uso de Entity Framework, cada vez está más en nuestro día a día, con una cantidad de versiones que avalan a este OMR de Microsoft.
Normalmente suele estar muy ligado a Sql Server, y la parte para Oracle es mucho menos conocida, aunque no por ello no menos práctica.
Esta entrada trata de explicar de forma bastante extensa el uso para EF de Autonuméricos, difiniendo este término por las propiedades Identity o Secuencias en Oracle, que para este ORM no tiene ningún tratamiento especial y todo hay, hay que hacerlo un poco de 0.
El contenido lo creé para elaborar un artículo en CodeProyect por allí por el 2013, pero si contamos con que no tengo mucho control con la lengua de Shakespeare y que traspapelé su versión, pues éste se quedó en el olvido. No hace mucho que he vuelto a encontrarlo en castellano, y al estar ejecutado sobre la versión de EF 5.0, completamente compatible con la actual 6.2, he creído que podría ser de utilidad.
Dentro de la versión de Entity Framework Core/7.0, tendremos una nueva característica que nos permitirá hacer una comunión con grupos de claves autonuméricas entre el cliente y la BD, que añadirá otra opción más a todas las que aparecen bajo estas líneas. Por supuesto todavía queda bastante para la versión final de Sql Server y que decir para la de Oracle, aunque últimamente se están poniendo las pilas y liberan sus versiones de ODP.Net para EntityFramework con fechas muy cercanas a las salidas de Visual Studio y el Net. Framework.
No es que me guste demasiado meter así post de otras tecnologías, soy más de empezar algo desde el principio como con LinQ, pero así esto no se quedará en el olvido. Si el tiempo y la entrega me lo permiten me gustaría atacar WPF, que hay un vacío en español inmensurable y después EntityFramework. Por mi cabeza también pasa tratar la TPL (Task Parallel Library), TDD, Unit Tests, y un largo etc, pero no se si el tiempo me lo permitirá. por ahora ahí queda eso.
sábado, 21 de noviembre de 2015
Breve parada en el camino
Esta entrada, es un poco atípica en mi blog, y es un poco explicativa, dado el tiempo que llevo sin postear.
El motivo de todo esto, es que estoy muy metido en el
desarrollo de un componente, que creo que puede ser bastante revolucionario. Es
un UserControl de
WPF,
realizado completamente en TDD
puro y con MVVM.
Dentro del mismo también utilizo la TPL
(Task Parallel Library), para darle soltura y respuesta rápida.
Este trabajo, está haciendo que el tiempo de
desarrollo aumente, y con él el retraso en nuestro curso de LinQ. Intentaré ir introduciendo
alguna entrega más entre medias del desarrollo, ya que todavía queda mucha tela
que cortar.
Mi idea es
acabar el curso de LinQ
por completo, y a ser posible poder iniciar otros con distinta temática, pero
con el mismo paradigma, que no es otro que entrar a fondo en los temas, con los
ejemplos más clarificadores posibles, alejándonos de los clones y arquetipos copy/paste que aparecen en la red.
Así que lo único que falta, es un poco de paciencia.
jueves, 27 de agosto de 2015
Novedades C# 6.0 (Parte 3)
Vamos a finalizar esta serie de posts de novedades de C# 6.0, entrando en profundidad dentro de los apartados de Name of Expressions, la utilización
de Await en los bloques catch y finally, y continuando con las excepciones,
acabaremos con una novedad adoptada de Visual Basic,
que no es otra que los bloques catchs
condicionales o filtrado de excepciones.