C-Sharp Code Generation Data Access

Cómo Auto-Generar Tablas de Base de Datos desde Clases de C# en Minutos

Crear tablas de base de datos manualmente puede ser una tarea tediosa, especialmente cuando se trata de un número significativo de clases. Si te encuentras en una situación en la que necesitas generar tablas rápidamente sin tener que escribir largos scripts SQL, estás en el lugar correcto. Esta publicación de blog proporciona una solución para auto-generar tablas de base de datos directamente desde tus clases de C# utilizando reflexión y un poco de magia de codificación.

El Problema

Imagina que tienes varias clases de C#, y con el crecimiento de tu aplicación, necesitas crear tablas de base de datos correspondientes a estas clases. La creación manual de estas tablas no solo es cansada, sino que también es propensa a errores. Aquí tienes un ejemplo de una clase simple de C#:

class Foo
{
    private string property1;
    public string Property1
    {
        get { return property1; }
        set { property1 = value; }
    }

    private int property2;
    public int Property2
    {
        get { return property2; }
        set { property2 = value; }
    }
}

A partir de esta clase, necesitarías una declaración SQL como:

CREATE TABLE Foo
(
    Property1 VARCHAR(500),
    Property2 INT
)

Además, manejar tipos complejos dentro de clases, como System.Management.ManagementObject, puede complicar aún más las cosas, como se muestra en una versión modificada de la clase Foo.

La Solución

Paso 1: Configurando el Entorno

Para comenzar, necesitarás crear una aplicación de consola en C#. Esta aplicación inspeccionará tus clases y generará scripts SQL correspondientes a ellas. Aquí tienes una versión simplificada de cómo funciona el código:

  1. Cargar el Ensamblaje: Usa reflexión para cargar el ensamblaje que contiene tus clases de C#.
  2. Iterar a través de los Tipos: Recorre cada clase dentro del ensamblaje y recoge sus propiedades.
  3. Crear Scripts SQL: Para cada clase, genera un script SQL CREATE TABLE basado en sus propiedades y tipos.

Paso 2: Implementación del Código

Aquí está el núcleo de la implementación que puedes modificar para adaptarla a tus necesidades.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace TableGenerator
{
    class Program
    {
        static void Main(string[] args)
        {
            List<TableClass> tables = new List<TableClass>();

            Assembly assembly = Assembly.LoadFile(args[0]);
            Type[] types = assembly.GetTypes();

            foreach (Type type in types)
            {
                TableClass tableClass = new TableClass(type);
                tables.Add(tableClass);
            }

            foreach (TableClass table in tables)
            {
                Console.WriteLine(table.CreateTableScript());
                Console.WriteLine();
            }
        }
    }

    public class TableClass
    {
        private List<KeyValuePair<string, Type>> fields = new List<KeyValuePair<string, Type>>();
        public string ClassName { get; set; }

        private Dictionary<Type, string> dataMapper = new Dictionary<Type, string>
        {
            { typeof(int), "BIGINT" },
            { typeof(string), "NVARCHAR(500)" },
            // Agrega más mapeos según sea necesario
        };

        public TableClass(Type type)
        {
            ClassName = type.Name;
            foreach (PropertyInfo property in type.GetProperties())
            {
                fields.Add(new KeyValuePair<string, Type>(property.Name, property.PropertyType));
            }
        }

        public string CreateTableScript()
        {
            var script = new System.Text.StringBuilder();
            script.AppendLine($"CREATE TABLE {ClassName}");
            script.AppendLine("(");
            script.AppendLine("\t ID BIGINT,");

            for (int i = 0; i < fields.Count; i++)
            {
                var field = fields[i];
                script.Append($"\t {field.Key} {(dataMapper.ContainsKey(field.Value) ? dataMapper[field.Value] : "BIGINT")}");

                if (i != fields.Count - 1)
                {
                    script.Append(",");
                }
                script.AppendLine();
            }

            script.AppendLine(")");
            return script.ToString();
        }
    }
}

Paso 3: Ejecutando Tu Código

Una vez que hayas cargado el ensamblaje con tus clases de datos, simplemente ejecuta el código. Producirá scripts SQL de forma abstracta similares a:

CREATE TABLE FakeDataClass
(
    ID BIGINT,
    AnInt BIGINT,
    AString NVARCHAR(255)
)

CREATE TABLE FKClass
(
    ID BIGINT,
    AFKInt BIGINT
)

Pensamientos Adicionales

  • Atributos para Filtrar: Considera agregar un atributo personalizado, como [SqlTable], a tus clases para asegurarte de que solo las clases designadas se conviertan en tablas.
  • Mejoras: El código puede ser optimizado y refactorizado aún más. Por ejemplo, el manejo de relaciones de clave externa es bastante rudimentario y podría beneficiarse de lógica adicional.

Esta solución proporciona un punto de partida robusto para automatizar la generación de tablas SQL basadas en estructuras de clases de C#. ¡Feliz codificación!