40. C# 6.0 (III) - Dictionary Initializers

Un diccionario es una estructura de datos de gran utilidad, esta estructura representa una colección de datos, en la que se tiene una relación de clave y valor (key,value), la característica principal es que la clave debe ser única, mientras que el valor no necesita serlo.

El objeto es realmente cercano a un diccionario físico, en el que tenemos una palabra con su definición.

Ademas de esto el diccionario es una clase genérica que nos permite asignarle prácticamente cualquier objeto creando una relación entre ellos.

C# 6.0 trae consigo una nueva forma de declarar un diccionario, esta nueva forma logra que su uso sea mas claro, al momento de efectuar la asignación de cada uno de los valores del par de datos que lo componen.

Con un poco de código:

En el código tenemos la definición de 2 diccionarios uno entero cadena y uno cadena cadena, como podemos ver la asignación de la clave valor,. se maneja de manera directa, mostrando una codificación limpia y clara.

Si ejecutamos el programa, obtenemos la salida de los valores solicitados, como se muestra a continuación

Saludos

39. C# 6.0 (II) - Property Initializers

Una de las nuevas características de C# 6.0 es la inicialización automática de propiedades, esta es una característica, que no va a mejorar ni el desempeño ni el uso de recursos de nuestra aplicación, lo que mejora es la legibilidad del código.

Esta característica nos permite definir una propiedad e inicializarla en ese mismo instante.

Como es esto, muy sencillo veamos el siguiente fragmento de código:

Como podemos ver, las propiedades podemos inicializarlas directamente, y dejar que el compilador se encargue de generar el código necesario para hacer este proceso.

Hasta la proxima

38. C# 6.0 (I) – Interpolated Strings

Esta es una de las nuevas funcionalidades de C# 6.0, es una funcionalidad que es muy útil porque busca crear cada vez un código más entendible.

Su uso no repercutirá en mejores tiempos de proceso, o en menor o mayor uso de recursos, ya que nos está ofreciendo es la posibilidad de intercalar variables en una cadena y que el compilador por si solo complemente el código necesario para hacer esto.

Con esta función eliminamos los caracteres extra para concatenar cadenas, creado la cadena desde su origen en una forma limpia, el compilador llamara automáticamente a toString(), del objeto que estemos concatenando y será con el que sustituirá la cadena.

Bueno menos letras y más código, veamos un ejemplo.

Que obtendría de salida al ejecutar el código anterior:

De esto podemos observar que se nos está presentando una manera más legible para lograr concatenar cadenas.

El signo $ es el que le indica al compilador que en la siguiente sentencia se usara la interoperabilidad de cadenas.

Bueno esto solo es una ayuda para que el código se vuelva más legible, pero no se queda hasta ahí.

Esto nos permite también generar tomas de decisiones dentro de la cadena, veamos el siguiente código:

Este es un ejemplo muy interesante, evaluó la variable Amigo, como mi variable amigo es falsa, me debe escribir lo que se encuentre en la cadena adiós.

Al compilar y ejecutar, obtengo lo siguiente:

Otra característica, es que se puede dar formato a las cadenas de una manera más sencilla y legible, tal y como se muestra en este fragmento de código:

Al consultar los datos del objeto, estos son reemplazados en la cadena

Esta nueva característica solo busca facilitarnos las cosas como desarrolladores, para que el software que construyamos pueda ser mantenido más fácilmente.

O una clase, mientras sea un objeto que tenga implementado la función toString, usar la interoperabilidad de cadenas es posible, veamos el siguiente código:

Con el signo: puedo establecer un formato a la cadena, lo que me permite que esta se defina de una forma mucho más sencilla.

Al ejecutar el proceso:

Es importante resaltar que esta funcionalidad se encuentra a partir del .net 4.6.

Felices líneas

Carlos

________________________________________________
"Una vez un ordenador me venció jugando al ajedrez, pero no me opuso resistencia cuando pasamos al kick boxing".
-- Emo Philips

37. Concatenar archivos (Ayuda Rápida VII)

