Diseñador y generador de Informes para usarlo en MonoDevelop sobre Linux. NReports 0.8.1

1. Tutorial
Reporteador Open Source “NReports 0.8.1”
Descripción:
“NReports es una biblioteca de informes utilizando el formato de archivos RDL, el objetivo es la
interoperabilidad con los Servicios de Reporteria de SQL.
Tiene su inicio como un fork de la última versión de fyIreporting 4.1 (ahora difunto).
Soporta .NET 3.5 (Windows) y Mono 2.6 o posterior (Linux).”
Fuente: http://nreports.codeplex.com/
La causa del desarrollo de este tutorial, esta basada en la búsqueda de un generador de informes
Open Source y por supuesto que pueda utilizarse en entornos Linux.
Actualmente, el desarrollo se encuentra en versión “Alfa”, y como lo dice la descripción: Soporta
.NET 3.5 y Mono 2.6.
Entre sus características tiene un diseñador y visor de informes usando Windows Forms para
representación (Windows), y un diseñador y visor de informes usando Gtk y Cairo para
representación (Linux).
En este trabajo, vamos a utilizar Linux (distribución Linux Mint 10), MonoDevelop 2.4 y
PostgreSQL como base de datos.
Autor:
José de Paz
jose.depaz@gmail.com
Guatemala – Colombia
Twitter: @_jdepaz

2. INICIO
Materiales:
Linux Mint 10 (escritorio GNOME)
PostgreSQL 8.4
MonoDevelop 2.4
Npgsql 2.0.11 para mono
NReports 0.8.1
Breve descripción de los materiales:
PostgreSQL: es un sistema de gestión de base de datos relacional orientada a objetos y libre,
publicada bajo la licencia BSD.
MonoDevelop: es un entorno de desarrollo integrado libre y gratuito, diseñado primordialmente
para C# y otros lenguajes .NET.
Npgsql: es un proveedor de datos .NET para PostgreSQL, esta implementado el 100% en código C#.
NReports: es un diseñador y visor de informes utilizando el formato de archivos RDL.
Primer paso:
PostgreSQL y MonoDevelop ya deben estar instalados en nuestro sistema operativo Linux, el
conector Npgsql lo podemos descargar de su respectivo sitio web: http://npgsql.projects.postgresql.org/,
luego en la pestaña “Downloads”, para luego seleccionar el archivo en formato ZIP “Npgsql2.0.11-bin-
mono2.0.zip”, como se muestra en la figura No. 1.
Figura No 1. Página de descargas Npgsql.

3. NReports lo podemos descargar de su respectivo sitio web: http://nreports.codeplex.com/, luego buscar
el botón “Download” y hacer clic sobre él, luego debemos aceptar la licencia de uso e
inmediatamente se realiza la descarga de archivo en formato ZIP NReports-0.8.1.zip, como se
muestra en la figura No. 2.
Figura No. 2 Sitio web de NReports.
Segundo paso:
Como se escribió con anterioridad, PostgreSQL será nuestro gestor de base de datos, entonces para
ello vamos a crear una tabla, a la cual le vamos a ingresar algunos registros, y estos mismos nos
servirán para visualizar en el informe que diseñaremos mas adelante, ahora; crear la tabla
“empleado” utilizando pgAdmin3, como se muestra en la figura No 3.
Figura No. 3 Script SQL para crear tabla “empleado” utilizando pgAdmin III.

4. Luego de crear la tabla “empleado”, vamos a ingresarle algunos registros, como se muestra en la
figura No. 4, o bien puedes ingresarle los que quieras, para este ejemplo ingresaremos solo cinco:
Figura No. 4 Ingresando cinco registros en la tabla “empleado” utilizando pgAdminIII
Siguiendo: ya teniendo creada la tabla y con cinco registros, seguimos adelante.
Tercer Paso:
Ahora vamos a crear una carpeta para nuestro ejercicio, en este caso puedes colocarle el nombre que
te guste; voy a crear una con el nombre “Ejercicio” dentro de “/home/jose” y dentro de ella vamos a
desempaquetar los archivos que descargamos según el paso uno; los cuales son: Npgsql2.0.11-bin-
mono2.0.zip y NReports-0.8.1.zip respectivamente, quedando la carpeta como se muestra en la figura
No. 5.
Figura No. 5 Carpeta “Ejercicio” con archivos desempaquetados.

