C# Template.Load方法代码示例

        private static void RunMustacheSpecs(MustacheSpec.MustacheTest test)
        {
            TemplateLocator testDataTemplateLocator = name =>
            {
                if (test.Partials != null && test.Partials[name] != null)
                {
                    var template = new Template();
                    template.Load(new StringReader(test.Partials[name].ToString()));
                    return template;
                };

                return null;
            };

            var rendered = Render.StringToString(test.Template, test.Example, testDataTemplateLocator);
            Assert.AreEqual(test.Expected, rendered, "JSON object rendering failed for " + test.Description);

            rendered = Render.StringToString(test.Template, test.StronglyTypedExample, testDataTemplateLocator);
            Assert.AreEqual(test.Expected, rendered, "Strongly typed rendering failed for " + test.Description);

            var templ = new Template();
            templ.Load(new StringReader(test.Template));

            if (!test.Name.ToLower().Contains("context miss") &&
                !test.Name.ToLower().Contains("broken chain") &&
                !(test.SpecName == "inverted" && (test.Name == "List" || test.Name == "Context")))
            {
                try
                {
                    var compiledTemplate = templ.Compile(
                    test.StronglyTypedExample != null ? test.StronglyTypedExample.GetType() : typeof(object),
                    testDataTemplateLocator);
                    rendered = compiledTemplate(test.StronglyTypedExample);
                    Assert.AreEqual(test.Expected, rendered, "Compiled Template rendering failed for " + test.Description);
                }
                catch (Nustache.Core.NustacheException ex)
                {
                    if (ex.Message.StartsWith("Unsupported:"))
                    {
                        Assert.Inconclusive(ex.Message);
                    }
                }
            }
            else
            {
                bool gotException = false;
                try
                {
                    var compiledTemplate = templ.Compile(
                        test.StronglyTypedExample != null ? test.StronglyTypedExample.GetType() : typeof(object),
                        testDataTemplateLocator);
                }
                catch (Compilation.CompilationException)
                {
                    gotException = true;
                }

                Assert.IsTrue(gotException, "Expected test to throw a compilation exception for an invalid template");
            }
        }

        public void It_can_include_templates_over_three_levels_with_external_includes()
        {
            var baseTemplate = new Template("Base");
            baseTemplate.Load(new StringReader("Base{{>BaseContent}}"));

            var masterTemplate = new Template("Master");
            masterTemplate.Load(new StringReader("{{<BaseContent}}Master{{>MasterContent}}{{/BaseContent}}{{>Base}}"));

            var templates = new Dictionary<string, Template>();
            templates.Add("Base", baseTemplate);
            templates.Add("Master", masterTemplate);

            TemplateLocator locateTemplate =
                name =>
                {
                    Template ret;
                    templates.TryGetValue(name, out ret);
                    if (ret == null) throw new KeyNotFoundException(string.Format("The view '{0}' could not be found.", name));
                    return ret;
                };

            var result = Render.StringToString("{{<MasterContent}}Hello{{/MasterContent}}{{>Master}}", null, locateTemplate);

            Assert.AreEqual("BaseMasterHello", result);
        }

        public void It_can_include_templates()
        {
            var fooTemplate = new Template();
            fooTemplate.Load(new StringReader("FOO"));

            var result = Render.StringToString(
                "before{{>foo}}after", null, name => fooTemplate);

            Assert.AreEqual("beforeFOOafter", result);
        }

 public NustacheView(NustacheViewEngine engine, VirtualPath path, IResource resource, IResourceResolver resolver)
 {
     _engine = engine;
     _path = path;
     _resolver = resolver;
     using (var stream = resource.Open())
     using (var reader = new StreamReader(stream)) {
         Template = new Template();
         Template.Load(reader);
     }
 }

        public void It_asks_the_RenderContext_to_include_a_named_template()
        {
            var a = new TemplateInclude("a");
            var template = new Template();
            template.Load(new Part[] { new LiteralText("b") });
            var writer = new StringWriter();
            var context = new RenderContext(new Template(), null, writer, name => template, Options.Defaults());

            a.Render(context);

            Assert.AreEqual("b", writer.GetStringBuilder().ToString());
        }

        public void AllTests(string name, Dictionary<object, object> data, string template, Dictionary<object, string> partials, string expected)
        {
            FixData(data);

            var actual = Render.StringToString(
                template,
                data,
                partial =>
                {
                    if (partials.ContainsKey(partial))
                    {
                        var t = new Template();
                        t.Load(new StringReader(partials[partial]));
                        return t;
                    }
                    else
                    {
                        return null;
                    }
                });

            Assert.AreEqual(expected, actual);
        }

        public void It_throws_to_prevent_infinite_template_recursion()
        {
            var fooTemplate = new Template();
            fooTemplate.Load(new StringReader("{{>foo}}"));

            Assert.Throws<NustacheException>(
                () => Render.StringToString(
                    "before{{>foo}}after", null, name => fooTemplate));
        }