Muchas veces durante el trabajo diario es necesario concatenar grandes cantidades de archivos, desde el sistema operativo teniendo 2 o mas archivos en una carpeta

Empleamos la instrucción type y agregamos la salida de un archivo al final de otro

type x.txt >> y.txt

con >> indicamos que los archivos se concatenaran, si empleamos únicamente > un archivo sobrescribirá a otro.

Bien esto nos soluciona el problema de manera manual. ¿Pero que pasa si lo queremos hacer desde C#? invocar un proceso externo siempre es costoso.

Para ello usaremos la instrucción CopyTo de FileStream, esta instrucción nos permite copiar el contenido de un archivo a otro de una manera muy rápida y sencilla.

El código queda como se muestra a continuación:

Que hace el código, bueno el código de copiado de un archivo a otro se resume en la siguiente linea:

                    using (FileStream strFuente = File.OpenRead(Archivo))

                        strFuente.CopyTo(strArchivo);

en donde abre el archivo y copia su contenido.

felices lineas

36. Patrones de Diseño (IV) - Proxy

Este blog inicio con la idea de construir un código ordenado, de hacer que nuestro código tuviera una mayor calidad, y hacer que el mantenimiento del mismo fuera menos costoso, nació porque hay muchas habilidades que debe tener un arquitecto antes de poder modelar una arquitectura de un sistema.

La sección de patrones de diseño se creó para brindar herramientas para evitar ese código salvaje, la sección sigue vigente, pero el blog ha crecido y junto con él se han incorporado nuevas secciones.

Pero hoy retomaremos los patrones de diseño, vamos a hablar de un patrón, que es muy sencillo porque su uso es muy común, tan común que mucha gente que no es desarrolladora, entiende el concepto o lo han usado principalmente para conectarse a internet, me refiero al patrón Proxy.

¿Qué hace el patrón proxy?, El patrón proxy juega como un intermediario que permite la creación y acceso de un objeto a otros, es decir me sirve como un puente entre objetos, su aplicación más común es el uso de proxies en internet, para acceder a paginas o para limitar el tráfico a las mismas.

Tratemos de ilustrar el patrón:

Contamos con una interfaz en la que se definen las tareas que se realizaran, esta interfaz se encuentra implementada tanto en el Proxy como en el objeto real.

El cliente consumirá la interfaz, de esta forma el Proxy se podrá agregar como intermediario sin necesidad de efectuar modificaciones en nuestro cliente.

Cuando el cliente efectué una llamada, nuestro cliente primero ira al proxy, en donde se puede agregar funcionalidad, después de eso el proceso se ira al objeto real.

Existen muchos tipos de proxy, entre los más comunes se puede mencionar:

Proxies Virtuales: Manejan la creación de objetos, en muchos casos hay objetos que requieren un tiempo muy elevado para su creación, este tipo de proxies pueden asumir la identidad del objeto como si ya estuviera creado, en lo que el verdadero objeto se genera.

Como es esto, el proxie invoca un objeto, el proxie en este caso es un objeto ligero pero que ya tiene las características del mismo, mientras el proxie crea el verdadero objeto, el proxie actúa como el objeto que se está creando, mostrando propiedades de manera preliminar.

Imaginen una clase de dibujo compleja con la que ya se puede interactuar, pero que varios de sus componentes se muestran con barras de carga, el proxy la clase compleja, que está construyendo los objetos que están en él.

Y como se crea, se construyen los métodos para tener las firmas, pero los datos se cargan conforme se está usando el objeto, estos datos se cargan en un segundo objeto, el objeto real.

Proxies de Autenticación: Muy comunes, su labor es establecer los permisos de acceso a un objeto.

El proxie tiene las mismas firmas que el objeto que se desea controlar, sin embargo analiza el acceso al mismo objeto, y si este no cumple con cierta característica no permite el acceso al mismo.

Proxie remoto: permite enviar información a través de la red comportándose como un objeto local, cuando se implementa el proxy efectúa las tareas de comunicación.

Proxie Inteligente: Puede efectuar cambios en el mensaje con condiciones específicas, por ejemplo una codificación, agregar atributos etc.

