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 NanoXLSX.Utils.Xml;
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 Stream stream;
        #endregion
 
        #region properties

        public virtual string DocumentType { get { return @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings"; } }

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

        public Workbook Workbook { get; set; }
        public IOptions Options { get; set; }
        public Action<Stream, 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(Stream stream, Workbook workbook, IOptions readerOptions, Action<Stream, 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
                {
                    StringBuilder sb = new StringBuilder();
                    using (XmlReader reader = XmlReader.Create(stream, XmlStreamUtils.CreateSettings()))
                    {
                        while (reader.Read())
                        {
                            if (!XmlStreamUtils.IsElement(reader, "si"))
                            {
                                continue;
                            }
                            sb.Clear();
                            ReadSiElement(reader, 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 ReadSiElement(XmlReader reader, StringBuilder sb)
        {
            using (XmlReader siSubtree = reader.ReadSubtree())
            {
                siSubtree.Read(); // consume the <si> open tag
                while (siSubtree.Read())
                {
                    if (siSubtree.NodeType != XmlNodeType.Element)
                    {
                        continue;
                    }
                    if (siSubtree.LocalName.Equals("rPh", StringComparison.OrdinalIgnoreCase))
                    {
                        if (capturePhoneticCharacters)
                        {
                            ReadPhoneticElement(siSubtree);
                        }
                        else
                        {
                            using (siSubtree.ReadSubtree()) { } // dispose immediately; positions siSubtree at </rPh>
                        }
                    }
                    else if (siSubtree.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase))
                    {
                        string text;
                        using (XmlReader tSubtree = siSubtree.ReadSubtree())
                        {
                            tSubtree.Read(); // position at <t>
                            text = tSubtree.ReadElementContentAsString();
                        }
                        if (!string.IsNullOrEmpty(text))
                        {
                            sb.Append(text);
                        }
                    }
                }
            }
        }

        private void ReadPhoneticElement(XmlReader reader)
        {
            string start = reader.GetAttribute("sb");
            string end = reader.GetAttribute("eb");
            string text = null;
            using (XmlReader rPhSubtree = reader.ReadSubtree())
            {
                rPhSubtree.Read(); // consume the <rPh> open tag
                while (rPhSubtree.Read())
                {
                    if (rPhSubtree.NodeType == XmlNodeType.Element
                        && rPhSubtree.LocalName.Equals("t", StringComparison.OrdinalIgnoreCase))
                    {
                        text = rPhSubtree.ReadElementContentAsString();
                    }
                }
            }
            if (!string.IsNullOrEmpty(text))
            {
                phoneticsInfo.Add(new PhoneticInfo(text, start, end));
            }
        }

        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
    }
}