DAM_M07_T07_P.txt

TEM
A
Tema 7: Documentación de Aplicaciones

Autoría: David Forteza

Tema 7: Documentación de Aplicaciones
¿Qué aprenderás?
• Documentar código
• Generar guías de usuario
• Ayuda en comandos y botones

¿Sabías que…?
• Visual Studio dispone de varias herramientas para generar ayuda
• Existen herramientas de terceros que pueden ser muy interesantes

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

7.1. Documentación de Aplicaciones
Al hablar de documentación de aplicaciones debemos distinguir dos tipos de documentación
distintos:
•

Documentación de código: Se trata de generar comentarios y ayudas en el código fuente.
Este tipo de ayudas van dirigidas a otros programadores que vayan a usar nuestro código.
Ya sean parte de nuestro equipo de trabajo o terceros en el caso de generar librearías para
ser distribuidas o vendidas. Es en ese último escenario dónde es especialmente importante
documentar el código de forma exhaustiva.

•

Documentación de usuario: Se trata de generar ayudas para el usuario final de la aplicación.
Estas pueden ser pequeños consejos y etiquetas implementadas en la propia interfaz o ser
archivos de ayuda en forma de hipertexto que pueden ser consultados e imprimidos de
forma independiente. También es importante generar tutoriales o guías de usuario en
formato pdf de forma clásica (es decir sin utilizar ninguna herramienta específica más allá de
un editor de texto) que se van a distribuir junto con la aplicación.

7.2. Documentación de código
Para explicar el proceso de documentar el código de nuestra aplicación vamos a usar un ejemplo en
el que se ha desarrollado una clase para manejar ecuaciones de segundo grado (que gráficamente
son parábolas). El código fuente completo de la clase es el siguiente:
public class Eq2
{
private int a;
private int b;
private int c;
public Eq2(int a,int b,int c)
{
if (a == 0) throw new Exception("El parametro a no puede ser 0");
this.a = a;
this.B = b;
this.C = c;
}
public int A { get => a; set { if (value != 0) a = value; } }

2

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

public int B { get => b; set => b = value; }
public int C { get => c; set => c = value; }
public PointF vertice()
{
PointF v = new PointF(0,0);
v.X = -b / (2.0f * a);
v.Y = -((b * b) / (4.0f * a)) + c;
return v;
}
public PointF foco()
{
PointF v = this.vertice();
v.Y += (1 / (4.0f * a));
return v;
}
public double[] cortes()
{
double[] sols = null;
int rad = (b * b) - (4 * a * c);
if (rad==0)
{
sols = new double[1];
sols[0] = -b / (2.0 * a);
}
if (rad > 0)
{
sols = new double[2];
sols[0] = (-b + Math.Sqrt(rad)) / (2.0 * a);
sols[1] = (-b - Math.Sqrt(rad)) / (2.0 * a);
}
return sols;
}
public float valor(float x)
{
return (a * x * x) + (b * x) + c;
}
3

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

public Bitmap grafica(int rango)
{
Bitmap b = new Bitmap(300, 300);
Graphics g;
g = Graphics.FromImage(b);
g.DrawRectangle(Pens.Black, 0, 0, 299, 299);
g.DrawLine(Pens.Black, 150, 0, 150, 300);
g.DrawLine(Pens.Black, 0, 150, 300, 150);
for (int i = 1; i < 2 * rango; i++)
{
g.DrawLine(Pens.Black, i * 150.0f / rango, 147, i * 150.0f / rango, 153);
g.DrawLine(Pens.Black, 147, i * 150.0f / rango, 153, i * 150.0f / rango);
}
for (int i = 0; i < 300; i++)
{
float x1 = (i - 150) / (150.0f / rango);
float x2 = (i - 149) / (150.0f / rango);
float y1 = this.valor(x1);
float y2 = this.valor(x2);
g.DrawLine(Pens.Blue, i, -(y1 * 150 / rango) + 150, i + 1, -(y2 * 150 / rango) + 150);
}
return b;
}
private String formatTerm(int num,int factor)
{
switch (factor)
{
case 2:
if (num != 1) return num + "x\xB2";
if (num == 1) return "x\xB2";
break;
case 1:
if (num > 1) return " + " + num + "x";
if (num == 1) return " + x";
if (num == 0) return "";
if (num == -1) return " - x";
4

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

if (num < -1) return " - "+ Math.Abs(num) + "x";
break;
case 0:
if (num > 0) return " + " + num;
if (num == 0) return "";
if (num < 0) return " - "+Math.Abs(num);
break;
}
return "";
}
public override string ToString()
{
return formatTerm(a, 2) + formatTerm(B, 1) + formatTerm(C, 0);
}
}