5. Cuarto Paso:
Uno de los archivos que desempaquetamos, específicamente el de “NReports”, contiene los archivos
fuente para compilarlos, entonces para ello vamos a utilizar “MonoDevelop”; antes de eso, vamos a
ver el contenido de la carpeta “NReports-0.8.1”, según como se muestra en la figura No. 6.
Figura No. 6 Contenido de la carpeta /home/jose/Ejercicio/NReports-0.8.1
Esta carpeta contiene los archivos “solución” o *.sln, los cuales vamos a abrir con “MonoDevelop” para
luego compilarlos y así, generar el archivo ejecutable del diseñador y la biblioteca correspondiente de
“NReports” la cual debemos incluir en el proyecto como referencia.
Adelantando, cuando terminamos de compilar los proyectos “NReports.sln” y “NReports.Gtk.sln”, se
generan el diseñador y el visor de informes, llamados respectivamente “NReportsDesigner.exe” y
“GtkTest.exe “.
Bien, llegando a este punto, procedemos a ejecutar “MonoDevelop”, como se muestra en la figura No. 7 y No
8:
Figura No. 7 Splash Screen de MonoDevelop

6. Figura No. 8 IDE de MonoDevelop
Teniendo cargado el IDE de MonoDevelop, vamos a abrir el proyecto solución “NReports.sln”, el cual se
encuentra en “../Ejercicio/NReports-0.8.1/”; para esto, hacemos clic en la opción “File” de la barra de menús,
luego en el ítem “Open”, como se muestra en la figura No. 9:
Figura No. 9 Ítem “Open” del menú “File

7. Quinto Paso ( Primera construcción):
Una vez abierta la solución; procedemos a construirla, seleccionando desde la ventana de “soluciones”, y
luego haciendo clic con el botón derecho del mouse, y elegir la opción “Build NReports” del menú contextual
que se despliega, como se muestra en la figura No. 10:
Figura No. 10 Construcción de la Solución NReports
Luego de haber construido la solución, podemos observar en la barra de mensajes de MonoDevelop, la cual
está en la parte inferior izquierda, que la construcción se llevo a cabo con “0” errores y unas “83”
advertencias, tomando como referencia la figura No. 11:
Figura No. 11 Después de la construcción de la solución; con 0 errores

8. Después de esto, vamos a ir a la siguiente ruta “../Ejercicio/NReports-0.8.1/NReports.RdlDesign/bin/Debug”,
y vemos que dentro de la carpeta “Debug”, se encuentran los archivos generados por la construcción anterior,
y nos centramos específicamente en el que tiene el nombre “NReportsDesigner.exe”, tal como se muestra en
la figura No. 12:
Figura No. 12 Archivos generados dentro de la carpeta Debug
Ahora lo que haremos, es ejecutar el archivo tipo aplicación “ NReportsDesigner.exe”, para realizar esto hay
que abrir una “Terminal” de línea de comandos y dirigirnos hasta la carpeta “Debug” para luego correr el
diseñador, tomando como referencia la figura No. 13:
Figura No. 13 Terminal de línea de comandos dentro de la carpeta Debug
Después de llegar hasta el interior de la carpeta “Debug”, escribimos lo siguiente: ./NReportsDesigner.exe y
luego presionamos la tecla “Enter”; debes saber que para ejecutar un archivo en Linux, hay que anteponer el
punto “.” y la barra “/” ( o slash ) al nombre del archivo.
Si todo marcha correctamente después de haber presionado la tecla “Enter”, tendremos visible el diseñador
tal como se muestra en la figura No. 14 y luego, en este paso solo vamos a verificar que la aplicación se
ejecuta, entonces luego de darle una vista, procedemos a cerrarla y regresar a “MonoDevelop”.

