Jorge Villabona García - Tecnología .Net

Seguridad en .NET

2010-01-23T13:52:00.002+01:00

Uno de los objetivos del examen 70-536 es conocer y saber utilizar el sistema de seguridad CAS (Code Access Security). CAS nos permite controlar que permisos tiene una aplicación .NET

A partir de Windows Vista apareció el controvertido Control de Cuentas de Usuario (User Account Control).Para muchos usuarios esta característica es molesta e inútil pero evidentemente, tiene su razón de ser.

Cuando accedemos a nuestro equipo personal lo hacemos con una cuenta de administrador. Esto supone que tenemos todos los permisos para hacer lo que queramos. En versiones anteriores de Windows esto no era muy recomendable, ya que cualquier aplicación que ejecutásemos heredaría todos nuestros permisos y por lo tanto podría hacer lo que quisiera con nuestro equipo.

Con el UAC activado, si una aplicación intentara acceder a un recurso protegido se nos avisaría y podríamos decidir si continuamos o no. El problema que ha tenido UAC en Windows Vista es que este tipo de alertas se repiten con demasiada frecuencia y llegan a ser molestas. Además entran en la rutina del usuario por lo que no se les presta atención. En Windows 7 parece que el tema ha mejorado (En este artículo hablan sobre ello)

En fin, volviendo al tema de la Seguridad .NET: CAS (Code Access Security) es un concepto que complementa a los sistemas de seguridad que ofrece el Sistema Operativo (Permisos de Usuarios, Roles, UAC…) ¿Cómo? CAS nos permite controlar que puede hacer cada aplicación.

Acceso al sistema de ficheros
Acceso al registro
Acceso a Impresoras
Acceso al registro de eventos
Peticiones Web, peticiones DNS…
Etc.

Elementos Principales

Para entender el funcionamiento de CAS es necesario saber cuáles son sus elementos:

Evidencias (Evidences): Es información que el sistema obtiene sobre el ensamblado. Con esta información se determina a qué grupo de código pertenece (code group) y que conjuntos de permisos tiene (permission set). Hay dos tipos de evidencias
- host evidences (Relacionadas con el origen del ensamblado. Por ejemplo: Directorio de la aplicación, sitio de la descarga…)
- assembly evidence (Relacionadas con la identificación del ensamblado. Por ejemplo código hash, strong name, empresa que desarrollado el software…)

Permiso (Permission): Un permiso determina si un ensamblado puede acceder (y de qué forma puede acceder) a un recurso en concreto. Por ejemplo el permiso de variables de entono define si el ensamblado puede acceder o no a las variables de entorno. Incluso se podría especificar que sólo pudiera acceder a una determinada variable.
Ejemplos de Permisos: Permiso para peticiones WEB o DNS, acceso al Active Directory Domain Services, permiso para el registro de eventos, para mostrar diálogos de fichero (abrir, guardar como…), para el sistema de archivos, para el acceso a registro…

Conjunto de Permisos (Permission Set): Son varios permisos agrupados. El framework .NET incluye varios conjuntos de permisos por defecto (FullTrust, Execution, LocalIntranet, Internet…) pero es posible agregar nuevos (usando la herramienta .NET Framework Configuration Tool).
Por ejemplo, si un ensamblado pertenece a un grupo de código asociado al conjunto de permisos ‘Internet’ tendrá los siguientes permisos: FileDialog, Insolated Storage File, Security, User Interface y Printing.

Cabe destacar que a un ensamblado no se puede asignar un permiso en concreto ni siquiera es posible asignar directamente un conjunto de permisos. El conjunto de permisos se asigna a los grupos de código ¿Pero como se sabe que un ensamblado pertenece a un grupo de código determinado?

Grupo de código (Code Group): El concepto es similar a los roles de usuario pero orientado a los ensamblados. El usuario puede ser asignado a un grupo o rol y por tanto tendrá sus mismos permisos.

Con los ensamblados y grupos de código pasa algo parecido. Cada grupo de código tiene asociado un conjunto de permisos que heredará el ensamblado. La diferencia es que no se puede indicar que un ensamblado pertenece a un grupo de forma directa.

Cuando se configura un grupo de código se especifica que evidencia deben tener los ensamblados para que pertenezcan al grupo y por tanto para que hereden en el conjunto de permisos asociado al grupo.

Es posible que un ensamblado pertenezca a varios grupos, ya que un ensamblado puede contener varias evidencias y que algunas de ellas estén asociadas a diferentes grupos de código.

En ese caso el ensamblado hereda el conjunto de permisos de ambos grupos.

Continuará…

Mas información: http://www.code-magazine.com/Article.aspx?quickid=0405031

Mi nuevo Ipod Suffle

2010-01-22T16:19:00.002+01:00

Estas navidades, entre las cosas que me han regalado está el nuevo Ipod Shuffle (¡Gracias David!)

Tenía yo ganas de volver a tener un Ipod (Mi último Ipod Nano no soportó un accidental lavado). La verdad es que me ha sorprendido mucho este invento. A parte de que es increíblemente pequeño (y fácilmente perdible) y que sobra decir que la calidad de sonido es excepcional, no tiene nada que envidiar a otros reproductores mp3 con pantalla.

Sólo dispone de un interruptor de tres posiciones (apagado, modo normal y modo aleatorio). Y tres botones en el cable de auricular. Dos para subir y bajar el volumen y un tercero multifunción.

