generación T4 simple para Simple POCO

Question

estoy buscando un tutorial, orientación o software que puede generar sencilla POCO de algunas tablas de SQL Server para su uso en ASP.NET MVC. Algo como esto:

1) Mantener una lista de los nombres de las tablas en la base de datos de SQL Server que debe tener un POCO genera

2) Alimentar la lista para algún programa

3) El programa genera una POCO simple (más como DTO) en un solo archivo .cs, o se agrega a Poco.cs. De cualquier manera, no importa.

Por ejemplo:

public class MyDto 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public bool? IsMale {get; set;} 
} 

4) Ejecutar el programa cada vez que quiero volver a generar

El programa de la POCO podría ser WinForm, comandos, o alguna otra cosa. No importa.

Answer 1

he querido responder a esta pero estado ocupado.

He creado un ejemplo sencillo de cómo leer un esquema de base de datos y generar las clases y propiedades de esta.

Básicamente, debe poder cortar esto en un archivo TT (consulte Oleg Sychs blog para saber cómo comenzar), actualice la cadena de conexión y guárdela para ejecutar la plantilla.

No pretendo que esto es una muestra completa, pero podría servir como punto de partida para usted:

<#@ template language = "C#"       #> 
    <#@ assembly name  = "Microsoft.CSharp"    #> 
    <#@ assembly name  = "System.Core"     #> 
    <#@ assembly name  = "System.Data"     #> 
    <#@ import  namespace = "System.Collections.Generic" #> 
    <#@ import  namespace = "System.Dynamic"    #> 
    <#@ import  namespace = "System.Linq"     #> 
    <#@ import  namespace = "System.Data.SqlClient"  #> 

    <# 
    var namespaceName = "Poco2"; 
    // Update the connection string to something appropriate 
    var connectionString = @"Data Source=localhost\SQLExpress;Initial Catalog=MyTest;Integrated Security=True"; 
    #> 

    <# 
    using (var db = new SqlConnection (connectionString)) 
    using (var cmd = db.CreateCommand()) 
    { 
     db.Open(); 
     var tables    = ReadRows (cmd, "SELECT * FROM sys.tables").ToArray(); 

     var columns    = ReadRows (cmd, "SELECT * FROM sys.columns").ToLookup (k => k.object_id); 

     var indexes    = ReadRows (cmd, "SELECT * FROM sys.indexes").ToLookup (k => k.object_id); 
     var indexColumns  = ReadRows (cmd, "SELECT * FROM sys.index_columns").ToLookup (k => k.object_id); 

     var foreignKeys   = ReadRows (cmd, "SELECT * FROM sys.foreign_keys").ToArray(); 
     var foreignKeyColumns = ReadRows (cmd, "SELECT * FROM sys.foreign_key_columns").ToArray(); 
    #> 
    namespace <#=namespaceName#> 
    { 
    using System; 
    using System.Data.Linq.Mapping; 

    <# 
     foreach (var table in tables) 
     {   
    #> 
    [Table] 
    partial class <#=table.name#> 
    { 
    <# 
      IEnumerable<dynamic> tc = columns[table.object_id]; 
      var tableColumns = tc.OrderBy (r => r.column_id).ToArray();   

      IEnumerable<dynamic> ti = indexes[table.object_id]; 
      var tableIndexes = ti.ToArray();   

      var primaryKeyIndex = tableIndexes.FirstOrDefault (i => i.is_primary_key); 
      var primaryKeyColumns = new Dictionary<dynamic, dynamic>(); 
      if (primaryKeyIndex != null) 
      { 
       IEnumerable<dynamic> pc = indexColumns[table.object_id]; 
       primaryKeyColumns = pc 
       .Where (c => c.index_id == primaryKeyIndex.index_id) 
       .ToDictionary (c => c.column_id, c => c.key_ordinal) 
       ; 
      } 

      foreach (var tableColumn in tableColumns) 
      { 
       var type = MapToType (tableColumn.user_type_id, tableColumn.max_length, tableColumn.is_nullable); 

    #> 
     [Column (IsPrimaryKey = <#=primaryKeyColumns.ContainsKey (tableColumn.column_id) ? "true" : "false"#>)] 
     public <#=type#> <#=tableColumn.name#> {get;set;} 

    <# 
      } 
    #> 

    } 
    <# 
     } 
    #> 
    } 
    <# 
    } 
    #> 

    <#+ 

    struct DataType 
    {  
     public readonly int  SizeOf; 
     public readonly string SingularType; 
     public readonly string PluralType; 

     public DataType (
      int sizeOf, 
      string singularType, 
      string pluralType = null 
      ) 
     { 
      SizeOf   = sizeOf; 
      SingularType = singularType; 
      PluralType  = pluralType ?? (singularType + "[]"); 
     } 

    } 
    static Dictionary<int, DataType> dataTypes = new Dictionary<int, DataType> 
     { 
      {61 , new DataType (8, "DateTime"   )}, 
      {127 , new DataType (8, "long"    )}, 
      {165 , new DataType (1, "byte"    )}, 
      {231 , new DataType (2, "char" , "string")}, 
     }; 

    static string MapToType (int typeId, int maxLength, bool isNullable) 
    { 
     DataType dataType; 

     if (dataTypes.TryGetValue (typeId, out dataType)) 
     { 
      var length = maxLength > 0 ? (maxLength/dataType.SizeOf) : int.MaxValue; 
      if (length > 1) 
      { 
       return dataType.PluralType; 
      } 
      else 
      { 
       return dataType.SingularType + (isNullable ? "?" : ""); 
      } 
     } 
     else 
     { 
      return "UnknownType_"+ typeId; 
     } 
    } 

    static IEnumerable<dynamic> ReadRows (SqlCommand command, string sql) 
    { 
     command.CommandText = sql ?? ""; 

     using (var reader = command.ExecuteReader()) 
     { 
      while (reader.Read()) 
      { 
       var dyn = new ExpandoObject(); 
       IDictionary<string, object> dic = dyn; 

       for (var iter = 0; iter < reader.FieldCount; ++iter) 
       { 
        dic[reader.GetName(iter) ?? ""] = reader.GetValue(iter); 
       } 

       yield return dyn; 
      } 

     } 
    } 


    #> 

Answer 2

que construyeron una herramienta de generación de costumbre similar hace más de 1 año, y no encontré un recurso unificado, integral para lograr este objetivo.

Oleg Sych proporciona una serie de publicaciones en el blog sobre el uso de T4 en his blog y mantiene una biblioteca para ayudar con la generación T4, T4 Toolbox. Confié mucho en ambos durante el desarrollo.

Para el descubrimiento esquema de base en las plantillas T4, solía SQL Server Management Objects.

Ejecuto mis plantillas T4 desde Visual Studio.

Answer 3

Usted puede utilizar la plantilla classes.tt (en linqtemplates, además SQLServer.ttinclude) en subsónica 3 (RUN en el estudio visual). http://subsonicproject.com/ Las propiedades generadas tienen las variables de respaldo, y algunas líneas adicionales para apoyar INotifyPropertyChanging y INotifyPropertyChanged, pero se puede editar la plantilla para sacar esas líneas.

Aquí es resultado de ejemplo y plantilla:

public partial class Order 
{ 
    public int OrderID { get; set; } 
    public string CustomerID { get; set; } 
    public int? EmployeeID { get; set; } 
    public DateTime? OrderDate { get; set; } 
    public DateTime? RequiredDate { get; set; } 
    public DateTime? ShippedDate { get; set; } 
    public int? ShipVia { get; set; } 
    public decimal? Freight { get; set; } 
    public string ShipName { get; set; } 
    public string ShipAddress { get; set; } 
    public string ShipCity { get; set; } 
    public string ShipRegion { get; set; } 
    public string ShipPostalCode { get; set; } 
    public string ShipCountry { get; set; } 
} 


<#@ template language="C#" debug="False" hostspecific="True" #> 
<#@ output extension=".cs" #> 
<#@ include file="SQLServer.ttinclude" #> 
<# 
    var tables = LoadTables(); 
#> 
using System; 
using System.ComponentModel; 
using System.Linq; 

namespace <#=Namespace#> 
{ 


<# foreach(Table tbl in tables){#>  

    /// <summary> 
    /// A class which represents the <#=tbl.Name#> table in the <#=DatabaseName#> Database. 
    /// This class is queryable through <#=DatabaseName#>DB.<#=tbl.ClassName#> 
    /// </summary> 

    public partial class <#=tbl.ClassName#> 
    { 
     #region Properties 

<#  foreach(var col in tbl.Columns){ 
      if (tbl.ClassName == col.CleanName) 
      { 
       col.CleanName += "X"; 
      } 
#> 
     public <#=col.SysType#><#=CheckNullable(col)#> <#=col.CleanName#> { get; set; } 
<#  }#> 

     #endregion 

    } 

<#}#> 
} 

Answer 4

St4bby en GitHub. Fuente abierta. T4. Muy fácil de leer y manipular como lo desee.