Archivo del sitio

POCO, POJO, POPO y otras chunches… Ahhh Y MetaData tambien…


POCO es un acrónimo de Plain Old CLR Object

POJO es un acrónimo de Plain Old Java Object

Ambos acrónimos son utilizados para definir clases simples que pueden ser utilizados por frameworks para ser llenados, como muchas personas que me siguen en este blog, se darán cuenta que son muy utilizados en mis post para crear clases de paso o clases de llenado de datos que a su vez generan listas, hoy me he encontrado con algo que me da flojera a ciencia cierta y es actualizar una clase junto con todos los cambios que estas representan en las diferentes capas que utilizo en el trabajo, por lo que hoy dedique mi tiempo a realizar una herramienta que me permite crear estas clases de “dominio” o “entidad” de manera rapida utilizando la MetaData de la base de datos, veamos el código para armarla y luego podremos descargarlo.

Crearemos una solución de Windows Forms para este caso, y agregaremos los siguientes elementos

  • cbDatabaseManager: Combo que contendrá las bases de datos para conectarse
  • Server: TextBox que nos permitirá escribir el servidor a conectarnos
  • Port: TextBox que nos permitirá cambiar de puerto si es necesario
  • User: TextBox que nos permitirá escribir el Usuario
  • Password: TextBox que nos permitirá escribir el Password
  • Connect: Boton que generará la conexión
  • DirectoryPath: Path donde serán guardadas nuestras clases
  • button1: (Ya comenzamos con problemas de flojera) Boton que nos permitirá seleccionar el Path donde guardaremos nuestras clases
  • cbDataBases: Combo que se llenará con las bases de datos una vez estemos conectados
  • lstbTables: ListBox  que nos permitirá mostrar las tablas y seleccionar más de una tabla para su generación en clase
  • cbLanguage: Combo que nos dirá en que lenguaje serán creados nuestros ¿POCO’s?, ¿POJO’s? lo que ustedes quieran siguien siendo clases simples y dependen de la sintaxis del lenguaje
  • Console: TextBox Multilinea que nos dira que esta pasando en nuestro proceso
  • button2: Boton que nos permitirá Ejecutar la generación de clases
  • fbdDirectory: Control de FileBoxDialog que nos permitirá en conjunto con el Boton1 seleccionar nuestro directorio

Una vez realizado nuestro formulario debe quedar más o menos así:

Bien una vez creado nuestro formulario creemos las clases para utilizarlo, crearemos una carpeta en la raíz de nuestro proyecto llamada Entity, en el cual crearemos las siguientes clases:

Catalog


publicclassCatalog
{
public string Key { get; set; }
public string Value { get; set; }
}

La clase anteriormente mostrada es generica, se utiliza para llenar catalogos tanto estaticos como dinamicos esta se utilizará para los combos y los listbox

Connector

 public class Connector
 {
 public string DataBaseManager { get; set; }
 public string Server { get; set; }
 public int Port { get; set; }
 public string Catalog { get; set; }
 public string User { get; set; }
 public string Password { get; set; }

 public string SourceConnectorMaster { get {
 StringBuilder conn = new StringBuilder();
 conn.Append("Data Source = ")
 .Append(Server)
 .Append("; User ID = ")
 .Append(User)
 .Append("; Password = ")
 .Append(Password);
 return conn.ToString();
 } }

 public string SourceConnectorComplete
 {
 get
 {
 StringBuilder conn = new StringBuilder();
 conn.Append("Data Source = ")
 .Append(Server)
 .Append("; Initial Catalog = ")
 .Append(Catalog)
 .Append("; User ID = ")
 .Append(User)
 .Append("; Password = ")
 .Append(Password);
 return conn.ToString();
 }
 }
 }

La clase connector contendrá la información de conexión a la base de datos así como los datos que recopilemos de la entrada del formulario además de tener 2 propiedades más SourceConnectorMaster y SourceConnectorComplete, las cuales definen las cadenas de conexion que se turilizarán en este caso es .NET, más adelante con un poco de imaginación podemos agregar más cadenas de conexión de diferentes Administradores de Bases de Datos.

MetaInfo

 public class MetaInfo
 {
 public string Table { get; set; }
 public string FieldName { get; set; }
 public string Type { get; set; }
 public bool ISNullable { get; set; }
 public int MaxChar { get; set; }
 }