Con este botón multifunción podemos pausar la canción (pulsando una vez), pasar a la siguiente canción (pulsando dos veces seguidas) y volver a la canción anterior (pulsando tres veces).

Además si dejamos pulsado una vez nos dirá que canción está sonando (pronunciada en el idioma correcto, por supuesto). Si pulsamos dos veces seguidas y mantenemos sin soltar, avanzará rápidamente. Si pulsamos tres y mantenemos rebobinará.

VoiceOver

Una de las funciones más sorprendentes es el hecho de que lea el título de canción que está sonando. Si el nombre está en castellano te lo lee perfectamente en castellano. Para que empiece a funcionar debes instalar en el Itunes el paquete de VoiceOver. Una vez lo tengas instalado, vuelve a sincronizar y tu ipod empezará a "leer".
Si te queda poca batería te dirá "batería baja".

Lista de reproducción

En este modelo ‘shuffle’ se incorpora la funcionalidad de poder cambiar de lista de reproducción.
Para ello deja pulsado el botón central multifunción hasta que oigas un pitido. Entonces leerá todas las listas de reproducción. Cuando llegue a la que quieres escuchar pulsa de nuevo el botón central y listo.

Conclusiones

Evidentemente no podemos comparar el Ipod Shuffle con ninguno de sus hermanos mayores en funcionalidad pero comparte con ellos la calidad que Apple da a todos sus productos. En este caso, la empresa estadounidense ha diseñado un reproductor muy apropiado para deportistas y personas que sólo buscan escuchar música. Como desventaja hay que decir que no podemos utilizar otros auriculares que los suministrados a no ser que compremos un adaptador. En fin, nadie es perfecto …

Xml Logging para .Net

2008-12-18T13:50:00.003+01:00

He sacado un poco de tiempo y he publicado la dll que tengo hecha para crear logs en Xml.

Tanto la librería, como su código fuente y un par de ejemplos pueden descargarse en:

http://xmllogging.blogspot.com/

Próximamente agregaré un pequeño tutorial de uso. Espero tener algo de tiempo en estas navidades.

Un saludo.

Iconos a tutiplén

2008-11-05T08:28:00.009+01:00

En ocasiones necesitamos incorporar en nuestras aplicaciones iconos y no queremos perder demasiado tiempo.

Podemos recurrir a la colecciones que se encuentran en internet. Yo principalmente utilizo estas tres:

http://www.freeiconsdownload.com/Index.html

http://salmosa.kaist.ac.kr/ICON/BULLET/bullet_image.html

http://commons.wikimedia.org/wiki/Crystal_Clear

Espero que sirva de ayuda. ¡Un saludo!

¿Qué es eso del RSS?

2008-10-13T10:41:00.001+02:00

Últimamente muchas páginas web incluyen funcionalidad RSS. ¿Qué significa esto? Significa que a parte de presentar su contenido en HTML, se presenta también en un formato especial, llamado RSS.

En general, RSS es un formato basado en XML, que debe incluir una serie de elementos estructurados de una determinada manera.

Cuando creamos contenido en formato HTML sabemos que nuestro objetivo es llegar a los navegadores web. HTML nos permite incluir cómo se presentará la información (colores, tipos de letra, posición de los diferentes elementos...).

La estructura de RSS sólo nos permite incluir contenido y nos obliga a seguir unas determinas reglas. Esto puede parece una desventaja pero si piensa un poco enseguida se ve que es una buena idea.

Si una aplicación de escritorio quiere obtener la información de un fichero HTML se va a encontrar con dos problemas:

+El formato incluido en un HTML (colores, fuentes...) es para un navegador WEB por lo que prácticamente tendrá que desecharlo. Se ha perdido tiempo en descargar, leer y procesar algo a desechar. Ya se sabe que no estamos como para desaprovechar tiempo ni recursos (que estamos en crisis)

+Cuando lees un HTML te puedes encontrar con cualquier cosa. Aunque últimamente se tiende a escribir en especificaciones de HTML más o menos estrictas es posible que el autor le haya bastado con que se viese bien en Internet Explorer. El procesado de la información podría ser muy complejo si queremos cubrirnos bien las espaldas.

Cuando una aplicación de cualquier tipo lea un 'feed' (un RSS) se va a encontrar siempre con información relevante y en formato XML. Cualquier entorno de programación incluye lectura de ficheros XML y va a ser muy fácil coger del fichero lo que se quiera mostrar porque ya sabemos que elementos incluye un RSS.

Esta facilidad para compartir con otras aplicaciones permite que nuestras publicaciones sean accesibles desde otras páginas web y desde otro tipo de sistemas (lectores de feeds..) y que por tanto lleguen a más lectores.

Enlaces

Más Info: http://es.wikipedia.org/wiki/RSS
Publicar RSS en PHP: http://www.davidbayon.net/index.php?mostrar=posts&post_id=239
¿Cómo crear RSS? http://es.geocities.com/rss_guia_facil/como_crear_rss.html#3

Windows Vs Linux

2008-09-30T12:44:00.005+02:00

Este artículo va relacionado un poco con lo que escribió hace unos meses un amigo en su blog: http://www.davidbayon.net/index.php?mostrar=posts&post_id=143

En primer lugar no entiendo ese odio irreconciliable que parece que tienen algunos 'linuxeros' contra Microsoft y todo lo subyacente.

Perdonadme pero, detrás de la marca comercial está evidentemente el trabajo de mucha gente. En la parte que a mi me concierne, están arquitectos, análistas, programadores, etc. . Y a lo que quiero llegar es que hacen un trabajo excepcional.