Como pueden ver es un objeto muy sencillo porque su función es solo servir de intermediario de mensajes pero que es muy útil en aplicaciones en el mundo real.

Hasta la próxima

35. Buen Software

Mucho se ha hablado de 4 grandes características que debe tener todo software:

·         Mantenibilidad

·         Confiabilidad

·         Eficiencia

·         Usabilidad

Son características que todo arquitecto debe tener en mente al momento de diseñar una solución, vamos a repasarlas un poco.

Ya habíamos hablado de usabilidad en usabilidad estableciendo los 10 principios que menciona Jakob Nielsen

·         Visibilidad del estado del sistema

·         Relación entre el sistema y el mundo real

·         Control y libertad del usuario

·         Consistencia y estándares

·         Prevención de errores

·         Reconocimiento antes que recuerdo

·         Flexibilidad y eficiencia de uso

·         Estética y diseño minimalista

·         Ayuda a los usuarios a reconocer

·         Ayuda y documentación

Mantenernos dentro de estos nos da un gran paso, confianza al usuario, el sistema se convierte en algo que él entiende y que facilitara su trabajo, que es nuestra principal misión.

Eficiencia: Este es otro tema que hemos tocado en este blog, http://carlosamonroy.blogspot.mx/2015/06/mi-codigo-puede-volar.html , que quiere decir usar correctamente los recursos del sistema, hacer consultas rápida, administrar correctamente la memoria, optimizar código, en la actualidad hemos perdido mucho esa capacidad de optimización debido a que al tener hardware cada vez más robusto, dejamos mucho de este trabajo al hardware, desperdiciando una gran cantidad de recursos, el no optimizar nuestro software para lograr la máxima eficiencia, cobra su factura cuando este crece, cuando este sale de un ambiente controlado y empieza a consumir recursos que son por mucho superiores a los que esperamos.

No debemos depender del hardware, debemos buscar siempre hacer las cosas de una manera eficiente, en muchos casos esto ocurre al depender de muchos componentes de terceros, o de componentes que mejoran la interfaz gráfica, estos componentes llegan a ser muy pesados, componentes que en una primera impresión son buenos, peor que causan una gran molestia al enfrentarse a problemas reales.

Confiabilidad: característica de oro, el software debe ser confiable, esto se traduce en que debe hacer correctamente su trabajo todo el tiempo, que debe tener buenas prácticas de seguridad, la información es un bien y es uno de los bienes más valiosos, si el software no es confiable, puede causar resultados que van más allá de una falla en el sistema, un quiebra de una empresa, la muerte de 28 soldados que fue consecuencia de un error en un misil Patriot http://sydney.edu.au/engineering/it/~alum/patriot_bug.html

Mantenibilidad: Todo evoluciona, es necesario adaptarnos al cambio, el software debe nacer para que este pueda evolucionar fácilmente, vivimos en una industria que se mueve a una gran velocidad, los cambios se dan de un día a otro, el tener o no una ventaja competitiva depende de tomar las oportunidades cuando estas aparezcan, que la evolución del software se pueda dar, de una manera en que se puedan satisfacer rápidamente las necesidades del usuario

Hasta la próxima

34. Nuestra Historia (IV) - Kenneth Thompson

Grandes mentes han pavimentado el camino que hoy recorremos, la vez pasada mencionamos a un grande Dennis Ritchie, pero no se puede hablar de Dennis Ritchie sin mencionar a Kenneth Thompson, un científico que también creo las bases de lo que hoy en día tenemos.

Nace en el 4 de Febrero de 1943, egresado de la universidad de California, con un grado de maestría en la universidad de Berkeley.

Premio Turing en 1983 junto con Dennis Richie, creo el lenguaje B precursor directo del lenguaje C, es el creador del sistema operativo UNIX, ha trabajado en google y es co-creador del lenguaje GO.

Cosas que usamos muy comúnmente hoy en día no serían posibles sin él, el desarrollo la codificación UTF-8 junto con Rob Pike, fue de los precursores de las expresiones regulares e implemento varios procesadores de texto que hacen uso de ellas, introdujo las pipes en los sistemas operativos.