9. Figura No. 14 Ventana de la aplicación NReports Designer
Sexto Paso (Segunda construcción):
Ahora que todo esta marchando correctamente, regresamos al IDE de “MonoDevelop”, y cerramos la
solución actual; para esto, hacemos clic en la opción “File” de la barra de menús, luego en el ítem “Close
Solution ”.
Seguido de esto, procedemos a abrir el proyecto solución “NReports.Gtk.sln”, el cual se encuentra en
“../Ejercicio/NReports-0.8.1/”; para esto, hacemos clic en la opción “File” de la barra de menús, luego en el
ítem “Open”, tomando como referencia la figura anterior No. 9.
Luego procedemos a construirla, seleccionando desde la ventana de “soluciones”, y luego haciendo clic con
el botón derecho del mouse, y elegir la opción “Build NReports.Gtk” del menú contextual que se despliega,
tomando como referencia la figura anterior No. 10.
En la construcción de esta solución, podemos observar en la “barra” de “mensajes” de “MonoDevelop”, la
cual está en la parte inferior izquierda, que la construcción se realizo con “0” errores y con “0” advertencias;
o sea una “Construcción exitosa”, tomando como referencia la figura No. 15:

10. Figura No. 15 Después de la construcción de la solución; con 0 errores y 0 advertencias
Ahora hacemos lo siguiente: nos vamos a dirigir a la siguiente ruta “../Ejercicio/NReports-
0.8.1/NReports.GtkReportViewer/bin/Debug”, y vemos que dentro de la carpeta “Debug”, se encuentran los
archivos generados por la construcción anterior, y nos centramos específicamente en el que tiene el nombre
“GtkTest.exe”, tal como se muestra en la figura No. 16:
Figura No. 16 Archivos generados dentro de la carpeta Debug
Ahora lo que haremos, es ejecutar el archivo tipo aplicación “ GtkTest.exe”, para realizar esto vamos a
regresar a “Terminal” de línea de comandos abierta anteriormente y dirigirnos hasta la carpeta “Debug” para
luego correr el visor de informes, tomando como referencia la figura No. 17:

11. Figura No. 17 Terminal de línea de comandos dentro de la carpeta Debug de GtkReportViewer
Después de llegar hasta el interior de la carpeta “Debug”, escribimos lo siguiente: ./GtkTest.exe y luego
presionamos la tecla “Enter”; Repito: debes saber que para ejecutar un archivo en Linux, hay que anteponer
el punto “.” y la barra “/” ( o slash ) al nombre del archivo.
Si todo marcha correctamente después de haber presionado la tecla “Enter”, tendremos visible el visor de
informes tal como se muestra en la figura No. 18 y luego, en este paso solo vamos a verificar que la
aplicación se ejecuta, entonces luego de darle una vista, procedemos a cerrarla y regresar a “MonoDevelop”.
Figura No. 18 Ventana de la aplicación NReport Viewer

12. Séptimo Paso (diseñando el informe):
Ahora que todo esta marchando correctamente, regresamos al IDE de “MonoDevelop”, y cerramos la
solución actual; para esto, hacemos clic en la opción “File” de la barra de menús, luego en el ítem “Close
Solution ”.
“Antes de encender el vehículo, necesitamos verificar que tenga combustible”
Antes de iniciar con el diseño del informe, necesitamos conocer y hacer algo al respecto: el diseñador utiliza
un archivo de configuración con extensión XML, llamado “RdlEngineConfig.xml”, en el cual están las
descripciones de los diferentes proveedores de datos, entre los cuales encontramos: SQL (Sql Server),
ODBC, OLEDB, MySQL, XML, puedes ver la siguiente figura, en donde se detalla parte del contenido de
este archivo:
Figura No. 19 Contenido del archivo RdlEngineConfig.xml
Como podemos observar, cada origen de datos esta compuesto por las siguientes etiquetas: DataProvider,
CodeModule, ClassName, TableSelect e Interface, pero específicamente no tiene el que necesitamos; en este
caso para “PostgreSQL”.
Entonces vamos a agregar las siguientes etiquetas; las cuales quedaran antes del DataSource para SQL, esto
quiere decir que el DataSource para PostgreSQL quedara como el primero; seguido, abrimos el archivo
“RdlEngineConfig.xml” el cual se encuentra en la siguiente ruta: “../Ejercicio/NReports-
0.8.1/NReports.RdlDesign/bin/Debug”; una vez abierto, agregamos las siguientes etiquetas tomando como
referencia la figura No. 20:

13. Figura No. 20 Agregando un DataSource al archivo RdlEngineConfig.xml
Si la figura no te ayuda, entonces toma como referencia las siguientes líneas:
<DataSource>
<DataProvider>PostgreSQL</DataProvider>
<TableSelect>SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE
TABLE_NAME NOT LIKE 'pg_%' ORDER BY 1
</TableSelect>
<CodeModule>Npgsql.dll</CodeModule>
<ClassName>Npgsql.NpgsqlConnection</ClassName>
<Interface>SQL</Interface>
</DataSource>
Después de agregar las líneas correspondientes al archivo, los guardamos y los cerramos.
Ahora es cuando vamos a hacer uso del proveedor de datos “Npgsql”, el cual ya hemos descargado y
desempaquetado con anterioridad, entonces nos dirigirnos a la siguientes ruta: “../Ejercicio/Mono2.0/bin” en
donde seleccionamos los siguientes archivos: Npgsql.dll, Mono.Security.dll y policy.2.0.Npgsql.dll y los
copiamos a la siguiente ruta: “../Ejercicio/NReports-0.8.1/NReports.RdlDesign/bin/Debug”.
Estos archivos que copiamos a donde corresponden, son los que necesita el diseñador para que al seleccionar
el origen de datos llamado “PostgreSQL”; haciendo uso de la librería “Npgsql.dll”, nos podamos conectar a
la base de datos sin ningún problema; observa entonces como queda el contenido de la carpeta
“../Ejercicio/NReports-0.8.1/NReports.RdlDesign/bin/Debug”, según la figura No. 21:
Figura No. 21 Archivos contenidos en la carpeta Debug

14. “Después que verificamos que tenemos combustible, proseguimos”
Regresamos entonces a la “Terminal” de línea de comandos y nos dirigirnos a la siguiente ruta:
“../Ejercicio/NReports-0.8.1/NReports.RdlDesign/bin/Debug” y procedemos a ejecutar el diseñador; para esto
escribimos “./NReportsDesigner.exe”y luego presionamos la tecla “Enter”, tal como se mostró en la figura
No 13, luego teniendo listo el diseñador, procedemos a crear el informe.
Ahora, hacemos clic en la opción “File” de la barra de menús, luego en el ítem “New Report”, tomando como
referencia la figura No. 19:
Figura No. 22 Opción “New Report” en el diseñador “NReport Designer”
Luego de haber seleccionando la opción de “New Report”, el diseñador nos muestra una ventana en donde
debemos configurar los datos del informe, como lo son: Report Info, Connection, Parameters, SQL,
Grouping, Report Syntax y Report Preview, como se muestra en la figura No. 23:
Figura No. 23 Ventana de configuración para el nuevo informe

15. Bien, entonces ahora solo vamos a configurar lo siguiente: en la pestaña “Report Info” dejamos tal como se
muestra, y seleccionamos la pestaña “Connection”, y procedemos a configurar esta sección tal como se
muestra en la figura No. 24, seleccionando el tipo de conexión “PostgreSQL” y escribiendo la cadena de
conexión en el cuadro de texto “Connection”, y luego probamos la conexión haciendo clic sobre el botón
“Test Connection”, y esperando que este todo correctamente, la prueba de conexión nos dará resultados
satisfactorios:
Figura No. 24 Ventana de configuración, pestaña “Connection”
Ahora, seguimos y seleccionamos la pestaña “SQL”, y procedemos a configurar esta sección tal como se
muestra en la figura No. 25, ingresando la sentencia SQL “SELECT * FROM empleado;” donde
corresponde:
Figura No. 25 Ventana de configuración, pestaña “SQL”