A pesar de que algunos dicen que Windows Vista es lo peor de lo peor, a mi me parece que se han añadido varias mejoras (visuales y no visuales) que uso a diario y que han mejorado considerablemente mi "calidad de usuario".

Hace poco probé MS Office 2007. Durante los primeros minutos estaba completamente perdido. Después de un rato trabajando con él descubrí que era una auténtica maravilla.
Yo utilizó (y seguiré utilizando) OpenOffice y versión a versión, el producto ha mejorado espectacularmente pero aún así, pierde mucho comparándolo con su homólogo de Microsoft.

Pero esto es algo normal y sucede en cualquier sector. Cuando pruebas un Audi y dices 'joer, esto es bastante mejor que mi coche'. Entonces piensas 'Es lo que hay, no me puedo comprar un Audi'. Seguro que nadie arremete contra Audi.

Si por ejemplo, Dell ha decidido incluir Windows Vista en sus equipos, no seamos ingenuos y pensemos que Microsoft ha chantajeado a Dell para que lo incluya de serie. Dell, aparte de que evidemente habrá sacado 'tajada' , habrá evaluado que Windows Vista funciona correctamente con sus equipos. Y es lógico que Microsoft que se ha gastado una pasta en desarrollar Windows Vista, quiera venderlo, haga ofertas y recorte presupuesto para desarrollar compatibilidades con versiones anteriores.

Y si a alguien esto le parece mal pues siento decirle que, en este mundo (capitalista), la mayoría de las cosas funcionan así, por lo que tiene mucho de que quejarse.

A mi me parece lógico que cada uno utilice lo que más le guste (y lo que más se ajuste a su presupuesto). Es genial que mi Dell haya venido con Windows Vista. Seguro que si hubiera comprado el equipo sin S.O. Preinstalado (no sé si existe la opción) no hubiera podido comprar una Licencia de Windows Vista con la diferencia que me hubiera ahorrado.

Entiendo también que esto atente contra la libertad de elección de S.O. pero si Dell no te ofrece la opción, habrá otras marcas que si que lo hagan.

En conclusión, si te gusta Linux, usa Linux. Si te gusta Windows, usa Windows. Y si te gustan los Mac, cómprate un Mac.
Mi elección es Windows así que, absténgase de acercarse Linuxeros Radicales si se van a dedicar a criticar mi elección. :)

Mi Nuevo Dell Studio 15

2008-09-11T09:05:00.001+02:00

Hace un par de meses me llegó a casa mi nuevo portátil: Un Dell Studio 15
-Intel Core 2 Duo T5750 (2.0GHz,667MHz,2MB)
-3Gb Ram
-250Gb Disco Duro
-Batería de 6 Celdas
-Tarjeta Gráfica: 256MB ATI Mobility RADEON HD 3450
-Precio: 778 Euros (Incluida Extensión de garantía a tres años)

¿Por qué Dell Studio 15?

Me decidí por esta marca principalmente porque había oído que el servicio técnico era muy bueno. Llevaba tiempo comparando entre el Dell Inspiron 1525 y el XPS. Al primero le faltaba tarjeta gráfica y el segundo me parecía excesivo en características y precio. Dell Studio se ajustaba perfectamente a mis necesidades (y a mi poder adquisitivo).

Características del Equipo

Durante estos dos meses he observado algunas cosas buenas y otras no tan buenas.

-En condiciones de uso normales es un portátil muy silencioso y su batería dura unas dos horas. Permite también la activación del modo "Extensión de batería" que reduce algunas características visuales con el que se aumenta sustancialmente la autonomía.

-Posee un teclado muy cómodo. No me ha costado nada acostumbrarme a la disposición de las teclas, como su tamaño y tacto.

-Buena recepción wifi. Tengo colocado el router en la segunda planta de la casa y puedo navegar sin problemas en cualquier parte. Con el portátil antiguo era imposible navegar en la planta baja.

-Los altavoces no son muy buenos. La música a volumen muy alto petardea. Sin embargo con auriculares o altavoces externos la calidad que da la tarjeta de sonido es más que aceptable.

-Las teclas multimedia deberían estar iluminadas levemente para poder localizar las diferentes funciones cuando no hay mucha luz. Es muy difícil encontrar las teclas de volumen. Buscándolas suele ser común darle a la de extraer cd. Otra solución sería habilitar una combinación de teclas que iluminase el panel durante un par de segundos.

-La pantalla da un buen nivel de brillo. En exterior, a pesar de no ser una pantalla opaca, puedes trabajar con el equipo perfectamente aumentando el brillo de la pantalla. Con mi anterior portátil de pantalla opaca no había manera de trabajar en exterior.

Servicio Técnico

Por desgracia he tenido que comprobar la calidad de servicio. Tuve un problema con la alimentación. Llame por teléfono y al día siguiente tenía en casa un nuevo adaptador de corriente. Al no ser ese el problema en tres días se presentó en mi casa un técnico de Getronics (Una de las empresas que hace el mantenimiento de Dell). En media hora cambio la placa base. Tampoco resultó ser ese el problema por lo que me ofrecieron un cambio de equipo. En unos días lo recibiré.

Recuerdo que el anterior portátil lo compré en una gran superficie de informática. Tuve dos problemas y me quede dos veces sin portátil. Tardaron un mes en cada reparación. Está clara la diferencia. ¿Verdad?