Trabajo en los míticos laboratorios Bell, en donde hizo mancuerna con Dennis Ritchie.

Él ha vivido la época de los grandes cambios en esta revolución de la informática, sin el mucho de lo que hoy tenemos no sería posible.

Su lectura de participación al recibir el premio Turing, es especialmente divertida, ya que habla de implantar un virus desde el mismo compilador, les recomiendo su lectura.

Lectura premio turing

33. Distinct en una lista C# (Ayuda Rápida VI)

Hoy toquemos un tema dentro de la categoría ayuda rápida, que es común a la hora de desarrollar, ¿Como obtengo los elementos diferentes que existen en una lista?

Por ejemplo:

Si tuviera la siguiente clase:

Como determino los tipos de animales

Mamífero, Pez, Ave.

La solución es muy sencilla, se emplea la estructura select de la lista, y se indice que seleccione el tipo y todos los que sean distintos.

Que tengo en este código, tengo 2 forma de hacer esta misma operación.

Animales.Select(c=>c.Tipo) ... Me permite decir que es lo que voy a seleccionar, esto haciendo un select sobre mi lista.

Si incluyo el modificador AsParallel, le indico al sistema que el select lo haga en paralelo, esto tendrá una mejora en el tiempo en que se recorre la lista.

Y finalmente la instrucción Distinct, me permite agrupar por el elemento que seleccione.

Cuando usar AsParallel y cuando no, depende principalmente de los recursos disponibles en el equipo, AsParallel sera mas rápido, pero con mayor consumo en el procesador.

En ambos casos la salida es:

Hasta la proxima

32. Build 2016

La tecnología avanza día a día, y es muy importante conocer los nuevos retos y conocer las nuevas herramientas que tenemos para poderla usar a nuestro beneficio.

Microsoft anuncia el día de hoy la fecha del Build 2016, el máximo evento de esa empresa para los desarrolladores.

El evento sea en San Francisco del 30 de Marzo al 1 de Abril, no importa que no puedan asistir en forma presencial, este evento se trasmite en tiempo real por diversos canales, les dejo la pagina de dicho evento.

Build 2016

Felices lineas

31. Ciclo de vida de Internet Explorer

Como desarrolladores, debemos conocer la tecnología y así como debemos de saber cuando hay alguna novedad en nuestro ámbito, también debemos de saber cuando un producto cierra su ciclo de vida, debemos estar preparados para ello, por que estos cambios siempre traen consigo mantenimientos que es mejor hacerlos programados y con tiempo a bajo una contingencia.

Ante esto hay 2 notas muy importantes:

1. El soporte y las actualizaciones de Internet Explorer cambiara y solo se dará soporte a la versión mas reciente del mismo partir del 12 de Enero de 2016, si bien esto se sabia desde 2014 es importante recordarlo por la cercania de las fechas para mayor información revisen: https://support.microsoft.com/es-mx/gp/microsoft-internet-explorer , esto nos deja con lo siguiente: Windows 7,  Windows 8.1 y Windows 10 unicamente tendra soporte Internet Explorer 11, Windows Vista únicamente tendrá soporte Internet Explorer 9
2. .Net Framework 4.6.1 se encuentra ya disponible.NET 4.6.1 , siempre es conveniente tener las ultimas verciones del Framework para los que trabajamos en .Net, esto por que tienen optimizaciones, correccion de errores y parches de seguridad.

Felices lineas

30. Usabilidad

Como técnicos perdemos rápidamente la vista del usuario, a veces pensamos que el sistema debe tener un comportamiento y que el usuario se debe adaptar al sistema.

No debemos perder algo de vista que es muy importante en nuestro trabajo, nos debemos al usuario, somos por el usuario, nuestra principal función es hacer que cualquier actividad sea más rápida y sencilla.

Sea análisis de información, sea automatizar un proceso, o una acceso a una base de datos, todas estas tareas siempre deben ser más fáciles de hacer para el usuario que lo que eran antes de que el sistema se implemente.

Debemos hablar su idioma, acercarnos a él para saber que quiere que busca y darle algo de acuerdo a sus necesidades.

Un error muy común es implementar algo, porque sabemos que es bueno o porque lo conocemos y olvidarnos del como el usuario hace sus actividades en el día a día, muchos de los sistemas impuestos, se convierten en un fracaso, porque la imposición genera resistencia.

Si yo obligo a alguien a hacer algo así este sea el mejor sistema lo va a rechazar de manera automática, lo mejor es buscar que la aceptación sede de manera natural.

Me preguntaran ¿Y cómo logro esto? Hay varias formas, la mejor es observar al usuario para determinar sus necesidades, si yo le pregunto al usuario ¿Qué necesitas? Muchas veces no lo sabe, y ¿Por qué no lo sabe? Porque con los medios con los que dispone en la actualidad ya están cubiertas sus necesidades, puede pedir más cosas, pero siempre es mejor involucrarse con las actividades para detectar los puntos de mejora, y buscar que estos se acepten de manera natural.

¿Pero cómo logro que el usuario se sienta cómodo con mi sistema? Jakob Nielsen es uno de los grandes gurús de la usabilidad, él ha establecido 10 principios que deberíamos considerar en todo sistema, estos principios ayudan a que el usuario se sienta cómodo y seguro dentro del sistema, sus principios son:

1.       Visibilidad del estado del sistema: en este punto normalmente fallamos, olvidamos informar que ocurre en el sistema y dejamos que este opere por sí solo, si bien esto es eficiente, hace que el usuario se desespere, no sabe que está pasando, peor aún puede pensar que está generando errores, que se trabo, el no informar el estado del sistema trae como consecuencia frustración, y como consecuencia nuestro sistema no será exitoso.

2.       Relación entre el sistema y el mundo real: Es muy importante tener el mismo vocabulario, que el sistema hable el vocabulario del usuario en sus términos y conceptos, que todo esté acorde a lo que el usuario conozca, y que el sistema no se convierta en tener un ente que requiera un traductor para su operación.

3.       Control y libertad del usuario: Funciones de deshacer y rehacer, que pasa si el usuario entro a una función a la que no quería por error, su proceso para salir de ella debe ser sencillo, no debería perderse en un mundo de menús, para deshacer un error.

4.       Consistencia y estándares: ¿Cuáles son los estándares del usuario? El debería entender el sistema por que el sistema habla su idioma.

5.       Prevención de errores: Un error común prevenir errores es enviar mensajes de error, esto no es la prevención de errores, un mensaje de error debe ser nuestra última opción, en muchos casos los sistema envían mensajes de error cuando ya no se puede hacer nada, y el proceso para recuperarse de ellos es largo y costoso, los sistemas deben tener un control de errores, para evitarlos, que no sea enviar un mensaje de error.

6.       Reconocimiento antes que recuerdo: El usuario no debe saberse los procesos de memoria, si se depende de la memoria para que estos se ejecuten en un orden correcto, es probable que se induzca error por parte de la misma operación del sistema, el usuario debería reconocer los pasos y actividades a realizar, y estos deben ser accesibles para el usuario todo el tiempo.

7.       Flexibilidad y eficiencia de uso: Hay varios tipos de usuarios, avanzados y básicos se debe brindar al usuario avanzado aceleradores y métodos para que este pueda mejorar la eficiencia de su trabajo, por dar un ejemplo de esto tenemos las combinaciones de teclas.

8.       Estética y diseño minimalista: Cada unidad extra de información irrelevante compite con la información relevante, se debe brindar únicamente la información importante, para que el usuario pueda interpretarla y entenderla.

9.       Ayuda a los usuarios a reconocer: Otro punto muy importante, que en la mayoría de los sistemas no se hace, cuando ocurre un error este se debe presentar en un lenguaje claro y simple, que indique el problema en forma precisa y ayude a construir su solución. El mensaje muy típico en los sistemas “Error fatal, consulte a su administrador del sistema” no es un error que cumpla con estas características, y menos cuando dicho error le da al administrador del sistema.

10.   Ayuda y documentación: Mas vale la más pálida tinta que la más brillante memoria, hoy conocemos el sistema pero que tan en 5 años cuando lo volvemos a ver, lo que para unos es lógico para otros no lo será, debemos dejar de pensar que un sistema se puede emplear con sentido común, dicen que el sentido común es el menos común de todos los sentidos, por esto hay que documentar, crear ayudas ¿Cómo trabaja?, ¿Cuáles son las reglas de negocio?  ¿Cómo se configura?, si soy un nuevo usuario ¿Cómo voy a usar el sistema?, cometemos un error muy grave aquí los desarrolladores, decimos es que el usuario no lee, si no lee los manuales para que los hago, no es lo mismo el que no los lea, pero que en caso de una duda pueda recurrir a ellos, a que en caso de una duda no exista nada a donde recurrir.

Bueno me despido por hoy, felices líneas

Carlos

29. Obtener la diferencia de tiempo entre 2 fechas (Ayuda Rápida V)

El obtener la diferencia que existe entre 2 fechas dadas es un tema muy útil sobre todo en la creación de reportes, para poder obtener la diferencia de tiempo que existe entre una fecha y otra es necesario usar un objeto llamado TimeSpan, este representa un intervalo de tiempo.

Para su uso simplemente restamos las 2 fechas con las que queremos trabajar y su resultado lo almacenamos en este objeto.

TimeSpan ts = HoraActual - HoraCreacion;

Una vez hecho eso, podemos saber cuandos días, horas, minutos, segundos existen entre una fecha y otra.

 int Dias = ts.Days;
 int Horas = ts.Hours;
 int Minutos = ts.Minutes;
 int Segundos = ts.Seconds;

Nos vemos en las próximas lineas.

28. Nuestra historia (III) - Dennis Ritchie

Tal y como lo prometí, mencionare, a los grandes, a los que nos han hecho llegar, si bien en este caso podemos hablar de una pareja de científicos que crearon las bases de la computación moderna, en este escrito me enfocare a uno de ellos, uno que ha dejado este mundo pero que se puede decir que fue de aquellas personas que su existencia estaba destinada a cambiarlo, a mejorarlo.

Dennis Ritchie, ¿Qué hizo?, pues el sembró la semilla de todo lo que tenemos hoy en día, ya que es el creador de uno de los lenguajes más populares  que han existido, un lenguaje que además es base para otros lenguajes, el lenguaje de programación C, además de ser creador del sistema operativo UNIX, siendo este sistema operativo la base de todo lo que hoy conocemos.

Nace el 9 de Septiembre de 1941, graduado de la universidad de Harvard, trabajo en los Laboratorios Bell de AT&T.

Fue un pionero de la informática moderna, y fue reconocido con el premio Turing en 1983 por su desarrollo en la teoría de sistemas operativos genéricos y su implementación en la forma del sistema UNIX.

Murió el 12 de Octubre de 2011, él es uno de los más grandes científicos del siglo XX, y un responsable de la revolución tecnológica que tenemos hoy en día, el maestro que creo las primeras piezas con las que construimos el universo de cómputo.

Dennis Ritchie, tiene un puesto muy especial dentro de la historia de la humanidad.

Felices líneas.

27. Parpadeo en DataGridView (Ayuda Rápida IV)

Un problema muy común al momento de usar un DataGridView dentro de un winForm es el molesto parpadeo que se da cada vez que se cargan los datos, esto ocurre sobre todo en casos en que la información que se encuentra en la tabla se encuentra actualizándose de manera continua.

La solución a este problema es muy sencilla, y analizando el código parecería que nosotros causaríamos parpadeo al implementar esta solución pero esto no es cierto, lo que se debe hace es ocultar el DataGridView, cargar este elemento con la nueva información y volverlo a mostrar.

Al cargar el control sin que este se muestre, la carga de sus columnas es muy rápida, por lo que el parpadeo que provocamos al ocultarlo y mostrar el control se vuelve imperceptible, eliminando de esta forma el molesto parpadeo que se da en este tipo de controles.

 dgVisor.Hide();
 dgVisor.DataSource = [Datos];
 dgVisor.Refresh();
 dgVisor.Show();


Felices lineas