Boton ComboBox de Visual. Hecho por De la Torre Hernandez Y De Leon

ComboBox by Alessia De laTorre on Scribd

SQL Server

En este artículo, la idea es obtener datos desde SQL Server, generar un XML con los mismos para luego escribir un archivo PDF y presentarlo.

Para la generación de PDF, utilizaremos una librería Open Source llamada iTextSharp que pueden obtener desde:

http://itextsharp.sourceforge.net

Una vez que hayamos bajado el fuente o el instalador de la librería, en nuestra aplicación tenemos que hacer referencia al proyecto o, si lo instalamos ya compilado, a la dll que se ha incorporado en el GAC.

El código que presento a continuación es una aplicación de consola en C#.
Para comenzar importaremos los namespaces que necesitamos para trabajar.

using System; 
using System.IO; 
using System.Xml; 
using System.Reflection; 
using System.Data; 
using System.Data.SqlClient;

Los únicos que no hemos utilizado nunca son los de la librería que acabamos de referenciar

using iTextSharp.text;
using iTextSharp.text.pdf;
using iTextSharp.text.xml;

Este último nos permite generar el PDF directamente desde un archivo xml, pero nosotros lo vamos a hacer en el aire.

   
namespace PDFApp
{

Vamos a definir y una clase con un método estático que traiga los datos desde SQLServer y los devuelva a nuestra aplicación como un documento DOM XML para que podamos generar nuestro archivo de resultado.

Nuestro método en cuestión esta sobrecargado por si necesitamos trabajar con transacciones (ya que estamos en el baile, bailemos).

   public class Query
   {
     public static XmlDocument ExecuteQuery(SqlCommand cmd, ref SqlTransaction trans) 
     {
       if( cmd == null )
         throw new ArgumentNullException("cmd", "El comando no puede ser null.");
       if( trans == null )
         throw new ArgumentNullException("trans", "La transaccion no puede ser null.");
 
       XmlNode xmlrow = null;
       XmlReader xmlreader = null;
       XmlDocument xmldoc = null;
       xmldoc = new XmlDocument();
       xmldoc.LoadXml("<ROOT/>");
       xmlreader = cmd.ExecuteXmlReader();
       xmlrow = xmldoc.ReadNode(xmlreader);
       while ( xmlrow != null )
       {
         xmldoc.DocumentElement.AppendChild(xmlrow);
         xmlrow = xmldoc.ReadNode(xmlreader);
       }
       xmlreader.Close();
       return xmldoc;
     }
     public static XmlDocument ExecuteQuery(SqlCommand cmd, SqlConnection conn)
     {
       XmlDocument xmldoc = null;
       SqlTransaction trans = null;
       if ( conn != null ) 
       {
         if ( conn.State != ConnectionState.Open ) 
         {
            conn.Open();
         }
         cmd.Connection = conn;
       }
       else
       {
         throw new ArgumentNullException("cmd", "El comando no puede ser null.");
       }
       trans = cmd.Connection.BeginTransaction();
       xmldoc = new XmlDocument();
       xmldoc.LoadXml("<ROOT/>");
       try       
       {
         cmd.Transaction = trans;
         xmldoc = ExecuteQuery(cmd, ref trans);
         trans.Commit();
       }
       catch (Exception ex) 
       {
         trans.Rollback();
         throw ex;
       }
       return xmldoc;
     }
   }

Aquí empieza lo bueno, vamos a definir nuestra clase con el entry point de la aplicación y generamos el PDF con los resultados.