Conclusiones

A pesar de los altavoces, las dificultades para encontrar las teclas multimedia o el problema de la alimentación, que puede pasar en equipos de cualquier marca, tengo la sensación de que he acertado con la compra. La características cubren de sobra mis necesidades y estoy muy satisfecho con el servicio técnico ofrecido, que para mi, es de las cosas más importantes.

Si alguien tiene alguna duda sobre este modelo que no dude en escribirme.

Un saludo y espero que el artículo sirva de ayuda.

Escribir log en formato XML para .NET (III)

2008-08-29T22:36:00.003+02:00

Actualización: Está ya disponible la librería XmlLog y su código fuente en http://xmllogging.blogspot.com/

En la parte anterior del artículo quedó definida la estructura de nuestro fichero XML donde registraremos el funcionamiento de una aplicación. Vimos también la forma en la que escribiremos en el fichero XML en C#.
Sólo queda ya escribir unas pocas lineas de código y ya tendremos nuestro sistema de escritura de log en XML.

Hay que recordar que para añadir un nuevo registro a un fichero xml no podemos escribir al final del fichero ya que, si lo hacemos, nos cargamos la estructura XML bien formada.

Creamos una nueva clase llamada XmlLog

Definimos en código los tres tipos de registros que utilizaremos(de error, informativo y de traza) y los diferentes valores de filtrado que servirán para indicar al objeto XmlLog que tipo de registros debe escribir.


public enum Tipo
{
ERROR, TRAZA, INFO
}
public enum Filtro
{
TODO             //Escribir registros informativos, errores y trazas
,INFORMACION     //Escribir registros informativos y de errores
,SOLO_ERRORES    //Escribir solo errores 
}

El constructor tendrá tres parametros.
-Una cadena de texto con la ruta donde se guardarán los ficheros generados.
-El nombre de la aplicación (Se utilizará junto a la fecha para nombrar a los ficheros generados)
-El valor de filtro (Indica que tipo de registros de escribir y cuales ignorar).


private String rutaCarpetaDestino;
private String nombreAplicacion;
private Filtro filtro;

public XmlLog(String rutaCarpetaDestino, String nombreAplicacion, Filtro filtro)
{
 this.nombreAplicacion = nombreAplicacion;
 this.rutaCarpetaDestino = rutaCarpetaDestino;
 this.filtro = filtro;
}

Para hacer una escribir en el fichero XML se utilizará el siguiente método:


public void escribirRegistro(Tipo tipo, string text, string usuario)
{

//Obtener nombre del método que llama al método actual
//Es necesario importar System.Diagnostics y System.Reflection
 StackTrace stackTrace = new StackTrace();
 StackFrame stackFrame = stackTrace.GetFrame(1);
 MethodBase methodBase = stackFrame.GetMethod();
 String nombreMetodoOrigen = methodBase.DeclaringType + "." + methodBase.Name;

//Escribir Registro (Comprobando el valor del filtro con el que se instanció)
 switch (tipo)
     {
         case Tipo.TRAZA:
             if (filtro == Filtro.TODO)
             {
                 appendToXml(Tipo.TRAZA, text, nombreMetodo, usuario);
             }
             break;
         case Tipo.INFO:
             if (filtro != Filtro.SOLO_ERRORES)
             {
                 appendToXml(Tipo.INFO, text, nombreMetodo, usuario);
             }
             break;
         case Tipo.ERROR:
             appendToXml(Tipo.ERROR, text, nombreMetodo, usuario);
             break;
     }
}

El código anterior hace referencia al método appendToXml. Este método comprueba si existe el fichero de log que se corresponde con el nombre de la aplicación y con la fecha actual.

En el caso de que no exista se crea y se escribe la cabecera del xml, el elemento raiz y se anida en él el nuevo registro.

Si el fichero existe, es necesario crear un fichero temporal y copiar la estructura del fichero xml original. Se copiará todo hasta justo antes del cierre del elemento raiz. Ahí es donde se escribirá el nuevo registro. Por supuesto, para terminar habrá que incluir el final del elemento raiz.

Una terminado el proceso anterior. Se eliminará el fichero original y se renombrará el temporal.

Éste es el código:


private void appendToXml(Tipo tipo, String text, String nombreMetodo, String usuario)
  {
      //¿Existe el directorio?
      if (!Directory.Exists(rutaCarpetaDestino)){return;}

      String nombreFichero = rutaCarpetaDestino + "/" + nombreAplicacion + "_log"+ DateTime.Now.Year + "_" + DateTime.Now.Month + "_" + DateTime.Now.Day + ".xml";

      FileInfo fileInfo = new FileInfo(nombreFichero);
      if (fileInfo.Exists)
      {
          XmlTextReader xmlReader = new XmlTextReader(fileInfo.OpenRead());
          XmlTextWriter xmlWriter = new XmlTextWriter(fileInfo.FullName + "_temp", xmlReader.Encoding);
          try
          {
              bool finalAlcanzado = false;
              string elementoRaiz = String.Empty;
              xmlWriter.Formatting = Formatting.Indented;
    
      //Recorrer la estructura elemento a elemento y copiar cada uno de ellos en el fichero temporal.
      //(Hasta encontrar el cierre del elemento raiz)
              while (!finalAlcanzado)
              {
                  xmlReader.Read();
                  switch (xmlReader.NodeType)
                  {
                      case XmlNodeType.DocumentType:
                          xmlWriter.WriteDocType(xmlReader.Name, null, null, null);
                          break;
                      case XmlNodeType.Element:
                          xmlWriter.WriteStartElement(xmlReader.LocalName);
                          if (xmlReader.HasAttributes)
                          {

                              while (xmlReader.MoveToNextAttribute())
                              {
                                  xmlWriter.WriteAttributeString(xmlReader.LocalName, xmlReader.Value);
                              }
                              xmlReader.MoveToElement();
                              break;
                          }

                          if (xmlReader.IsEmptyElement)
                              xmlWriter.WriteEndElement();
                          if (elementoRaiz.Equals(String.Empty))
                              elementoRaiz = xmlReader.LocalName;
                          break;
                      case XmlNodeType.EndElement:
                          if (elementoRaiz == xmlReader.LocalName)
                              finalAlcanzado = true;
                          else
                              xmlWriter.WriteEndElement();
                          break;
                      case XmlNodeType.Text:
                          xmlWriter.WriteString(xmlReader.Value);
                          break;
                      case XmlNodeType.Whitespace:
                          xmlWriter.WriteWhitespace(xmlReader.Value);
                          break;
                      case XmlNodeType.ProcessingInstruction:
                          xmlWriter.WriteProcessingInstruction(xmlReader.Name, xmlReader.Value);
                          break;

                  }
              }
              //AÑADIR EL NUEVO ELEMENTO
              escribirElemento(xmlWriter, tipo, text, nombreMetodo, usuario);
              //ESCRIBIR FINAL XML
              xmlWriter.WriteEndElement();
              xmlWriter.Flush();
              xmlWriter.Close();
              xmlReader.Close();
              fileInfo.Delete();
              File.Move(fileInfo.FullName + "_temp", fileInfo.FullName);
          }
          catch (Exception ex)
          {
              xmlWriter.Close();
              xmlReader.Close();
              File.Delete(fileInfo.FullName + "_temp");
          }
      }
      else
      {
          XmlTextWriter xmlWriter = new XmlTextWriter(nombreFichero, System.Text.Encoding.UTF8);
          try
          {
              // Write processor information
              xmlWriter.WriteProcessingInstruction("xml-stylesheet", "type='text/xsl' href='log.xsl'");
              xmlWriter.WriteStartElement("registros");
              xmlWriter.Formatting = Formatting.Indented;

              escribirElemento(xmlWriter, tipo, text, nombreMetodo, usuario);
              xmlWriter.WriteEndElement();
              xmlWriter.Flush();
          }
          catch (Exception ex)
          {
          }
          xmlWriter.Close();
      }
  }

Sólo falta el método escribirElemento que escribirá el registro xml tal y como lo definimos.


private void escribirElemento(XmlTextWriter xmlWriter, Tipo tipo, String text, String nombreMetodo, String usuario)
  {
  xmlWriter.WriteStartElement("registro"); //Inicio Elemento Registro
      switch (tipo)
      {
          case Tipo.ERROR:
              xmlWriter.WriteAttributeString("tipo", "error");
              break;
          case Tipo.INFO:
      xmlWriter.WriteAttributeString("tipo", "info");
              break;
          case Tipo.TRAZA:
              xmlWriter.WriteAttributeString("tipo", "traza");
              break;
      }

  xmlWriter.WriteAttributeString("fechahora", DateTime.Now.ToString());
  xmlWriter.WriteAttributeString("metodo", nombreMetodo);
  xmlWriter.WriteAttributeString("usuario", usuario);
  xmlWriter.WriteString(text);
  xmlWriter.WriteEndElement();  //Fin elemento Registro
  }

Cuando se ha creado el encabezamiento del fichero xml se ha incluido la siguiente instrucción:

xmlWriter.WriteProcessingInstruction("xml-stylesheet", "type='text/xsl' href='log.xsl'");

La hoja xsl "log.xsl" será la hoja que crearemos en la última parte del artículo y que nos servirá para dar un formato amigable a fichero xml.

Microsoft SQL Server Integration Services (SSIS): Introducción

2008-08-28T09:07:00.000+02:00

¿Qué es SSIS?

SSIS es una potente herramienta que nos permite mover información entre un sistema origen (Fichero de texto plano, fichero XML, hoja Excel, una base de datos...) a un sistema destino (Fichero de texto plano, fichero XML, hoja Excel, una base de datos...). SSIS nos ofrece también la posibilidad de transformar los datos obtenidos del origen antes de que pasen al sistema destino.

El paquete (Package) es el objeto que implementa la funcionalidad de Integration Services y puede contener:
-Elementos de flujo de control: Tareas, contenedores y restricciones de precedencia.
-Elementos de flujo de datos: orígenes, transformaciones y destinos.

Tareas

Una Tarea (Task) proporciona funcionalidad. Podemos encontrar tareas para ejecutar un conjunto de sentencias SQL (Execute SQL Task), para mandar un correo electrónico (Send Mail Task), para subir un fichero FTP (FTP Task) o para ejecutar fragmentos de Visual Basic .Net (Script Task)

Una tarea importante es DataFlow Task. Cuando la insertamos estamos creando un flujo de datos en el que especificaremos de donde queremos obtener información , que transformaciones queremos hacer y a donde llegará la información transformada. En un flujo de Control podemos insertar varios flujos de datos.

Relaciones de Precedencia

Dentro del flujo de control podremos insertar varias tareas. Para saber que tareas se ejecutan y el orden que se debe seguir utilizaremos las Relaciones de Precedencia (Precedence Constraint).

