Lección 1 – Logueando eventos
Es casi imposible saber de antemano todas las situaciones que pueden surgir después de que se implementa la aplicación, la forma de averiguarlo es usando un event log.
Usando Microsoft Windows Events y logueandolos
Es común tener informes de problemas de los usuarios utilizando la terminología que los desarrolladores no entendemos.
Ej: hice clic en esa ventanita de acá, se me puso blanca y me salto un cartel….
La falta de comunicación hace de la comprobación de errores un proceso difícil. Una forma de controlar esto, es el registro de sucesos, estos proporcionan un mecanismo para que las aplicaciones registren las cosas que les suceden.
Esta característica tiene muchos beneficios. Al utilizar el registro de sucesos, los desarrolladores pueden guardar determinados aspectos del estado de una solicitud, incluyendo errores graves. Se pueden grabar casi cualquier cosa.
Visor de eventos de Windows XP:
Creando y borrando un Event Log
Para crear un event log. Net Framework provee la clase EventLog. Para usarla se debe referenciar el namespace System.Diagnostics:
Después de crear un EventLog y especificar el source (de donde toma los datos, en este caso Cap10), se puede ver su información en el visor de eventos de Windows después de ejecutar el codigo.
Borrar un Eventlog es igual de simple:
Escribiendo un Event Log
El método WriteEntry parece bastante simple, pero existen 10 sobrecargas de este método:
Además de leer logs personalizados, el objeto EventLog permite leer y escribir en Evenlogs existentes como los de seguridad y logs de sistema.
Ejemplo de cómo escribir dentro de estos: (se deben tener permisos de escritura)
Aplication Log:
SecurityLog:
SystemLog:
Leyendo un Event Log
Los objetos event logs tienen una propiedad Entries, que es una instancia de EventLogEntryCollection, esta nos permite iterar a través de ella y ver los EventLogEntry que contiene:
La forma de limpiarlo es llamando al método clear del objeto Eventlog.
Lección 2 - Depurando y la trazando
Escribiendo Salidas (Output)
Una función importante de los desarrolladores es recorrer el código y buscar errores. Aprender a utilizar eficazmente las herramientas disponibles para esta tarea es fundamental por muchas razones:
- · Para comprobar que el código hace lo que se espera.
- · Si usamos las clases Debug y Debugger se puede obtener un feedback para confirmar si funciona como lo planeado.
- · Usando herramientas para localizar los errores después de que han surgido
La clase Debugger
Permite la comunicación con una aplicación debugeadora. Tiene múltiples miembros:
Metodos:
| Nombre | Descripción |
| Break | detiene la ejecución del depurador |
| IsAttached | indica cuando el depurador está asociado a un proceso. |
| isLogging | indica si el depurador se encuentra en el registro. |
| Launch | lanza el depurador y lo asocia a un proceso |
| Log | envía un mensaje al depurador actual |
Otro método importante en la clase debugger es el método Log, que envía información a un depurador asociado, si no se encuentra asociado a ninguno, no realiza nada.
Cuando usamos el método log, este escribe en cualquier objeto que escuche y este asociado al debugger.para usar este método se debe llamarlo e indicar el nivel, categoría y mensaje (en listener simple es el DefaultTraceListener):
La clase Debug
Aunque la clase Debugger es muy útil, que, sólo ofrece dos métodos (break y log) y hay momentos en que necesita más granularidad. En esos casos, la clase de debug se ajusta mejor
Metodos:
| Nombre | Descripción |
| Assert | Evalúa una condición y muestra un mensaje si la condición es falsa. |
| Close | Vacía el búfer de salida y luego llama al método Close en cada uno de los oyentes (listeners) conectados. |
| Fail | Muestra un mensaje de error. Vacía el búfer de salida, y escribe la información en la colección Listeners. |
| Indent | Incrementa el nivelde incidencia. Este método es especialmente útil para dar formato. |
| Imprimir | Escribe un mensaje seguido de un terminador de línea para rastrear a los oyentes de la colección Listeners. |
| Unindent | Opuesto del método Incident. Disminuye el nivel de incidencia en una unidad. |
| Write | Escribe la información adjunta sobre depuración u objetos de la clase Trace escucha de la colección Listeners. |
| WriteIf | Lleva a cabo la misma acción que el método Write, pero lo hace sólo si la condición especificada se cumple. |
| WriteLine | Escribe información adjunta de los debuggers o de seguimiento de los Listeners. |
| WriteLineIf | Realiza la misma acción que el método WriteLine, pero lo hace sólo si la condición especificada se cumple |
El método Assert
Uno de los beneficios del uso de estas clases es que permite llevar a cabo su aplicación y examinar la salida sin tener que pasar manualmente a través del código. Una de las mejores herramientas para ayudar a depurar es el método Assert. Se debe colocar el código con los métodos Debug.Assert con una condición verdadera o falsa. si la condición no es cierta, se romperá en el depurador automáticamente. Cuando se utiliza correctamente el metodo Assert, simplemente ejecuta la aplicación y se produce una notificación inmediata frente a un problema.
Ejemplo estamos usando un objeto IConfigurationSectionHandler y alguien ha eliminado la entrada en el archivo de configuración. Sin una afirmación de depuración, puede pasar 20 minutos tratando de localizar el objeto antes de darse cuenta de que alguien lo elimino.
Suponga que tenemos un archivo de configuración, pero los ajustes fueron eliminado:
Referenciando al namespace System.Diagnostics se podrá saber inmediatamente:
Si no se encuentran los valores, se mostrara un mensaje de aviso.
El método fail, es un método que causa que la clase debugger haga un break y muestre un mensaje:
En cada uno de estos escenarios, el cuadro de diálogo presenta tres opciones :
■ Abort: Detiene la ejecución del programa completo.
■ Retry : reintenta ejecutar el bloque de código nuevo.
■ Ignore: Salta la falla, y trata de reanudar la ejecución.
El método Write
Se llama seguido del mensaje que se quiere mostrar:
El método Writeif
Trabaja de forma idéntica al write, salvo lo realiza solo si se cumple una condición:
Los métodos WriteLine y WriteLineIf funcionan de manera similar a estos anteriores, salvo que además contienen un terminador de línea al final del mensaje.
El método Print
Funciona de forma similar a los métodos writes, solo que escribe si se encuentra enlazado a un objeto listener.
Método flush
Es usado para introducir todos los datos en un objeto listener. No necesita parámetros, solo se llama:
Atributos de debug
Son atributos que permiten especificar la forma en que la aplicación se debe comportar.
Un atributo, describe el comportamiento de un objeto y llamadas de este de antemano para saber cómo manejar la situación. Debido a esta capacidad, los atributos están particularmente bien adaptados a escenarios de depuración.
Atributos:
- DebuggerBrowsableAttribute
- DebuggerDisplayAttribute
- DebuggerHiddenAttribute
- DebuggerNonUserCodeAttribute
- DebuggerStepperBoundaryAttribute
- DebuggerStepThroughAttribute
- DebuggerTypeProxyAttribute
- DebuggerVisualizerAttribute
Si le pasamos datos:
Y le hacemos un breakpoint, vamos a observar los miembros públicos y los privados.
DebuggerBrowsableAttribute
Si en los miembros privados agregamos el atributo DebuggerBrowsableAttribute, y establecemos la enumeración DebuggerBrowsableState en nunca ( siempre Usando el namespace Sytems.Diagnostics), y volvemos a poner un breakpoint, al ejecutar la aplicación, se ve el siguiente cuadro:
La enumeración DebuggerBrowsableState
Valores:
| Never | El elemento nunca esta visible |
| Collapsed | Muestra el elemento colapsado. |
| RootHidden | No muestra el elemento principal pero si los elementos hijos. |
DebuggerDisplayAttribute
Colocando sobre el nombre de la clase el atributo DebuggerDisplay podemos formatear como queremos que se muestre el elemento principal:
Se vería de esta forma:
DebuggerHiddenAttribute y DebuggerNonUserCodeAttribute El propósito de estas, es que si se tiene un punto de interrupción establecido, en el momento de ejecutarlo es simplemente ignorado.
DebuggerStepperBoundaryAttribute
Se utiliza este atributo cuando algo creado por el diseñador contiene una o más propiedades o métodos de interés. Le permite ver una parte del código sin tener que ver todo lo demás.
DebuggerTypeProxyAttribute
Permite cambiar cómo un tipo determinado se muestra. Este atributo se usa normalmente cuando se tiene un tipo interno y desea tener control sobre cómo aparecen:
DebuggerVisualizerAttribute
Este atributo le indica al depurador que tiene un visualizador asociado para la clase dada.
Creación de agentes listeners Siempre se habló de la salida del depurador pero, ninguno de estos métodos tiene ningún valor sin estar asociado a un listener. Las dos clases principales más usadas son Trace y Debug que se utilizan de forma idéntica, la diferencia está en que trace se realiza en la compilación tanto en Release como Debug, mientras que de debug es sólo en debug.
Los métodos más usados son:
| Nombre | Descripcion |
| AutoFlush | Para obtener o establecer si el objeto se vacía después de cada escritura. |
| Close | Vacía el búfer de salida, y cierra todos los listeners asociados |
| Fail | emite un mensaje de error con la información sobre este |
| Flush | Vacía el búfer y escribe la salida a todos los objetos listeners |
| Listeners | obtiene la colección de listeners que monitorea |
| TraceInformation | muestra mensajes de información de todo lo que sucede |
Objetos listeners (oyentes)
Las clases Debug y Trace dependen de los objetos listeners, ya que estos son los que toman sus datos y los dejan analizar. De forma predeterminada, Visual Studio asigna un listener que envía los datos a la ventana de salida.
La clase DefaultTraceListener
Los oyentes pueden añadir de forma manual o mediante el archivo de configuración. Ejemplo de cómo añadir una DefaultTraceListener:
O en el archivo de configuración:
Clase TextWriterTraceListener
Es uno de los listeners más simples de usar y sirve para escribir la salida a un archivo de texto o un stream:
O por el archivo de configuración:
Clase XmlWriterTraceListener
Envía la información recibida, a un objeto TextWriter o un objeto Stream. Para ver un poco de información sobre sus métodos aquí. Se crea de la siguiente manera:
O en el archivo de configuración:
.....................................................................................................................................................
2da parte >>
.....................................................................................................................................................
No hay comentarios:
Publicar un comentario