public MvcCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) : base(className, rootNamespaceName, sourceFileName, host) { // set the default model type to "dynamic" (Dev10 bug 935656) // don't set it for "special" pages (such as "_viewStart.cshtml") SetBaseType(DefaultModelTypeName); }
public GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName) { GeneratorResults razorResults; var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName; host.DefaultNamespace = defaultnamespace; host.DefaultClassName = defaultclassname; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("BulaqCMS.Models"); host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral"); var engine = new RazorTemplateEngine(host); using (var reader = new StringReader(TemplateCode)) { razorResults = engine.GenerateCode(reader); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; using (StringWriter writer = new StringWriter()) { IndentedTextWriter indentwriter = new IndentedTextWriter(writer, " "); codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options); indentwriter.Flush(); indentwriter.Close(); LastGeneratedCode = writer.GetStringBuilder().ToString(); string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs"; File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8); } } return razorResults; }
private static GeneratorResults GenerateCode(RazorTemplateEntry entry, Type baseType) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseType.FullName; host.DefaultNamespace = "TeamConfig.Razor.Template"; host.DefaultClassName = entry.TemplateName + "Template"; host.NamespaceImports.Add("System"); //filter out page directives and add them as namespace string templateString = entry.TemplateString; foreach (Match match in PageDirectivePattern.Matches(templateString)) { string usedNamespace = match.Groups["Namespace"].Value; templateString = templateString.Replace(match.Value, string.Empty); if (usedNamespace.StartsWith("using")) { host.NamespaceImports.Add(usedNamespace); } } GeneratorResults razorResult = null; using (TextReader reader = new StringReader(templateString)) { var templateEngine = new RazorTemplateEngine(host); razorResult = templateEngine.GenerateCode(reader); } return razorResult; }
public BackgroundParser(RazorEngineHost host, string fileName) { _main = new MainThreadState(fileName); _bg = new BackgroundThread(_main, host, fileName); _main.ResultsReady += (sender, args) => OnResultsReady(args); }
public SimpleCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) : base(className, rootNamespaceName, sourceFileName, host) { var baseType = new CodeTypeReference("SimpleTemplateModelBase<dynamic>"); Context.GeneratedClass.BaseTypes.Clear(); Context.GeneratedClass.BaseTypes.Add(baseType); }
public Type Compile(string className, CodeCompileUnit codeCompileUnit, RazorEngineHost host) { var compilerParameters = new CompilerParameters {GenerateInMemory = true, CompilerOptions = "/optimize"}; AppDomain.CurrentDomain.GetAssemblies() .Where(x => !x.IsDynamic) .Each(x => compilerParameters.ReferencedAssemblies.Add(x.Location)); CompilerResults compilerResults; using (var codeDomProvider = Activator.CreateInstance(host.CodeLanguage.CodeDomProviderType).As<CodeDomProvider>()) { compilerResults = codeDomProvider.CompileAssemblyFromDom(compilerParameters, codeCompileUnit); if (compilerResults.Errors.HasErrors) { using (var sw = new StringWriter()) using (var tw = new IndentedTextWriter(sw, " ")) { codeDomProvider.GenerateCodeFromCompileUnit(codeCompileUnit, tw, new CodeGeneratorOptions()); var source = sw.ToString(); throw CreateExceptionFromCompileError(compilerResults, source); } } } var templateTypeName = "{0}.{1}".ToFormat(host.DefaultNamespace, className); var templateType = compilerResults.CompiledAssembly.GetType(templateTypeName); return templateType; }
public Engine() { _host = new RazorEngineHost(new CSharpRazorCodeLanguage()); _host.DefaultBaseClass = "MiniMvc.ViewBase"; //_host.GeneratedClassContext = new System.Web.Razor.Generator.GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", "something", "DefineSection", "BeginContext", "EndContext"); _host.GeneratedClassContext = new System.Web.Razor.Generator.GeneratedClassContext("Execute", "Write", "WriteLiteral", null, null, null, "DefineSection", null, null); }
public HtmlMinifierMvcCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, IHtmlPageMinifier htmlPageMinifier, IDebugStatusReader debugStatusReader) : base(className, rootNamespaceName, sourceFileName, host) { m_HtmPagelMinifier = htmlPageMinifier; m_DebugStatusReader = debugStatusReader; }
public static ParsedTemplate parse(string sourceFilename, string cshtmlContent, string effectiveTemplateClassName, Type modelType) { var csCodeLanguage = new CSharpRazorCodeLanguage(); var templateHost = new RazorEngineHost(csCodeLanguage, () => new HtmlMarkupParser()); var concreteBaseClassType = getBaseClassTypeFromModel(modelType); templateHost.DefaultBaseClass = concreteBaseClassType.FullName; var templateEngine = new RazorTemplateEngine(templateHost); var trimmedcshtmlContent = HeaderLines.trim(cshtmlContent); GeneratorResults res; using (var input = new StringReader(trimmedcshtmlContent)) { res = templateEngine.GenerateCode(input, effectiveTemplateClassName, GeneratedTemplateNamespace, sourceFilename); } if (!res.Success) throw new Exception("Failed to generate code"); var compileUnit = res.GeneratedCode; var fullyQualifiedClassName = GeneratedTemplateNamespace + "." + effectiveTemplateClassName; return new ParsedTemplate(fullyQualifiedClassName, compileUnit); }
public SimpleCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) : base(className, rootNamespaceName, sourceFileName, host) { var baseType = new CodeTypeReference(SimpleRazorConfiguration.BaseClass); Context.GeneratedClass.BaseTypes.Clear(); Context.GeneratedClass.BaseTypes.Add(baseType); }
void ReadHtmlSpans(string html) { RazorEngineHost razorEngineHost = new RazorEngineHost(codeLanguage); RazorTemplateEngine engine = new RazorTemplateEngine(razorEngineHost); ParserResults results = engine.ParseTemplate(new StringReader(html)); spans = new List<Span>(results.Document.Flatten()); spans.RemoveAll(span => span.Kind != SpanKind.Markup); }
public SimpleRazorBuildProvider() { this._codeLanguage = new CSharpRazorCodeLanguage(); this._compilerType = GetDefaultCompilerTypeForLanguage(this._codeLanguage.LanguageName); this._host = new SimpleRazorEngineHost(this._codeLanguage); this._virtualPathDependencies = null; this._typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", this._host.DefaultNamespace, "Foot"); }
void ReadBlockSpans(string markup) { var razorEngineHost = new RazorEngineHost(codeLanguage); var engine = new RazorTemplateEngine(razorEngineHost); var results = engine.ParseTemplate(new StringReader(markup)); spans = new List<Span>(results.Document.Flatten()); spans.RemoveAll(span => !span.IsBlock); }
public MvcCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) : base(className, rootNamespaceName, sourceFileName, host) { var mvcHost = host as MvcWebPageRazorHost; if (mvcHost != null && !mvcHost.IsSpecialPage) { // set the default model type to "dynamic" (Dev10 bug 935656) // don't set it for "special" pages (such as "_viewStart.cshtml") SetBaseType(_defaultModelTypeName); } }
/// <summary> /// Constructs a new RazorTemplateEngine with the specified host /// </summary> /// <param name="host">The host which defines the environment in which the generated template code will live</param> public RazorTemplateEngine(RazorEngineHost host) { if (host == null) { throw new ArgumentNullException("host"); } Host = host; }
/// <summary> /// Gets the generator result. /// </summary> /// <param name="host">The razor engine host.</param> /// <param name="template">The template.</param> /// <returns>The generator result.</returns> private static GeneratorResults GetGeneratorResult(System.Web.Razor.RazorEngineHost host, string template) { var engine = new RazorTemplateEngine(host); GeneratorResults result; using (var reader = new StringReader(template)) result = engine.GenerateCode(reader); return(result); }
public HtmlOptimizerMvc4CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, IMinifier minifier) : base(className, rootNamespaceName, sourceFileName, host) { var webPageRazorHost = host as MvcWebPageRazorHost; if (webPageRazorHost == null || webPageRazorHost.IsSpecialPage) return; this.SetBaseType("dynamic"); _minifier = minifier; }
/// <summary> /// Initializes a new instance of the <see cref="CSharpRazorBuildProvider"/> class. /// </summary> public CSharpRazorBuildProvider() { this.compilerType = this.GetDefaultCompilerTypeForLanguage("C#"); this.host = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = typeof(ViewPageRef).FullName, DefaultNamespace = "RazorOutput", DefaultClassName = "ViewPage" }; }
/// <summary> /// Initializes a new instance of the <see cref="CSharpRazorCodeGenerator"/> class. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="rootNamespaceName">Name of the root namespace.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="host">The host.</param> /// <param name="strictMode">Flag to specify that this generator is running in struct mode.</param> public CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, bool strictMode) : base(className, rootNamespaceName, sourceFileName, host) { StrictMode = strictMode; var mvcHost = host as Compilation.RazorEngineHost; if (mvcHost != null) { SetBaseTypeFromHost(mvcHost); } }
private RazorTemplateEngine InitializeRazorEngine(Type baseClassType, string namespaceOfGeneratedClass, string generatedClassName) { RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseClassType.FullName; host.DefaultClassName = generatedClassName; host.DefaultNamespace = namespaceOfGeneratedClass; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("System.Collections.Generic"); host.NamespaceImports.Add("System.Linq"); return new RazorTemplateEngine(host); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpRazorCodeGenerator"/> class. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="rootNamespaceName">Name of the root namespace.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="host">The host.</param> /// <param name="strictMode">Flag to specify that this generator is running in struct mode.</param> public CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host, bool strictMode) : base(className, rootNamespaceName, sourceFileName, host) { StrictMode = strictMode; var mvcHost = host as Compilation.RazorEngineHost; if (mvcHost != null) { // set the default model type to "dynamic" SetBaseType("dynamic"); } }
internal void Parse(TextReader razorTemplate, TextWriter output) { RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage()); RazorTemplateEngine engine = new RazorTemplateEngine(host); ParserResults result = engine.ParseTemplate(razorTemplate); if (!result.Success) { ThrowParserError(result); } WriteTemplateFunction(result.Document, output); }
private static RazorTemplateEngine CreateEngine() { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = typeof (TemplateBase).FullName, DefaultNamespace = "RazorOutput", DefaultClassName = "Template" }; host.NamespaceImports.Add("System"); return new RazorTemplateEngine(host); }
public virtual void RenderClientTemplate(TextReader razorTemplate, TextWriter output) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); var engine = new RazorTemplateEngine(host); var parserResults = engine.ParseTemplate(razorTemplate); if(parserResults.Success == false) // TODO: Less suck throw new RazorClientTemplateException("Template parse exception"); RenderClientTemplate(parserResults.Document, output); }
/// <summary> /// Constructs the editor parser. One instance should be used per active editor. This /// instance _can_ be shared among reparses, but should _never_ be shared between documents. /// </summary> /// <param name="host">The <see cref="RazorEngineHost"/> which defines the environment in which the generated code will live. <see cref="F:RazorEngineHost.DesignTimeMode"/> should be set if design-time code mappings are desired</param> /// <param name="sourceFileName">The physical path to use in line pragmas</param> public RazorEditorParser(RazorEngineHost host, string sourceFileName) { if (host == null) { throw new ArgumentNullException("host"); } if (String.IsNullOrEmpty(sourceFileName)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "sourceFileName"); } Host = host; FileName = sourceFileName; }
public static RazorTemplateEngine CreateEngine() { var language = new CSharpRazorCodeLanguage(); var host = new RazorEngineHost(language); host.DefaultBaseClass = typeof(RazorTemplate<Context>).FullName; host.DefaultNamespace = "RazorOutput"; host.DefaultClassName = "Template"; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("System.IO"); //host.NamespaceImports.Add("System.Linq"); // host.NamespaceImports.Add("System.Text.RegularExpressions"); var engine = new RazorTemplateEngine(host); return engine; }
private static RazorTemplateEngine GetRazorTemplateEngine() { RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = typeof(RazorViewBase).FullName; host.DefaultNamespace = "RazorOutput"; host.DefaultClassName = "RazorView"; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("System.IO"); host.NamespaceImports.Add("Microsoft.CSharp.RuntimeBinder"); return new RazorTemplateEngine(host); }
public MvcCodeGenerator(string className, string baseClass, string rootNamespaceName, string sourceFileName, RazorEngineHost host) : base(className, rootNamespaceName, sourceFileName, host) { string baseType; if (IsSpecialPage(sourceFileName)) { baseType = typeof(ViewStartPage).FullName; } else { baseType = baseClass + '<' + DefaultModelTypeName + '>'; } SetBaseType(baseType); }
// Returns an instance of the razor template, compiled from the file stored as an embedded resource. // The first time this method is executed, the Razor template is compiled and stored. // This method will throw an InvalidDataException if the template contains syntax errors. public TemplateBase CreateRazorTemplateInstance() { if (templateType == null) { var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = typeof(TemplateBase).FullName; host.DefaultNamespace = "RazorOutput"; host.DefaultClassName = "Template"; host.NamespaceImports.Add("System"); GeneratorResults razorResult = null; var templateStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Curtsy.Resources.curtsy.cshtml"); if (templateStream == null) throw new FileNotFoundException("Could not find embedded resource 'Curtsy.Resources.curtsy.cshtml'"); using (var reader = new StreamReader(templateStream)) { razorResult = new RazorTemplateEngine(host).GenerateCode(reader); } var compilerParams = new CompilerParameters { GenerateInMemory = true, GenerateExecutable = false, IncludeDebugInformation = false, CompilerOptions = "/target:library /optimize" }; compilerParams.ReferencedAssemblies.Add(typeof(Program).Assembly.CodeBase.Replace("file:///", "").Replace('/', Path.DirectorySeparatorChar)); var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); var results = codeProvider.CompileAssemblyFromDom(compilerParams, razorResult.GeneratedCode); if (results.Errors.HasErrors) { StringBuilder errors = new StringBuilder(); foreach (var err in results.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning)) errors.AppendFormat("Error compiling template: ({0}, {1}) {2}", err.Line, err.Column, err.ErrorText); throw new InvalidDataException(errors.ToString()); } templateType = results.CompiledAssembly.GetType("RazorOutput.Template"); } return (TemplateBase)Activator.CreateInstance(templateType); }
public GeneratorResults GenerateCode(RazorTemplate descriptor, string className, RazorEngineHost host) { var engine = new RazorTemplateEngine(host); GeneratorResults results; using (var fileStream = new FileStream(descriptor.FilePath, FileMode.Open, FileAccess.Read)) using (var reader = new StreamReader(fileStream)) { results = engine.GenerateCode(reader, className, host.DefaultNamespace, descriptor.ViewPath); } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), descriptor.Name()); } return results; }
public RazorTemplatesCompiler(string templatesNamespaceName, Type defaultTemplatesBaseClass) { _templatesNamespaceName = templatesNamespaceName; var razorHost = new RazorEngineHost(new CSharpRazorCodeLanguage()) { DefaultBaseClass = defaultTemplatesBaseClass.Name, GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", null, "DefineSection") }; string[] namespaces = new[] { "System", "System.Collections.Generic", "System.Linq", "System.Text" }; foreach (var ns in namespaces) { razorHost.NamespaceImports.Add(ns); } _razorEngine = new RazorTemplateEngine(razorHost); string[] references = new[] { "System.Core.dll", "Microsoft.CSharp.dll" }; var assemblies = AppDomain.CurrentDomain.GetAssemblies(); _compilerParameters = new CompilerParameters(assemblies .Where(x => !x.IsDynamic) .Where(a => !references.Contains(a.ManifestModule.Name)) .Select(a => new Uri(a.CodeBase).LocalPath) .Distinct() .ToArray()) { GenerateInMemory = true }; _compilerParameters.ReferencedAssemblies.AddRange(references); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpRazorCodeGenerator"/> class. /// </summary> /// <param name="className">Name of the class.</param> /// <param name="rootNamespaceName">Name of the root namespace.</param> /// <param name="sourceFileName">Name of the source file.</param> /// <param name="host">The host.</param> /// <param name="strictMode">Flag to specify that this generator is running in struct mode.</param> public CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, System.Web.Razor.RazorEngineHost host, bool strictMode) : base(className, rootNamespaceName, sourceFileName, host) { StrictMode = strictMode; var mvcHost = host as Compilation.RazorEngineHost; if (mvcHost != null) { SetBaseTypeFromHost(mvcHost); } }
/// <summary> /// Constructs the code generator. Must return a new instance on EVERY call to ensure thread-safety /// </summary> public abstract RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host);
/// <summary> /// Constructs a new instance of the code generator for this language with the specified settings /// </summary> public override RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host) { return(new CSharpRazorCodeGenerator(className, rootNamespaceName, sourceFileName, host)); }
internal virtual BackgroundParseTask CreateBackgroundTask(RazorEngineHost host, string fileName, TextChange change) { return(BackgroundParseTask.StartNew(new RazorTemplateEngine(Host), FileName, change)); }