XlsxReader.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 System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Threading.Tasks;
using NanoXLSX.Exceptions;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Styles;
using NanoXLSX.Utils;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Readers
{
    public class XlsxReader : IDisposable
    {
        #region privateFields
        private readonly string filePath;
        private readonly Stream inputStream;
        private readonly ReaderOptions readerOptions;
        private MemoryStream memoryStream;
        #endregion
 
        #region properties
        public Workbook Workbook { get; internal set; }
        #endregion
 
        #region constructors
        public XlsxReader(string path, ReaderOptions options = null)
        {
            filePath = path;
            readerOptions = options;
        }

        public XlsxReader(Stream stream, ReaderOptions options = null)
        {
            inputStream = stream;
            readerOptions = options;
        }
        #endregion
 
        #region methods

        public void Read()
        {
            try
            {
                using (memoryStream = new MemoryStream())
                {
                    Task.Run(() => ReadInternal()).GetAwaiter().GetResult();
                }
            }
            catch (NotSupportedContentException)
            {
                throw; // rethrow
            }
            catch (IOException)
            {
                throw; // rethrow
            }
            catch (Exception ex)
            {
                throw new IOException("There was an error while reading an XLSX file. Please see the inner exception:", ex);
            }
        }

        public async Task ReadAsync()
        {
            try
            {
                using (memoryStream = new MemoryStream())
                {
                    await ReadInternal();
                }
            }
            catch (IOException)
            {
                throw; // rethrow
            }
            catch (Exception ex)
            {
                throw new IOException("There was an error while reading an XLSX file. Please see the inner exception:", ex);
            }
        }

        private async Task ReadInternal()
        {
            ZipArchive zf;
            if (inputStream == null && !string.IsNullOrEmpty(filePath))
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open))
                {
                    await fs.CopyToAsync(memoryStream);
                }
            }
            else if (inputStream != null)
            {
                using (inputStream)
                {
                    await inputStream.CopyToAsync(memoryStream);
                }
            }
            else
            {
                throw new IOException("No valid stream or file path was provided to open");
            }
 
            memoryStream.Position = 0;
            zf = new ZipArchive(memoryStream, ZipArchiveMode.Read);
 
            await Task.Run(() =>
            {
                ReadZip(zf);
            }).ConfigureAwait(false);
        }

        private void ReadZip(ZipArchive zf)
        {
            MemoryStream ms;
            Workbook wb = new Workbook
            {
                importInProgress = true // Disables checks during load
            };
            Dictionary<string, ZipArchiveEntry> entryLookup = new Dictionary<string, ZipArchiveEntry>(zf.Entries.Count, StringComparer.Ordinal);
            foreach (ZipArchiveEntry entry in zf.Entries)
            {
                entryLookup[entry.FullName] = entry;
            }
            HandleQueuePlugIns(PlugInUUID.ReaderPrependingQueue, entryLookup, ref wb);
 
            ISharedStringReader sharedStringsReader = PlugInLoader.GetPlugIn<ISharedStringReader>(PlugInUUID.SharedStringsReader, new SharedStringsReader());
            if (entryLookup.TryGetValue("xl/sharedStrings.xml", out ZipArchiveEntry sharedStringsEntry) && sharedStringsEntry.Length > 0)
            {
                if (PlugInLoader.HasQueuePlugins(PlugInUUID.SharedStringsInlineReader))
                {
                    // Inline plugins need a seekable stream; buffer so the handler can reset position
                    MemoryStream ssMs = GetEntryStream("xl/sharedStrings.xml", entryLookup);
                    sharedStringsReader.Init(ssMs, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                    sharedStringsReader.Execute();
                }
                else
                {
                    // Direct-stream from ZIP entry — no intermediate MemoryStream
                    using (Stream sharedStringsStream = sharedStringsEntry.Open())
                    {
                        sharedStringsReader.Init(sharedStringsStream, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                        sharedStringsReader.Execute();
                    }
                }
            }
            Dictionary<int, string> themeStreamNames = GetSequentialStreamNames("xl/theme/theme", entryLookup);
            if (themeStreamNames.Count > 0)
            {
                // There is not really a definition whether multiple themes can be managed in one workbook.
                // the suffix number (e.g. theme1) indicates it. However, no examples were found and therefore
                // (currently) only the first occurring theme will be read
                foreach (KeyValuePair<int, string> streamName in themeStreamNames)
                {
                    IPluginBaseReader themeReader = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.ThemeReader, new ThemeReader());
                    ms = GetEntryStream(streamName.Value, entryLookup);
                    themeReader.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                    themeReader.Execute();
                    break;
                }
            }
            StyleRepository.Instance.ImportInProgress = true; // TODO: To be checked
            IPluginBaseReader styleReader = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.StyleReader, new StyleReader());
            ms = GetEntryStream("xl/styles.xml", entryLookup);
            styleReader.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
            styleReader.Execute();
            StyleRepository.Instance.ImportInProgress = false;
 
            ms = GetEntryStream("xl/workbook.xml", entryLookup);
            IPluginBaseReader workbookReader = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.WorkbookReader, new WorkbookReader());
            workbookReader.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
            workbookReader.Execute();
 
            ms = GetEntryStream("docProps/app.xml", entryLookup);
            if (ms != null && ms.Length > 0) // If null/length == 0, no docProps/app.xml seems to be defined
            {
                IPluginBaseReader metadataAppReader = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.MetadataAppReader, new MetadataAppReader());
                metadataAppReader.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                metadataAppReader.Execute();
            }
            ms = GetEntryStream("docProps/core.xml", entryLookup);
            if (ms != null && ms.Length > 0) // If null/length == 0, no docProps/core.xml seems to be defined
            {
                IPluginBaseReader metadataCoreReader = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.MetadataCoreReader, new MetadataCoreReader());
                metadataCoreReader.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                metadataCoreReader.Execute();
            }
 
            IPluginBaseReader relationships = PlugInLoader.GetPlugIn<IPluginBaseReader>(PlugInUUID.RelationshipReader, new RelationshipReader());
            ms = GetEntryStream("xl/_rels/workbook.xml.rels", entryLookup);
            relationships.Init(ms, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
            relationships.Execute();
 
            IWorksheetReader worksheetReader = PlugInLoader.GetPlugIn<IWorksheetReader>(PlugInUUID.WorksheetReader, new WorksheetReader());
            worksheetReader.SharedStrings = sharedStringsReader.SharedStrings;
            List<Relationship> relationshipDefinitions = wb.AuxiliaryData.GetDataList<Relationship>(PlugInUUID.RelationshipReader, PlugInUUID.RelationshipEntity);
            int worksheetVisualIndex = 0;
            WorksheetDefinition definition;
            while ((definition = wb.AuxiliaryData.GetData<WorksheetDefinition>(PlugInUUID.WorkbookReader, PlugInUUID.WorksheetDefinitionEntity, worksheetVisualIndex)) != null)
            {
                Relationship relationship = relationshipDefinitions.SingleOrDefault(r => r.RID == definition.RelId);
                if (relationship == null)
                {
                    throw new IOException("There was an error while reading an XLSX file. The relationship target of the worksheet with the RelID " + definition.RelId + " was not found");
                }
                if (!entryLookup.TryGetValue(relationship.Target, out ZipArchiveEntry worksheetEntry))
                {
                    throw new IOException("There was an error while reading an XLSX file. The worksheet entry '" + relationship.Target + "' was not found in the archive");
                }
                worksheetReader.CurrentWorksheetID = worksheetVisualIndex;
                if (PlugInLoader.HasQueuePlugins(PlugInUUID.WorksheetInlineReader))
                {
                    // Inline plugins need a seekable stream; buffer so the handler can reset position
                    MemoryStream wsMs = GetEntryStream(relationship.Target, entryLookup);
                    worksheetReader.Init(wsMs, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                    worksheetReader.Execute();
                }
                else
                {
                    // Direct-stream from ZIP entry — largest single allocation on big files
                    using (Stream worksheetStream = worksheetEntry.Open())
                    {
                        worksheetReader.Init(worksheetStream, wb, readerOptions, ReaderPlugInHandler.HandleInlineQueuePlugins);
                        worksheetReader.Execute();
                    }
                }
                worksheetVisualIndex++;
            }
            if (wb.Worksheets.Count == 0)
            {
                throw new IOException("No worksheet was found in the workbook");
            }
            HandleQueuePlugIns(PlugInUUID.ReaderAppendingQueue, entryLookup, ref wb);
            wb.importInProgress = false; // Enables checks for runtime
            wb.AuxiliaryData.ClearTemporaryData(); // Remove temporary staging data
            this.Workbook = wb;
        }

        private static MemoryStream GetEntryStream(string name, Dictionary<string, ZipArchiveEntry> entryLookup)
        {
            if (!entryLookup.TryGetValue(name, out ZipArchiveEntry entry))
            {
                return null;
            }
            int capacity = (int)Math.Min(entry.Length, int.MaxValue);
            MemoryStream ms = new MemoryStream(capacity);
            using (Stream src = entry.Open())
            {
                src.CopyTo(ms);
            }
            ms.Position = 0;
            return ms;
        }

        private static Dictionary<int, string> GetSequentialStreamNames(string namePrefix, Dictionary<string, ZipArchiveEntry> entryLookup)
        {
            Dictionary<int, string> files = new Dictionary<int, string>();
            int index = 1; // Assumption: There is no file that has the index 0 in its name
            while (true)
            {
                string name = namePrefix + ParserUtils.ToString(index) + ".xml";
                if (entryLookup.ContainsKey(name))
                {
                    files.Add(index, name);
                }
                else
                {
                    break;
                }
                index++;
            }
            return files;
        }

        private void HandleQueuePlugIns(string queueUuid, Dictionary<string, ZipArchiveEntry> entryLookup, ref Workbook workbook)
        {
            string lastUuid = null;
            IPluginQueueReader queueReader;
            do
            {
                string currentUuid;
                queueReader = PlugInLoader.GetNextQueuePlugIn<IPluginQueueReader>(queueUuid, lastUuid, out currentUuid);
                MemoryStream ms = null;
                if (queueReader != null)
                {
                    if (queueReader is IPluginPackageReader)
                    {
                        string streamPartName = (queueReader as IPluginPackageReader).StreamEntryName;
                        if (!string.IsNullOrEmpty(streamPartName))
                        {
                            ms = GetEntryStream(streamPartName, entryLookup);
                            if (ms == null)
                            {
                                lastUuid = currentUuid;
                                continue; // Skip if the stream part name was defined but not found
                            }
                        }
                    }
                    queueReader.Init(ms, workbook, this.readerOptions, null); // stream may be null, inlinePluginAction is not used here
                    queueReader.Execute();
                    lastUuid = currentUuid;
                }
                else
                {
                    lastUuid = null;
                }
 
            } while (queueReader != null);
        }

        public void Dispose()
        {
            this.inputStream?.Dispose();
            GC.SuppressFinalize(this);
        }
 
 
        #endregion
    }
}