XlsxWriter.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using NanoXLSX.Exceptions;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Writer;
using NanoXLSX.Internal.Structures;
using NanoXLSX.Registry;
using NanoXLSX.Styles;
using NanoXLSX.Utils;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Packaging;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using IOException = NanoXLSX.Exceptions.IOException;
using PackagePartType = NanoXLSX.Internal.Structures.PackagePartDefinition.PackagePartType;
using XmlElement = NanoXLSX.Utils.Xml.XmlElement;
 
namespace NanoXLSX.Internal.Writers
{
    internal class XlsxWriter : IBaseWriter
    {
 
        #region staticFields
        private static readonly DocumentPath WORKBOOK = new DocumentPath("workbook.xml", "xl/");
        private static readonly DocumentPath STYLES = new DocumentPath("styles.xml", "xl/");
        private static readonly DocumentPath APP_PROPERTIES = new DocumentPath("app.xml", "docProps/");
        private static readonly DocumentPath CORE_PROPERTIES = new DocumentPath("core.xml", "docProps/");
        private static readonly DocumentPath SHARED_STRINGS = new DocumentPath("sharedStrings.xml", "xl/");
        private static readonly DocumentPath THEME = new DocumentPath("theme1.xml", "xl/theme/");
        #endregion
 
        #region privateFields
        private int rootPackageIndex = 1;
        private int xlPackageIndex = 1;
        private Package package = null;
 
        private readonly List<PackagePartDefinition> packagePartDefinitions = new List<PackagePartDefinition>();
        private readonly Dictionary<string, Dictionary<string, PackagePart>> packageParts = new Dictionary<string, Dictionary<string, PackagePart>>();
        private readonly Dictionary<int, DocumentPath> worksheetPaths = new Dictionary<int, DocumentPath>();
        private readonly HashSet<string> preparedWriterFeatures = new HashSet<string>();
        private readonly Dictionary<string, PackagePart> queuedPackageParts = new Dictionary<string, PackagePart>(StringComparer.Ordinal);
 
        #endregion
 
        #region properties
        public Workbook Workbook { get; }

        public IWriterProcessingData WriterProcessingData { get; set; }

        public ISharedStringWriter SharedStringWriter { get; set; }
 
        #endregion
 
        #region constructors
        public XlsxWriter(Workbook workbook)
        {
            this.Workbook = workbook;
        }
        #endregion
 
        #region documentCreation_methods

        public void Save()
        {
            try
            {
                FileStream fs = new FileStream(Workbook.Filename, FileMode.Create);
                SaveAsStream(fs);
 
            }
            catch (Exception e)
            {
                throw new IOException("An error occurred while saving. See inner exception for details: " + e.Message, e);
            }
        }

        public async Task SaveAsync()
        {
            await Task.Run(() => { Save(); });
        }

        public async Task SaveAsStreamAsync(Stream stream, bool leaveOpen = false)
        {
            await Task.Run(() => { SaveAsStream(stream, leaveOpen); });
        }

        public void SaveAsStream(Stream stream, bool leaveOpen = false)
        {
            preparedWriterFeatures.Clear();
            WriterProcessingData = new WriterProcessingData(Workbook, StyleRepository.Instance);
            try
            {
                // preparing processor(s)
                IPluginWriteProcessor preparingProcessor = PlugInLoader.GetPlugIn<IPluginWriteProcessor>(PlugInUUID.PreparingProcessor, new PreparingProcessor());
                preparingProcessor.Init(this, WriterPlugInHandler.HandleInlineQueueProcessorPlugins);
                preparingProcessor.Execute();
                // Compatibility check
                CompatibilityProcessor compatibilityProcessor = new CompatibilityProcessor(); // This core processor cannot be overwritten
                compatibilityProcessor.Init(this, WriterPlugInHandler.HandleInlineQueueProcessorPlugins);
                compatibilityProcessor.Execute();
                // Workbook can now be written
                RegisterCommonPackageParts();
                HandlePackageRegistryQueuePlugIns();
                HandleQueuePlugIns(PlugInUUID.WriterPrependingQueue);
 
                using (Package xlsxPackage = Package.Open(stream, FileMode.Create))
                {
                    this.package = xlsxPackage;
                    PreparePackage();
                    PackagePart part;
 
                    // Workbook
                    IPluginWriter workbookWriter = PlugInLoader.GetPlugIn<IPluginWriter>(PlugInUUID.WorkbookWriter, new WorkbookWriter());
                    workbookWriter.Init(this);
                    workbookWriter.Execute();
                    part = packageParts[WORKBOOK.Path][WORKBOOK.Filename];
                    AppendXmlToPackagePart(workbookWriter.XmlElement, part);
 
                    // Style
                    IPluginWriter styleWriter = PlugInLoader.GetPlugIn<IPluginWriter>(PlugInUUID.StyleWriter, new StyleWriter());
                    styleWriter.Init(this);
                    styleWriter.Execute();
                    part = packageParts[STYLES.Path][STYLES.Filename];
                    AppendXmlToPackagePart(styleWriter.XmlElement, part);
 
                    // Shared strings - preparation
                    SharedStringWriter = PlugInLoader.GetPlugIn<ISharedStringWriter>(PlugInUUID.SharedStringsWriter, new SharedStringWriter());
                    SharedStringWriter.Init(this);
                    // Worksheets
                    IWorksheetWriter worksheetWriter = PlugInLoader.GetPlugIn<IWorksheetWriter>(PlugInUUID.WorksheetWriter, new WorksheetWriter());
                    worksheetWriter.Init(this);
                    if (Workbook.Worksheets.Count > 0)
                    {
                        for (int i = 0; i < Workbook.Worksheets.Count; i++)
                        {
                            Worksheet item = Workbook.Worksheets[i];
                            part = packageParts[worksheetPaths[i].Path][worksheetPaths[i].Filename];
                            worksheetWriter.CurrentWorksheet = item;
                            worksheetWriter.Execute();
                            AppendXmlToPackagePart(worksheetWriter.XmlElement, part);
                            worksheetWriter.ReleaseXmlElement();
                            GC.Collect(1, GCCollectionMode.Optimized); // 
                        }
                    }
                    else
                    {
                        part = packageParts[worksheetPaths[0].Path][worksheetPaths[0].Filename];
                        worksheetWriter.CurrentWorksheet = new Worksheet("sheet1");
                        worksheetWriter.Execute();
                        AppendXmlToPackagePart(worksheetWriter.XmlElement, part);
                        worksheetWriter.ReleaseXmlElement();
                    }
 
                    // Shared strings - write after collection of strings
                    part = packageParts[SHARED_STRINGS.Path][SHARED_STRINGS.Filename];
                    SharedStringWriter.Execute();
                    AppendXmlToPackagePart(SharedStringWriter.XmlElement, part);
 
                    // Metadata
                    if (this.Workbook.WorkbookMetadata != null)
                    {
                        IPluginWriter metadataAppWriter = PlugInLoader.GetPlugIn<IPluginWriter>(PlugInUUID.MetadataAppWriter, new MetadataAppWriter());
                        metadataAppWriter.Init(this);
                        metadataAppWriter.Execute();
                        part = packageParts[APP_PROPERTIES.Path][APP_PROPERTIES.Filename];
                        AppendXmlToPackagePart(metadataAppWriter.XmlElement, part);
                        IPluginWriter metadataCoreWriter = PlugInLoader.GetPlugIn<IPluginWriter>(PlugInUUID.MetadataCoreWriter, new MetadataCoreWriter());
                        metadataCoreWriter.Init(this);
                        metadataCoreWriter.Execute();
                        part = packageParts[CORE_PROPERTIES.Path][CORE_PROPERTIES.Filename];
                        AppendXmlToPackagePart(metadataCoreWriter.XmlElement, part);
                    }
 
                    // Theme
                    if (Workbook.WorkbookTheme != null)
                    {
                        IPluginWriter themeWriter = PlugInLoader.GetPlugIn<IPluginWriter>(PlugInUUID.ThemeWriter, new ThemeWriter());
                        themeWriter.Init(this);
                        themeWriter.Execute();
                        part = packageParts[THEME.Path][THEME.Filename];
                        AppendXmlToPackagePart(themeWriter.XmlElement, part);
                    }
 
                    HandleQueuePlugIns(PlugInUUID.WriterAppendingQueue);
 
                    this.package.Flush();
                    this.package.Close();
                    if (!leaveOpen)
                    {
                        stream.Close();
                    }
 
                }
                Workbook.AuxiliaryData.ClearTemporaryData();
            }
            catch (Exception e)
            {
                throw new IOException("An error occurred while saving. See inner exception for details: " + e.Message, e);
            }
        }

        private void RegisterCommonPackageParts()
        {
            // Workbook should always be the lowest index
            RegisterPackagePart(PackagePartType.Root, PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX, WORKBOOK, @"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument");
            if (this.Workbook.WorkbookMetadata != null)
            {
                int index = PackagePartDefinition.METADATA_PACKAGE_PART_START_INDEX;
                RegisterPackagePart(PackagePartType.Root, index, CORE_PROPERTIES, @"application/vnd.openxmlformats-package.core-properties+xml", @"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties");
                RegisterPackagePart(PackagePartType.Root, index + 1000, APP_PROPERTIES, @"application/vnd.openxmlformats-officedocument.extended-properties+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties");
            }
            int worksheetOrderNumber = PackagePartDefinition.WORKSHEET_PACKAGE_PART_START_INDEX;
            if (this.Workbook.Worksheets.Count == 0)
            {
                RegisterPackagePart(PackagePartType.Worksheet, worksheetOrderNumber, "sheet1.xml", "xl/worksheets", @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet");
            }
            else
            {
                for (int i = 0; i < this.Workbook.Worksheets.Count; i++)
                {
                    string fileName = "sheet" + ParserUtils.ToString(i + 1) + ".xml";
                    RegisterPackagePart(PackagePartType.Worksheet, worksheetOrderNumber, fileName, "xl/worksheets", @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet");
                    worksheetOrderNumber++;
                }
            }
            int postWorksheetOrderNumber = PackagePartDefinition.POST_WORkSHEET_PACKAGE_PART_START_INDEX;
            if (Workbook.WorkbookTheme != null)
            {
                RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, THEME, @"application/vnd.openxmlformats-officedocument.theme+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme");
                postWorksheetOrderNumber += 1000;
            }
            RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, STYLES, @"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles");
            postWorksheetOrderNumber += 1000;
            RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, SHARED_STRINGS, @"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings");
            // TODO: add themeIndex once if media is embedded
 
            this.Workbook.AuxiliaryData.SetData(PlugInUUID.WriterPackageRegistryQueue, PlugInUUID.LastPackageOrderNumber, postWorksheetOrderNumber, false);
        }

        private void PreparePackage()
        {
            List<PackagePartDefinition> definitions = PackagePartDefinition.Sort(this.packagePartDefinitions);
            PackagePartDefinition workbookDefinition = definitions.First(p => p.OrderNumber == PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX);
            PackagePart workbookPart = CreateRootPackagePart(workbookDefinition.Path, workbookDefinition.ContentType, workbookDefinition.RelationshipType);
            foreach (PackagePartDefinition definition in definitions)
            {
                if (definition.OrderNumber == PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX)
                {
                    continue;
                }
                PackagePart createdPart;
                string workbookRelationshipId = null;
                if (definition.PartType == PackagePartType.Root)
                {
                    createdPart = CreateRootPackagePart(definition.Path, definition.ContentType, definition.RelationshipType);
                }
                else
                {
                    createdPart = CreateXlPackagePart(workbookPart, definition.Path, definition.ContentType, definition.RelationshipType, out workbookRelationshipId);
                    if (definition.PartType == PackagePartType.Worksheet)
                    {
                        worksheetPaths.Add(definition.GetWorksheetIndex(), definition.Path);
                    }
                }
                if (definition.UniquePackagePartIndex != null)
                {
                    queuedPackageParts.Add(definition.UniquePackagePartIndex, createdPart);
                    if (workbookRelationshipId != null)
                    {
                        Workbook.AuxiliaryData.SetData(PlugInUUID.WriterPackageRegistryQueue, PlugInUUID.PackagePartRelationshipId, definition.UniquePackagePartIndex, workbookRelationshipId);
                    }
                }
                CreatePackagePartRelationships(createdPart, definition.Relationships);
            }
        }

        private static void CreatePackagePartRelationships(PackagePart packagePart, IReadOnlyList<PackagePartRelationshipDefinition> relationships)
        {
            foreach (PackagePartRelationshipDefinition relationship in relationships)
            {
                bool rootRelativeInternalTarget = relationship.TargetMode == TargetMode.Internal
                    && relationship.Target.StartsWith("/", StringComparison.Ordinal);
                Uri targetUri = new Uri(relationship.Target, rootRelativeInternalTarget ? UriKind.Relative : UriKind.RelativeOrAbsolute);
                packagePart.CreateRelationship(targetUri, relationship.TargetMode, relationship.RelationshipType, relationship.RelationshipId);
            }
        }

        internal PackagePart CreateRootPackagePart(DocumentPath documentPath, string contentType, string relationshipType)
        {
            Uri uri = new Uri(documentPath.GetFullPath(), UriKind.Relative);
            PackagePart part = this.package.CreatePart(uri, contentType, CompressionOption.Normal);
            if (!packageParts.ContainsKey(documentPath.Path))
            {
                packageParts.Add(documentPath.Path, new Dictionary<string, PackagePart>());
            }
            packageParts[documentPath.Path].Add(documentPath.Filename, part);
            this.package.CreateRelationship(uri, TargetMode.Internal, relationshipType, "rId" + ParserUtils.ToString(rootPackageIndex));
            rootPackageIndex++;
            return part;
        }

        internal PackagePart CreateXlPackagePart(PackagePart parentPart, DocumentPath documentPath, string contentType, string relationshipType, out string relationshipId)
        {
            Uri uri = new Uri(documentPath.GetFullPath(), UriKind.Relative);
            PackagePart part = this.package.CreatePart(uri, contentType, CompressionOption.Normal);
            if (!packageParts.ContainsKey(documentPath.Path))
            {
                packageParts.Add(documentPath.Path, new Dictionary<string, PackagePart>());
            }
            packageParts[documentPath.Path].Add(documentPath.Filename, part);
            relationshipId = "rId" + ParserUtils.ToString(xlPackageIndex);
            parentPart.CreateRelationship(uri, TargetMode.Internal, relationshipType, relationshipId);
            xlPackageIndex++;
            return part;
        }

        internal void RegisterPackagePart(PackagePartDefinition.PackagePartType type, int orderNumber, string fileNameInPackage, string pathInPackage, string contentType, string relationshipType)
        {
            this.packagePartDefinitions.Add(new PackagePartDefinition(type, orderNumber, fileNameInPackage, pathInPackage, contentType, relationshipType));
        }

        internal void RegisterPackagePart(PackagePartType type, int orderNumber, DocumentPath documentPath, string contentType, string relationshipType)
        {
            this.packagePartDefinitions.Add(new PackagePartDefinition(type, orderNumber, documentPath, contentType, relationshipType));
        }

        private void RegisterPackagePart(PackagePartType type, int orderNumber, DocumentPath documentPath, string contentType, string relationshipType, string uniquePackagePartIndex, IReadOnlyList<IPluginPackageRelationship> relationships)
        {
            this.packagePartDefinitions.Add(new PackagePartDefinition(type, orderNumber, documentPath, contentType, relationshipType, uniquePackagePartIndex, relationships));
        }
 
        #endregion
 
        #region interface_methodes

        public void MarkFeatureAsPrepared(string featureUuid)
        {
            ValidateFeatureUuid(featureUuid);
            preparedWriterFeatures.Add(featureUuid);
        }

        public bool IsFeaturePrepared(string featureUuid)
        {
            ValidateFeatureUuid(featureUuid);
            return preparedWriterFeatures.Contains(featureUuid);
        }

        private static void ValidateFeatureUuid(string uuid)
        {
            if (string.IsNullOrWhiteSpace(uuid))
            {
                throw new ArgumentException("The feature UUID must not be null, empty or whitespace");
            }
            // TODO add other validation checks here if applicable (e.g. UUID must be officially registered)
        }
 
        #endregion
 
        #region helper_methods
        private void HandleQueuePlugIns(string queueUuid)
        {
            IPlugin queuePlugIn;
            string lastUuid = null;
            do
            {
                queuePlugIn = PlugInLoader.GetNextQueuePlugIn<IPlugin>(queueUuid, lastUuid, out string currentUuid);
                if (queuePlugIn != null)
                {
                    lastUuid = currentUuid;
                    if (!(queuePlugIn is IPluginWriter queueWriter))
                    {
                        continue;
                    }
                    queueWriter.Init(this);
                    if (queueWriter is IPluginIndexedWriter indexedWriter)
                    {
                        HandleIndexedWriter(indexedWriter, queueUuid);
                    }
                    else
                    {
                        queueWriter.Execute();
                    }
                }
                else
                {
                    lastUuid = null;
                }
 
            } while (queuePlugIn != null);
        }

        private void HandleIndexedWriter(IPluginIndexedWriter indexedWriter, string queueUuid)
        {
            int maxIndex = indexedWriter.MaxIndex;
            if (maxIndex < -1)
            {
                throw new IOException("Invalid maximum index in indexed writer plug-in: " + indexedWriter.GetType().Name);
            }
            if (maxIndex == -1)
            {
                return;
            }
            if (queueUuid == PlugInUUID.WriterPrependingQueue)
            {
                throw new IOException("Indexed writer plug-ins cannot be executed in the writer prepending queue: " + indexedWriter.GetType().Name);
            }
 
            for (int i = 0; i <= maxIndex; i++)
            {
                indexedWriter.CurrentIndex = i;
                indexedWriter.Execute();
                string uniquePackagePartIndex = indexedWriter.CurrentUniquePackagePartIndex;
                if (uniquePackagePartIndex == null)
                {
                    continue;
                }
                if (string.IsNullOrWhiteSpace(uniquePackagePartIndex))
                {
                    throw new IOException("Blank package part index in indexed writer plug-in: " + indexedWriter.GetType().Name);
                }
                if (!queuedPackageParts.TryGetValue(uniquePackagePartIndex, out PackagePart packagePart))
                {
                    throw new IOException("Unknown package part index '" + uniquePackagePartIndex + "' in indexed writer plug-in: " + indexedWriter.GetType().Name);
                }
                if (indexedWriter.XmlElement == null)
                {
                    throw new IOException("Missing XML element in indexed writer plug-in: " + indexedWriter.GetType().Name);
                }
                AppendXmlToPackagePart(indexedWriter.XmlElement, packagePart);
            }
        }

        private void HandlePackageRegistryQueuePlugIns()
        {
            IPlugin queuePlugIn;
            string lastUuid = null;
            do
            {
                queuePlugIn = PlugInLoader.GetNextQueuePlugIn<IPlugin>(PlugInUUID.WriterPackageRegistryQueue, lastUuid, out string currentUuid);
                if (queuePlugIn != null)
                {
                    lastUuid = currentUuid;
                    if (!(queuePlugIn is IPluginPackageRegistry packageRegistry))
                    {
                        continue;
                    }
                    packageRegistry.Init(this);
                    packageRegistry.Execute();
                    int counter = ValidatePackageRegistryPlugin(packageRegistry);
                    for (int i = 0; i < counter; i++)
                    {
                        ValidatePackageRegistryEntry(packageRegistry, i);
                        PackagePartType packagePartType = packageRegistry.ArePackagePartsRoot[i] ? PackagePartType.Root : PackagePartType.Other;
                        RegisterPackagePart(
                            packagePartType,
                            packageRegistry.OrderNumbers[i],
                            new DocumentPath(packageRegistry.PackagePartFileNames[i], packageRegistry.PackagePartPaths[i]),
                            packageRegistry.ContentTypes[i],
                            packageRegistry.RelationshipTypes[i],
                            packageRegistry.UniquePackagePartIndices[i],
                            packageRegistry.PackagePartRelationships[i]);
                    }
                }
                else
                {
                    lastUuid = null;
                }
 
            } while (queuePlugIn != null);
        }

        private static int ValidatePackageRegistryPlugin(IPluginPackageRegistry plugin)
        {
            if (plugin.OrderNumbers == null ||
                plugin.ArePackagePartsRoot == null ||
                plugin.ContentTypes == null ||
                plugin.PackagePartFileNames == null ||
                plugin.PackagePartPaths == null ||
                plugin.RelationshipTypes == null ||
                plugin.UniquePackagePartIndices == null ||
                plugin.PackagePartRelationships == null)
            {
                throw new IOException("Null collection in package registry plug-in: " + plugin.GetType().Name);
            }
 
            int count = plugin.OrderNumbers.Count;
            if (plugin.ArePackagePartsRoot.Count != count ||
                plugin.ContentTypes.Count != count ||
                plugin.PackagePartFileNames.Count != count ||
                plugin.PackagePartPaths.Count != count ||
                plugin.RelationshipTypes.Count != count ||
                plugin.UniquePackagePartIndices.Count != count ||
                plugin.PackagePartRelationships.Count != count)
            {
                throw new IOException("Inconsistent package registry plug-in detected: " + plugin.GetType().Name);
            }
            return count;
        }

        private void ValidatePackageRegistryEntry(IPluginPackageRegistry plugin, int index)
        {
            string uniquePackagePartIndex = plugin.UniquePackagePartIndices[index];
            if (string.IsNullOrWhiteSpace(uniquePackagePartIndex))
            {
                throw new IOException("Blank package part index in package registry plug-in: " + plugin.GetType().Name);
            }
            if (packagePartDefinitions.Any(definition => string.Equals(definition.UniquePackagePartIndex, uniquePackagePartIndex, StringComparison.Ordinal)))
            {
                throw new IOException("Duplicate package part index '" + uniquePackagePartIndex + "' in package registry plug-in: " + plugin.GetType().Name);
            }
            if (string.IsNullOrWhiteSpace(plugin.PackagePartPaths[index]) ||
                string.IsNullOrWhiteSpace(plugin.PackagePartFileNames[index]) ||
                string.IsNullOrWhiteSpace(plugin.ContentTypes[index]) ||
                string.IsNullOrWhiteSpace(plugin.RelationshipTypes[index]))
            {
                throw new IOException("Invalid package part definition in package registry plug-in: " + plugin.GetType().Name);
            }
            ValidatePackagePartRelationships(plugin, index);
        }

        private static void ValidatePackagePartRelationships(IPluginPackageRegistry plugin, int index)
        {
            IReadOnlyList<IPluginPackageRelationship> relationships = plugin.PackagePartRelationships[index];
            if (relationships == null)
            {
                throw new IOException("Null package relationship collection in package registry plug-in: " + plugin.GetType().Name);
            }
 
            HashSet<string> relationshipIds = new HashSet<string>(StringComparer.Ordinal);
            foreach (IPluginPackageRelationship relationship in relationships)
            {
                ValidatePackagePartRelationship(plugin, relationship, relationshipIds);
            }
        }

        private static void ValidatePackagePartRelationship(IPluginPackageRegistry plugin, IPluginPackageRelationship relationship, HashSet<string> relationshipIds)
        {
            if (relationship == null)
            {
                throw new IOException("Null package relationship in package registry plug-in: " + plugin.GetType().Name);
            }
            if (string.IsNullOrWhiteSpace(relationship.RelationshipId))
            {
                throw new IOException("Blank package relationship ID in package registry plug-in: " + plugin.GetType().Name);
            }
            try
            {
                XmlConvert.VerifyNCName(relationship.RelationshipId);
            }
            catch (XmlException)
            {
                throw new IOException("Invalid package relationship ID '" + relationship.RelationshipId + "' in package registry plug-in: " + plugin.GetType().Name);
            }
            if (!relationshipIds.Add(relationship.RelationshipId))
            {
                throw new IOException("Duplicate package relationship ID '" + relationship.RelationshipId + "' in package registry plug-in: " + plugin.GetType().Name);
            }
            if (string.IsNullOrWhiteSpace(relationship.RelationshipType) ||
                !Uri.TryCreate(relationship.RelationshipType, UriKind.Absolute, out _)) // Check URI of type, not target
            {
                throw new IOException("Invalid package relationship type in package registry plug-in: " + plugin.GetType().Name);
            }
            if (string.IsNullOrWhiteSpace(relationship.Target) ||
                !Uri.TryCreate(relationship.Target, UriKind.RelativeOrAbsolute, out Uri targetUri)) // Check URI of target
            {
                throw new IOException("Invalid package relationship target in package registry plug-in: " + plugin.GetType().Name);
            }
            if (relationship.TargetMode != TargetMode.Internal && relationship.TargetMode != TargetMode.External)
            {
                throw new IOException("Invalid package relationship target mode in package registry plug-in: " + plugin.GetType().Name);
            }
            bool rootRelativeTarget = relationship.Target.StartsWith("/", StringComparison.Ordinal);
            if (relationship.TargetMode == TargetMode.Internal && relationship.Target.StartsWith("//", StringComparison.Ordinal))
            {
                throw new IOException("Network-path internal package relationship target in package registry plug-in: " + plugin.GetType().Name);
            }
            if (relationship.TargetMode == TargetMode.Internal && targetUri.IsAbsoluteUri && !rootRelativeTarget)
            {
                throw new IOException("Absolute internal package relationship target in package registry plug-in: " + plugin.GetType().Name);
            }
        }

        private static void AppendXmlToPackagePart(XmlElement rootElement, PackagePart pp)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                XmlWriterSettings settings = new XmlWriterSettings
                {
                    Encoding = new UTF8Encoding(false), // No BOM
                    Indent = true,
                    OmitXmlDeclaration = true, // Include <?xml version="1.0" encoding="utf-8"?>
                    CloseOutput = false
                };
 
                using (XmlWriter writer = XmlWriter.Create(ms, settings))
                {
                    writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"");
                    rootElement.WriteTo(writer);
                    writer.Flush();
                }
 
                AddStreamToPackagePart(ms, pp);
            }
        }

        internal static void AddStreamToPackagePart(MemoryStream stream, PackagePart pp)
        {
            stream.Position = 0;
            stream.CopyTo(pp.GetStream());
            stream.Flush();
        }
 
        #endregion
    }
}