// Recursively write new sections for each section group.
        private bool WriteNewConfigDefinitionsRecursive(XmlUtilWriter utilWriter, SectionUpdates sectionUpdates, int linePosition, int indent, bool skipFirstIndent) {
            bool wroteASection = false;

            string[] movedSectionNames = sectionUpdates.GetMovedSectionNames();
            if (movedSectionNames != null) {
                wroteASection = true;
                foreach (string configKey in movedSectionNames) {
                    DefinitionUpdate update = sectionUpdates.GetDefinitionUpdate(configKey);
                    WriteSectionUpdate(utilWriter, update, linePosition, indent, skipFirstIndent);
                    utilWriter.AppendNewLine();
                    skipFirstIndent = false;
                }
            }

            string[] newGroupNames = sectionUpdates.GetNewGroupNames();
            if (newGroupNames != null) {
                foreach (string group in newGroupNames) {

                    if (TargetFramework != null) {
                        ConfigurationSectionGroup g = GetSectionGroup(group);
                        if (g != null && !g.ShouldSerializeSectionGroupInTargetVersion(TargetFramework)){
                            sectionUpdates.MarkGroupAsRetrieved(group);
                            continue;
                        }
                    }

                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    utilWriter.Write("<" + group + ">\r\n");
                    bool recurseWroteASection = WriteNewConfigDefinitionsRecursive(
                            utilWriter, sectionUpdates.GetSectionUpdatesForGroup(group), linePosition + indent, indent, false);

                    if (recurseWroteASection) {
                        wroteASection = true;
                    }

                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    utilWriter.Write("</" + group + ">\r\n");
                }
            }

            sectionUpdates.IsNew = false;

            return wroteASection;
        }
 private void WriteUnwrittenConfigDeclarationsRecursive(SectionUpdates declarationUpdates, XmlUtilWriter utilWriter, int linePosition, int indent, bool skipFirstIndent)
 {
     string[] unretrievedSectionNames = declarationUpdates.GetUnretrievedSectionNames();
     if (unretrievedSectionNames != null)
     {
         foreach (string str in unretrievedSectionNames)
         {
             if (!skipFirstIndent)
             {
                 utilWriter.AppendSpacesToLinePosition(linePosition);
             }
             skipFirstIndent = false;
             DeclarationUpdate declarationUpdate = declarationUpdates.GetDeclarationUpdate(str);
             if ((declarationUpdate != null) && !string.IsNullOrEmpty(declarationUpdate.UpdatedXml))
             {
                 utilWriter.Write(declarationUpdate.UpdatedXml);
                 utilWriter.AppendNewLine();
             }
         }
     }
     string[] unretrievedGroupNames = declarationUpdates.GetUnretrievedGroupNames();
     if (unretrievedGroupNames != null)
     {
         foreach (string str2 in unretrievedGroupNames)
         {
             if (base.TargetFramework != null)
             {
                 ConfigurationSectionGroup sectionGroup = this.GetSectionGroup(str2);
                 if ((sectionGroup != null) && !sectionGroup.ShouldSerializeSectionGroupInTargetVersion(base.TargetFramework))
                 {
                     declarationUpdates.MarkGroupAsRetrieved(str2);
                     continue;
                 }
             }
             if (!skipFirstIndent)
             {
                 utilWriter.AppendSpacesToLinePosition(linePosition);
             }
             skipFirstIndent = false;
             SectionUpdates sectionUpdatesForGroup = declarationUpdates.GetSectionUpdatesForGroup(str2);
             DeclarationUpdate sectionGroupUpdate = sectionUpdatesForGroup.GetSectionGroupUpdate();
             if (sectionGroupUpdate == null)
             {
                 utilWriter.Write("<sectionGroup name=\"" + str2 + "\">");
             }
             else
             {
                 utilWriter.Write(sectionGroupUpdate.UpdatedXml);
             }
             utilWriter.AppendNewLine();
             this.WriteUnwrittenConfigDeclarationsRecursive(sectionUpdatesForGroup, utilWriter, linePosition + indent, indent, false);
             utilWriter.AppendSpacesToLinePosition(linePosition);
             utilWriter.Write("</sectionGroup>\r\n");
         }
     }
 }
        private void WriteUnwrittenConfigDeclarationsRecursive(SectionUpdates declarationUpdates, XmlUtilWriter utilWriter, int linePosition, int indent, bool skipFirstIndent) {
            string[] unretrievedSectionNames = declarationUpdates.GetUnretrievedSectionNames();
            if (unretrievedSectionNames != null) {
                foreach (string configKey in unretrievedSectionNames) {
                    Debug.Assert(!IsImplicitSection(configKey), "We should never write out an implicit section");
                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    DeclarationUpdate update = declarationUpdates.GetDeclarationUpdate(configKey);
                    if (update != null && !string.IsNullOrEmpty(update.UpdatedXml)) {
                        utilWriter.Write(update.UpdatedXml);
                        utilWriter.AppendNewLine();
                    }
                }
            }

            string[] unretrievedGroupNames = declarationUpdates.GetUnretrievedGroupNames();
            if (unretrievedGroupNames != null) {
                foreach (string group in unretrievedGroupNames) {
                    if (TargetFramework != null) {
                        ConfigurationSectionGroup g = GetSectionGroup(group);
                        if (g != null && !g.ShouldSerializeSectionGroupInTargetVersion(TargetFramework)){
                            declarationUpdates.MarkGroupAsRetrieved(group);
                            continue;
                        }
                    }
                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    SectionUpdates declarationUpdatesChild = declarationUpdates.GetSectionUpdatesForGroup(group);
                    DeclarationUpdate groupUpdate = declarationUpdatesChild.GetSectionGroupUpdate();
                    if (groupUpdate == null) {
                        utilWriter.Write("<sectionGroup name=\"" + group + "\">");
                    }
                    else {
                        utilWriter.Write(groupUpdate.UpdatedXml);
                    }
                    utilWriter.AppendNewLine();

                    WriteUnwrittenConfigDeclarationsRecursive(declarationUpdatesChild, utilWriter, linePosition + indent, indent, false);
                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    utilWriter.Write("</sectionGroup>\r\n");
                }
            }
        }
 private bool WriteNewConfigDefinitionsRecursive(XmlUtilWriter utilWriter, SectionUpdates sectionUpdates, int linePosition, int indent, bool skipFirstIndent)
 {
     bool flag = false;
     string[] movedSectionNames = sectionUpdates.GetMovedSectionNames();
     if (movedSectionNames != null)
     {
         flag = true;
         foreach (string str in movedSectionNames)
         {
             DefinitionUpdate definitionUpdate = sectionUpdates.GetDefinitionUpdate(str);
             this.WriteSectionUpdate(utilWriter, definitionUpdate, linePosition, indent, skipFirstIndent);
             utilWriter.AppendNewLine();
             skipFirstIndent = false;
         }
     }
     string[] newGroupNames = sectionUpdates.GetNewGroupNames();
     if (newGroupNames != null)
     {
         foreach (string str2 in newGroupNames)
         {
             if (base.TargetFramework != null)
             {
                 ConfigurationSectionGroup sectionGroup = this.GetSectionGroup(str2);
                 if ((sectionGroup != null) && !sectionGroup.ShouldSerializeSectionGroupInTargetVersion(base.TargetFramework))
                 {
                     sectionUpdates.MarkGroupAsRetrieved(str2);
                     continue;
                 }
             }
             if (!skipFirstIndent)
             {
                 utilWriter.AppendSpacesToLinePosition(linePosition);
             }
             skipFirstIndent = false;
             utilWriter.Write("<" + str2 + ">\r\n");
             if (this.WriteNewConfigDefinitionsRecursive(utilWriter, sectionUpdates.GetSectionUpdatesForGroup(str2), linePosition + indent, indent, false))
             {
                 flag = true;
             }
             utilWriter.AppendSpacesToLinePosition(linePosition);
             utilWriter.Write("</" + str2 + ">\r\n");
         }
     }
     sectionUpdates.IsNew = false;
     return flag;
 }