   class Consola
   {
     [STAThread]
     static void main(string [] args)
     {

A continuación, creamos un objeto document con el tamaño de la pagina y sus márgenes, expresados en floats

       // *******************************************************
       // Generación del documento, aplicando los margenes
       // *******************************************************
       Document document = new Document(PageSize.A4, 90f, 50f, 90f, 60f);
       try 
       {

Pero para generar el PDF vamos a necesitar los datos.
Para ello vamos a llamar al método ExecuteQuery de la clase que definimos antes, la cual nos va a devolver el XML, pasandole los datos que necesite para obtener los datos desde el servidor de base de datos.

         XmlDocument Doc = new XmlDocument();
         SqlConnection cnx = new SqlConnection("Integrated Security=SSPI;Persist Security Info=False;
   Initial Catalog=BASEDEDATOS;Data Source=SERVIDORSQL");
         SqlCommand cmd = new sqlcommand("select * from personas for xml raw"); 

Hay que notar que es muy importante que la consulta desde el motor devuelva XML, para eso incluí en el SQL "FOR XML RAW" para que nuestro amigo SQL Server nos regale los resultados como queremos, asi la clase anterior entiende de que estamos hablando.

         cmd.Connection = cnx;
         Doc = Query.ExecuteQuery(cmd, cnx);

Bien, ya tenemos el XML en el objeto Doc.

Ahora solo tenemos que jugar con los datos para obtener el archivo, pero antes, vamos a decirle a la librería como son algunas de las propiedades que queremos, tales como donde va a escribir el archivo, los tipos de letra, etc, etc.

         // *******************************************************
         // Configuración del documento PDF
         // *******************************************************
         string FullPathOut = "c:\\SalidaPDF.pdf";
         PdfWriter.getInstance(document, new filestream(fullpathout, filemode.create));  
         // *******************************************************
         // Fonts y colores
         // ******************************************************* 
         Font font_celdas = FontFactory.getFont(FontFactory.HELVETICA, 8, Font.NORMAL);
         Font font_titulo_tabla = FontFactory.getFont(FontFactory.HELVETICA, 9, Font.BOLD, 
   new Color(255,255,255));
         Color color_negro = new color(0, 0, 0); 

Bueno, vamos a ver como mostramos los datos.
Primero tenemos que abrir el documento.

         document.Open();

Ahora vamos a generar una tabla dinámica con algunos de los datos que vamos a obtener.
Yo utilice para el ejemplo, las columnas Nombre, Apellido y Teléfono de la tabla de la base de datos.

         // *******************************************************
         // Tabla
         // ******************************************************* 
         Table table = new Table(3);
         table.BorderWidth = 0;
         table.BorderColor = color_negro;
         table.Padding = 1;
         table.Spacing = 1; 
         Cell titulo = new cell(new Phrase("Datos de la tabla", font_titulo_tabla));
         titulo.Header = true ;
         titulo.BackgroundColor = color_negro;
         titulo.Colspan = 3;
         table.addCell(titulo);
         table.addCell(new Phrase("Nombre", font_celdas));
         table.addCell(new Phrase("Num. Documento", font_celdas));
         table.addCell(new Phrase("Teléfono", font_celdas));
         table.endHeaders();

Como pueden ver, las propiedades para la tabla y para las celdas son muy parecidos a los atributos que definimos en HTML asi que nos vamos a dar cuenta en seguida si necesitamos agregar alguna otra propiedad que querramos.

Ahora vamos a agregar todo lo que nos viene en nuestro XML.

         foreach(xmlelement elem in Doc.SelectNodes("/ROOT/row"))
         {
            table.addCell(new Phrase(Elem.GetAttribute("Usu_Apellido"), font_celdas));
            table.addCell(new Phrase(Elem.GetAttribute("Usu_NroDocumento"), font_celdas));
            table.addCell(new Phrase(Elem.GetAttribute("Usu_Telefono"), font_celdas));
         }

Ya está, ahora solo agreguemos todo esto que generamos a nuestro documento, y.... listo!...

         document.Add(table);
       }

Por las dudas.....

       catch (XmlException xex)
       {
         Console.Error.WriteLine(xex.Message);
       }
       catch (DocumentException de) 
       {
         Console.Error.WriteLine(de.Message);
       }
       catch (IOException ioe) 
       {
         Console.Error.WriteLine(ioe.Message);
       }     

Finalmente cerramos todo, no es cuestión de dejar las cosas así porque si...

       finally
       {
         document.Close();
       }
     }
   }
}

Diagrama De Clases De Un Torneo De Basquetbol

Torneo de Basquetbol

Diagrama De Clases De Un Torneo De Basquetbol by Alessia De laTorre on Scribd

Diagrama De Clases De Un Torneo De Basquetball

Agregar leyenda

Clases del torneo de Basqueball.pdf

37 KB

UML

 (Lenguaje unificado de modelado)