Más allá del conocimiento matemático que se tenga esta clase permite asignar los tres coeficientes
que definen una parábola, así como calcular sus puntos clave (foco, vértice y puntos de corte con el
eje x) y también es capaz de generar un bitmap con la gráfica.
Vamos a crear un nuevo proyecto en .NET i añadiremos una
clase con el código anterior. Luego vamos a crear una
pequeña interfaz que use esa clase para ver qué ocurre
cuando el código no está debidamente documentado.
Puntos clave de una parábola.

Vemos que al definir una instancia de la clase Eq2 el pequeño cuadro de texto flotante que aparece
no muestra ninguna información más allá del nombre de la clase y el espacio de nombres dónde
está definida. Vamos a añadir algunos comentarios al código y observaremos como cambia.
5

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Nos situamos en el código fuente de la clase Eq2 justo encima
de la cabecera de la clase.
Luego escribimos tres barras: ///
Y automáticamente se crea el siguiente texto:
namespace Tema7

{
/// <summary>
///
/// </summary>
public class Eq2
{

Esto es un comentario de código que modifica los cuadros de ayuda que muestra visual al usar
clases, métodos y propiedades. Sigue un estilo XML usando tags para definir los elementos que
deben mostrarse. En ese caso vemos el tag principal llamado summary que nos permite crear un
comentario de ayuda personalizado. Vamos a añadir un texto descriptivo para la clase Eq2:
{
/// <summary>
/// Esta clase muestra y realiza cálculos con ecuaciones de 2º grado
/// </summary>
public class Eq2

Ahora al establecer una nueva instancia de la clase Eq2 en nuestro formulario el cuadro de ayuda
muestra la descripción que hemos añadido.

Esta será el método utilizado para documentar toda nuestra clase. Según comentemos un clase,
propiedad o método utilizaremos distintos tags para documentar sus elementos. Vamos a ver un
ejemplo de cómo se comentaría un atributo. En ese caso sol usaremos el tag summary para añadir
un texto descriptivo tal y como hemos hecho con la definición de la clase. En el caso del parámetro
“a” podemos añadir que no puede tener el valor 0.
6

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

/// <summary>
/// Obtiene o establece el valor del parámetro a (no puede ser 0)
/// </summary>
public int A { get => a; set { if (value != 0) a = value; } }
/// <summary>
/// Obtiene o establece el valor del parámetro b
/// </summary>
public int B { get => b; set => b = value; }
/// <summary>
/// Obtiene o establece el valor del parámetro c
/// </summary>
public int C { get => c; set => c = value; }

Ahora vamos a documentar los métodos. Es ese caso vamos a usar algunos tag adicionales, para
comentar los parámetros necesarios, el valor de retorno y las posibles excepciones.
La estructura general es:
/// <summary>
/// Descripción del método
/// </summary>
/// <param name="parámetro 1">Descripción del parámetro 1</param>
/// <param name="parámetro 2">Descripción del parámetro 2</param>
...
/// <exception cref="Tipo de excpción">Descripción de la excepción</exception>
/// <returns>Descripción del valor devuelto</returns>

Ahora vamos a documentar los métodos de la clase. No es necesario documentar los métodos
privados ya que no serán accesibles desde fuera de la clase.
/// <summary>
/// Constructor de la classe Eq2
/// </summary>
/// <param name="a">Coeficiente de Segundo grado (no puede ser 0)</param>
7

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

/// <param name="b">Coeficiente de Primer grado</param>
/// <param name="c">Coeficiente indepenediente</param>
/// <exception cref="Exception">Se genera una excepción si el coeficiente a es
0</exception>
public Eq2(int a,int b,int c)
{
if (a == 0) throw new Exception("El parametro a no puede ser 0");
this.a = a;
this.B = b;
this.C = c;
}
/// <summary>
/// Obtiene o establece el valor del parámetro a (no puede ser 0)
/// </summary>
public int A { get => a; set { if (value != 0) a = value; } }

/// <summary>
/// Obtiene o establece el valor del parámetro b
/// </summary>
public int B { get => b; set => b = value; }

/// <summary>
/// Obtiene o establece el valor del parámetro c
/// </summary>
public int C { get => c; set => c = value; }
/// <summary>
/// Calcula el vertice de la parabola
/// </summary>
/// <returns>Devuelve un PointF con las coordenadas del vertice</returns>
public PointF vertice()
{
PointF v = new PointF(0,0);
v.X = -b / (2.0f * a);
v.Y = -((b * b) / (4.0f * a)) + c;
return v;
}

8

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

/// <summary>
/// Calcula el foco de la parabola
/// </summary>
/// <returns>Devuelve un PointF con las coordenadas del foco</returns>
public PointF foco()
{
PointF v = this.vertice();
v.Y += (1 / (4.0f * a));
return v;
}

/// <summary>
/// Calcula los puntos de corte en el eje X
/// </summary>
/// <returns>Un array con los puntos de corte o null si no los tiene</returns>
public double[] cortes()
{
double[] sols = null;
int rad = (b * b) - (4 * a * c);
if (rad==0)
{
sols = new double[1];
sols[0] = -b / (2.0 * a);
}
if (rad > 0)
{
sols = new double[2];
sols[0] = (-b + Math.Sqrt(rad)) / (2.0 * a);
sols[1] = (-b - Math.Sqrt(rad)) / (2.0 * a);
}
return sols;
}
/// <summary>
/// Calcula el valor Y para una X especificada
/// </summary>
/// <param name="x">Coordenada X a calcular</param>
/// <returns>El valor y correspondiente</returns>
public float valor(float x)
9

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

{
return (a * x * x) + (b * x) + c;
}

/// <summary>
/// Genera la grafica de la parabola
/// </summary>
/// <param name="rango">Rango de coordenadas a dibujar [-rango,rango]</param>
/// <returns>Un bitmap de 300x300 con la grafica</returns>
public Bitmap grafica(int rango)
{
Bitmap b = new Bitmap(300, 300);
Graphics g;
g = Graphics.FromImage(b);
g.DrawRectangle(Pens.Black, 0, 0, 299, 299);
g.DrawLine(Pens.Black, 150, 0, 150, 300);
g.DrawLine(Pens.Black, 0, 150, 300, 150);
for (int i = 1; i < 2 * rango; i++)
{
g.DrawLine(Pens.Black, i * 150.0f / rango, 147, i * 150.0f / rango, 153);
g.DrawLine(Pens.Black, 147, i * 150.0f / rango, 153, i * 150.0f / rango);
}
for (int i = 0; i < 300; i++)
{
float x1 = (i - 150) / (150.0f / rango);
float x2 = (i - 149) / (150.0f / rango);
float y1 = this.valor(x1);
float y2 = this.valor(x2);
g.DrawLine(Pens.Blue, i, -(y1 * 150 / rango) + 150, i + 1, -(y2 * 150 /
rango) + 150);
}
return b;
}

10

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Ahora ya tenemos documentada toda nuestra clase. A continuación, vemos algunos ejemplos de
las ayudas generadas:

Si queremos ver toda la documentación de una clase podemos usar el panel Examinador de objetos.
Lo podemos abrir desde el menú Ver o con el atajo Ctrl+Alt+j. Una vez abierto el panel localizamos
en el esquema de la parte izquierda la clase que queremos inspeccionar (Eq2 en nuestro caso). En
la parte derecha veremos todos los elementos (propiedades y métodos) de la clase. Y en la parte
inferior el texto de ayuda del seleccionado.

Examinador de objetos

11

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

7.2.1.

Herramientas para la documentación de código

7.2.1.1.

GhostDoc

Para usar la herramienta GhostDoc antes debemos descargarla e instalarla. Para ello vamos
elegimos la opción Extensiones y actualizaciones del menú herramientas y buscamos la extensión
en la red y la descargamos.

Luego nos indica que demos reiniciar Visual Studio para activar la extensión.

Al cerrar Visual se activa la instalación
de forma automática.
Al iniciar visual de nuevo podemos ver
que el menú herramientas hay una
nueva opción.

12

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Sin embargo, debemos notar que muchas de
sus opciones solo están disponibles para la
versión Pro que es de pago. Para documentar
usando GhostDoc debemos poner el cursor en
el elemento que queremos documentar.
Luego activando la opción Document this o el
atajo Ctrl+Mays+D se activa el panel para
comentar ese elemento.

Aquí podemos editar de una forma sencilla nuestro elemento. En el cuadro en gris podemos poner
la descripción. Además, disponemos de una barra con herramientas de formato en la parte superior.
Vamos a poner el mismo comentario que antes.

Si activamos la solapa Source View podremos ver el código XML que se insertará.

Una vez hemos terminado pulsamos el botón Save para insertar el código en nuestro programa.
El sistema detecta los aspectos más relevantes del elemento que deseamos comentar. Veamos esto
comentando el constructor de la clase (que contiene parámetros y genera excepciones):

13

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Como podemos ver la herramienta autogenera un comentario para el método y sus parámetros,
aunque desafortunadamente en inglés. También ha recuperado el mensaje de la excepción que en
ese caso no hay que modificar ya que esta extraído directamente del código, y por lo tanto en
español. Si en algún caso no se recuperar algún aspecto que deseamos incluir en la documentación
o queremos añadir cualquier tag.
Disponemos de un menú para ello en la parte superior izquierda:
De esa forma podemos generar los mismos comentarios que
antes, pero de una forma asistida y más amigable que
haciéndolo de forma manual. Podemos trabajar de una forma
“híbrida” estableciendo los comentarios directamente en el
código y luego usar GhostDoc para realizar “ajustes” como
formatos y aspectos avanzados ya que quizás no conocemos
todos los tags y opciones disponibles de memoria.

14

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

7.2.1.2.

Sandcastle

Sancastle es otra herramienta que nos ayuda a documentar nuestro código. Se suele usar junto a
todo lo visto anteriormente ya que consiste en un compilador de XML que lo que hace es recoger
todos los comentarios que hemos introducido en el código (ya sea manualmente o mediante
GhostDoc) y crea un documento con toda la documentación. Dicho documento puede ser en el
típico formato de archivos de ayuda Microsoft o en forma Web.
La herramienta Sandcastle es algo compleja de instalar.
Lo primero que vamos a hacer es descargar el motor de
compilación Sandcastle de la web. Este es un producto
Microsoft con lo que vamos a encontrarlo en su web.
Con eso ya tendríamos suficiente en principio. Lo que ocurre es que es una herramienta que debe
utilizarse desde la línea de comandos y es un poco complejo. Para ello lo que vamos a hacer es
descargar un frontend gráfico llamado Sandcastle Help File Builder que nos va a facilitar mucho la
tarea de compilar y crear la documentación.
Vamos a la web del desarrollador:
https://ewsoftware.github.io/SHFB/html/bd1ddb51-1c4f-434f-bb1a-ce2135d3a909.htm
Y en el apartado Getting Started/ Installation Instructions hallaremos el enlace de descarga.

15

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Al ejecutar el instalador aparece un asistente poco habitual.

Vamos pulsando en Next y vamos avanzando hasta llegar al paso HTML Help 1 Compiler. Esto es un
complementa capaz de compilar archivo tipo help de Windows. Es muy posible que nos salte un
error indicando que dicho compilador no está disponible. Podemos terminar la instalación y
podremos generar nuestras ayudas, pero solo en formato Web.
Para activar ese complemento podemos hacer instalando una herramienta que veremos en la
próxima sección llamada HelpNDoc. Lo más recomendable es abortar la instalación en ese punto.
Instalar la herramienta HelpNDoc (ver siguiente sección) y reanudar la instalación pera que
Sandcastle Help File Builder se instale completo.
Tras la instalación completa de SHFW abrimos de nuevo Visual Studio y cargamos nuestro proyecto
con comentarios XML. Luego debemos modificar las propiedades del proyecto para que se genere
un archivo XML con todos los comentarios insertados.
Para ello abrimos las propiedades del proyecto (En el menú Proyecto o con el atajo Alt+Intro). Una
vez abierta la ventana de propiedades elegimos la sección Compilación. En sus propiedades
veremos un aparatado llamado Salida dónde hay un check llamado Archivo de documentación XML.
Hay que activarlo (si no lo está ya) y podemos elegir ubicación y nombre del archivo XML con los
comentarios.

16

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Ahora en cuanto compilemos la solución se genera el archivo XML con todos los comentarios.
Ahora vamos a ejecutar el SHFW para generar nuestro fichero de documentación.
Creamos un nuevo proyecto (lo llamaremos Eq2Doc) y deberíamos ver algo como esto:

Ahora hay que añadir el archivo XML con
todos los cometarios al proyecto. Para ello
abrimos el menú File y elegimos Project
Explorer / Documentation Sources / Add
DocumentationSource ….

17

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Localizamos el archivo XML generado y aceptamos. En la parte
derecha de la interfaz deberíamos ver los archivos añadidos.

Ahora en la sección Build this help formats elegimos el formato de
archivo que queremos compilar.

Vamos a marcar HTML Help 1 y Website. Luego del menú Documentation elegimos la opción Build
Project (o el atajo Ctrl+Mays+B) para generar las ayudas. Si todo funciona veremos un mensaje
como ese en el log de compilación.

Ahora podemos ver el resultado tanto en forma de fichero (extensión .chm) o en forma web (fichero
index.html).

18

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

7.3. Documentación de Usuario
Esta sección la vamos a dedicar a explicar cómo documentar nuestra interfaz para el usuario final.
Es decir que su objetivo no es ayudar a un desarrollador a usar nuestro código, sino ayudar al usuario
final que va a utilizar nuestra interfaz. Existen distintas técnicas para ayudar al usuario a utilizar
nuestra aplicación. No son excluyentes entre ellas y de hecho es recomendable combinarlas todas
para lograr la mejor experiencia al usuario final.

7.3.1.

Tutoriales y guías de usuario

Esos elementos pueden ser de distintos tipos como documentos, videotutoriales, webs, etc. Se
confeccionan con herramientas TIC externas como Procesadores de texto, capturadores de pantalla
editores de imagen y similares. Se suelen distribuir junto a la aplicación, aunque a veces están
disponibles en línea pera ser consultadas.

7.3.2.

Ayudas en la interfaz

Se trata de ayudas implementadas en la misma interfaz. Las más habituales son esos pequeños
rótulos flotantes que aparecen al poner el puntero del ratón encima de los elementos de la interfaz.
Se llaman ToolTips y son una propiedad de los controles que debemos configurar (ya se vieron en
el tema de usabilidad). Basta con añadir el texto deseado en la propiedad ToolTipText del control.

Otro de los elementos de ayuda disponibles en la propia interfaz es el uso de la tecla F1 que en
entorno Windows es el estándar para activar las ayudas. En ese caso hay que utilizar el evento
llamado HelpRequested que se lanza al pulsar la tecla F1 con el control seleccionado o enfocado.
19

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

En ese evento debemos programar lo que sea que deba ocurrir cuando el usuario pida ayuda. En
nuestro caso vamos a hacer un pequeño ejemplo en el que vamos a generar una ayuda para el
control que permite establecer el parámetro a de la ecuación de 2º grado. Lo que vamos a hacer es
mostrar una ventana de información indicando que el valor de ese parámetro no puede ser 0. Para
ello generemos un evento HelpRequested para ese control:
private void nudaHelpRequested(object sender, HelpEventArgs hlpevent)
{
MessageBox.Show("El valor del parámetro a no puede ser 0", "Valor",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}

Y al ejecutar pulsamos la tecla F1 con el control
enfocado ese será el resultado:

7.3.3.

Herramientas externas de ayuda

Se trata de herramientas externas al propio Visual Studio que permiten generar ayudas para el
usuario. Una de las más utilizadas en el programa HelpNDoc que permite crear los clásicos archivos
de ayuda Microsoft.

Podemos descargar el programa de la red. Disponemos de una versión gratuita totalmente funcional
con el único “pero” que añade un pequeño banner en la parte inferior.
20

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Salvo ese detalle que no es demasiado importante nos permite generar archivos de ayuda en
muchos formatos: CHM, HTML, PDF, Word, EPUB,… Es un programa bastante simple de manejar
basta con crear un nuevo proyecto. Le ponemos un título, elegimos el idioma y creamos una tabla
de contenidos usando tabuladores para crear una jerarquía de temas:

Una vez creado el proyecto el panel izquierdo podemos ver el
esquema de nuestro proyecto.

21

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Lugo hay que ir editando cada una de las secciones en el panel derecho. Es un editor de texto típico
deponemos de herramientas de formato, inserción,… casi idénticas a Word.

Una vez terminada la edición podemos generar nuestro fichero de ayuda
en distintos formatos. De esa forma podemos generar todas las ayudas
necesarias para el usuario de la aplicación.

7.4. Tipos de Manuales
Existen diferentes tipos de manuales según cual sea su objetivo.
Manual de instalación. En él se determinan una serie de detalles necesarios a la hora de realizar la
instalación, como pueden ser, entre otros, los diferentes aspectos que debe tener el software según
el sistema operativo que se utilice, las aplicaciones que es necesario tener instaladas, las
características que debe tener la parte hardware, la cantidad de memoria RAM disponible, etcétera.
Se puede desarrollar la documentación en dos versiones diferentes:
•

Reducida: se lleva a cabo una instalación rápida con los valores seleccionados por defecto
sin entrar en muchos más detalles.

•

Detallada: esta versión explica de forma más detallada todos los aspectos que intervienen
en el proceso de instalación.

Documentación de configuración. En el caso de la documentación de configuración, se deben hacer
constar todos aquellos parámetros que tengan que ver con la configuración de una determinada
aplicación, además de todos aquellos cambios que se puedan producir en el momento en el que
funcione la aplicación.
22

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

En este tipo de documentación se tratan distintos aspectos, como pueden ser los aspectos software,
hardware, visuales, etcétera. Además, se define la forma en la que se van a ejecutar las diferentes
aplicaciones o librerías que va a necesitar el proyecto en cuestión. Asimismo, se tienen en cuenta
aquellos aspectos que pueden variar y, por tanto, las consecuencias que se van a producir en el
funcionamiento de la aplicación.
Cuando se habla de la documentación de configuración, es bastante frecuente diferenciar entre dos
niveles distintos:
•

Configuración normal.

•

Configuración avanzada: es muy parecida a la anterior, aunque, en este caso, se detallan
de forma más exhaustiva distintos aspectos más complejos que necesitan que los usuarios
tengan una mayor experiencia y conocimiento (administradores).

Manual de usuario. Al igual que en otros modelos de manuales, en el manual de usuario también
se diferencian dos versiones:
•

Rápida.

•

Detallada: esta versión amplía las diferentes opciones a la hora de realizar las diversas
posibilidades de aplicación.

En algunos casos, puede que esta información la incorpore la interfaz de usuario de una aplicación
determinada. De esta forma, es preciso indicar al usuario los diferentes pasos que se deben seguir
para poder desarrollar un trabajo mediante las ventanas/pantallas/páginas de la interfaz de usuario.
Así, el usuario final debe poder identificar las imágenes en la interfaz real de la aplicación en
cuestión. Según el nivel de los usuarios del sistema, existen distintos tipos de versiones: principiante,
inicial, medio, avanzado y experto. Según el caso, se profundizará más o menos en las diferentes
aplicaciones (describiendo cada acción y los valores que debemos proporcionar o elegir para
ejecutarlas).
Guía de usuario. El objetivo principal de la guía de usuario es el mismo que el anterior (manual de
usuario), con la diferencia de que, en este caso, cambia la extensión y la cantidad de información
disponible. Tiene como objetivo indicar de forma rápida y sencilla ciertas funcionalidades del
producto.
23

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Guía rápida. En esta guía rápida se dispone de un resumen con todos los aspectos más importantes
que se han desarrollado en la documentación previa. Se detalla de forma breve y muy sintetizada.

Manual de administración. Este manual detalla la instalación junto con la administración del
sistema. Además, en él viene explicado el proceso de configuración de aquellos componentes que
forman parte del sistema. Las personas encargadas de desarrollar estos manuales suelen ser los
administradores, ya que son los que tienen otorgados más privilegios a nivel operativo.

24

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Recursos y enlaces
•

HelpNDoc: https://www.helpndoc.com

•

SandCastle: https://www.microsoft.com/en-us/download/details.aspx?id=10526

•

SHFW: https://ewsoftware.github.io/SHFB/html/bd1ddb51-1c4f-434f-bb1ace2135d3a909.htm

Conceptos clave
•

Documentación de código: Consiste en documentar nuestro código para permitir a otros
programadores a usarlo con facilidad

•

Documentación de usuario: Consiste en generar ayudas para el usuario final de nuestra
aplicación. Ya sean implementadas en la misma interfaz o mediante archivos externos o
páginas web.

25

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Test de autoevaluación
1. Cuál es el objetivo de la documentación de código
a. Poner comentarios en nuestro código para no olvidarnos de su función
b. Crear ayudas a otros programadores para usar nuestras clases
c. Vender nuestro código en la red
d. Es necesario para poder exportar las librerías.
2. Cuál de las siguientes herramientas no se usa para documentar código
a. SandCastle
b. GhostDoc
c. Edición XML
d. HelpNDoc
3. ¿Qué es falso sobre GhostDoc?
a. Es una ayuda para el usuario
b. Genera comentarios XML
c. Es una alternativa al comentario manual del código
d. Se puede combinar con SandCastle
4. Sobre SandCastle
a. Es una herramienta que compila comentarios XML
b. Es una alternativa a GhostDoc para documentar código
c. Es una extensión de Visual Studio
d. Está instalada en Windows de forma predeterminada
5. Cuál es la diferencia entre Manual de usuario y Guía de usuario
a. No hay diferencia, son lo mismo.
b. La Guía es una versión resumida del Manual
c. Son lo mismo, pero difieren en extensión y cantidad de información.
d. En la Guía se explica lo que no aparece en el Manual.
6. ¿Cuál de los siguientes manuales es el más importante para desplegar una aplicación?
a. Guía de administración
b. Manual de instalación
c. Guía de usuario
d. Manual de configuración

26

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Ponlo en práctica
Disponemos de una clase que es capaz de gestionar una colección de imágenes disponemos de las
siguientes funcionalidades:
•

Añadir imágenes a la colección

•

Obtener la imagen actual

•

Obtener las imágenes siguiente y anterior a la actual

•

Saltar hacia adelanta o hacia atrás un número de imágenes

•

Ir a una imagen determinada

•

Girar 90 grados en sentido horario o antihorario la imagen actual

•

Voltear vertical o horizontalmente la imagen actual.

La actividad consiste en documentar la clase y generar un archivo chm con dicha documentación.
El código de la clase es el siguiente (dispones del fichero en los archivos del tema)
public class Fotos
{
private List<Image> fotos;
private int indice;
public Fotos()
{
fotos = new List<Image>();
indice = -1;
}
public int Cantidad
{
get { return fotos.Count; }
}
public void AnadirFoto(String Ruta)
{
Image img = null;
try {
img = Bitmap.FromFile(Ruta);
} catch (Exception ex)
{
throw new Exception("Error al cargar la imagen");
}
27

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

fotos.Add(img);
indice = fotos.Count - 1;
}
private void salto(int num)
{
indice += num;
while(indice >= fotos.Count) indice -= fotos.Count;
while (indice<0) indice += fotos.Count;
}
public Image Foto()
{
return fotos[indice];
}
public Image Siguiente()
{
salto(1);
return Foto();
}
public Image Anterior()
{
salto(-1);
return Foto();
}
public Image Saltar(int Cantidad)
{
salto(Cantidad);
return Foto();
}
public Image IrA(int Num)
{
if (Num < 1 || Num > fotos.Count) throw new
IndexOutOfRangeException("No existe esta foto");
indice = Num - 1;
return Foto();
}
public Image rotarHor()
{
fotos[indice].RotateFlip(RotateFlipType.Rotate90FlipNone);
return Foto();
28

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

}
public Image rotarAntiHor()
{
fotos[indice].RotateFlip(RotateFlipType.Rotate270FlipNone);
return Foto();
}
public Image VoltearVert()
{
fotos[indice].RotateFlip(RotateFlipType.RotateNoneFlipY);
return Foto();
}
public Image VoltearHor()
{
fotos[indice].RotateFlip(RotateFlipType.RotateNoneFlipX);
return Foto();
}

}

29

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

Solucionarios
Test autoevaluativo
1. Cuál es el objetivo de la documentación de código
a. Poner comentarios en nuestro código para no olvidarnos de su función
b. Crear ayudas a otros programadores para usar nuestras clases
c. Vender nuestro código en la red
d. Es necesario para poder exportar las librerías.
2. Cuál de las siguientes herramientas no se usa para documentar código
a. SandCastle
b. GhostDoc
c. Edición XML
d. HelpNDoc
3. ¿Qué es falso sobre GhostDoc?
a. Es una ayuda para el usuario
b. Genera comentarios XML
c. Es una alternativa al comentario manual del código
d. Se puede combinar con SandCastle
4. Sobre SandCastle
a. Es una herramienta que compila comentarios XML
b. Es una alternativa a GhostDoc para documentar código
c. Es una extensión de Visual Studio
d. Está instalada en Windows de forma predeterminada
5. Cuál es la diferencia entre Manual de usuario y Guía de usuario
a. No hay diferencia, son lo mismo.
b. La Guía es una versión resumida del Manual
c. Son lo mismo, pero difieren en extensión y cantidad de información.
d. En la Guía se explica lo que no aparece en el Manual.

30

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

6. ¿Cuál de los siguientes manuales es el más importante para desplegar una aplicación?
a. Guía de administración
b. Manual de instalación
c. Guía de usuario
d. Manual de configuración

Ponlo en práctica
Disponemos de una clase que es capaz de gestionar una colección de imágenes disponemos de las
siguientes funcionalidades:
•

Añadir imágenes a la colección

•

Obtener la imagen actual

•

Obtener las imágenes siguiente y anterior a la actual

•

Saltar hacia adelanta o hacia atrás un número de imágenes

•

Ir a una imagen determinada

•

Girar 90 grados en sentido horario o antihorario la imagen actual

•

Voltear vertical o horizontalmente la imagen actual.

La actividad consiste en documentar la clase y generar un archivo chm con dicha documentación.
Solución: Esta es la clase con comentarios. Dispones del fichero chm en los archivos de solución.

/// <summary>Esta clase permite manejar una colcección de fotos</summary>
public class Fotos
{
/// <summary>Lista con las fotos de la colección</summary>
private List<Image> fotos;
/// <summary>Indice que indica la foto actual dentro de la
colección</summary>
private int indice;
/// <summary>
///

<para>Crea una nueva instáncia de la clase <see cref="Fotos"

/>.</para>

31

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

///

<para>La colección esta vacía y el indice es -1.</para>

/// </summary>
public Fotos()
{
fotos = new List<Image>();
indice = -1;
}
/// <summary>Devuelve la cantidad de fotos de la colección.</summary>
/// <value>The cantidad.</value>
public int Cantidad
{
get { return fotos.Count; }
}
/// <summary>Añade una nueva foto al final de la colección.</summary>
/// <param name="Ruta">Ruta de disco de la imagen que queremos
añadir.</param>
/// <exception cref="System.Exception">Error al cargar la
imagen</exception>
public void AnadirFoto(String Ruta)
{
Image img = null;
try {
img = Bitmap.FromFile(Ruta);
} catch (Exception ex)
{
throw new Exception("Error al cargar la imagen");
}
fotos.Add(img);
indice = fotos.Count - 1;
}
/// <summary>Salta un número de fotos especificado.</summary>
/// <param name="num">La cantidad de fotos a saltar</param>
private void salto(int num)
{
indice += num;
while(indice >= fotos.Count) indice -= fotos.Count;
while (indice<0) indice += fotos.Count;
}
/// <summary>Obtiene la foto apuntada por el índice</summary>
32

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto obtenida.<br /></returns>
public Image Foto()
{
return fotos[indice];
}
/// <summary>Devuelve la siguiente foto en la colección.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto obtenida.<br /></returns>
public Image Siguiente()
{
salto(1);
return Foto();
}
/// <summary>Devuelve la foto anterior en la colección.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto obtenida.<br /></returns>
public Image Anterior()
{
salto(-1);
return Foto();
}
/// <summary>Salta un número de fotos en la colección y devuelve la foto
apuntada.</summary>
/// <param name="Cantidad">La cantidad de fotos a saltar</param>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto obtenida.<br /></returns>
public Image Saltar(int Cantidad)
{
salto(Cantidad);
return Foto();
}
/// <summary>Obtiene una foto de la colección a partir de su
índice</summary>
/// <param name="num">El índice (empezando en 1) de la foto que desamos
obtener</param>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto obtenida.<br /></returns>
public Image IrA(int num)
33

DAM_M07_Desarrollo de Interfaces
Tema 7: Documentación de Aplicaciones

{
if (num < 1 || num > fotos.Count) throw new
IndexOutOfRangeException("No existe esta foto");
indice = num - 1;
return Foto();
}
/// <summary>Rota la imagen actual 90 grados hacia la derecha.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto rotada.<br /></returns>
public Image rotarHor()
{
fotos[indice].RotateFlip(RotateFlipType.Rotate90FlipNone);
return Foto();
}
/// <summary>Rota la imagen actual 90 grados hacia la izquierda.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto rotada.<br /></returns>
public Image rotarAntiHor()
{
fotos[indice].RotateFlip(RotateFlipType.Rotate270FlipNone);
return Foto();
}
/// <summary>Voltea verticalmente la imagen actual.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto rotada.<br /></returns>
public Image VoltearVert()
{
fotos[indice].RotateFlip(RotateFlipType.RotateNoneFlipY);
return Foto();
}
/// <summary>Voltea horizontalmente la imagen actual.</summary>
/// <returns>Devuelve un objeto <font color="#31859b">Image </font>con la
foto rotada.<br /></returns>
public Image VoltearHor()
{
fotos[indice].RotateFlip(RotateFlipType.RotateNoneFlipX);
return Foto();
}
}
34