C# ITemplate类代码示例

		public bool TryProcess(IDocumentProcessor docProcessor, XmlNode node, bool isRoot, ITemplate template, IRenderFunction currentRenderFunction) {
			if (node.NodeType != XmlNodeType.Element)
				return false;

			GenericElementProcessorContext context = new GenericElementProcessorContext();

			currentRenderFunction.AddFragment(new LiteralFragment("<" + node.Name));
			AddAttributeFragments(docProcessor, node, isRoot, template, currentRenderFunction, context);

			if (context.Id != null) {
				string tagName = node.Name;
				if (tagName.ToLowerCase() == "input" && context.Type != null)
					tagName += "/" + context.Type;
				template.AddMember(new NamedElementMember(tagName, context.Id));
			}

			if (noContentTags.Contains(node.Name)) {
				if (Utils.GetNumChildNodes(node) > 0)
					throw ParserUtils.TemplateErrorException("The tag " + node.Name + " can not have children.");
				currentRenderFunction.AddFragment(new LiteralFragment("/>"));
			}
			else {
				currentRenderFunction.AddFragment(new LiteralFragment(">"));
				Utils.DoForEachChild(node, delegate(XmlNode child) {
					docProcessor.ProcessRecursive(child, template, currentRenderFunction);
				});
				currentRenderFunction.AddFragment(new LiteralFragment("</" + node.Name + ">"));
			}

			return true;
		}

        public StatsModule(ITemplate tmpl, IIdGenerator idgen, SavegameStorage storage)
        {
            Post["/games"] = _ =>
            {
                // Get the temporary location of the file on the server
                var file = Request.Headers["X-FILE"].FirstOrDefault();

                // Get the extension of the file when it was uploaded as the
                // temporary file doesn't have an extension
                var extension = Request.Headers["X-FILE-EXTENSION"].FirstOrDefault();
                if (file == null)
                    throw new ArgumentException("File can't be null");
                if (extension == null)
                    throw new ArgumentException("File extension can't be null");

                Save savegame;
                using (var stream = getStream(file, extension))
                using (parsingTimer.NewContext())
                    savegame = new Save(stream);

                // Turn the savegame into html and return the url for it
                var stats = statsTimer.Time(() => Aggregate(savegame));
                string contents = templateTimer.Time(() => tmpl.Render(stats));
                string id = idgen.NextId();
                return storage.Store(contents, id);
            };
        }

		public IFragment TryParse(string markup, ITemplate template) {
			if (markup.StartsWith("code:"))
				return new CodeExpressionFragment(Utils.Substring(markup, 5, markup.Length - 5).Trim());
			else if (markup.StartsWith("{=") && markup.EndsWith("}"))
				return new CodeExpressionFragment(Utils.Substring(markup, 2, markup.Length - 3).Trim());
			return null;
		}

		/// <summary>
		/// Set template variable value with data from template (all occurrences will be replaced)
		/// </summary>
		/// <param name="variableName">Variable name in master template file</param>
		/// <param name="template">The template.</param>
		public void Add(string variableName, ITemplate template)
		{
			if (template == null)
				return;

			Add(variableName, template.Get());
		}

 public TemplateOveridingDefinitionTile(string name, ITemplate template, ITile extends,
                                    IEnumerable<TileAttribute> attributes)
     : base(name, template, attributes)
 {
     _extends = extends;
     Attributes.MergeTileLazy(_extends);
 }

        private void AddTemplateAsControl(ITemplate anyTemplate, object cuurentItem)
        {
            javascript.Visible = false;
            templateContentHolder  = new EbuyPopupContenido(cuurentItem);
            MensajePopUp.Text = Titulo;

            if (BotonCancelar)
                Cancelar.Visible = true;
            else
                Cancelar.Visible = false;
            if (BotonAceptar)
            {
                Aceptar.Visible = true;
                if (BotonAceptarDesapareceAlApretar)
                {
                    javascript.Visible = true;
                    Literal1.Text = this.ID;
                    Aceptar.OnClientClick += "javascript:BotonAceptarDesaparece"+this.ID+"();";
                }
            }
            else
                Aceptar.Visible = false;

            if (BotonOK)
                OK.Visible = true;
            else
                OK.Visible = false;
            Aceptar.Click += AceptarOnClick;
            anyTemplate.InstantiateIn(templateContentHolder);
            PanelContenedor.Controls.Add(templateContentHolder);
               // this.Controls.Add(PanelContenedor);
        }

        public DocumentParser(ITemplate template)
        {
            Ensure.ArgumentNotNull(template, "template");

            _template = template;
            _markdown = new Markdown();
        }

		public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template) {
			if (isArray) {
				StringBuilder sb = new StringBuilder();
				sb.Append("new int[] {");
				int[] ints;
				if (value.Trim() != "") {
					string[] split = value.Split('|');
					ints = new int[split.Length];
					for (int i = 0; i < split.Length; i++) {
						if (Utils.RegexExec(split[i], Utils.IntRegex, "") == null)
							throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
						sb.Append(i > 0 ? ", " : " ");
						ints[i] = Utils.ParseInt(split[i]);
						sb.Append(Utils.ToStringInvariantInt(ints[i]));
					}
				}
				else
					ints = new int[0];
				sb.Append(" }");
				return new TypedMarkupData(sb.ToString(), delegate() { return ints; });
			}
			else {
				if (Utils.RegexExec(value, Utils.IntRegex, "") == null)
					throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
				int i = Utils.ParseInt(value);
				return new TypedMarkupData(Utils.ToStringInvariantInt(i), delegate() { return i; });
			}
		}

 /// <summary>
 /// Adds an item with the specified template.
 /// </summary>
 /// <param name="template"></param>
 /// <param name="item"></param>
 /// <param name="itemNumber"></param>
 /// <param name="selected"></param>
 protected void AddItemTemplate(ITemplate template, PageData item, int itemNumber, bool selected)
 {
     if (AddSeparator)
         AddSeparatorTemplate();
     AddTemplate(new PageDataItemTemplateContainer(item, itemNumber, selected), template);
     Added = true;
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="Tpl" /> class.
		/// </summary>
		/// <param name="template">The template.</param>
		/// <param name="title">The site title.</param>
		public Tpl(ITemplate template, string title)
		{
			if (template != null)
				Data = template.Get();

			Title = title;
		}

 public RuntimeEntity(int uniqueId, ITemplate template, IEventDispatcher eventDispatcher)
     : this(uniqueId, eventDispatcher, "") {
     foreach (DataAccessor accessor in template.SelectData()) {
         Data.IData data = template.Current(accessor);
         AddData_unlocked(accessor, data.Duplicate());
     }
 }

		public TypedMarkupData Parse(string registeredPrefix, bool isArray, string value, ITemplate template) {
			if (isArray) {
				StringBuilder sb = new StringBuilder();
				sb.Append("new Position[] {");
				Position[] positions;
				if (value.Trim() != "") {
					string[] split = value.Split('|');
					positions = new Position[split.Length];
					for (int i = 0; i < split.Length; i++) {
						StringPositionPair v = ParseSingle(split[i]);
						if (v == null)
							throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
						sb.Append(i > 0 ? ", " : " ");
						positions[i] = v.p;
						sb.Append(v.s);
					}
				}
				else
					positions = new Position[0];

				sb.Append(" }");
				return new TypedMarkupData(sb.ToString(), delegate() { return positions; });
			}
			else {
				StringPositionPair v = ParseSingle(value);
				if (v == null)
					throw ParserUtils.TemplateErrorException(ParserUtils.MakeTypedMarkupErrorMessage(registeredPrefix, isArray, value));
				return new TypedMarkupData(v.s, delegate { return v.p; });
			}
		}

		public void Render(ITemplate tpl, IInstantiatedTemplateControl ctl, StringBuilder sb) {
			if (IsCData)
				sb.Append("<![CDATA[");
			sb.Append(Text);
			if (IsCData)
				sb.Append("]]>");
		}

 public static double ProbabilityCalculation(ITemplate template, IDictionary<JointType, InputVector> input)
 {
     var end = template.EndCondition(input);
     var start = template.StartCondition(input);
     var motion = template.MotionCharacteristic(input);
     return end*start*motion;
 }

 protected void AddTemplate(ITemplate template) {
     if (template != null) {
         TemplateItem i = new TemplateItem();
         template.InstantiateIn(i);
         Controls.Add(i);
     }
 }