Contenedores

A veces será necesario realizar una tarea varias veces o agrupar una serie de tareas. Para ello utilizaremos los contenedores (Containers). Hay contenedores que ejecutan un flujo repetidamente mediante un enumerador (Foreach Loop Container), contenedores pare ejecutar un flujo repetidamente mientras se cumpla una condición (For Loop Container) y para agrupar tareas para que tengan un mismo ámbito de ejecución (Sequence Container) .

En un contenedor podemos tener otros contenedores anidados.

¿Como trabajamos con SSIS?

SQL Server Integration Services está integrado en SQL Server en las versiones Developer o Enterprise. El entorno de desarrollo se llama SQL Server Business Intelligence Development Studio (BIDS) y éste se integra en Visual Studio .Net.

Escribir log en formato XML para .NET (II)

2008-08-21T20:52:00.006+02:00

Actualización: Está ya disponible la librería XmlLog y su código fuente en http://xmllogging.blogspot.com/

En la primera parte de artículo vimos las ventajas que tendría que nuestro sistema de logs escribiese ficheros en formato xml.

Nos ponemos manos a la obra.

El primer paso es definir el esquema del xml que escribirá nuestro sistema.
Lo haremos de forma informal, es decir, no vamos a crear un fichero xsd ya que nos extenderíamos demasiado y no es objetivo del artículo.

Se me ocurre que podemos tener tres tipos de registro:
-Registro de error (Ej: Excepción en abrirFichero()...)
-Registro informativo (Ej: El usuario 1111 ha iniciado sesión...)
-Registro de traza (Ej: Se ha abierto correctamente el fichero)

En cada registro se informará:
Cuándo: La fecha y hora del evento
Qué: tipo de registro de que se trata (de error, informativo, de traza)
Quién: Usuario responsable de la acción que ha desencadenado el registro.
Dónde: El nombre de la clase y del método origen.
Por qué: Una descripción completa del suceso.

Vemos un ejemplo de la estructura XML

<registros>
 <registro tipo="info" fechahora="21/08/2008 20:16" metodo="Clase.metodo" usuario="jorge">
     Iniciada Aplicación
 </registro>
 <registro tipo="traza" fechahora="21/08/2008 20:17" metodo="Clase.metodo" usuario="jorge">
     Se va a intentar abrir el fichero.
 </registro>
 <registro tipo="error" fechahora="21/08/2008 20:18" metodo="Clase.metodo" usuario="jorge">
     Se ha producido una excepción cuando se intentaba abrir el fichero.
 </registro>
 <registro tipo="info" fechahora="21/08/2008 20:19" metodo="Clase.metodo" usuario="jorge">
     Fin de la aplicación con errores.
 </registro>
</registros>

¿Como hacemos para escribir lo anterior en fichero XML en C#?

Hay varias formas. Nosotros utilizaremos la clase XmlTextWriter (Dentro de System.Xml)


XmlTextWriter xmlWriter = new XmlTextWriter("log_de_prueba.xml", System.Text.Encoding.UTF8);

xmlWriter.WriteStartElement("registros"); //Inicio Elemento Registros

xmlWriter.WriteStartElement("registro"); //Inicio Elemento Registro
xmlWriter.WriteAttributeString("tipo", "info");
xmlWriter.WriteAttributeString("fechahora", DateTime.Now.ToString());
xmlWriter.WriteAttributeString("metodo", nombreMetodoOrigen);
xmlWriter.WriteAttributeString("usuario", usuario);
xmlWriter.WriteString("Se va a intentar abrir el fichero.");
xmlWriter.WriteEndElement();  //Fin elemento Registro

xmlWriter.WriteStartElement("error"); //Inicio Elemento Registro
xmlWriter.WriteAttributeString("tipo", "info");
xmlWriter.WriteAttributeString("fechahora", DateTime.Now.ToString());
xmlWriter.WriteAttributeString("metodo", nombreMetodoOrigen);
xmlWriter.WriteAttributeString("usuario", usuario);
xmlWriter.WriteString("Se ha producido una excepción cuando se intentaba abrir el fichero.");
xmlWriter.WriteEndElement(); //Fin elemento Registro

...

xmlWriter.WriteEndElement(); //Fin Elemento Registros

¿Cómo conseguimos el nombre del método origen del registro?

using System.Diagnostics;
using System.Reflection;
public class XmlLog{
...

public static void escribirRegistro(...){

//Obtener nombre del método que llama al método actual
StackTrace stackTrace = new StackTrace();
StackFrame stackFrame = stackTrace.GetFrame(1);
MethodBase methodBase = stackFrame.GetMethod();
String nombreMetodoOrigen = methodBase.DeclaringType + "." + methodBase.Name;

//Escribir Registro
...
}
}

Si dentro de Clase.metodo hacemos la llamada al método XmlLog.escribirRegistro(...)

Class Clase{
  void metodo(){
      XmlLog.escribirRegistro(..);
  }
}

nombreMetodoOrigen (en XmlLog.escribirRegistro) tomará valor "Clase.metodo"

Seguiremos dándole forma a nuestro sistema de logs Xml en la parte siguiente del artículo.

Un saludo.

Fuentes:
http://www.codeproject.com/KB/dotnet/MethodName.aspx
http://www.codeproject.com/KB/XML/XmlAppending.aspx

Escribir log en formato XML para .NET (I)

2008-08-13T22:15:00.008+02:00

