C# Template.Render方法代码示例

 public void TestConditional_True()
 {
     var template = new Template("$if(value)$yes$endif$", '$', '$');
     template.Add("value", true);
     var output = template.Render();
     Assert.AreEqual("yes", output);
 }

 public void TestDefaultDelimiter()
 {
     var template = new Template("hello <token>.");
     template.Add("token", "world");
     var output = template.Render();
     Assert.AreEqual("hello world.", output);
 }

 public void TestConditional_NotNull()
 {
     var template = new Template("$if(value)$yes$endif$", '$', '$');
     template.Add("value", "Some Object");
     var output = template.Render();
     Assert.AreEqual("yes", output);
 }

        public void renders_the_template()
        {
            var theValue = TemplateValue.For("field", "FirstName");
            var theTemplate = new Template(StringToken.FromKeyString("Test", "{field} is required"), theValue);

            theTemplate.Render().ShouldBe("FirstName is required");
        }

        public NotificationMessage(StringToken stringToken, params TemplateValue[] values)
        {
            StringToken = stringToken;

            _template = new Template(stringToken, values);
            _message = new Lazy<string>(() => _template.Render());
        }

        public static void GenerateMain(string entryType, string entryNamespace, bool inputArgs)
        {
            StreamWriter writer = new StreamWriter(FileWritterManager.WorkingPath + "main.cpp");

            string txt;
            Template template;

            string altTools = Environment.GetEnvironmentVariable("ALTERNATIVE_TOOLS_PATH");

            if(altTools == null)
                altTools = Path.Combine(Environment.CurrentDirectory, (@"..\..\..\Tools").Replace('\\','/'));

            StreamReader sr = new StreamReader((altTools + @"\Templates\Code\main.stg").Replace('\\', '/'));
            txt = sr.ReadToEnd();
            template = new Template(txt);

            StreamReader fs = new StreamReader(Path.Combine(altTools, "Text/notice"));
            string notice = fs.ReadToEnd();

            template.Add("NOTICE", notice);
            template.Add("ENTRY_TYPE", entryType);
            template.Add("ENTRY_NAMESPACE_NEEDED", !String.IsNullOrEmpty(entryNamespace));
            template.Add("ENTRY_NAMESPACE", entryNamespace);
            template.Add("INPUT_ARGS", inputArgs);

            string output = template.Render();

            writer.Write(output);
            writer.Flush();
            writer.Close();

            FileWritterManager.AddSourceFile("main.cpp");
        }

 public void TestAlternateDelimiter()
 {
     var template = new Template("hello ~token~.", '~', '~');
     template.Add("token", "world");
     var output = template.Render();
     Assert.AreEqual("hello world.", output);
 }

 public void TestComplicatedExpression()
 {
     var templateContent = "${(8+2)*(5+5) - ((2+8)/2)}";
     var template = new Template(templateContent);
     var render = template.Render();
     Assert.AreEqual("95", render);
 }

        /// <summary>
        /// Expands the macros in the given string using the variables stored inside
        /// this object. The resulting string will have the macros expanded.
        /// </summary>
        /// <param name="input">The input string.</param>
        /// <returns>The output string with macros expanded.</returns>
        public string ExpandMacros(string input)
        {
            // If we have a null, then just return a null.
            if (string.IsNullOrWhiteSpace(input))
            {
                return input;
            }

            // We have to repeatedly run through the macros since we have macros
            // that expand into other macros.
            string results = input;

            while (results.IndexOf('{') >= 0)
            {
                // Create a template with all of the variables inside it.
                var template = new Template(results, '{', '}');

                foreach (KeyValuePair<string, string> macro in Substitutions)
                {
                    template.Add(macro.Key, macro.Value);
                }

                // Render out the template to the results.
                results = template.Render();
            }

            // Return the resulting string.
            return results;
        }

 public void TestComent()
 {
     var templateContent = "你好,$*使用简写符加星号可对代码注释*$欢迎使用";
     var template = new Template(templateContent);
     template.Set("name", "jntemplate");
     var render = template.Render();
     Assert.AreEqual("你好,欢迎使用", render);
 }

 public void TestClassFunction()
 {
     var templateContent = "$fun.Test(\"字符串\",1,true)";
     var template = new Template(templateContent);
     template.Set("fun", new TemplateMethod());
     var render = template.Render();
     Assert.AreEqual("您输入的参数是有：字符串 1 True ", render);
 }

 public void TestLambdaIsCalledOnceFromCustomAssignsOverMultipleParsesAndRenders()
 {
     Template t = new Template();
     int global = 0;
     Hash assigns = Hash.FromAnonymousObject(new { number = (Proc) (c => ++global) });
     Assert.AreEqual("1", t.ParseInternal("{{number}}").Render(assigns));
     Assert.AreEqual("1", t.ParseInternal("{{number}}").Render(assigns));
     Assert.AreEqual("1", t.Render(assigns));
 }

 public void TestAttr()
 {
     string template = "hi $name$!";
     Template st = new Template(template, '$', '$');
     st.Add("name", "Ter");
     string expected = "hi Ter!";
     string result = st.Render();
     Assert.AreEqual(expected, result);
 }

 public void TestLambdaIsCalledOnceFromPersistentAssignsOverMultipleParsesAndRenders()
 {
     Template t = new Template();
     int global = 0;
     t.Assigns["number"] = (Proc) (c => ++global);
     Assert.AreEqual("1", t.ParseInternal("{{number}}").Render());
     Assert.AreEqual("1", t.ParseInternal("{{number}}").Render());
     Assert.AreEqual("1", t.Render());
 }

 public void TestEarlyEval()
 {
     string template = "<(name)>";
     Template st = new Template(template);
     st.Add("name", "Ter");
     string expected = "Ter";
     string result = st.Render();
     Assert.AreEqual(expected, result);
 }