La clase MetaInfo contendrá la información de la Metadata de la base de datos Información de Tablas, Tamaños, Nombres de Columna, Tipos de Dato, etc…

CacheManager

 public static class CacheManager
 {
 public static List<Catalog> DataBaseManager;
 public static List<Catalog> Language;

 public static void init()
 {
 DataBaseManager = new List<Catalog>() {
 new Catalog() { Key="1", Value="SQLServer" }
 };

 Language = new List<Catalog>()
 {
 new Catalog() { Key="1", Value="C#" },
 new Catalog() { Key="2", Value="Java"}
 };
 }
 }

La clase CacheManager es una clase que se inicializará al abrir nuestro formulario y por lo tanto estatica, la cual contiene las listas estaticas dentro de nuestro programa, se utiliza para llenar los combos de Lenguaje y DataBaseManager, esto nos permite ir mostrando mientras crecemos la implementación, Estamos dieñando un programita, pero recordemos que si trabajamos en diferentes lenguajes seria un error crear una herramienta solo para uno de los lenguajes que utilizamos y peor aun si ligamos los lenguajes a bases de datos podria decirse que nativas o de paridad emmm… que quiero decir con esto, que si usas C# probablemente estes usando .NET o en su defecto si usas PHP, seguramente estas usando MySQL por esto es que voy a hacer el programa de tal manera que pueda crecer a mis necesidades.

Hora de preparar las conexiones a base de datos en este caso por prisa, solo utilizare, net; pero no obstante dejaré el proyecto preparado para crecer, así que crearé una carpeta DataAccess y dentro de ella una interface IData y una clase SQLServer, las cuales me permitirán trabajar y extender mi trabajo despues, veamos el contenido:

IData


public interface IData
{
List<Catalog> GetTables(string Connector);

List<Catalog> GetDataBases(string Connector);

List<MetaInfo> GetMetaInfo(string Connector);
}

Esta clase podemos ver que solo tiene las funciones que voy a utilizar en las demás clases esto me permitirá usar un poco de polimorfismo y algunos factorys para vivir mi experiencia un poco más ordenada (Si, a mi me va bien así…)

SQLServer


