t4를 통해 사용자 정의 클래스를 생성하는 방법은 무엇입니까?

Question

T4를 통해 아래 코드를 생성하려고합니다.

using System; 
using MyDAL; 

namspace Test 
{ 
// Select... 
    public partial class MyCustomer 
    { 
     public int id { get ;set;} 
     public string name { get ;set;} 
     public string surname { get ;set;} 

     public MyCustomer() 
     { 

     } 

     public List<Customer> GetById(int id) 
     { 
     // do something... 
     } 
    } 
     // Delete,Update,Save 
    public partial class MyCustomer 
    { 
     public bool Save(new MyCustomer) 
     { 
     // do something... 
     } 

     public bool delete(int id) 
     { 
     // do something... 
     } 

     public bool Update(int id) 
     { 
     // do something... 
     } 
    } 
} 

내가 지금까지 가지고있는 T4 템플릿 :

<#@ template language="C#"#> 
<#@ assembly name="Microsoft.SqlServer.Management.Sdk.Sfc" #> 
<#@ assembly name="Microsoft.SqlServer.ConnectionInfo" #> 
<#@ assembly name="Microsoft.SqlServer.Smo" #> 



<#@ import namespace="Microsoft.SqlServer.Management.Smo" #> 

namespace DbClasses 
{ 
    <# 

    Server srv = new Server(); 
    Database db = new Database(srv,"NarDb"); 
    db.Refresh(); 
    foreach (Table tablo in db.Tables) 
     { 

      WriteLine("public class " +tablo.Name+"{"); 
      foreach (Column column in tablo.Columns) 
       { 
        if(column.DataType.Name=="nvarchar") 
          WriteLine("public "+"string " +""+column.Name+";"); 
        else 
         WriteLine("public "+"int " +""+column.Name+";"); 
       } 
       WriteLine("}"); 



     } 
    #> 
} 

Answer 1

난 당신이 직면하고있는 문제가 무엇인지 정확히 모르겠어요 :하지만 T4 코드와 아무 문제가 없습니다. 두 번째 클래스의 저장 방법의 서명은 새가 그 오류입니다 :

public bool Save(new MyCustomer) 

는 또한

public bool Save(MyCustomer customer) 

해야 GetById 하나 개의 요소가 아닌 목록을 반환해야합니다.

테이블, 열 등의 더미 클래스를 작성하여 데이터베이스에 연결하지 않고 작성한 코드를 시도했지만 작성한 T4 코드에는 아무런 문제가 없습니다. 단, 요구 사항에 따라 작성한 코드는 예외입니다. 부분 클래스를 생성하지 않고 속성을 생성합니다. 공개 필드 (속성이 아님)가있는 각 테이블에 대해 하나의 부분이 아닌 클래스를 만듭니다. 부분 클래스와 속성 (및 메소드)을 올바른 방향으로 생성하려면 (생성 된 파일에서 탭 및 줄 바꿈을 추가하여 Ctrl + K, Ctrl + D를 눌러 포맷을 다시 할 수 있음) 비록 :

<# 

foreach (Table tablo in tables) 
{ 
//start class 
WriteLine("public partial class My" +tablo.Name+"\n{"); 
foreach (Column column in tablo.Columns) 
{ 
if(column.DataType.Name=="nvarchar") 
WriteLine("\tpublic string " + column.Name+"{get; set;}"); 
else 
WriteLine("\tpublic int " + column.Name+"{get; set;}"); 
} 
//output the contructor 
WriteLine("\tpublic My" + tablo.Name + "()\n\t{\n\t\t//constructor\n\t}"); 
WriteLine("\tpublic List<" + tablo.Name + "> GetById(int id)\n\t{\n\t\t// do something\n\t}"); 
//end class 
WriteLine("}"); 

//output comment and start class 
WriteLine("//Delete,Update,Save"); 
WriteLine("public partial class My" +tablo.Name+"\n{"); 
WriteLine("\tpublic bool Save(My" + tablo.Name + " " + tablo.Name + ")\n\t{\n\t\t// do something\n\t}"); 
WriteLine("\tpublic bool Delete(int id)\n\t{\n\t\t// do something\n\t}"); 
WriteLine("\tpublic bool Update(int id)\n\t{\n\t\t// do something\n\t}"); 
WriteLine("}"); 

} 
#> 

