C-Sharp Code Generation Data Access

Como Auto-Gerar Tabelas de Banco de Dados a partir de Classes C# em Minutos

Criar tabelas de banco de dados manualmente pode ser uma tarefa tediosa, especialmente quando lidamos com um número significativo de classes. Se você se encontra em uma situação onde precisa gerar tabelas rapidamente sem ter que escrever longos scripts SQL, você está no lugar certo. Este post de blog fornece uma solução para auto-gerar tabelas de banco de dados diretamente a partir das suas classes C# usando reflexão e um pouco de mágica de codificação.

O Problema

Imagine que você tem várias classes C#, e com o crescimento da sua aplicação, você precisa criar tabelas de banco de dados correspondentes a essas classes. A criação manual dessas tabelas não é apenas cansativa, mas também propensa a erros. Aqui está um exemplo de uma classe C# simples:

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 dessa classe, você precisaria de uma instrução SQL como:

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

Além disso, lidar com tipos complexos dentro das classes, como System.Management.ManagementObject, pode complicar ainda mais as coisas, como mostrado em uma versão modificada da classe Foo.

A Solução

Passo 1: Configurando o Ambiente

Para começar, você precisará criar uma aplicação de console em C#. Esta aplicação inspecionará suas classes e gerará scripts SQL correspondentes a elas. Aqui está uma versão simplificada de como o código funciona:

  1. Carregar o Assembly: Use reflexão para carregar o assembly contendo suas classes C#.
  2. Iterar através dos Tipos: Percorra cada classe dentro do assembly e colete suas propriedades.
  3. Criar Scripts SQL: Para cada classe, gere um script SQL CREATE TABLE baseado em suas propriedades e tipos.

Passo 2: Implementação do Código

Aqui está o núcleo da implementação que você pode modificar para se adequar às suas necessidades.

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)" },
            // Adicione mais mapeamentos conforme necessário
        };

        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();
        }
    }
}

Passo 3: Executando Seu Código

Uma vez que você tenha o assembly carregado com suas classes de dados, simplesmente execute o código. Ele produzirá scripts SQL abstratos semelhantes a:

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

CREATE TABLE FKClass
(
    ID BIGINT,
    AFKInt BIGINT
)

Considerações Adicionais

  • Atributos para Filtragem: Considere adicionar um atributo personalizado, como [SqlTable], às suas classes para garantir que apenas classes designadas sejam convertidas em tabelas.
  • Melhorias: O código pode ser otimizado e refatorado ainda mais. Por exemplo, o tratamento de relações de chave estrangeira é bastante rudimentar e poderia se beneficiar de lógica adicional.

Esta solução oferece um ponto de partida robusto para automatizar a geração de tabelas SQL com base nas estruturas de classe C#. Boa codificação!