public class SQLServer : IData
{
public List GetMetaInfo(string Connector)
{
List<MetaInfo> metaInfo = new List<MetaInfo>();
SqlConnection conn = new SqlConnection(Connector);
try
{
conn.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
#region Query
cmd.CommandText = @"SELECT
C.TABLE_CATALOG,C.TABLE_NAME,C.COLUMN_NAME,C.IS_NULLABLE,C.DATA_TYPE,C.CHARACTER_MAXIMUM_LENGTH
FROM INFORMATION_SCHEMA.COLUMNS C
INNER JOIN INFORMATION_SCHEMA.TABLES A ON C.TABLE_NAME=A.TABLE_NAME
WHERE A.TABLE_NAME NOT IN('SYSSCHEMAARTICLES','SYSPUBLICATIONS','MSREPL_ERRORS','TRANSACTIONS','MSMERGE_HISTORY','MSMERGE_AGENT_PARAMETERS','MSMERGE_REPLINFO',
'SYSSUBSCRIPTIONS','SYSMERGEARTICLES','VW_TRAMITES_CONCEPTOS','SYSARTICLEUPDATES','MSPUB_IDENTITY_RANGE','SYSTRANSCHEMAS','SYSMERGESCHEMAARTICLES','SYSMERGEPARTITIONINFOVIEW',
'SYSMERGEPARTITIONINFO','MSMERGE_SUPPORTABILITY_SETTINGS','MSMERGE_SESSIONS','MSMERGE_PAST_PARTITION_MAPPINGS','MSMERGE_GENERATION_PARTITION_MAPPINGS','SYSMERGESUBSCRIPTIONS',
'MSDYNAMICSNAPSHOTJOBS','MSDYNAMICSNAPSHOTVIEWS','MSMERGE_AGENT_PARAMETERS','MSMERGE_ARTICLEHISTORY','MSMERGE_ALTSYNCPARTNERS','MSMERGE_CONTENTS','MSMERGE_CURRENT_PARTITION_MAPPINGS',
'MSMERGE_DYNAMIC_SNAPSHOTS','MSMERGE_ERRORLINEAGE','MSMERGE_GENHISTORY','MSMERGE_IDENTITY_RANGE','MSMERGE_LOG_FILES','MSMERGE_METADATAACTION_REQUEST','MSMERGE_PARTITION_GROUPS',
'MSMERGE_SETTINGSHISTORY','MSMERGE_TOMBSTONE','MSPEER_CONFLICTDETECTIONCONFIGREQUEST','MSPEER_LSNS','MSPEER_ORIGINATORID_HISTORY','MSPEER_REQUEST','MSPEER_TOPOLOGYREQUEST',
'SYSARTICLECOLUMNS','SYSARTICLES','SYSEXTENDEDARTICLESVIEW','SYSMERGEEXTENDEDARTICLESVIEW','SYSMERGEPUBLICATIONS','SYSMERGESCHEMACHANGE'
)
AND A.TABLE_TYPE NOT IN('VIEW')
ORDER BY A.TABLE_NAME";
#endregion
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandTimeout = 0;
using (SqlDataReader r = cmd.ExecuteReader())
{
while (r.Read())
{
MetaInfo mi = new MetaInfo();
mi.Table = Convert.ToString(r["TABLE_NAME"]);
mi.FieldName = Convert.ToString(r["COLUMN_NAME"]);
mi.Type = Convert.ToString(r["DATA_TYPE"]);
mi.ISNullable = Convert.ToString(r["IS_NULLABLE"]) == "YES" ? true : false;
metaInfo.Add(mi);
}
}
}
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return metaInfo;
}

public List<Catalog> GetDataBases(string Connector)
{
List<Catalog> catalogs = new List();
Catalog c = new Catalog();
c.Key = "0";
c.Value = "Select one";
catalogs.Add(c);
SqlConnection conn = new SqlConnection(Connector);
try
{
conn.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
#region Query
cmd.CommandText = @"SELECT name, database_id FROM sys.databases";
#endregion
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandTimeout = 0;
using (SqlDataReader r = cmd.ExecuteReader())
{
while (r.Read())
{
c = new Catalog();
c.Key = Convert.ToString(r["database_id"]);
c.Value = Convert.ToString(r["name"]);
catalogs.Add(c);
}
}
}
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return catalogs;
}

public List GetTables(string Connector)
{
List<Catalog> catalogs = new List<Catalog>();
SqlConnection conn = new SqlConnection(Connector);
try
{
conn.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
#region Query
cmd.CommandText = @"SELECT * FROM INFORMATION_SCHEMA.TABLES ORDER BY TABLE_NAME";
#endregion
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandTimeout = 0;
using (SqlDataReader r = cmd.ExecuteReader())
{
while (r.Read())
{
Catalog c = new Catalog();
c.Key = Convert.ToString(r["TABLE_NAME"]);
c.Value = Convert.ToString(r["TABLE_NAME"]);
catalogs.Add(c);
}
}
}
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return catalogs;
}
}

Como podemos ver la clase SQLServer hereda de IData, esto me permite implementar los mismos metodos en todas mis clases ahora solo veamos que es lo que debemos hacer en cuanto a los metodos, creo que si eres desarrollador en .NET lo importante no es tanto el código si no más bien los querys veamos la información y expliquemoslos de poco en poco:

Metodo GetDataBases


SELECT name, database_id FROM sys.databases

Con este query obtenemos la información de todas las bases de datos en la instancia

Metodo GetTables

SELECT * FROM INFORMATION_SCHEMA.TABLES ORDER BY TABLE_NAME

Este query a su vez nos devuelve las tablas que estan dentro de una base de datos seleccionada

Metodo MetaInfo

