Alleen-metagegevens en selectief XLSX-laden met HotXLS

HotXLS kan een XLSX-werkmap openen en helemaal geen werkblad-cel parsen. TXLSXWorkbook.MetadataOnly leest werkboomeigenschappen, gedefinieerde namen, werkbladnamen en zichtbaarheidsstaten, stijlen, thema, verbindingen en externe links, en stopt dan vóór de cel-XML. Voor een scanner die moet weten wat er in een map met werkmappen zit, is dat het verschil tussen minuten en seconden

Drie gerelateerde schakelaars maken het plaatje compleet: SelectedSheets parst cellen voor een benoemde subset, LoadSheet materialiseert een overgeslagen werkblad later vanuit het oorspronkelijke archief, en PreserveRawParts kopieert de gecomprimeerde bytes van ongewijzigde parts rechtstreeks door bij opslaan. Samen gebruikt veranderen ze "een werkmap openen" van één alles-of-niets-operatie in iets wat je kunt scoppen

Wat kun je leren zonder één cel te parsen?

Meer dan de meeste discovery-taken nodig hebben. Met MetadataOnly ingesteld vóór Open, komt de werkmap terug met zijn werkbladnamen en zichtbaarheidsstaten, zijn gedefinieerde namen, zijn documenteigenschappen, zijn stijlen en thema, zijn externe links en zijn verbindingen. De werkbladen zijn aanwezig als objecten met nul cellen

Dat is precies de informatie waarop een catalogus, een audit of een routeringsbeslissing draait. Welke werkmappen definiëren een naam genaamd TaxRate? Welke hebben verborgen werkbladen? Welke linken naar een server die is uitgefaseerd? Dat beantwoorden door elk bestand volledig te laden is hoe een nachtelijke taak een hele-nacht-taak wordt

var
  Workbook: TXLSXWorkbook;
  I: Integer;
begin
  Workbook := TXLSXWorkbook.Create(nil);
  try
    Workbook.MetadataOnly := True;      // set before Open
    Workbook.Open(FileName);
    for I := 1 to Workbook.Sheets.Count do      // Sheets[] is 1-based
      if not Workbook.Sheets[I].Visible then
        Report.Add(FileName + ': hidden sheet ' +
          Workbook.Sheets[I].Name);
  finally
    Workbook.Free;
  end;
end;

Twee werkbladen laden van de veertig

SelectedSheets is een TStringList van werkbladnamen. Wanneer die niet-leeg is, parst Open cel-XML alleen voor de werkbladen die hij noemt; elk ander werkblad behoudt zijn juiste naam en zichtbaarheidsstaat en bevat geen cellen. Een lege lijst betekent het vorige gedrag, namelijk alles laden

De interactie met MetadataOnly is de moeite waard om ronduit te stellen, want het omdraaien produceert een verwarrend lege werkmap: MetadataOnly = True overschrijft de selectie en slaat alle werkbladen over. Gebruik de een of de ander. Discovery gebruikt alleen-metagegevens; gericht werk gebruikt een selectie

Workbook.SelectedSheets.Add('Summary');
Workbook.SelectedSheets.Add('Q3 Detail');
Workbook.Open('consolidated-2026.xlsx');
// Later, when the user opens a tab you skipped.
// LoadSheet takes the 0-based position and needs the source file,
// so it does not work on a workbook opened from a stream
if Workbook.LoadSheet(ZeroBasedPosition) then
  Grid.Refresh;

LoadSheet(Index) materialiseert een overgeslagen werkblad op aanvraag vanuit het oorspronkelijke archief, wat dit patroon bruikbaar maakt in een interactieve applicatie in plaats van alleen in een batch. Open met het werkblad waar de gebruiker naar kijkt, laad de anderen wanneer hij klikt. Het archief blijft om precies die reden open, dus houd de werkmap levend zolang de gebruiker om een ander werkblad zou kunnen vragen

Waarom verandert een round-trip parts die je nooit hebt aangeraakt?

Omdat een naïeve opslaan alles regenereert. Decomprimeer het thema, bouw een objectmodel, serialiseer het terug, hercomprimeer — en nu verschillen de bytes hoewel er niets aan het thema is veranderd. Voor VBA-projecten en pivot-caches is dat erger dan verspillend, want die parts dragen structuur die het objectmodel niet volledig vertegenwoordigt

PreserveRawParts antwoordt hierop door de gecomprimeerde representatie van ongewijzigde parts tijdens SaveAs rechtstreeks vanuit het bronarchief te kopiëren. Thema, VBA-project, pivottabellen en pivot-caches gaan als bytes over wanneer ze niet zijn gewijzigd. Geen decompressie, geen hercompressie, geen risico om iets te verliezen in een serialisatie-round-trip

De prijs is een beperking die je al had: het bronarchief moet nog beschikbaar zijn op het moment van opslaan. Als je workflow een bestand in geheugen leest, het sluit en een uur later opslaat, heeft het raw-copy-pad niets om van te kopiëren. Houd de bron bereikbaar voor de levensduur van de werkmap, wat dezelfde vereiste is die LoadSheet oplegt

Een discovery-pijplijn die met opzet heropent

Het patroon dat in productie werkt heeft twee passes en geen slimheid. Pass één opent alleen-metagegevens en beslist. Pass twee heropent de bestanden die er toe doen met een werkbladselectie en doet het werk. Heropenen voelt verspillend tot je telt wat pass één vermeed: de tweede open is de enige die cellen parst, en het parst alleen de werkbladen die pass één selecteerde

// Pass 1: discovery
Workbook.MetadataOnly := True;
Workbook.Open(FileName);
Wanted := SheetsMatching(Workbook, 'Invoice');
Workbook.Free;

// Pass 2: targeted load
Workbook := TXLSXWorkbook.Create(nil);
Workbook.SelectedSheets.AddStrings(Wanted);
Workbook.Open(FileName);

Probeer niet een alleen-metagegevens-werkmap in-place te promoten door de flag na Open te wissen. De flag wordt gelezen tijdens het openen; hem daarna wissen verandert niets aan een werkmap waarvan de cel-XML nooit is bezocht

Waar dit past bij de andere hefbomen voor grote bestanden

Selectief laden vermindert wat je parst. Het vermindert niet wat een werkblad kost eens geladen, en het helpt niet wanneer je werkelijk elke cel van elk werkblad nodig hebt. Voor dat geval ligt het relevante werk aan de opslagkant, beschreven in de notities over rijblok-celopslag en interval-stijloverlays, en aan de parseerkant in parallel XLSX-parsen en de geheugenallocator. Wanneer de taak een pure scan is zonder enige bewerking, slaat de streaming direct reader het objectmodel helemaal over en zal het elke laadstrategie verslaan die er een bouwt

HotXLS opent XLS- en XLSX-bestanden vanuit native Delphi en C++Builder-code zonder Excel-afhankelijkheid, zodat een server-side discovery-taak draait met niets geïnstalleerd dan je eigen executable — zie de HotXLS-spreadsheetcomponentpagina voor de ondersteunde formaten en licentiëring