C# Template类代码示例

 public DefaultServerGridLayoutOptions(
     ContextualizedHelpers helpers,
     IList<RowType> rows,
     IList<KeyValuePair<string, string>> toolbars,
     Template<LayoutTemplateOptions> layoutTemplate,
     IEnumerable<Template<LayoutTemplateOptions>> subTemplates, 
     IHtmlContent mainContent,
     GridType type,
     string id,
     string prefix,
     GridErrorMessages messages,
     string cssClass,
     string caption,
     Type localizerType
     ) : base(rows, toolbars, layoutTemplate, subTemplates, mainContent)
 {
     this.helpers = helpers;
     Type = type;
     Messages = messages;
     Id = id;
     Prefix = prefix;
     CssClass = cssClass;
     Caption = caption;
     var first = rows.FirstOrDefault();
     MustAddButtonColumn = first.MustAddButtonColumn(helpers, Type== GridType.Batch);
     VisibleColumns = first.VisibleColumns(helpers, Type == GridType.Batch);
     LocalizerType = localizerType;
     Localizer = LocalizerType != null ? helpers.LocalizerFactory.Create(LocalizerType) : null;
 }

        public ActionResult Create(Template template)
        {
            var templateToCreate = new Template();
            Mapper.Map(template, templateToCreate);
            templateToCreate.Seminar = SiteService.GetLatestSeminar(Site, true);

            ModelState.Clear();
            templateToCreate.TransferValidationMessagesTo(ModelState);
            if (ModelState.IsValid)
            {
                // inactivate all old templates
                foreach (var t in _templateRepository.Queryable.Where(a => a.NotificationType == templateToCreate.NotificationType))
                {
                    t.IsActive = false;
                    _templateRepository.EnsurePersistent(t);
                }

                _templateRepository.EnsurePersistent(templateToCreate);

                Message = "Template Created Successfully";

                return RedirectToAction("Index");
            }

            var viewModel = TemplateViewModel.Create(Repository, templateToCreate);
            return View(viewModel);
        }

 public DefaultServerDetailLayoutOptions(
     ContextualizedHelpers helpers,
     IList<RowType> rows,
     IList<KeyValuePair<string, string>> toolbars,
     Template<LayoutTemplateOptions> layoutTemplate,
     IEnumerable<Template<LayoutTemplateOptions>> subTemplates,
     IHtmlContent mainContent,
     string id,
     string prefix,
     string cssClass,
     Type localizerType,
     bool editMode,
     string formAction,
     string formMethod,
     bool? antiforgery,
     bool noSubmit=false
     ) : base(rows, toolbars, layoutTemplate, subTemplates, mainContent)
 {
     this.helpers = helpers;
     Id = id;
     Prefix = prefix;
     CssClass = cssClass;
     LocalizerType = localizerType;
     Localizer = LocalizerType != null ? helpers.LocalizerFactory.Create(LocalizerType) : null;
     EditMode = editMode;
     Antiforgery = antiforgery;
     FormAction = formAction;
     FormMethod = formMethod;
     NoSubmit = noSubmit;
 }

        public void SetUp()
        {
            var source1 = new TestSource
            {
                Name = "-artist-",
                GetAllItemsFunc = c => new[]
                {
                    new DynamicItem("beatles", new [] { new ContextItem("artist-id", "1") }),
                    new DynamicItem("beach-boys", new [] { new ContextItem("artist-id", "2") })
                }
            };

            var source2 = new TestSource
            {
                Name = "-album-",
                GetAllItemsFunc = c =>
                    {
                        return c.Any(i => i.Name == "artist-id" && i.Value == "1")
                        ? new[] { new DynamicItem("revolver") }
                        : new[] { new DynamicItem("pet-sounds") };
                    }
            };

            var dynamicSourceProvider = MockRepository.GenerateMock<IDynamicSourceProvider>();

            dynamicSourceProvider.Stub(p => p.Get("-artist-")).Return(source1);
            dynamicSourceProvider.Stub(p => p.Get("-album-")).Return(source2);
            var pathInstanceBuilder = new PathInstanceBuilder(dynamicSourceProvider);

            var template = new Template(new[] { "static", "-artist-", "-album-" });
            template.BuildInstancePaths(pathInstanceBuilder);

            this.resource = new TemplateResourceBuilder().Build(template) as TemplateResource;
        }

        /// <summary>
        /// Creates a new session for assembling documents using the HotDocs Cloud Services Rest API.
        /// </summary>
        /// <param name="template">The template to use with the session.</param>
        /// <param name="billingRef">This parameter lets you specify information that will be included in usage logs for this call. For example, you can use a string to uniquely identify the end user that initiated the request and/or the context in which the call was made. When you review usage logs, you can then see which end users initiated each request. That information could then be used to pass costs on to those end users if desired.</param>
        /// <param name="answers">The answers to use.</param>
        /// <param name="markedVariables">An array of variable names, whose prompts should be "marked" when displayed in an interview.</param>
        /// <param name="interviewFormat">The format to use when displaying an interview.</param>
        /// <param name="outputFormat">The format to use when assembling a document.</param>
        /// <param name="settings">The settings to use with the session.</param>
        /// <param name="theme">The interview theme.</param>
        /// <param name="showDownloadLinks">Indicates whether or not links for downloading the assembled document(s) should appear at the end of the interview.</param>
        /// <returns></returns>
        public string CreateSession(
			Template template,
			string billingRef = null,
			string answers = null,
			string[] markedVariables = null,
			InterviewFormat interviewFormat = InterviewFormat.JavaScript,
			OutputFormat outputFormat = OutputFormat.Native,
			Dictionary<string, string> settings = null,
			string theme = null,
			bool showDownloadLinks = true
		)
        {
            return (string)TryWithoutAndWithPackage(
                (uploadPackage) => CreateSessionImpl(
                    template,
                    billingRef,
                    answers,
                    markedVariables,
                    interviewFormat,
                    outputFormat,
                    settings,
                    theme,
                    showDownloadLinks,
                    uploadPackage)
            );
        }

        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 static void InvokeTemplateSelected(TemplateProfile profile, Template oldTemplate)
		{
			if (profile != null && !profile.Deleted && OnTemplateSelected != null)
			{
				OnTemplateSelected(profile, oldTemplate);
			}
		}

        public static TemplateGenerationStatusEventArgs CreateWaiting(Template template)
        {
            if (template == null)
                throw new ArgumentNullException("template");

            return new TemplateGenerationStatusEventArgs(template, GenerationStatus.Waiting);
        }

        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 virtual Template GetMessageTemplate(bool verbose)
        {
            Template messageST = new Template(GetErrorType().msg);
            messageST.impl.Name = errorType.Name;

            messageST.Add("verbose", verbose);
            object[] args = GetArgs();
            for (int i = 0; i < args.Length; i++)
            {
                string attr = "arg";
                if (i > 0)
                    attr += i + 1;
                messageST.Add(attr, args[i]);
            }
            if (args.Length < 2)
                messageST.Add("arg2", null); // some messages ref arg2

            Exception cause = GetCause();
            if (cause != null)
            {
                messageST.Add("exception", cause);
                messageST.Add("stackTrace", cause.StackTrace);
            }
            else
            {
                messageST.Add("exception", null); // avoid ST error msg
                messageST.Add("stackTrace", null);
            }

            return messageST;
        }

		public virtual IUimlElement Resolve(Template t, IUimlElement placeholder)
		{
			// add all children of the template's top element to placeholder's children 
			Console.Write("Trying to unite element '{0}' with template '{1}'... ", ((UimlAttributes) placeholder).Identifier, t.Identifier);

			try
			{
				// check if types are compatible
				if (t.Top.GetType().Equals(placeholder.GetType()))
				{
					// TODO: check for children with the same identifier, and resolve name conflicts!
					// add elements from template's top element
					placeholder.Children.AddRange(t.Top.Children);	
					Console.WriteLine("OK!");
				}
				else
					Console.WriteLine("Failed! -> incompatible types, no action taken");
			}
			catch (Exception e)
			{
				Console.WriteLine("Failed!");
			}

			return placeholder; // always return placeholder, whether it's modified or not
		}

 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);
 }

 public void TestUnknownVariablesAreIgnored()
 {
     Template template = new Template("Hello, ${name}");
     template.Set("unknown", "Hi");
     template.Set("name", "Tom");
     Assert.AreEqual("Hello, Tom", template.Evaluate());
 }

        public bool AddTemplate(Template template) {
            Debug.Assert(template.ImportPrecedence == 0);

            template.ImportPrecedence = this.importPrecedence;
            template.OrderNumber      = this.orderNumber++;

            compiler.AllTemplates.Add(template);

            if (template.Name != null) {
                Template old;
                if (!compiler.NamedTemplates.TryGetValue(template.Name, out old)) {
                    compiler.NamedTemplates[template.Name] = template;
                } else {
                    Debug.Assert(template.ImportPrecedence <= old.ImportPrecedence, "Global objects are processed in order of decreasing import precedence");
                    if (old.ImportPrecedence == template.ImportPrecedence) {
                        return false;
                    }
                }
            }

            if (template.Match != null) {
                Templates.Add(template);
            }
            return true;
        }

        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");
        }