16. Por último, si todo lo indicado lo hemos realizado correctamente, entonces nos dirigirnos a la pestaña
“Report Preview” y podrás ver una vista preliminar del informe; con esto, como se muestra en la figura No.
26 podremos decir que vamos bien:
Figura No. 26 Ventana de configuración, pestaña “Report Preview”
Entonces como vimos en la figura anterior, ahora cerramos la ventana respectiva de configuraciones y el
diseñador nos devuelve a diseñador (valga la redundancia) en donde podremos cambiar o agregar encabezado
de página, pie de página, entre otras cosas, como se muestra en la figura No. 27:
Figura No. 27 Informe creado según la configuración de conexión

17. Octavo Paso (terminando el informe):
Ahora antes que ocurra una falla eléctrica o al parecido, vamos a guardar el informe, para realizar esto
hacemos clic sobre el ícono respectivo o bien seleccionando la opción “File” del menú de opciones y luego
sobre el ítem “Save”; para este informe le pondremos el nombre “empleado.rdl”.
Ya teniéndolo guardado, vamos a insertarle su respectivo encabezado; para realizarlo hacemos clic sobre el
ícono para agregar un “Textbox” y luego nos dirigirnos a la rejilla donde dice “Page Header” y como
buenos artesanos en el uso del mouse, agregamos un “Textbox” y luego lo redimensionamos tomando como
referencia la figura No. 28 y después le cambiamos la propiedad “Value”, - esta se encuentra en la parte
derecha del diseñador, en la sección de “Properties” - borrando la que tiene “Text” y le ingresamos “Reporte
de Empleados”, luego le cambiamos el tamaño de letra de 10 a 18 y listo, procedemos a “guardarlo”.
Figura No. 28 Agregando un encabezado al informe utilizando un Textbox
Creo que hasta aquí nuestro trabajo se esta realizando con éxito; entonces prosigo, ahora vamos a ver una
“Vista Previa” del informe desde el diseñador, para esto hacemos clic sobre la pestaña “Preview”, la cual se
encuentra en la parte inferior izquierda, después de las pestañas “Designer”y “RDL Text” respectivamente,
luego vamos a ver el código fuente del informe, o sea el archivo “empleado.rdl”, para realizarlo solo
hacemos clic sobre la pestaña “RDL Text”, tomar como referencia las figuras No. 29 y No. 30; luego de
observar, podemos decir que hemos terminado de diseñar el informe; entonces solo queda cerrar el diseñador.

18. Figura No. 29 Vista previa del informe con su encabezado
Figura No. 30 Código fuente del archivo empleado.rdl

19. Noveno Paso (Creando proyecto):
Llegando casi al final de este ejercicio, lo que nos resta es crear un proyecto o solución en “MonoDevelop” y
proceder a llamar el informe.
Entonces que esperamos, abrimos el IDE de “MonoDevelop” y luego hacemos clic sobre la opción “File” del
menú y luego sobre el ítem “New” y luego sobre el sub-ítem “Solution”, haciendo esto se nos abre una
ventana como se muestra en la figura No. 31, en la cual vamos a seleccionar que sea un proyecto en lenguaje
C#, y que sea de tipo “Gtk # 2.0 Project”, luego le ingresamos un nombre respectivo y la ruta respectiva; en
este caso estoy usando la carpeta “Tutorial” en donde guarde el informe “empleado.rdl”, luego de esto,
hacemos clic en el botón “Forward”, tomar como referencia la figura No 31:
Figura No. 31 Creando una nueva solución tipo Gtk # 2.0 en MonoDevelop
Después de hacer clic sobre el botón “Forward”, se nos abre una ventana como se muestra en la figura No.
32, la cual vamos a dejar tal como se muestra y luego presionamos el botón “Ok” para terminar.