Answer 2

그것의 전체 그러나 아마 다음 T4는 영감 역할을 할 수

이 그것을 사용하는 방법입니다하지 :.

using (var sqlConnection = new SqlConnection (@"Data Source=localhost\SQLExpress;Initial Catalog=MinTest;Integrated Security=True")) 
using (var sqlCommand = sqlConnection.CreateCommand()) 
{ 
    sqlConnection.Open(); 
    var customers = sqlCommand.Get_Customer (Id:10, CompId:20).ToArray(); 

    foreach (var customer in customers) 
    { 
     Console.WriteLine (customer.Id); 
     Console.WriteLine (customer.CompId); 
     Console.WriteLine (customer.FirstName); 
     Console.WriteLine (customer.LastName); 
     Console.WriteLine (customer.OrgNo); 
    } 

    var deleteCount = sqlCommand.Delete_Customer (Id:20, CompId:20); 
    Console.WriteLine ("Deleted rows: {0}", deleteCount); 
    Console.ReadKey(); 
} 

T4 :

<#@ template language = "C#"          #> 
<#@ assembly name  = "Microsoft.SqlServer.Management.Sdk.Sfc" #> 
<#@ assembly name  = "Microsoft.SqlServer.ConnectionInfo"  #> 
<#@ assembly name  = "Microsoft.SqlServer.Smo"     #> 
<#@ assembly name  = "System.Core"        #> 
<#@ assembly name  = "System.XML"        #> 
<#@ import  namespace = "Microsoft.SqlServer.Management.Smo"  #> 
<#@ import  namespace = "System.Collections.Generic"    #> 
<#@ import  namespace = "System.Linq"        #> 
<#@ import  namespace = "System.Text"        #> 

// ReSharper disable InconsistentNaming 
// ReSharper disable PartialTypeWithSinglePart 

<# 
    // Update SQL Server and namespace 
    var nameSpace = "MyNameSpace"; 
    var server  = new Server (@"localhost\SQLExpress"); 
    var database = new Database (server,"MyDB"); 
    var maxTables = int.MaxValue; 
    database.Refresh(); 
#> 

namespace <#=nameSpace#> 
{ 
    using System; 
    using System.Collections.Generic; 
    using System.Data.SqlClient; 

    static partial class Extensions 
    { 
     static int Lookup (Dictionary<string, int> dic, string key) 
     { 
      int value; 
      return dic.TryGetValue (key, out value) ? value : -1; 
     } 

     static byte[] GetByteArray (this SqlDataReader reader, int index) 
     { 
      var byteLength = reader.GetBytes (index, 0, null, 0, 0); 
      var bytes = new byte[byteLength]; 
      reader.GetBytes (index, 0, bytes, 0, bytes.Length); 
      return bytes; 
     } 

<# 
    foreach (var table in database.Tables.OfType<Table>().Take (maxTables)) 
    { 
#> 
     // -------------------------------------------------------------------- 
     // Deletes <#=table.Name#> 
     // -------------------------------------------------------------------- 
     public static int Delete_<#=table.Name#> (
      this SqlCommand command 
<# 
       foreach (var column in table.Columns.OfType<Column>().Where (c => c.InPrimaryKey)) 
       { 
#> 
      , <#=GetType (column)#> <#=column.Name#> 
<# 
       } 
#> 
      ) 
     { 
      if (command != null) 
      { 
       command.CommandText = "DELETE FROM <#=table.Schema#>.<#=table.Name#> <#=GetWhereClause (table)#>"; 
       command.Parameters.Clear(); 
<# 
       foreach (var column in table.Columns.OfType<Column>().Where (c => c.InPrimaryKey)) 
       { 
#> 
       command.Parameters.AddWithValue (@"<#=column.Name#>", <#=column.Name#>); 
<# 
       } 
#> 
       return command.ExecuteNonQuery(); 
      } 
      else 
      { 
       return 0; 
      } 
     } 
     // -------------------------------------------------------------------- 

     // -------------------------------------------------------------------- 
     // Gets <#=table.Name#> 
     // -------------------------------------------------------------------- 
     public static IEnumerable<<#=table.Name#>> Get_<#=table.Name#> (
      this SqlCommand command 
<# 
       foreach (var column in table.Columns.OfType<Column>().Where (c => c.InPrimaryKey)) 
       { 
#> 
      , <#=GetType (column)#> <#=column.Name#> 
<# 
       } 
#> 
      ) 
     { 
      if (command != null) 
      { 
       command.CommandText = "SELECT * FROM <#=table.Schema#>.<#=table.Name#> <#=GetWhereClause (table)#>"; 
       command.Parameters.Clear(); 
<# 
       foreach (var column in table.Columns.OfType<Column>().Where (c => c.InPrimaryKey)) 
       { 
#> 
       command.Parameters.AddWithValue (@"<#=column.Name#>", <#=column.Name#>); 
<# 
       } 
#> 
       using (var reader = command.ExecuteReader()) 
       { 
        foreach (var row in reader.To_<#=table.Name#>()) 
        { 
         yield return row; 
        } 
       } 
      } 
     } 
     // -------------------------------------------------------------------- 

     // -------------------------------------------------------------------- 
     // Deserializes a <#=table.Name#> 
     // -------------------------------------------------------------------- 
     public static IEnumerable<<#=table.Name#>> To_<#=table.Name#> (this SqlDataReader reader) 
     { 
      if (reader != null) 
      { 
       var fieldCount = reader.FieldCount; 
       var dictionary = new Dictionary<string, int>(); 
       for (var iter = 0; iter < fieldCount; ++iter) 
       { 
        dictionary[reader.GetName (iter)] = iter; 
       } 

       while (reader.Read()) 
       { 
        var instance = new <#=table.Name#>(); 
<# 
       foreach (var column in table.Columns.OfType<Column>()) 
       { 
#> 
        { 
         var index = Lookup (dictionary, "<#=column.Name#>"); 
         if (index > -1) 
         { 
          instance.<#=column.Name #> = reader.<#=GetGetter (column)#> (index); 
         } 
        } 
<#     
       } 
#> 
        yield return instance; 
       } 
      } 
     } 
     // -------------------------------------------------------------------- 

<# 
    } 
#> 
    } 

<# 
    foreach (var table in database.Tables.OfType<Table>().Take (maxTables)) 
    { 
#> 
    // ------------------------------------------------------------------------ 
    // Table: <#=table.Name#> 
    // ------------------------------------------------------------------------ 
    partial class <#=table.Name#> 
    { 
<# 
     foreach (var column in table.Columns.OfType<Column>()) 
     { 
#> 
     // <#=column.DataType.Name#> (<#=column.Nullable#>, <#=column.DataType.MaximumLength#>, <#=column.DataType.SqlDataType#>) 
     public <#=GetType (column)#> <#=column.Name#> {get;set;} 
<# 
     } 
#> 
    } 
    // ------------------------------------------------------------------------ 

<# 
    } 
#> 

} 

<#+ 
    sealed class DataTypeDescriptor 
    { 
     public readonly bool IsValueType; 
     public readonly string Type; 
     public readonly string Getter; 

     public DataTypeDescriptor (
      bool isValueType, 
      string type, 
      string getter = null 
      ) 
     { 
      IsValueType  = isValueType; 
      Type   = type; 
      Getter   = getter ?? ("Get" + type); 
     } 
    } 

    readonly static Dictionary<SqlDataType, DataTypeDescriptor> s_typeDescriptors = 
     new Dictionary<SqlDataType, DataTypeDescriptor>() 
      { 
       // Unsupported: 
       // ------------ 
       // None, 
       // UserDefinedDataType, 
       // UserDefinedDataType, 
       // XML, 
       // SysName, 
       // UserDefinedTableType, 
       // HierarchyId, 
       // Geometry, 
       // Geography 
       {SqlDataType.BigInt    , new DataTypeDescriptor (true , "Int64"   )}, 
       {SqlDataType.Binary    , new DataTypeDescriptor (true , "Byte"   )}, 
       {SqlDataType.Bit    , new DataTypeDescriptor (true , "Boolean"   )}, 
       {SqlDataType.Char    , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.DateTime   , new DataTypeDescriptor (true , "DateTime"  )}, 
       {SqlDataType.Decimal   , new DataTypeDescriptor (true , "Decimal"  )}, 
       {SqlDataType.Float    , new DataTypeDescriptor (true , "Double"   )}, 
       {SqlDataType.Image    , new DataTypeDescriptor (false , "byte[]" , "GetByteArray"   )}, 
       {SqlDataType.Int    , new DataTypeDescriptor (true , "Int32"   )}, 
       {SqlDataType.Money    , new DataTypeDescriptor (true , "Decimal"  )}, 
       {SqlDataType.NChar    , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.NText    , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.NVarChar   , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.NVarCharMax  , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.Real    , new DataTypeDescriptor (true , "Double"   )}, 
       {SqlDataType.SmallDateTime  , new DataTypeDescriptor (true , "DateTime"  )}, 
       {SqlDataType.SmallInt   , new DataTypeDescriptor (true , "Int16"   )}, 
       {SqlDataType.SmallMoney   , new DataTypeDescriptor (true , "Decimal"  )}, 
       {SqlDataType.Text    , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.Timestamp   , new DataTypeDescriptor (false , "byte[]" , "GetByteArray"   )}, 
       {SqlDataType.TinyInt   , new DataTypeDescriptor (true , "Byte"   )}, 
       {SqlDataType.UniqueIdentifier , new DataTypeDescriptor (false , "byte[]" , "GetByteArray"   )}, 
       {SqlDataType.VarBinary   , new DataTypeDescriptor (false , "byte[]" , "GetByteArray"  )}, 
       {SqlDataType.VarBinaryMax  , new DataTypeDescriptor (false , "byte[]" , "GetByteArray"  )}, 
       {SqlDataType.VarChar   , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.VarCharMax   , new DataTypeDescriptor (false , "String"   )}, 
       {SqlDataType.Variant   , new DataTypeDescriptor (false , "object" , "GetValue")}, 
       {SqlDataType.Numeric   , new DataTypeDescriptor (true , "Decimal"  )}, 
       {SqlDataType.Date    , new DataTypeDescriptor (true , "DateTime"  )}, 
       {SqlDataType.Time    , new DataTypeDescriptor (true , "TimeSpan"  )}, 
       {SqlDataType.DateTimeOffset  , new DataTypeDescriptor (true , "DateTimeOffset" )}, 
       {SqlDataType.DateTime2   , new DataTypeDescriptor (true , "DateTime"  )}, 
      };                     


    static string GetGetter (Column column) 
    { 
     var dataType = column.DataType; 
     DataTypeDescriptor descriptor; 
     if (!s_typeDescriptors.TryGetValue (dataType.SqlDataType, out descriptor)) 
     { 
      return 
        "Error__Unsupported_Type_" 
       + dataType.SqlDataType 
       ; 
     } 

     return descriptor.Getter; 
    } 

    static string GetType (Column column) 
    { 
     var dataType = column.DataType; 
     DataTypeDescriptor descriptor; 
     if (!s_typeDescriptors.TryGetValue (dataType.SqlDataType, out descriptor)) 
     { 
      return 
        "Error__Unsupported_Type_" 
       + dataType.SqlDataType 
       ; 
     } 

     if (column.Nullable && descriptor.IsValueType) 
     { 
      return descriptor.Type + "?"; 
     } 

     return descriptor.Type; 
    } 

    static string GetWhereClause (Table table) 
    { 
     var sb = new StringBuilder ("WHERE "); 

     var first = true; 
     foreach (var column in table.Columns.OfType<Column>().Where (c => c.InPrimaryKey)) 
     { 
      if (first) 
      { 
       first = false; 
      } 
      else 
      { 
       sb.Append (" AND "); 
      } 

      sb.AppendFormat ("{0} = @{0}", column.Name); 
     } 

     return sb.ToString(); 
    } 
#>