Een archiefintake weigert een spreadsheet met één enkele klacht: het rootelement van xl/workbook.xml staat in de namespace http://schemas.openxmlformats.org/spreadsheetml/2006/main. Excel opent exact hetzelfde bestand zonder mopperen. Beide uitkomsten zijn correct. ISO/IEC 29500 definieert Strict SpreadsheetML in deel 1 en houdt de transitionele vorm, met zijn legacy-compatibiliteitsfeatures, bij in deel 4, en de URI die de validator citeerde hoort bij Transitional. Een aanbesteding of bewaarbeleid dat ISO 29500 Strict noemt, verwacht in elk onderdeel van het pakket de purl.oclc.org-vocabulaire, en een bestand kan Excel tevreden stellen en die toets volledig niet doorstaan
Wat verandert er tussen Strict en Transitional?
Het zichtbare verschil is het vocabulaire. Een Strict-werkmaponderdeel declareert http://purl.oclc.org/ooxml/spreadsheetml/main als root-namespace en http://purl.oclc.org/ooxml/officeDocument/relationships voor r:id-verwijzingen. De DrawingML-, chart-, picture- en spreadsheet-drawing-namespaces verschuiven op dezelfde manier, en de documentproperty-onderdelen doen dat ook. Relationshiptypes veranderen mee: het root-relationshipsonderdeel wijst naar http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument, en de extended- en custom-propertytypes worden camelCased als extendedProperties en customProperties, waar Transitional ze met koppeltekens schrijft
Het minder zichtbare verschil is het bereik. Strict laat de delen van het transitionele schema weg die alleen bestonden om legacy binair gedrag te dragen, en het heeft voor de extensies die Office later toevoegde helemaal geen vocabulaire. Zoeken-en-vervangen over strings dicht die kloof niet, omdat sommige features simpelweg geen Strict-spelling hebben. Een pakket converteren betekent daarmee twee klussen: alles hernoemen dat een Strict-equivalent heeft, en beslissen wat je met alles wat dat niet heeft doet
Een Delphi-export omschakelen naar StrictOOXML
In HotXLS is de schakelaar één Boolean op TXLSXWorkbook, StrictOOXML, die standaard op False staat. Code die een werkmap opbouwt verandert niet. Je bouwt sheets, cellen en formules zoals altijd, stelt de property in en slaat op. SaveAs geeft 1 terug bij succes; al het andere betekent dat het pakket niet is weggeschreven, en de reden staat in Diagnostics
var
Wb: TXLSXWorkbook;
Sh: TXLSXWorksheet;
I: Integer;
begin
Wb := TXLSXWorkbook.Create;
try
Sh := Wb.Sheets.Add('Data');
Sh.Cells[1, 1].Value := 'Product';
Sh.Cells[1, 2].Value := 'Amount';
Sh.Cells[2, 1].Value := 'Widget';
Sh.Cells[2, 2].Value := 17;
Sh.Cells[3, 1].Value := 'Gadget';
Sh.Cells[3, 2].Value := 25;
Sh.Cells[4, 2].Formula := '=SUM(B2:B3)';
Wb.StrictOOXML := True; // ISO/IEC 29500 Strict-vocabulaire
if Wb.SaveAs('archive-copy.xlsx') <> 1 then
begin
for I := 0 to Wb.Diagnostics.Count - 1 do
WriteLn(Wb.Diagnostics[I].Message);
raise Exception.Create('Strict save was refused');
end;
finally
Wb.Free;
end;
end;
De property wordt aan het begin van elke opslagbewerking gelezen en stuurt een per-opslag-schakelaar aan waar de writers naar kijken, dus een opslag die halverwege mislukt kan de strikte vertaling niet aangezet laten voor de volgende. Op een server waar één werkmapobject meerdere exportverzoeken beantwoordt, kun je StrictOOXML tussen aanroepen door omzetten en krijgt elke opslag precies de vocabulaire die er is gevraagd
Twee grenzen zijn handig om vooraf te kennen. Strikte uitvoer geldt voor de Open XML-formaten: workbook, template en macro-enabled template. .xlsb vragen terwijl StrictOOXML op True staat wordt geweigerd met een diagnostic die je vraagt de property uit te zetten, want het binaire formaat heeft geen Strict-variant. En het openen van een bestand dat Excel als "Strict Open XML Spreadsheet" heeft opgeslagen zet de property niet voor je aan. Laad zo'n bestand en sla het op zonder StrictOOXML aan te raken, dan krijg je een transitioneel pakket terug
Waarom weigert een strikte opslag te draaien?
Een strikte opslag weigert te draaien zodra de werkmap content bevat die ISO 29500 Strict niet kan uitdrukken. De families die HotXLS controleert zijn VBA-projecten, formuliercontrols met hun ctrlProps-onderdelen, threaded comments (het moderne persons-and-threads-model, niet klassieke notities), slicers, metadata voor dynamische matrices, databalken die voor features als effen vulling, negatieve balkkleuren of een eigen as op het extensieblok van 2009 leunen, en Timelines zolang er geen conversiebeleid is gekozen
Weigeren is hier de juiste default. Het alternatief is het macroproject of de slicers laten vallen en het resultaat toch als Strict stempelen; daarmee geef je iemand een werkmap die netjes opent en zich anders gedraagt dan degene die werd geëxporteerd. Excel vlagt dat nooit. Een weigering benoemt de feature terwijl je code nog weet bij welk rapport het hoorde. De meeste weigeringen komen als SaveAs die -1 teruggeeft met een diagnostic als StrictOOXML: Strict output cannot embed VBA. De opslag van dynamische-matrixmetadata wordt beslist terwijl het pakket wordt weggeschreven, dus een formule die in deze sessie is toegekend kan de opslag nog stoppen met een uitzondering die de metadata noemt; wikkel een strikte SaveAs dus ook in try..except, naast het controleren van het resultaat. Heeft de werkmap zijn macro's nodig, dan hoort die thuis op het transitionele .xlsm-pad uit VBA-projecten en externe koppelingen behouden
Dat hoeft niet via een opslag te ontdekken. GetConversionReport inspecteert de werkmap zonder te herberekenen en geeft een TXLSConversionReport terug waarvan de items een featurenaam, een getrouwheidsniveau, een werkbladindex en een melding dragen. Onder StrictOOXML komen de blokkerende items terug als xlsConversionUnsupported. Het Timeline-geval laat ook de ene plek zien waar je bewust content inruilt tegen conformiteit: StrictTimelineOutputPolicy op xlsxStrictTimelineDateCriteria zetten zet ondersteunde Timeline-selecties om naar standaard draaitabel-datumcriteria en laat de Timeline-UI weg, samen met zijn cache-onderdelen, relationships en gedefinieerde namen. Het rapport vermeldt dat als xlsConversionDropped, en de bronwerkmap in het geheugen blijft ongewijzigd
function StrictBlockers(Wb: TXLSXWorkbook; Log: TStrings): Boolean;
var
Report: TXLSConversionReport;
I: Integer;
begin
Wb.StrictOOXML := True;
// De gedocumenteerde Timeline-ruil accepteren: datumcriteria blijven, Timeline-UI gaat weg
Wb.StrictTimelineOutputPolicy := xlsxStrictTimelineDateCriteria;
Report := Wb.GetConversionReport(xlsConversionOpenXmlWorkbook);
try
Result := False;
for I := 0 to Report.Count - 1 do
if Report[I].Fidelity in [xlsConversionUnsupported, xlsConversionDropped] then
begin
Log.Add(Format('%s (sheet %d): %s',
[Report[I].Feature, Report[I].SheetIndex, Report[I].Message]));
if Report[I].Fidelity = xlsConversionUnsupported then
Result := True;
end;
finally
Report.Free;
end;
end;
Draai dit vóór de export en log elke regel die het teruggeeft. Een werkbladindex van -1 markeert een item op werkmapniveau zoals het VBA-project; werkbladitems dragen het werkbladnummer vanaf 1 en de werkbladnaam, passend bij de manier waarop Sheets is geïndexeerd. Het rapport ziet dynamische-matrixmetadata die een geladen werkmap al bevat; voor formules die in code zijn toegekend vertrouw je op de scalaire herschrijving in de volgende sectie
De formule die stilletjes een dynamische matrix wordt
De weigering die mensen verrast, is dynamische-matrixmetadata in een werkmap die nooit FILTER of SEQUENCE gebruikte. Excel 365 evalueert een operator toegepast op een bereik over meerdere cellen als een matrix, ook binnen een reductiefunctie, dus =SUM(B2:B4*C2:C4) is in Excel's ogen een matrixformule. Wijs je die tekst toe aan Formula, dan slaat HotXLS de cel op zoals Excel dat zou doen: als dynamische matrix van één cel met een cm-verwijzing naar xl/metadata.xml; anders zou Excel bij het laden impliciete doorsnijding toepassen en #VALUE! tonen. De achtergrond staat in matrixoperatorformules en impliciete doorsnijding. Strict heeft geen vocabulaire voor dat metadata-onderdeel, dus de opslag stopt
// Matrixopslag: het product van twee bereiken wordt als matrix geëvalueerd
Sh.Cells[5, 2].Formula := '=SUM(B2:B4*C2:C4)'; // blokkeert een strikte opslag
// Scalaire opslag: gewone bereikargumenten, zelfde totaal
Sh.Cells[5, 2].Formula := '=SUMPRODUCT(B2:B4,C2:C4)';
Voor Strict-exports schrijf je de scalaire vorm. SUMPRODUCT met gewone bereikargumenten geeft hetzelfde totaal, vereist geen dynamische-matrixondersteuning in wat het bestand later ook leest, en houdt de cel helemaal buiten het metadata-onderdeel. Dezelfde herschrijving werkt voor voorwaardelijke tellingen: SUMPRODUCT((A2:A4="x")*1) vermenigvuldigt nog steeds matrices, dus kies daar liever COUNTIF(A2:A4,"x"). Wil een rapport echt spill-resultaten tonen, dan heeft het transitionele uitvoer nodig
Behouden onderdelen worden herbouwd in plaats van gekopieerd
De werkblad-XML is het makkelijke deel van strikte uitvoer. Het moeilijke deel is alles wat een snelle writer liever letterlijk kopieert. Als HotXLS een bestaand pakket opent, houdt het het originele thema, connections, externe koppelingen, grafieken en draaitabelonderdelen vast, en bij een transitionele opslag kopieert het hun gecomprimeerde bytes rechtstreeks door zolang het model niet is veranderd. Dat is de juiste zet voor getrouwheid en de verkeerde voor Strict, want die bytes dragen nog steeds transitionele namespaces
Met StrictOOXML aan wordt het byte-kopieerpad voor al die onderdelen omzeild. Connections, externe koppelingen en grafieken worden vanuit het model herbouwd; het thema en de vastgelegde draaitabel-, cachedefinitie- en cacherecords-XML worden opnieuw afgespeeld via de namespacevertaler. Die vertaler parseert elke starttag en herschrijft maar twee dingen: namespace-declaraties, en het Type-attribuut van Relationship-elementen in .rels-onderdelen. Celtekst, andere attribuutwaarden, comments en CDATA-secties gaan byte voor byte door, dus een gedeelde tekenreeks die toevallig http://schemas.openxmlformats.org/... bevat wordt nooit aangeraakt. Namespace-URI's buiten schemas.openxmlformats.org, zoals de Microsoft-extensie-namespaces binnen extLst-blokken, blijven zoals ze zijn; wijst je validator ook extensiecontent af naast transitionele namespaces, haal die features dan uit de bronwerkmap vóór de export
Gestreamde werkbladen volgen dezelfde regel met één draai. De writer bouwt eerst het werkbladskelet, vertaalt het, en splitst het pas daarna op <sheetData> om de rijen daartussen te streamen. Rijblokken bevatten geen vocabulaire-URI's, dus grote sheets betalen niets extra voor strikte uitvoer. Gedeelde tekenreeksen en draaitabelcacherecords werken hetzelfde: alleen het headerelement wordt vertaald. Meer over de behoudkant staat in verliesvrije round-trips van thema's, extensielijsten en calcChain
Strict-bestanden lezen en controleren wat je schreef
Bestanden die Excel als Strict opsloeg openen als elke andere werkmap. HotXLS mapt Strict-relationshiptypes op hun transitionele tegenhangers waar ook een relationshipsonderdeel wordt geparseerd: bij de pakketwortel, werkbladen, drawings, externe koppelingen en draaitabellen, en de lezer herkent elementnamen via de namespace-URI in plaats van via het prefix. Generators van derden binden prefixes vrij, dus dezelfde mechaniek dient ook gewone bestanden; ze staat beschreven in OPC-relationshipresolutie in XLSX-pakketten. Bij een transitionele opslag van zo'n bestand wordt elk behouden XML-onderdeel waarvan de root nog een Strict-namespace gebruikt op de uitweg weer teruggezet, zodat het resultaat niet half het ene en half het andere vocabulaire wordt
Verifieer strikte uitvoer tegen het pakket, nooit tegen Excel, dat beide vormen problemloos opent. Unzip het resultaat en controleer drie dingen: xl/workbook.xml declareert http://purl.oclc.org/ooxml/spreadsheetml/main, geen enkel onderdeel bevat de string schemas.openxmlformats.org/spreadsheetml, en de Type-waarden in _rels/.rels en xl/_rels/workbook.xml.rels beginnen met http://purl.oclc.org/ooxml/. Een korte findstr /s /m "schemas.openxmlformats.org/spreadsheetml" *.xml over de uitgepakte map hoort niets op te leveren
Open het bestand daarna opnieuw via TXLSXWorkbook.Open en vergelijk waarden, formules, getalnotaties en hyperlinks met de bronwerkmap. Die teruglezing test tegelijk de lezerskant van de mapping. Bevat de werkmap grafieken of draaitabellen, neem ze dan op in de vergelijking, want beide wisselen onder StrictOOXML van byte-kopie naar een herbouwd of opnieuw afgespeeld pad
Strikte uitvoer, Strict-bewust lezen en verliesvrije round-trips van transitionele pakketten delen één OOXML-engine in HotXLS for Delphi and C++Builder; de HotXLS Delphi spreadsheet component-pagina zet de formaten en features op een rij die de engine dekt