20. Figura No. 32 Opciones adicionales de la solución tipo Gtk # 2.0 en MonoDevelop
Ahora bien, ya hemos creado la solución y luego de esto volvemos al IDE y podemos observar en el
explorador de soluciones; los elementos que componen la solución y así mismo el IDE nos muestra también
en la ventana del editor de código fuente; el contenido del archivo principal “Main.cs” como podremos
observar en la figura No. 33:
Figura No. 33 Solución “Tutorial” recién creada en MonoDevelop

21. Yo se que estamos impacientes por ver algo, entonces vamos a construir la aplicación y luego correrla, para
esto presionamos la combinación de teclas “Ctrl + F5” o bien haciendo clic sobre el botón “Run” el cual se
encuentra entre los siguientes íconos: específicamente el tercero de izquierda a derecha.
Haciendo esto podrás ver que se muestra una ventana con el título “MainWindow”, esto es porque al crear
una solución de este tipo, el IDE nos crea por defecto una clase llamada “MainWindow.cs”, la cual deriva del
namespace “Gtk.Window” y a su vez contiene un “widget” contenedor tipo “Form”.
Para ver esto, hacemos doble clic sobre el archivo “MainWindow.cs” que tenemos en el explorador de
soluciones y luego se nos muestra otra pestaña en el editor de código fuente, como se muestra en la figura
No. 34 y luego hacemos clic sobre el botón “Designer”, el cual se encuentra en la parte inferior del editor y al
realizarlo se nos muestra el diseño de la clase “MainWindow”, tomando como referencia la figura No. 35:
Figura No. 34 Código fuente de archivo MainWindow.cs
Figura No. 35 Diseñador del archivo MainWindow.cs con componente gráfico.

22. Décimo Paso (agregando referencias NReports):
Ya nos encontramos en los últimos pasos para terminar, espero no estéis impacientes como lo estoy yo.
Pues bien; seguimos, para tener la disponibilidad de NReports en nuestra solución, vamos a agregar las
respectivas referencias; las cuales son: “NReports.dll” y “NReports.GtkRender.dll”, esto archivos los
encontramos en la ruta donde construimos la solución “NReports.GtkViewer”; específicamente en:
“../Ejercicio/NReports-0.8.1/NReports.GtkReportViewer/bin/Debug”.
Entonces para agregar estas referencias a la solución, vamos a realizar lo siguiente: hacemos clic con el botón
derecho sobre el ítem “References” que se encuentra en el explorador de soluciones; tomando como
referencia la figura No. 36, y luego elegimos la opción “Edit References”, después de realizarlo, se nos abre
una ventana como se muestra en la figura No. 37, en la cual nos vamos a la pestaña “.Net Assembly”, luego
exploramos hasta donde se encuentran los archivos mencionados
anteriormente, y cuando los encontramos, procedemos a seleccionarlos y
luego presionamos el botón “Add” que se encuentra en la parte superior
derecha y por último presionamos el botón “Ok” que se encuentra en la parte
inferior derecha, y te lo repito: toma como referencia la figura No. 37.
Figura No. 36 Explorador
Figura No. 37 Agregando Referencias “.Net Assembly”a la solución