SELECT 
 C.TABLE_CATALOG,C.TABLE_NAME,C.COLUMN_NAME,C.IS_NULLABLE,C.DATA_TYPE,C.CHARACTER_MAXIMUM_LENGTH
 FROM INFORMATION_SCHEMA.COLUMNS C
 INNER JOIN INFORMATION_SCHEMA.TABLES A ON C.TABLE_NAME=A.TABLE_NAME
 WHERE A.TABLE_NAME NOT IN('SYSSCHEMAARTICLES','SYSPUBLICATIONS','MSREPL_ERRORS','TRANSACTIONS','MSMERGE_HISTORY','MSMERGE_AGENT_PARAMETERS','MSMERGE_REPLINFO',
 'SYSSUBSCRIPTIONS','SYSMERGEARTICLES','VW_TRAMITES_CONCEPTOS','SYSARTICLEUPDATES','MSPUB_IDENTITY_RANGE','SYSTRANSCHEMAS','SYSMERGESCHEMAARTICLES','SYSMERGEPARTITIONINFOVIEW',
 'SYSMERGEPARTITIONINFO','MSMERGE_SUPPORTABILITY_SETTINGS','MSMERGE_SESSIONS','MSMERGE_PAST_PARTITION_MAPPINGS','MSMERGE_GENERATION_PARTITION_MAPPINGS','SYSMERGESUBSCRIPTIONS',
 'MSDYNAMICSNAPSHOTJOBS','MSDYNAMICSNAPSHOTVIEWS','MSMERGE_AGENT_PARAMETERS','MSMERGE_ARTICLEHISTORY','MSMERGE_ALTSYNCPARTNERS','MSMERGE_CONTENTS','MSMERGE_CURRENT_PARTITION_MAPPINGS',
 'MSMERGE_DYNAMIC_SNAPSHOTS','MSMERGE_ERRORLINEAGE','MSMERGE_GENHISTORY','MSMERGE_IDENTITY_RANGE','MSMERGE_LOG_FILES','MSMERGE_METADATAACTION_REQUEST','MSMERGE_PARTITION_GROUPS',
 'MSMERGE_SETTINGSHISTORY','MSMERGE_TOMBSTONE','MSPEER_CONFLICTDETECTIONCONFIGREQUEST','MSPEER_LSNS','MSPEER_ORIGINATORID_HISTORY','MSPEER_REQUEST','MSPEER_TOPOLOGYREQUEST',
 'SYSARTICLECOLUMNS','SYSARTICLES','SYSEXTENDEDARTICLESVIEW','SYSMERGEEXTENDEDARTICLESVIEW','SYSMERGEPUBLICATIONS','SYSMERGESCHEMACHANGE'
 )
 AND A.TABLE_TYPE NOT IN('VIEW')
 ORDER BY A.TABLE_NAME

Y este nos da la información de tablas agrupadas por columnas con sus respectivas informaciónes por cada registro.

Una vez realizado esto tenemos la mitad de nuestro codigo para jugar, en realidad la otra mitad esta en la generación de los archivos, para hacerlo con más velocidad solo crearemos el de generacion de clases en C#; en la carpeta Entity crearemos otra carpeta llamada Servicio en la cual crearemos IFileWriter, CSharpFile y FileWriterFactory. Y veremos como nos queda:

IFileWriter

public interface IFileWriter
{
void GenerateFile(string Table, List meta);
void Save(string Path);
}

Nuevamente definimos una interfaz que nos apoyará en el camino de la extención de nuestro código.

CSharpFile

 public class CSharpFile : IFileWriter
 {
 private string Data;
 private string NameFile;
 public void GenerateFile(string Table, List<MetaInfo> meta)
 {
 this.NameFile = Table + ".cs";
 StringBuilder str = new StringBuilder();
 List<MetaInfo> TableInfo = meta.Where(MI => MI.Table == Table).ToList();
 str.Append("public class ").Append(Table).Append(" {").Append(Environment.NewLine);
 foreach (MetaInfo FieldInfo in TableInfo)
 {
 str.Append("\tpublic ");
 switch (FieldInfo.Type)
 {
 case "nchar":
 str.Append("string").Append(" ");
 break;
 case "varchar":
 str.Append("string").Append(" ");
 break;
 case "text":
 str.Append("string").Append(" ");
 break;
 case "int":
 str.Append("int").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "bigint":
 str.Append("long").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "smallint":
 str.Append("short").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "tinyint":
 str.Append("short").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "datetime":
 str.Append("DateTime").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "money":
 str.Append("decimal").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 case "bit":
 str.Append("bool").Append(FieldInfo.ISNullable ? "?" : "").Append(" ");
 break;
 }
 str.Append(FieldInfo.FieldName).Append(" { get;set; }").Append(Environment.NewLine);
 }
 str.Append(" } ");
 Data = str.ToString();
 }
 public void Save(string Path)
 {
 string FullPath = System.IO.Path.Combine(Path, NameFile);
 System.IO.StreamWriter file = new System.IO.StreamWriter(FullPath);
 file.WriteLine(Data);
 file.Close();
 }
 }