Actualización: Está ya disponible la librería XmlLog y su código fuente en http://xmllogging.blogspot.com/

Cuando se realiza el mantenimiento de una aplicación se recurre muchas veces a la visualización de logs que ésta genera. Los datos que ellos contienen pueden dar pistas sobre las causas de los errores que van surgiendo. Es importante que dispongamos de un buen sistema de escritura de logs en nuestra aplicación.

Razones por las cuales incorporar un sistema de escritura de logs.

En caso de error de la aplicación un buen log nos va a informar cuando se produce el error, donde se produce, cuál es la causa y el porqué y quién la produce (en aplicaciones que den servicio a varios usuarios).
Hay que veces que el error es producido por causas ajenas (fallo en la conexión con algún servidor...). Si el log nos informa de este hecho sabremos que no hay que tocar nada en la aplicación y ahorraremos tiempo.
En el caso de que sea necesario podremos configurar el sistema de logs para que escriba trazas para ver cual ha sido el camino lógico escogido por la aplicación antes de un error.
Un log nos puede ayudar a saber quien ha realizado una determinada acción. En concreto, para ámbitos comerciales un log puede demostrar que una operación de un determinado cliente se ha realizado (o no) en caso de disputa.

Características de un buen sistema de logs

Formato estándar y legible para el ser humano
Debe registrar sólo aquellos datos oportunos (Qué, Cuándo, Dónde, Por qué, Quién...). Todo dato superfluo dificultará la lectura.
Debe ser diseñado teniendo en cuenta las limitaciones de disco duro (En algunos casos habrá que mover o eliminar ficheros antiguos para no comprometer la fiabilidad del sistema)
Configurable para escribir (o no) diferentes tipos de registros:
- Registro de error (Ej: Excepción en abrirFichero()...)
- Registro de información (Ej: El usuario 1111 ha iniciado sesión...)
- Registro de traza (Ej: Se ha abierto correctamente el fichero)

En mi opinión, escribir un log en XML puede darnos ventajas. Es un formato estándar y se puede organizar la información de tal forma que sea incluso más agradable de leer por el ser humano que un fichero de texto plano. También existe la posibilidad (y esto es lo que más me gusta) de darle el formato que queramos (por ejemplo HTML) usando plantillas XSL. Con un poco de CSS y un poco de Javascript podremos presentar el registro de nuestra aplicación ofreciendo funcionalidades añadidas (filtrado por tipo de registro, por fecha, interfaz intuitiva...)

Pasar de un log en texto plano a uno en formato XML puede parecer una trivialidad. Pero no lo es tanto. Para escribir un registro en un fichero de texto plano basta con escribir en el inicio del fichero o al final. En un fichero XML si escribimos al final (o al principio) dejaremos de tener un XML bien formado. En un fichero XML debemos incluir el registro como mínimo dentro del nodo principal.
¿Cómo? Hay varios métodos. Esta página explica algunos de ellos para .NET: http://www.codeproject.com/KB/XML/XmlAppending.aspx

En el próximo artículo sobre este tema nos pondremos manos a la obra. Definiremos una estructura de XML para nuestro sistema de log y lo implementaremos para C# (utilizando uno de los métodos de página anterior). Por último crearemos una hoja XSL que presente el fichero XML con funcionalidades extras.

¡Hasta pronto!

Listas Genéricas .Net: Uso de FindAll(Predicate<>)

2008-08-06T12:57:00.006+02:00

A continuación voy a mostrar un ejemplo de como usar el método FindAll en una lista genérica de objetos de una clase en concreto.

Partimos de la siguiente clase:

class Persona
{
private string nombre;

public string Nombre
{
   get { return nombre; }
}

private string provincia;

public string Provincia
{
   get { return provincia; }
}
public Persona(string nombre, string provincia)
{
   this.nombre = nombre;
   this.provincia = provincia;
}
public override string ToString()
{
   return "Nombre:" + this.nombre + " Provincia:" + this.provincia;
}
}

Queremos introducir en una lista diferentes personas con su datos.

List<Persona> listaPersonas = new List<Persona>();
listaPersonas.Add(new Persona("Juan", "Navarra"));
listaPersonas.Add(new Persona("Pedro", "Zaragoza"));
listaPersonas.Add(new Persona("María", "Navarra"));

Una vez tenemos la lista con los datos, nos interesaría saber que personas viven en una determinada provincia.
Para ello utilizaremos el método FindAll (dentro de List).
Este método necesita como parámetro un predicado (Predicate).
Un predicado es un método en el cual se definen una serie de criterios y es capaz de determinar si un objeto encaja con esos criterios.

Ejemplo:

private bool match(Persona persona)
{
return (persona.Provincia.Equals("Navarra"));
}

Entonces para buscar en nuestra lista ejecutaríamos los siguiente:

List<Persona> listaPersonasEnNavarra;
listaPersonasEnNavarra = listaPersonas.FindAll(match);

El problema es que necesitaríamos un método para cada una de las 50 provincias del territorio español (y dos más para las ciudades autónomas)

private bool matchBadajoz(Persona persona){return (persona.Provincia.Equals("Badajoz"));}
private bool matchCaceres(Persona persona){return (persona.Provincia.Equals("Cáceres"));}
private bool matchCiudadReal(Persona persona){return (persona.Provincia.Equals("Ciudad Real"));}
...

Esto no es muy práctico.

Para solucionarlo lo que haremos es construir una clase nueva:

class BusquedaPorProvincia
{
private string provinciaABuscar;
public BusquedaPorProvincia(string provinciaABuscar){
    this.provinciaABuscar = provinciaABuscar;
}
public Predicate<Persona> getPredicate()
{
    return match;
}
private bool match(Persona persona)
{
    return (persona.Provincia.Equals(provinciaABuscar));
}
}

Y ahora para obtener las personas de una provincia determinada... :

BusquedaPorProvincia busquedaPorProvincia = new BusquedaPorProvincia("Navarra");
List<Persona> listaPersonasEnNavarra;
listaPersonasEnNavarra = listaPersonas.FindAll(busquedaPorProvincia.getPredicate());

Esto puede ser aplicado para los métodos Find, FindLast... de la lista genérica.

Código fuente del ejemplo: Descargar

Fuente de información: http://www.codeproject.com/KB/cs/predicates.aspx

Un saludo.

Desarrollo del manual de una aplicación Web

2008-07-25T09:23:00.008+02:00

Seguramente si te dedicas al desarrollo de aplicaciones web, bien como profesional o bien como estudiante, en algún momento habrás tenido la necesidad de realizar un manual. No es una tarea que guste a todo el mundo ya que normalmente hay que invertir mucho tiempo.

Fireshot (http://screenshot-program.com/fireshot/) es add-on de Firefox (luego veremos como integrarlo también en Internet Explorer) que nos va a facilicitar mucho la vida. Con un clic tendremos la captura de la área visible (o de la página completa) y podremos añadir formas y anotaciones explicativas con el formato que más nos guste. Veamos un ejemplo:

Instalación para FireFox

Para integrarlo Fireshot en nuestro FireFox descargaremos el add-on (https://addons.mozilla.org/en-US/firefox/addon/5648) y lo instalaremos.
Una vez reiniciado FireFox aparecerá un icono en la parte superior derecha del explorador:
Ya estamos listos para hacer capturas de nuestra aplicación.

Accederemos a la página de la cual queremos hacer la captura y pulsaremos sobre el icono. Aparecerá una ventana con la captura y las barras de herramientas necesarias para añadir anotaciones.

Nota: En el primer uso Fireshot me ha preguntado si quería integrarlo con Internet Explorer y si quería utilizar la versión "Pro" durante 30 días (está versión es de pago, unos 20$ ). En principio he contestado que no ya que ambas tareas se pueden realizar más adelante. Además para empezar, la versión básica es suficiente.

La versión básica nos ofrece herramientas de selección, dibujo de formas, inserción de textos, líneas e imágenes. Podemos mover, duplicar o recortar una selección. Su uso es muy sencillo y en poco minutos empezaremos a hacer cosas útiles.

Una vez terminada la edición podremos guardarlo como archivo, dejarlo en el portapapeles o subirlo a internet.

Instalación para Internet Explorer

No es nada raro que nos encontremos con una página que no funciona en FireFox o que simplemente no se ve correctamente. No hay problema. Integraremos Fireshot en el explorador de Microsoft.

En FireFox, pulsaremos sobre la fecha que hay junto al icono de Fireshot. En el menú seleccionaremos "Intregate into Internet Explorer". Después de unos pasos tendremos también instalado Fireshot en Internet Explorer.

Ahora sólo queda practicar.

Blogger: Código fuente formateado

2008-07-24T13:15:00.005+02:00

Cuando se escriben artículos sobre programación es inevitable tener que incluir fragmentos de código. Formatear esos fragmentos ayudan notablemente a su compresión.

En este artículo incluyo una forma de incluir código fuente en una entrada de Blogger. La idea se puede aplicar perfectamente a otros tipos de blog.

Para ello utilizaremos la siguiente página: http://manoli.net/csharpformat/format.aspx. Aquí podemos transformar fragmentos de C#, VB, Html, XML, ASP.Net o SQL en su equivalente en xhtml pero coloreado.

El código HTML generado en esta página utiliza clases para definir el formato por lo que es necesario incluir el código CSS correspondiente en nuestra plantilla de Blogger.

Para ello,

Copiamos el siguiente código (si tenemos ganas podemos incluso modificarlo a nuestro gusto)


<!-- code formatted by http://manoli.net/csharpformat/ -->
<style type="text/css">
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: Consolas, "Courier New", Courier, Monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
</style>

Accedemos a la página de personalización los elementos de página de nuestro Blogger (pestaña Diseño) y hacemos clic sobre "Añadir un elemento de página"

En la ventana emergente hacemos clic sobre "Añadir al BLOG" en el elemento "HTML/Javascript"

Insertamos en "Contenido" el código CSS copiado anteriormente. El título lo dejamos en blanco. Pulsamos sobre "Guardar"

Ya tenemos todo listo para introducir fragmentos de código coloreados en nuestros artículos.

Iremos a la página anteriormente citada: http://manoli.net/csharpformat/format.aspx
En ella introduciremos el código fuente que queramos incluir en nuestro artículo (1), seleccionaremos el lenguaje en el que está escrito (2) y pulsaremos sobre "format my code" (3).

Pegaremos el código HTML obtenido en la nuestra entrada de Blogger (En la pestaña "Edición de HTML").
Si accedemos a la vista previa veremos el código con un formato diferente pero sin colorear. No hay problema, en la vista final se verá correctamente.

En el caso del XML usado en el ejemplo este será el resultado:


<xml atributo="nombre_del_atributo">
<item nombre="nombre_del_item">contenido</item>
</xml>