23. Antes de seguir, voy a comentarles que al agregar las respectivas referencias de “NReports”, se agregar dos
componentes visuales, los cuales los podemos observar en la caja de herramientas, como se muestra en la
figura No. 38; entonces, el componente que nos realizará el trabajo de “ver el
informe” será el llamado “ReportViewer”.
Seguido, vamos a agregar otro formulario; el cual no servirá para enviar una
“vista previa” del informe, a nuestra solución en donde vamos a cargar este
componente, para luego que este formulario “Preview” sea llamado desde el
formulario principal o “MainWindow”, ¡espero que les haya quedado claro!
Figura No. 38 ToolBox
Después de lo expuesto anteriormente, vamos al diseñador del primer formulario y vamos a agregar un
“contenedor” de componentes para colocar un botón de comando; para realizar esto, buscamos en la caja de
herramientas el componente “Fixed” y luego lo seleccionamos y lo arrastramos al formulario
“MainWindow”, seguido de esto, vamos otra vez a la caja de herramientas, solo que ahora nos dirigirnos a la
sección “widgets”, y seleccionamos el componente “Button” y lo arrastramos al formulario, para estas
instrucciones puedes tomar como referencia las figuras No. 39 y No. 40:
Figura No. 40 Componente Button
Figura No. 39 Contenedor Fixed
Ahora bien, el formulario debería quedar como se muestra en la figura No. 41, ya teniendo agregado el botón
de comando, le cambiamos la propiedad “Label” ingresando el siguiente texto: “Abrir Informe”.
Para cambiar las propiedades de los componentes, solo debemos seleccionar primero el componente; en este
caso el botón, y luego nos dirigimos a la paleta de “Propierties” que se encuentra en la parte izquierda del
IDE y buscar respectivamente la propiedad a cambiar.
En Linux -si esto no es así, por favor me pueden corregir -, específicamente en MonoDevelop, cada
componente tiene sus señales -Signals- llamados así a diferencia de otros entornos en los cuales se les llama
Eventos.
Entonces a este botón llamado “button1” le vamos a codificar una señal para cuando sea presionado; o sea la
señal “Clicled”

24. Figura No. 41 Formulario MainWindow con componentes agregados
Bien hasta aquí, ahora que ya hemos explicado lo que vamos a realizar con anterioridad, procedemos a
agregar otro formulario a la solución, entonces hacemos clic con el botón derecho del mouse sobre el ítem
“Tutorial” que se encuentra en el explorador de soluciones, y luego buscamos y seleccionamos la opción
“Add” y por último la opción “New Window”, tomando como referencia la figura No. 42:
Figura No. 43 Agregando un nuevo formulario
Seguido, se abre una ventana para que elijamos el tipo de formulario o ventana, entonces para este caso
seleccionamos que sea de tipo “Gtk”, luego que sea tipo “Window”, y por último le asignamos el nombre
“Preview” y listo, presionamos el botón “New”, entonces tomamos como referencia la figura No. 44:

25. Figura No. 44 Agregando una nueva ventana o formulario a la solución
Ya que hemos agregado un nuevo formulario,; entonces, como escribimos anteriormente, este nos servirá
para visualizar el informe. Seguido, agregamos un contenedor al formulario, para esto agregamos el
componente “Scrolled Window”; como se muestra en la figura No. 45, que se encuentra en la sección
“Containers” de la caja de herramientas, luego de esto, agregamos el componente “ReportViewer”; el cual lo
encontramos en la sección “General” de la caja de herramientas; según como se muestra en la figura No. 46,
luego haber arrastrado los componentes al formulario, este nos quedara como se muestra en la figura No. 47
Figura No. 45 Contenedor
Figura No. 46 Componente
ReportViewer
Figura No. 47 Formulario Preview con el componente ReportViewer

26. Ahora que ya tenemos listo el formulario “Preview” con sus componentes respectivos, vamos a codificar el
método constructor de la clase “Preview.cs”; para esto nos vamos a la pestaña “Source Code” y nos
dirigirnos al método en mención y agregamos un parámetro de entrada llamado “sInforme” de tipo “string” y
la siguiente línea: “this.reportviewer.LoadReport(sInforme)” tomando como referencia la figura No. 49:
Figura No. 49 Código del método constructor Preview
Lo que exactamente estamos realizando es lo siguiente: al cargarse el formulario “Preview”, este a su vez
recibe un parámetro de tipo “string” en su constructor, el cual tendrá el nombre del informe; para este
ejemplo será “empleado.rdl” y luego le asignamos este parámetro al método “LoadReport” de componente
“reportviewer”, el cual hace la tarea de generar el informe y seguidamente visualizarlo.
Bueno, ya casi terminando, -la olla ya va a pitar- vamos a codificar la señal del botón que llamará al
formulario que nos hará el trabajo de vista previa del informe, entonces ahora nos vamos al formulario
“MainWindow” y seleccionamos el botón respectivo y luego nos dirigirnos a las propiedades y luego a la
pestaña “Signals”y buscamos la señal “Clicked” y teniéndola seleccionada hacemos doble clic sobre ella,
como se muestra en la figura No. 50:
Figura No. 50 Señal Clicked del botón de comando
Después de haber creado la señal para el botón respectivo, se nos abre el edito de código fuente, en el cual
vamos a agregar la directiva: “using Tutorial;” la cual nos servirá para poder crear un objeto del tipo de
formulario “Preview”, al cual lo instanciamos enviándole como parámetro el nombre del informe, en este

