C# ControlBuilder.ProcessGeneratedCode方法代码示例

		protected void CreateControlTree (ControlBuilder builder, bool inTemplate, bool childrenAsProperties)
		{
			EnsureID (builder);
			bool isTemplate = builder.IsTemplate;
			
			if (!isTemplate && !inTemplate) {
				CreateField (builder, true);
			} else if (!isTemplate) {
				bool doCheck = false;				
				bool singleInstance = false;
				ControlBuilder pb = builder.ParentBuilder;
				TemplateBuilder tpb;
				while (pb != null) {
					tpb = pb as TemplateBuilder;
					if (tpb == null) {
						pb = pb.ParentBuilder;
						continue;
					}
					
					if (tpb.TemplateInstance == TemplateInstance.Single)
						singleInstance = true;
					break;
				}
				
				if (!singleInstance)
					builder.ID = builder.GetNextID (null);
				else
					doCheck = true;

				CreateField (builder, doCheck);
			}

			InitMethod (builder, isTemplate, childrenAsProperties);
			if (!isTemplate || builder.GetType () == typeof (RootBuilder))
				CreateAssignStatementsFromAttributes (builder);

			if (builder.Children != null && builder.Children.Count > 0) {
				StringBuilder sb = new StringBuilder ();
				foreach (object b in builder.Children) {
					if (b is string) {
						sb.Append ((string) b);
						continue;
					}

					FlushText (builder, sb);
					if (b is ObjectTagBuilder) {
						ProcessObjectTag ((ObjectTagBuilder) b);
					} else if (b is StringPropertyBuilder) {
						StringPropertyBuilder pb = b as StringPropertyBuilder;
						if (pb.Children != null && pb.Children.Count > 0) {
							StringBuilder asb = new StringBuilder ();
							foreach (string s in pb.Children)
								asb.Append (s);
							CodeMemberMethod method = builder.Method;
							CodeAssignStatement assign = new CodeAssignStatement ();
							assign.Left = new CodePropertyReferenceExpression (ctrlVar, pb.PropertyName);
							assign.Right = new CodePrimitiveExpression (asb.ToString ());
							method.Statements.Add (AddLinePragma (assign, builder));
						}
					} else if (b is ContentBuilderInternal) {
						ContentBuilderInternal cb = (ContentBuilderInternal) b;
						CreateControlTree (cb, false, true);
						AddContentTemplateInvocation (cb, builder.Method, cb.Method.Name);
						continue;
					}

					// Ignore TemplateBuilders - they are processed in InitMethod
					else if (b is TemplateBuilder) {
					} else if (b is CodeRenderBuilder) {
						AddCodeRender (builder, (CodeRenderBuilder) b);
					} else if (b is DataBindingBuilder) {
						AddDataBindingLiteral (builder, (DataBindingBuilder) b);
					} else if (b is ControlBuilder) {
						ControlBuilder child = (ControlBuilder) b;
						CreateControlTree (child, inTemplate, builder.ChildrenAsProperties);
						AddChildCall (builder, child);
						continue;
					} else
						throw new Exception ("???");

					ControlBuilder bldr = b as ControlBuilder;
					bldr.ProcessGeneratedCode (CompileUnit, BaseType, DerivedType, bldr.Method, bldr.DataBindingMethod);
				}

				FlushText (builder, sb);
			}

			ControlBuilder defaultPropertyBuilder = builder.DefaultPropertyBuilder;
			if (defaultPropertyBuilder != null) {
				CreateControlTree (defaultPropertyBuilder, false, true);
				AddChildCall (builder, defaultPropertyBuilder);
			}
			
			if (builder.HasAspCode) {
				CodeMemberMethod renderMethod = builder.RenderMethod;
				CodeMethodReferenceExpression m = new CodeMethodReferenceExpression ();
				m.TargetObject = thisRef;
				m.MethodName = renderMethod.Name;

				CodeDelegateCreateExpression create = new CodeDelegateCreateExpression ();
//.........这里部分代码省略.........

        protected virtual void BuildSourceDataTreeFromBuilder(ControlBuilder builder,
                                                    bool fInTemplate, bool topLevelControlInTemplate,
                                                    PropertyEntry pse) {

            // Don't do anything for Code blocks
            if (builder is CodeBlockBuilder || builder is CodeStatementBuilder)
                return;

            // Is the current builder for a template?
            bool fTemplate = (builder is TemplateBuilder);

            // For the control name in the compiled code, we use the
            // ID if one is available (but don't use the ID inside a template)
            // Otherwise, we generate a unique name.
            if (builder.ID == null || fInTemplate) {
                // Increase the control count to generate unique ID's
                _controlCount++;

                builder.ID = "__control" + _controlCount.ToString(NumberFormatInfo.InvariantInfo);
                builder.IsGeneratedID = true;
            }

            // Process the children
            if (builder.SubBuilders != null) {
                foreach (object child in builder.SubBuilders) {
                    if (child is ControlBuilder) {
                        // Do not treat it as top level control in template if the control is at top-level of a file.
                        bool isTopLevelCtrlInTemplate =
                            fTemplate && typeof(Control).IsAssignableFrom(((ControlBuilder)child).ControlType) && !(builder is RootBuilder);
                        BuildSourceDataTreeFromBuilder((ControlBuilder)child, fInTemplate, isTopLevelCtrlInTemplate, null);
                    }
                }
            }

            foreach (TemplatePropertyEntry entry in builder.TemplatePropertyEntries) {
                bool inTemplate = true;

                // If the template container does not allow multiple instances,
                // treat the controls as if not in templates.
                if (entry.PropertyInfo != null) {
                    inTemplate = entry.IsMultiple;
                }

                BuildSourceDataTreeFromBuilder(((TemplatePropertyEntry)entry).Builder, inTemplate, false /*topLevelControlInTemplate*/, entry);
            }

            foreach (ComplexPropertyEntry entry in builder.ComplexPropertyEntries) {
                // Don't create a build method for inner property strings
                if (!(entry.Builder is StringPropertyBuilder)) {
                    BuildSourceDataTreeFromBuilder(((ComplexPropertyEntry)entry).Builder, fInTemplate, false /*topLevelControlInTemplate*/, entry);
                }
            }

            // Build a field declaration for the control if ID is defined on the control.
            // (Not a generated ID)
            if (!builder.IsGeneratedID)
                BuildFieldDeclaration(builder);

            CodeMemberMethod buildMethod = null;
            CodeMemberMethod dataBindingMethod = null;

            // Skip the rest if we're only generating the intermediate class
            if (_sourceDataClass != null) {

                if (!_designerMode) {
                    // Build a Build method for the control
                    buildMethod = BuildBuildMethod(builder, fTemplate, fInTemplate, topLevelControlInTemplate, pse, false);
                }

                // Build a Render method for the control, unless it has no code
                if (builder.HasAspCode) {
                    BuildRenderMethod(builder, fTemplate);
                }

                // Build a method to extract values from the template
                BuildExtractMethod(builder);

                // Build a property binding method for the control
                dataBindingMethod = BuildPropertyBindingMethod(builder, false);
            }

            // Give the ControlBuilder a chance to look at and modify the tree
            builder.ProcessGeneratedCode(_codeCompileUnit, _intermediateClass,
                _sourceDataClass, buildMethod, dataBindingMethod);

            if (Parser.ControlBuilderInterceptor != null) {
                Parser.ControlBuilderInterceptor.OnProcessGeneratedCode(builder, _codeCompileUnit,
                    _intermediateClass, _sourceDataClass, buildMethod, dataBindingMethod, builder.AdditionalState);
            }

            // Give the ParseRecorder a chance to look at and modify the tree
            Parser.ParseRecorders.ProcessGeneratedCode(builder, _codeCompileUnit,
                _intermediateClass, _sourceDataClass, buildMethod, dataBindingMethod);
        }

 public void VerifyProcessGeneratedCode(ControlBuilder builder) {
     CodeCompileUnit ccu = new CodeCompileUnit();
     ccu.Namespaces.Add(new CodeNamespace());
     builder.ProcessGeneratedCode(ccu, null, null, null, null);
     VerifyDefaultNameSpaces(ccu);
 }

 protected virtual void BuildSourceDataTreeFromBuilder(ControlBuilder builder, bool fInTemplate, bool topLevelControlInTemplate, PropertyEntry pse)
 {
     if (!(builder is CodeBlockBuilder))
     {
         bool fTemplate = builder is TemplateBuilder;
         if ((builder.ID == null) || fInTemplate)
         {
             this._controlCount++;
             builder.ID = "__control" + this._controlCount.ToString(NumberFormatInfo.InvariantInfo);
             builder.IsGeneratedID = true;
         }
         if (builder.SubBuilders != null)
         {
             foreach (object obj2 in builder.SubBuilders)
             {
                 if (obj2 is ControlBuilder)
                 {
                     bool flag2 = (fTemplate && typeof(Control).IsAssignableFrom(((ControlBuilder) obj2).ControlType)) && !(builder is RootBuilder);
                     this.BuildSourceDataTreeFromBuilder((ControlBuilder) obj2, fInTemplate, flag2, null);
                 }
             }
         }
         foreach (TemplatePropertyEntry entry in builder.TemplatePropertyEntries)
         {
             bool isMultiple = true;
             if (entry.PropertyInfo != null)
             {
                 isMultiple = entry.IsMultiple;
             }
             this.BuildSourceDataTreeFromBuilder(entry.Builder, isMultiple, false, entry);
         }
         foreach (ComplexPropertyEntry entry2 in builder.ComplexPropertyEntries)
         {
             if (!(entry2.Builder is StringPropertyBuilder))
             {
                 this.BuildSourceDataTreeFromBuilder(entry2.Builder, fInTemplate, false, entry2);
             }
         }
         if (!builder.IsGeneratedID)
         {
             this.BuildFieldDeclaration(builder);
         }
         CodeMemberMethod buildMethod = null;
         CodeMemberMethod dataBindingMethod = null;
         if (base._sourceDataClass != null)
         {
             if (!base._designerMode)
             {
                 buildMethod = this.BuildBuildMethod(builder, fTemplate, fInTemplate, topLevelControlInTemplate, pse, false);
             }
             if (builder.HasAspCode)
             {
                 this.BuildRenderMethod(builder, fTemplate);
             }
             this.BuildExtractMethod(builder);
             dataBindingMethod = this.BuildPropertyBindingMethod(builder, false);
         }
         builder.ProcessGeneratedCode(base._codeCompileUnit, base._intermediateClass, base._sourceDataClass, buildMethod, dataBindingMethod);
     }
 }