/// <summary> /// Initializes the class with all the arguments of the parameter class. /// </summary> /// <param name="arguments">Cannot be null</param> /// <exception cref="ArgumentNullException">If arguments is null</exception> public TemplateArguments(TemplateArguments arguments) { if (arguments == null) throw new ArgumentNullException("arguments"); _arguments = new Dictionary<string, ArgumentContainer>(arguments._arguments); }
/// <summary> /// Compiles the specified args. /// </summary> /// <param name="args">Arguments, should contain "name, value, name, value" etc.</param> /// <param name="template">c# code that will be included in the generated template class</param> /// <param name="templateId">Id of the template class</param> /// <returns>Tiny template if successful; otherwise null.</returns> /// <exception cref="CompilerException">If compilation fails</exception> /// <exception cref="ArgumentException">If args are incorrect</exception> public ITinyTemplate Compile(TemplateArguments args, string template, string templateId) { ArgumentContainer[] arguments = args.GetArguments(); foreach (ArgumentContainer arg in arguments) _compiler.Add(arg.Type); string members = string.Empty; string body = string.Empty; foreach (ArgumentContainer arg in arguments) { members += Compiler.GetTypeName(arg.Type) + " " + arg.Name + ";" + Environment.NewLine; body += "this." + arg.Name + " = (" + Compiler.GetTypeName(arg.Type) + ")args[\"" + arg.Name + "\"].Object;" + Environment.NewLine; } body += template; _generatedTemplate = TemplateBase.Replace("{id}", templateId).Replace("{members}", members).Replace("{body}", body); _compiler.Compile(_generatedTemplate); return _compiler.CreateInstance<ITinyTemplate>(); }
/// <summary> /// A function that merges two argument holders updating and adding values /// </summary> /// <param name="arguments"></param> /// <exception cref="ArgumentNullException">If arguments is null</exception> public void Update(TemplateArguments arguments) { if (arguments == null) throw new ArgumentNullException("arguments"); foreach (ArgumentContainer argument in arguments.GetArguments()) { if (_arguments.ContainsKey(argument.Name)) _arguments[argument.Name] = argument; else _arguments.Add(argument.Name, argument); } }
/// <summary> /// Compiles the specified code. /// </summary> /// <param name="fileName">Name of template.</param> /// <param name="code">c# code generated from a template.</param> /// <param name="arguments">Arguments as in name, value, name, value, name, value</param> /// <param name="templateId"> /// An id to specify the exact instance of a template. Made from joining the 'TemplateClass' with the hashcode of the filename /// and the hash code of the supplied arguments /// </param> /// <returns>Template</returns> /// <exception cref="TemplateException">If compilation fails</exception> /// <exception cref="ArgumentException">Code is not specified.</exception> protected ITinyTemplate Compile(string fileName, string code, TemplateArguments arguments, string templateId) { if (string.IsNullOrEmpty(code)) throw new ArgumentException("Code is not specified."); var compiler = new TemplateCompiler(); foreach (Type type in _includedTypes) compiler.Add(type); try { return compiler.Compile(arguments, code, templateId); } catch (CompilerException err) { throw new TemplateException(fileName, err); } }
/// <summary> /// Render a partial /// </summary> /// <param name="filename">Path and filename</param> /// <param name="templateArguments">Variables used in the template. Should be specified as "name, value, name, value" where name is variable name and value is variable contents.</param> /// <param name="partialArguments">Arguments passed from parent template</param> /// <returns></returns> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="TemplateException"></exception> /// <exception cref="ArgumentException"></exception> public string RenderPartial(string filename, TemplateArguments templateArguments, TemplateArguments partialArguments) { templateArguments.Update(partialArguments); return Render(filename, templateArguments); }
/// <summary> /// Generate HTML from a template. /// </summary> /// <param name="filename">Path and filename</param> /// <param name="args">Variables used in the template. Should be specified as "name, value, name, value" where name is variable name and value is variable contents.</param> /// <exception cref="InvalidOperationException"></exception> /// <exception cref="CompilerException"></exception> /// <exception cref="ArgumentException"></exception> /// <example> /// <code> /// string html = cache.Generate("views\\users\\view.haml", new TemplateArguments("user", dbUser, "isAdmin", dbUser.IsAdmin), null); /// </code> /// </example> public string Render(string filename, TemplateArguments args) { if (args == null) args = new TemplateArguments(); GetGeneratorForWildCard(ref filename); string templateName = "TemplateClass" + filename.GetHashCode() + args.GetHashCode(); templateName = templateName.Replace('-', 'N'); TemplateInfoImp info; lock (_compiledTemplates) { if (_compiledTemplates.ContainsKey(templateName)) info = _compiledTemplates[templateName]; else { info = new TemplateInfoImp { Filename = filename, Template = null, CompiledWhen = DateTime.MinValue }; _compiledTemplates.Add(templateName, info); } } lock (info) { if (!CheckTemplate(info) || info.Template == null) { string code = GenerateCode(ref filename); info.Template = Compile(filename, code, args, templateName); info.CompiledWhen = DateTime.Now; info.Filename = filename; } return info.Template.Invoke(args, this); } }