27. caso “empleado.rdl” y luego hacemos uso del método “Show();” para abrirlo o mostrarlo como bien te
parezca.
Para agregar las líneas de código respectivo, toma como referencia la figura No. 51 y agrega según la
correspondiente a la directiva y las que corresponden al método “OnButton1Clicked” que es la señal
correspondiente al botón “Abrir Informe” :
Figura No. 51 Código de la clase MainWindow.cs
Sabiendo que eres precavido, espero que estés guardando los cambios para no tener que arrepentirse mas
adelante, tampoco espero que te adelantes y hayas ejecutado la aplicación; ya que en este punto, si lo has
hecho y has presionado el botón “Abrir Informe”, seguro que se te presentaran errores, así que mejor espera
la siguiente instrucción.
Para que el componente “reportviewer” informe pueda generar y mostrar los datos, necesita de lo siguiente:
El archivo informe de tipo RDL, en este caso “empleado.rdl”
El proveedor de datos, en este caso la biblioteca “Npgsql.dll“ y “Mono.Security.dll”, “police.2.0.Npgsql.dll”
El archivo de configuración, en este caso: “RdlEngineConfig.xml”
Entonces sabiendo esto, vamos a copiar estos archivos en la carpeta
“../Ejercicio/Tutorial/Tutorial/Tutorial/bin/Debug”, ahora bien, ¿Donde encontramos los archivos
mencionados anteriormente?, te recomiendo que busques en el inicio de este tutorial y verifiques donde
están para luego copiarlos.

28. Entonces toma como referencia la figura 52 para verificar que tengas todos los archivos correspondientes y
que la aplicación pueda ejecutarse sin ningún problema.
Figura No. 52 Archivos contenidos en la carpeta Debug
Llegando al final
Ahora si, presionemos el ícono respectivo para construir la aplicación o bien la combinación de teclas
“Ctrl+F5” y luego se nos abre la ventana respectiva y seguido presionemos el botón “Abrir Informe” y
haciendo esto seras testigo que todo este trabajo si tuvo la pena, como se muestra en la figura No. 53:
Figura No. 53 Solución Tutorial ejecutándose con la presentación del informe “empleado.rdl”

29. FINAL
Espero que este tutorial tenga su efecto, y que ayude a todos aquellos que andan en la búsqueda de un
generador de informes, y que por supuesto para Linux.
También puedo decirles que aunque NReports esta en versión Alfa, trabaja muy bien y claro esta que la
retroalimentación a los creadores sería de bastante ayuda, por tal situación los invito a que lo usen y que
prueben con otros informes mas detallistas, como lo pueden ser informes que reciban parámetros.
Falto explicar y trabajar sobre otras funcionalidades, pero espero mas adelante poder realizar otro tutorial
que continué explicando las otras características de este generador y sus posibles alternativas.
Entonces espero recibir tus comentarios al respecto y las sugerencias respectivas a las cuales estaré muy
agradecido de recibir y contestar.
Si tienes alguna invitación a desarrollar otro tutorial sobre otra herramienta, pueden contar conmigo.
Este tutorial se lo dedico a mi esposa por ser paciente y esperarme, a mi hija por ser mi inspiración, también a
mis amigos y colegas Milton, Nery y Luis.
“No seas sabio en tu propia opinión; Teme a Jehová, y apártate del mal”
Proverbios 3:7