Este archivo implementa los metodos de IFileWriter y nos permitirá crear una seccion que se dedicará solamente al codigo de .NET, no creo que tenga que explicar gran cosa, simplemente se crea un string que contiene la clase parseada en base a una serie de patrones

FileWriterFactory

 public static class FileWriterFactory
 {
 public static IFileWriter GenerateWriter(string Language)
 {
 IFileWriter writer = null;
 switch (Language)
 {
 case "C#":
 writer = new CSharpFile();
 break;
 case "Java":
//...
 break;
 case "PHP":
//...
 break;
 }
 return writer;
 }
 }

Un factory que contiene un switch con la información de que tipo de lenguaje usaremos.

Una vez realizado es hora de darle funcionalidad a nuestro From inicial.

Agregaremos las siguientes lineas que definirán nuestro “repositorio” de datos (Repository) y nuestro conector


Connectorconnector = newConnector();
IData Repository;

Después agregaremos la funcion Onload del formulario, que nos permitirá ejecutar operaciones al momento de la carga del form

 private void Form1_Load(object sender, EventArgs e)
 {
 CacheManager.init();
 cbLanguage.DisplayMember = cbDatabaseManager.DisplayMember = "Value";
 cbLanguage.ValueMember = cbDatabaseManager.ValueMember = "Key";
 cbLanguage.DataSource = CacheManager.Language;
 cbDatabaseManager.DataSource = CacheManager.DataBaseManager;
 }

Con estas operaciones llenamos los combos iniciales que son cbLanguaje y cbDatabaseManager.


private void Connect_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(Server.Text) && string.IsNullOrEmpty(User.Text) && string.IsNullOrEmpty(Password.Text))
{
MessageBox.Show("The Server, User and Password can't be blank");
}

Catalog databaseManager = (Catalog)cbDatabaseManager.SelectedItem;

connector.Server = Server.Text;
connector.User = User.Text;
connector.Password = Password.Text;

switch (databaseManager.Value)
{
case "SQLServer":
Repository = new SQLServer();
break;
}

List<Catalog> DataBases = Repository.GetDataBases(connector.SourceConnectorMaster);
cbDataBases.DisplayMember = "Value";
cbDataBases.ValueMember = "Key";
cbDataBases.DataSource = DataBases;
}

Con el código anteriror damos funcionalidad al boton connect podemos checar nuestra conección y crear los repositorios.


privatevoid cbDataBases_SelectedIndexChanged(object sender, EventArgs e)
{
if (cbDataBases.SelectedItem != null)
{
Catalog dataBaseSelected = (Catalog)cbDataBases.SelectedItem;
if (dataBaseSelected.Key != "0")
{
connector.Catalog = Convert.ToString(dataBaseSelected.Value);
List<Catalog> Tables = Repository.GetTables(connector.SourceConnectorComplete);
lstbTables.ValueMember = "Key";
lstbTables.DisplayMember = "Value";
lstbTables.DataSource = Tables;
}
}
}

Despues agregamos el evento SelectedIndexChanged de cbDataBases que nos permite que cuando se seleccione un nuevo item del combo automaticamente nos muestre las tablas de la base de datos que se selecciono y los despliega en lstbTables

private void button1_Click(object sender, EventArgs e)
 {
 fbdDirectory.ShowDialog();
 DirectoryPath.Text = fbdDirectory.SelectedPath;
 }

Que nos da la funcionalidad para seleccionar carpeta.

 private void button2_Click(object sender, EventArgs e)
 {
 Catalog languaje = (Catalog)cbLanguage.SelectedItem;
 IFileWriter writer = FileWriterFactory.GenerateWriter(languaje.Value);
 if (writer == null)
 {
 MessageBox.Show("must be select a language");
 return;
 }

 List<MetaInfo> data = Repository.GetMetaInfo(connector.SourceConnectorComplete);
 foreach(Catalog item in lstbTables.SelectedItems) {
 writer.GenerateFile(item.Value, data);
 writer.Save(DirectoryPath.Text);
 Console.Text += Console.Text+ "Se ha Generado el archivo " + item.Value + " en "+ DirectoryPath.Text + Environment.NewLine;
 }
 }

y finalmente el botton2 que nos permitira generar el código…

Es interesante como siguiendo ciertos patrones de programación podemos generar código de manera automatica… y evitarnos la tediosa talacha.

(Descargar)

 

A %d blogueros les gusta esto: