SharedStringsReader.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.Text;
using System.Xml;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Registry.Attributes;
using NanoXLSX.Utils;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Readers
{
    [NanoXlsxPlugIn(PlugInUUID = PlugInUUID.SharedStringsReader)]
    public class SharedStringsReader : ISharedStringReader
    {
 
        #region privateFields
        private bool capturePhoneticCharacters;
        private readonly List<PhoneticInfo> phoneticsInfo;
        private MemoryStream stream;
        #endregion
 
        #region properties

        public List<string> SharedStrings { get; private set; }

        public Workbook Workbook { get ; set; }
        public IOptions Options { get; set; }
        public Action<MemoryStream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }
        #endregion
 
        #region constructors
        public SharedStringsReader()
        {
            phoneticsInfo = new List<PhoneticInfo>();
            SharedStrings = new List<string>();
        }
        #endregion
 
        #region methods
        public void Init(MemoryStream stream, Workbook workbook, IOptions readerOptions, Action<MemoryStream, Workbook, string, IOptions, int?> inlinePluginHandler)
        {
            this.stream = stream;
            this.Workbook = workbook;
            this.Options = readerOptions;
            this.InlinePluginHandler = inlinePluginHandler;
            if (readerOptions is ReaderOptions options)
            {
                this.capturePhoneticCharacters = options.EnforcePhoneticCharacterImport;
            }
        }

        public void Execute()
        {
            try
            {
                using (stream) // Close after processing
                {
                    XmlDocument xr = new XmlDocument
                    {
                        XmlResolver = null
                    };
                    using (XmlReader reader = XmlReader.Create(stream, new XmlReaderSettings() { XmlResolver = null }))
                    {
                        xr.Load(reader);
                        StringBuilder sb = new StringBuilder();
                        foreach (XmlNode node in xr.DocumentElement.ChildNodes)
                        {
                            if (node.LocalName.Equals("si", StringComparison.OrdinalIgnoreCase))
                            {
                                sb.Clear();
                                GetTextToken(node, ref sb);
                                if (capturePhoneticCharacters)
                                {
                                    SharedStrings.Add(ProcessPhoneticCharacters(sb));
                                }
                                else
                                {
                                    SharedStrings.Add(sb.ToString());
                                }
                            }
                        }
                        InlinePluginHandler?.Invoke(stream, Workbook, PlugInUUID.SharedStringsInlineReader, Options, null);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new IOException("The XML entry could not be read from the " + nameof(stream) + ". Please see the inner exception:", ex);
            }
        }

        private void GetTextToken(XmlNode node, ref StringBuilder sb)
        {
            if (node.LocalName.Equals("rPh", StringComparison.OrdinalIgnoreCase))
            {
                if (capturePhoneticCharacters && !string.IsNullOrEmpty(node.InnerText))
                {
                    string start = node.Attributes.GetNamedItem("sb").InnerText;
                    string end = node.Attributes.GetNamedItem("eb").InnerText;
                    phoneticsInfo.Add(new PhoneticInfo(node.InnerText, start, end));
                }
                return;
            }
 
            if (node.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(node.InnerText))
            {
                sb.Append(node.InnerText);
            }
            if (node.HasChildNodes)
            {
                foreach (XmlNode childNode in node.ChildNodes)
                {
                    GetTextToken(childNode, ref sb);
                }
            }
        }

        private string ProcessPhoneticCharacters(StringBuilder sb)
        {
            if (phoneticsInfo.Count == 0)
            {
                return sb.ToString();
            }
            string text = sb.ToString();
            StringBuilder sb2 = new StringBuilder();
            int currentTextIndex = 0;
            foreach (PhoneticInfo info in phoneticsInfo)
            {
                sb2.Append(text.Substring(currentTextIndex, info.StartIndex + info.Length - currentTextIndex));
                sb2.Append('(').Append(info.Value).Append(')');
                currentTextIndex = info.StartIndex + info.Length;
            }
            sb2.Append(text.Substring(currentTextIndex));
 
            phoneticsInfo.Clear();
            return sb2.ToString();
        }
 
 
        #endregion
 
        #region sub-classes
        sealed class PhoneticInfo
        {
            public string Value { get; private set; }
            public int StartIndex { get; private set; }
            public int Length { get; private set; }

            public PhoneticInfo(string value, string start, string end)
            {
                Value = value;
                StartIndex = ParserUtils.ParseInt(start);
                Length = ParserUtils.ParseInt(end) - StartIndex;
 
            }
        }
        #endregion
    }
}