 ¿Qué es?

Es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad; está respaldado por el Object Management Group (OMG).

Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos, funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y compuestos reciclados.

Es importante remarcar que UML es un "lenguaje de modelado" para especificar o para describir métodos o procesos. 

Se utiliza para definir un sistema, para detallar los artefactos en el sistema y para documentar y construir.

Se puede aplicar en el desarrollo de software gran variedad de formas para dar soporte a una metodología de desarrollo de software (tal como el Proceso Unificado Racional, Rational Unified Process o RUP), pero no especifica en sí mismo qué metodología o proceso usar.

UML no puede compararse con la programación estructurada,  no es programación, solo se diagrama la realidad de una utilización en un requerimiento. Mientras que programación estructurada es una forma de programar como lo es la orientación a objetos, la programación orientada a objetos viene siendo un complemento perfecto de UML, pero no por eso se toma UML solo para lenguajes orientados a objetos.

¿Para que sirve?

Sirve para representar visualmente las reglas de creación, estructura y comportamiento de un grupo relacionado de objetos y procesos.

Para visualizar de forma eficiente la complejidad de un sistema u organización en un reducido número de diagramas.

Ventajas:

• UML Se puede usar para diferentes tipos de sistemas.
• UML consolida muchas de las notaciones y conceptos más usadas orientados a objetos. 
• UML se entiende fácilmente.

Desventajas:

• UML no es un método de desarrollo. 
• UML al no ser un método de desarrollo es independiente del ciclo de desarrollo
• UML no se presta con facilidad al diseño de sistemas distribuidos

Tipos de diagramas UML

CASO DE USO:

Los Casos de Uso no forma parte de la llamada Fase de Diseño, sino parte de la fase de Análisis, respondiendo el interrogante ¿Qué?. De forma que al ser parte del análisis ayuda a describir que es lo que el sistema debe hacer.

Estos diagramas muestran operaciones que se esperan de una aplicación o sistema y como se relaciona con su entorno, es por ello que se ve desde el punto de vista del usuario. Describen un uso del sistema y como éste interactúa con el usuario.
Los casos de usos se representan en el diagrama por una elipses la cual denota un requerimiento solucionado por el sistema.El conjunto de casos de usos representa la totalidad de operaciones que va a desarrollar el sistema. Por último a estos elipses lo acompaña un nombre significativo de manera de rótulo.

DIAGRAMA DE CLASES:

Es uno de los tipos de diagramas o símbolo estático y tiene como fin describir la estructura de un sistema mostrando sus clases, atributos y relaciones entre ellos.

Estos diagramas son utilizados durante el proceso de análisis y diseño de los sistemas informáticos, en donde se intentan conformar el diagrama conceptual de la información que se manejará en el sistema.

Como ya sabemos UML es un modelado de sistema Orientados a Objetos, por ende los conceptos de este paradigma se incorporan a este lenguaje de modelado.

DIAGRAMA DE OBJETOS:

Forma parte de la vista estática del sistema. En este diagrama se modelan las instancias de la clases del Diagrama de Clases. Este diagrama cabe aclarar que cuenta con objetos y enlaces. En estos diagramas también es posible encontrar las clases para tomar como referencia su instauración.

DIAGRAMA DE ACTIVIDAD:

Representa un flujo de trabajo paso a paso de negocio y operacionales de los componentes en un sistema.

En UML 1, un diagrama de actividades es una variación del Diagrama de Estados UML donde los estados representan operaciones y las transiciones representan las actividades que ocurren cuando la operación es completa.

En la actualidad, el diagrama de actividades en UML 2.0 es similar al aspecto del diagrama en UML 1, solo que ahora la semántica esta basada en lo que se conoce como Redes de Petri. En UML 2.0, el diagrama general de interacción está basado en el diagrama de Actividad.

Componentes:

• Inicio: el inicio de un diagrama de actividades es representado por un círculo de color negro sólido.
• Actividad: Una actividad representa la acción que será realizada por el sistema la cual representa dentro de un óvalo.
• Transición: Una transición ocurre cuando se lleva acabo el cambio de una actividad a otra, la transición es representada simplemente por una línea con una flecha en su terminación para indicar su dirección.

DIAGRAMA DE SECUENCIA:

Un Diagrama de Secuencias muestra una interacción ordenada según la secuencia temporal de eventos y el intercambio de mensajes. Los diagramas diagramas de secuencia ponen especial énfasis en el orden y el momento en el que se envían los mensajes a los objetos.

DIAGRAMA DE COLABORACIÓN:

Un diagrama de colaboración, se puede decir que es una forma alternativa al diagrama de secuencias a la hora de mostrar un escenario.
Este tipo de diagrama muestra las interacciones que ocurren entre los objetos que participan en una situación determinada.
A diferencia del diagrama de secuencia, el diagrama de colaboración se enfoca en la relación entre los objetos y su topología de comunicación.

En estos diagramas los mensajes enviados de un objeto a otro se representa mediante flechas, acompañado del nombre del mensaje, los parámetros y la secuencia del mensaje.

Estos diagramas están indicados para mostrar una situación o flujo de programa específico y son considerados uno de los mejores diagramas para mostrar o explicar rápidamente un proceso dentro de la lógica del programa

DIAGRAMA DE DESPLIEGUE:

Básicamente este tipo de diagrama se utiliza para modelar el Hardware utilizado en la implementación del sistema y la relaciones entre sus componentes.

Los elementos usados por este tipo de diagrama son nodos, componentes y asociaciones. En el UML 2.0 los componentes ya no están dentro de nodos, en cambio puede haber artefactos (archivo, un programa, una biblioteca o Base de datos) u otros nodos dentro de nodos.

DIAGRAMA DE COMPONENTES:

Lo que distingue el Diagrama de Componentes de otro tipo de diagramas es sin duda su contenido. Normalmente contiene componentes, interfaces y relaciones entre ellos.Los componentes perteneces a un mundo físico, es decir, representan a un bloque de construcción al modelar aspectos físicos de un sistema.

Cada componente debe tener un nombre que lo distinga de los demás. Al igual que las clases los componentes pueden enriquecerse con compartimientos adicionales que muestran sus detalles.

DIAGRAMA DE TRANSICIÓN DE ESTADO:

Es un diagrama utilizado para identificar cada una de las rutas o caminos que puede tomar un flujo de información luego de ejecutarse cada proceso.

Permite identificar bajo qué argumentos se ejecuta cada uno de los procesos y en qué momento podrían tener una variación.

El diagrama de estados permite visualizar de una forma secuencial la ejecución de cada uno de los procesos.

Simbología: