क्या T4 के बगल में टेम्पलेट के आधार पर रेजर दृश्य (.cshtml) उत्पन्न करने के लिए वैसे भी है?

Question

मैं डेटाबेस टेबल पर आधारित मॉडल, नियंत्रकों और विचारों को उत्पन्न करने के लिए कुछ कोड जनरेटर विकसित कर रहा हूं ताकि मैं एएसपी.नेट एमवीसी 3 वेबसाइट बना सकूं। मैं अब कोडडॉम के साथ मॉडल और नियंत्रक उत्पन्न कर सकता हूं लेकिन विचारों को उत्पन्न करने के लिए मुझे टेम्पलेट बनाने के लिए कुछ चाहिए, जैसे कि .cs से एक .cshtml उत्पन्न करना, मैंने सोचा कि टी 4 अच्छा विचार होगा लेकिन मेरे कुछ सहयोगियों ने टी 4 का उपयोग न करने का आग्रह किया है, क्या कोई और तरीका है? धन्यवाद

Answer 1

आपका उत्तर यहाँ है: https://stackoverflow.com/a/2457206/538387

कौन सा ASP.NET MVC and virtual views

Answer 2

हमने कोड स्मिथ को बड़े पैमाने पर इस्तेमाल किया और एक प्लगइन भी लिखा। टी 4 के साथ हालांकि कक्षाएं केवल कक्षाएं उत्पन्न कर सकती हैं और फिर टेम्पलेट को हटा सकती हैं - टी 4 के विरोध में क्यों?

Answer 3

निश्चित रूप से, मैं अच्छा एक्सटेंशन RazorGenerator का उपयोग कर अपने सभी कोड जनरेशन (और ईमेल पीढ़ी, आदि) के लिए रेजर का उपयोग करता हूं। यह आपको इस "एक्सटेंशन" के रूप में इस एक्सटेंशन को निर्दिष्ट करने की अनुमति देता है और आपके .cshtml इनपुट के परिणामी सी # कक्षा को उत्पन्न करता है जिसे आप आमंत्रित कर सकते हैं (और @model में पास करें) ताकि आप जो भी आउटपुट चाहते हैं उसे पाठ में परिवर्तित कर सकें। (कुछ हद तक विडंबनात्मक रूप से आपके मामले में, यह razor => रेजर रूपांतरण होगा)

Answer 4

मुझे यकीन नहीं है कि वे टी 4 का उपयोग करने के खिलाफ क्यों होंगे, जिसमें एंटीटी फ्रेमवर्क का उपयोग करने वाले कोड पुस्तकालयों के बहुत सारे हैं। ऐसा लगता है जैसे आप कुछ कर रहे हैं मैंने अभी खत्म कर दिया है। मुझे प्री-प्रोसेस किए गए टी 4 टेम्पलेट्स का उपयोग करना पसंद आया, इसलिए मैं उन्हें सी # कोड से डेटा खिला सकता हूं और फाइलें जेनरेट कर सकता हूं। यह आपको डेटा को पास करने के लिए एकाधिक फाइल आउटपुट और मूल रूप से पैरामीटर रखने की अनुमति देता है।

जिस तरह से मैं इसका उपयोग करता हूं .. मैंने एक कक्षा बनाई जिसका उपयोग डेटाबेस के बारे में सारी जानकारी इकट्ठा करने के लिए किया गया था .. कौन सी टेबल शामिल या बहिष्कृत करने के लिए .. और फिर पीएम या पहचान जैसे प्रत्येक कॉलम के बारे में जानकारी और इस तरह की जानकारी । मैंने अपने प्रीप्रोसेस्ड टी 4 टेम्पलेट्स को प्लग किया है, जिसमें यह जानकारी सभी एसक्यूएल, विचार, मॉडल, नियंत्रक जानकारी उत्पन्न करने में सक्षम थी .. और जब भी डेटाबेस बदल गया .. मैं बस अपना कंसोल ऐप चलाता हूं और बैम को फिर से पुन: उत्पन्न करता हूं।

preprocessed: http://odetocode.com/Blogs/scott/archive/2011/01/03/preprocessed-t4-templates.aspx

इकाई की रूपरेखा: http://msdn.microsoft.com/en-us/data/gg558520.aspx

MVCScaffolding: http://blog.stevensanderson.com/2011/04/06/mvcscaffolding-overriding-the-t4-templates/

T4MVC: http://mvccontrib.codeplex.com/wikipage?title=T4MVC

फिर मुझे पता है यह आपके प्रश्न का उत्तर देने के लेकिन टी -4 मदद नहीं करता है आश्चर्यजनक है और मैं होगा टी 4 का उपयोग न करने पर बहस सुनने में दिलचस्पी है .. यहां तक ​​कि इसमें भी बनाया गया है!

btw यहाँ कुछ IntelliSense !: http://t4-editor.tangible-engineering.com/T4-Editor-Visual-T4-Editing.html

हो जाता है यो कोई प्रश्न कृपया मुझे मारा करने के लिए मैं टी -4 प्यार के लिए स्वतंत्र महसूस और मैं किसी भी प्रश्न का जवाब कर सकते हैं मैं करने को तैयार हो चाहते हैं तो।

यहां मेरे टेम्पलेट मॉडल जेनरेट करने के लिए उपयोग किए जाने वाले टेम्पलेट का एक उदाहरण है .. डेटा को पास करने के लिए मेरे सामान्य सी # विधियों का उपयोग करने की पूर्व-संसाधित क्षमताओं के लिए बहुत कुछ निकाला गया है। यह टेम्पलेट मेरे लिए 55 मॉडल बनाता है डेटाबेस में टेबल के आधार पर।

मेरा "स्कीमकॉल्टर" डेटाबेस इन्फॉर्मेशन, टेबलइन्फो, और कॉलमइन्फो क्लास का उपयोग करता है जिसे मैंने आवश्यक सभी स्कीमा रखने के लिए बनाया है। तब मेरे पास 9 अन्य टी 4 टेम्पलेट्स हैं जो डेटा को पॉप्युलेट करने के लिए स्कीमा कोलेक्टर क्लास का भी उपयोग करते हैं।

यहां विस्तार है जिसका उपयोग मैं पीढ़ी के लिए टेम्पलेट में डेटा को पास करने के लिए करता हूं।मेरे पास कॉन्फ़िगरेशन के लिए एक्सएमएल फाइलों का उपयोग करने के लिए यह सब सेटअप है, लेकिन यह अनावश्यक है कि मैं चाहता हूं कि यह वास्तव में पुन: प्रयोज्य हो।

public partial class PocoGenerator 
    { 
     public string Namespace { get; set; } 
     public string Inherit { get; set; } 
     public DatabaseInfo Schema { get; set; } 
     public bool Contract { get; set; } 
     public string SavePath { get; set; } 
    } 

यहां विधि है जिसे मैं कॉल करने और टेम्पलेट को पॉप्युलेट करने और सहेजने के लिए उपयोग करता हूं।

static void GeneratePoco(Config config) 
     { 
      var template = config.Poco; 
      template.Schema = config.DatabaseInfo; 

      File.WriteAllText(template.SavePath, template.TransformText()); 

      Console.WriteLine("  - POCOs generated for " + config.DatabaseInfo.DatabaseName + " complete"); 
     } 

यहाँ टेम्पलेट

<#@ template debug="true" hostSpecific="true" #> 
<#@ output extension=".cs" #> 
<#@ Assembly Name="System.Core.dll" #> 
<#@ Assembly Name="System.Windows.Forms.dll" #> 
<#@ import namespace="System" #> 
<#@ import namespace="System.IO" #> 
<#@ import namespace="System.Diagnostics" #> 
<#@ import namespace="System.Linq" #> 
<#@ import namespace="System.Collections" #> 
<#@ import namespace="System.Collections.Generic" #> 
<#@ assembly name="System.Xml.dll" #> 
<#@ assembly name="System.Data.dll" #> 
<#@ import namespace="System.Data" #> 
<#@ import namespace="System.Data.SqlClient" #> 
<#@ import namespace="CodeGenerator.Utilities" #> 

using System; 
using System.Runtime.Serialization; 

namespace My.Models 
{ <# 
     List<TableInfo> tables = Schema.Tables; 
    #> 

    //######################################################################################################### 
    // This file has been generated from the tables contained in the <#= Schema.DatabaseName #> database. 
    // Changes to this file will be overwritten when the file is regenerated. Generated: <#= DateTime.Now #> 
    //######################################################################################################### 
    <# 
    foreach (TableInfo table in tables) 
    { 
    #> 

    [DataContract] 
    public class <#= table.Name #> : IConfigTable 
    { 

     <# 
     PushIndent("  "); 
      foreach (ColumnInfo col in table.Columns) 
      { 
       if(col.IsKey || col.IsIdentity) 
        WriteLine("[Key]"); 

       WriteLine("[DataMember]"); 
       if(col.IsNullable && col.Type != "string") 
        WriteLine("public " + col.Type + "? " + col.Name+ " { get; set; }"); 
       else 
        WriteLine("public " + col.Type + " " + col.Name+ " { get; set; }"); 
      }PopIndent();#>  
    } 
    <# } #> 
} 

Answer 5

हम समान कार्य है, हम गतिशील वेब रूपों है कि प्रपत्र परिभाषा के साथ इनपुट json फ़ाइल पर आधारित होते हैं crating कर रहे हैं। संपादक विभिन्न नियंत्रण निर्दिष्ट करते हैं जिन्हें एक फॉर्म पर प्रस्तुत किया जाना चाहिए (नियंत्रण में विभिन्न गुण, क्रियाएं, सत्यापनकर्ता शामिल हैं)। नीचे मैं अपने तर्क की मूल प्रक्रिया का वर्णन करने की कोशिश करूंगा:

1. जेसन फ़ाइल को बेकार और मान्य करें।
2. डेटा तैयार करें जो टी 4 टेम्पलेट को पास किया जाएगा।
3. डेटा से एमवीसी मॉडल और नियंत्रक जेनरेट करें (चरण 2)।
4. अतिरिक्त कक्षाएं उत्पन्न करें (उदाहरण के लिए कुछ सहायक, मॉडल से जटिल प्रकार)।
5. असेंबली एम्बेड किए गए संसाधनों में ऐसे डेटा स्रोत आदि, छवियों को जो भी हो।
6. उपरोक्त सभी सामग्री संकलित करें।
7. मॉडल फ़ोल्डर में ड्रॉप डीएलएल।
8. साइट को पुनरारंभ करें।

मॉडल के सभी गुण एक आंशिक दृश्य के नाम के साथ उनके [UIHint] गुण होते हैं। हमारे पास लगभग 10 आंशिक विचार हैं जो जानता है कि प्रत्येक संपत्ति का प्रतिनिधित्व कैसे करें। इस तर्क का समर्थन करने के लिए हम ViewEngine और ModelMetadata प्रदाता का विस्तार करते हैं।

व्यूइंजिन अतिरिक्त फ़ोल्डर में विचारों को देखता है। ModelMetada प्रदाता "अतिरिक्त मूल्य" कस्टम गुणों में जोड़ता है।

एक मॉडल के लिए हमारा दृष्टिकोण एक पंक्ति

@Html.EditorForModel() 

हम संभाल करने 'गहरी बंधन' Object.cshtml overrided था। सबसे कठिन भाग एक संग्रह के साथ थे जहां संग्रह आइटम जटिल प्रकार के थे।