Een werkmap die om 09:30 op een buildmachine in Shanghai is gegenereerd, opent in Excel en Bestand > Info meldt dat hij om 17:30 is aangemaakt. De unittest die het bestand produceerde slaagde: hij wees 09:30 toe, sloeg op, heropende en las 09:30 rechtstreeks terug. Beide uitlezingen komen uit dezelfde bytes. Het bestand bevat 09:30 gemarkeerd als UTC, Excel eert die markering en telt er acht uur bij op, en de test heeft naar de markering helemaal niet gekeken. Documenttijdstempels in Excel-bestanden zijn op schijf UTC, de waarde waarmee een programma werkt is lokale tijd, en elke conversie tussen beide moet de zomertijdregels van de eigen datum van de stempel gebruiken
De fout van één dag die een round trip niet ziet
In een .xls-bestand zijn de aanmaak- en opslagtijden FILETIME-waarden: een 64-bits telling van tikken van 100 nanoseconden sinds 1601-01-01 UTC ([MS-DTYP] §2.3.3). Een Delphi-TDateTime telt dagen vanaf 1899-12-30, dezelfde serial-oorsprong die wordt behandeld in Excel-datumserials in Delphi en de systemen 1900 versus 1904. Omzetten tussen beide vergt één constante, het aantal dagen tussen de twee tijdperken, en dat getal is 109205. Er is een snelle manier om dat te controleren zonder kalender. Het Unix-tijdperk is 25569 als TDateTime en 134774 dagen na het FILETIME-tijdperk, en 25569 + 109205 = 134774
Tel de dagen met de hand en tel beide einddata mee, dan komt u op 109206. Een schrijver en lezer die op die constante zijn gebouwd zijn het perfect met elkaar eens. Elke aanmaak- en opslagstempel gaat één dag te laat het bestand in en komt één dag te vroeg weer uit, dus een opslag-en-heropen-test ziet exact de waarde die hij toewees, terwijl Excel, of elke lezer die het juiste tijdperk gebruikt, morgen toont
const
// dagen van het FILETIME-tijdperk (1601-01-01) naar het TDateTime-tijdperk (1899-12-30)
// controle: 25569 + 109205 = 134774, het Unix-tijdperk in FILETIME-dagen
FileTimeDayBias = 109205;
function UtcDateTimeToFileTimeTicks(UtcStamp: TDateTime): Int64;
begin
// Rond eerst af op hele milliseconden, schaal dan naar tikken van 100 ns.
// De Double rechtstreeks naar tikken schalen maakt van 04:00 03:59:59.9999
Result := Round((UtcStamp + FileTimeDayBias) * 86400000.0) * 10000;
end;
Het afrondcommentaar in die schets telt ook mee. Een TDateTime-fractie is een binaire Double, en haar rechtstreeks met 864.000.000.000 tikken per dag vermenigvuldigen duwt de representatiefout naar de lage cijfers, dus een stempel van exact 04:00 wordt teruggelezen als 03:59:59.9999 en getoond als 03:59. HotXLS rond eerst af op hele milliseconden en schaalt pas daarna naar tikken. Waarden op hele uren overleven. De schets neemt met opzet een UTC-invoer; de tijdzonstap komt later en is de moeilijkere helft
Welke SummaryInformation-property-ids bevatten de datums?
De propertyset \005SummaryInformation gedefinieerd door [MS-OLEPS] bewaart de aanmaaktijd onder property-id $0C (PIDSI_CREATE_DTM), de laatst-opgeslagen-tijd onder $0D (PIDSI_LASTSAVE_DTM) en de totale bewerkingstijd onder $0A (PIDSI_EDITTIME). De id direct na de opslagstempel, $0E, is PIDSI_PAGECOUNT. Zet daar een opslagtijd neer en Excel heeft geen opslagdatum meer om te tonen, plus een property voor paginatelling met daarin een FILETIME. HotXLS schrijft de opslagstempel onder $0D, en wanneer hij een bestand leest waarin $0D ontbreekt maar $0E een VT_FILETIME draagt, neemt hij die waarde als de laatst-opgeslagen-tijd. Een string of een ander type dat in een misvormd bestand onder een van deze ids staat, wordt overgeslagen in plaats van verkeerd als datum gelezen. Voor een blik op de rauwe streams zelf, zie OLE2-compound-bestanden in Delphi lezen zonder COM IStorage
PIDSI_EDITTIME is de vreemde eend. Hij is getypeerd als VT_FILETIME maar bevat een duur: de rauwe telling van verstreken tikken van 100 ns, zonder toegevoegd tijdperk. Behandel hem als de andere twee, converteer EditTimeMinutes / 1440 door de tijdperkwiskunde, en 125 minuten bewerken verandert in een waarde van circa 299 jaar lang. HotXLS schrijft de rauwe tiktelling (minuten × 600.000.000). Op Windows vangt de lezer de datumvormige codering ook op grootte, want geen enkele echte bewerkingssessie overspant drie eeuwen: elke bewerkingstijd van 109206 dagen of meer krijgt die offset afgetrokken voordat EditTimeMinutes wordt gevuld
.xls-tijdstempels zetten met TXLSWorkbook
TXLSWorkbook.CreatedDate en TXLSWorkbook.LastSavedDate nemen lokale TDateTime-waarden aan, en HotXLS zet ze bij het opslaan van de werkmap om naar UTC-FILETIMEs. RevisionNumber en EditTimeMinutes zitten in dezelfde stream. Een nulwaarde betekent "sla deze property over", en zo verwijdert u ook alle vier: maak ze leeg en de volgende opslag schrijft er geen. HotXLS stempelt niet zelf Now in LastSavedDate. Wat u toewijst komt in het bestand, en dat is de juiste standaard voor een bibliotheek. Een batchjob die de rapporten van vorig jaar opnieuw genereert, wil meestal de datums van vorig jaar, en een automatische stempel zou die stilletjes overschrijven
var
Book: TXLSWorkbook;
begin
Book := TXLSWorkbook.Create;
try
Book.Title := 'Q3 settlement';
// API-waarden zijn lokale tijd; het bestand bewaart UTC-FILETIMEs
Book.CreatedDate := EncodeDate(2026, 1, 15) + EncodeTime(9, 30, 0, 0);
Book.LastSavedDate := Now; // weggeschreven zoals toegewezen, nooit automatisch gestempeld
Book.RevisionNumber := 7;
Book.EditTimeMinutes := 125; // een duur, bewaard als rauwe tikken
if Book.SaveAs('settlement.xls') <> 1 then
raise Exception.Create('Save failed');
finally
Book.Free;
end;
end;
Het openen van een bestand vult dezelfde vier properties weer in, omgerekend naar de lokale tijd van de machine die leest. Een dienst die op UTC draait en een desktop in Tokio melden voor dezelfde werkmap verschillende CreatedDate-waarden, negen uur uit elkaar, en beide zijn correct. Moeten twee systemen stempels vergelijken, reken dan aan uw kant naar UTC vóór de vergelijking, of bewaar de UTC-waarde erbij
Waarom zitten XLSX-datums er precies de tijdzone-offset naast?
XLSX-datums komen de tijdzone-offset ernaast uit wanneer een schrijver lokale tijd stempelt en die UTC noemt. In docProps/core.xml zijn dcterms:created en dcterms:modified W3CDTF-waarden onder het core-properties-model van ECMA-376 Part 2, en de gebruikelijke vorm eindigt op Z. Now formatteren en er een Z achter plakken is de voor de hand liggende one-liner. Op een UTC+8-machine maakt die van 09:30 09:30:00Z, en Excel op diezelfde machine toont 17:30 — precies het openingsvoorbeeld. Aangepaste datumproperties die als vt:filetime zijn opgeslagen volgen dezelfde regel, net als de binaire FILETIMEs in .xls. HotXLS converteert op alle drie de paden vóór het schrijven: TXLSXWorkbook.Created, TXLSXWorkbook.Modified en datums die via CustomProperties.AddDate worden toegevoegd zijn aan de API-kant lokaal en in het bestand UTC met een Z
Welke Windows-functie de conversie doet, blijkt belangrijker dan mensen verwachten. LocalFileTimeToFileTime past de offset toe die nu geldt. Converteert u een januaristempel in juli, in welke zone met zomertijd dan ook, dan landt hij een uur ernaast. HotXLS gebruikt TzSpecificLocalTimeToSystemTime bij het schrijven en SystemTimeToTzSpecificLocalTime bij het lezen, en beide kiezen standaard- of zomertijd op basis van de datum die wordt geconverteerd, niet van vandaag. Een niet-ingestelde waarde van nul gaat in beide richtingen onaangeroerd door, dus een lege property wordt nooit een datum van 30 december 1899 verschoven met een paar uur
var
Book: TXLSXWorkbook;
begin
Book := TXLSXWorkbook.Create;
try
if Book.Open('report-template.xlsx') <> 1 then
raise Exception.Create('Template not available');
Book.Created := EncodeDate(2026, 7, 1) + EncodeTime(9, 30, 0, 0);
Book.Modified := Now;
Book.CustomProperties.AddDate('ApprovedOn',
EncodeDate(2026, 1, 20) + EncodeTime(17, 0, 0, 0));
if Book.SaveAs('report.xlsx') <> 1 then
raise Exception.Create('Save failed');
// Op een machine die op Central European Time staat, bevat core.xml nu
// <dcterms:created xsi:type="dcterms:W3CDTF">2026-07-01T07:30:00Z</dcterms:created>
// (UTC+2 in juli), terwijl ApprovedOn als 16:00Z wordt weggeschreven (UTC+1 in januari)
finally
Book.Free;
end;
end;
Buiten Windows verloopt dezelfde conversie via de tijdzoneondersteuning van de RTL. In Delphi is dat TTimeZone.Local, en de twee ongemakkelijke uren van het jaar krijgen daar een vast antwoord: een lokale tijd binnen het vooruit-sprongsgat bestaat niet en wordt ongewijzigd weggeschreven, en een herfstuur dat twee keer voorkomt geldt als de standaardtijd-voorkoming
W3CDTF-stempels van andere generatoren lezen
Excel schrijft Z, andere generatoren doen dat niet altijd, en een lezer die alleen op Z op positie 20 controleert, krijgt twee veelvoorkomende vormen verkeerd. 2026-07-01T01:30:00.5Z heeft een fractie in de weg, en 2026-07-01T09:30:00+08:00 heeft een expliciete offset. Een naïeve parser leest beide als lokale tijd zonder aanpassing. De HotXLS-lezer voor Created, Modified en datumwaardige aangepaste properties accepteert breukseconden van elke lengte, Z, en +hh:mm / -hh:mm-offsets; hij converteert het moment van de opgegeven offset naar UTC en daarna naar lokale tijd. Een stempel met alleen een datum, zoals 2026-07-01, wordt gelezen als die datum om middernacht, en een stempel die helemaal niet parseert komt als nul terug
Het ene geval dat de specificaties openlaten is een tijd zonder enige zonemarker, zoals 2026-07-01T09:30:00. Het W3CDTF-profiel vereist een zoneaanduiding zodra er een tijd staat, en ECMA-376 Part 2 geeft geen regel voor een stempel die haar weglaat. HotXLS leest zo'n waarde als lokale tijd, ongewijzigd. Haar als UTC behandelen zou op papier even goed verdedigbaar zijn geweest, maar de meest waarschijnlijke bron van een stempel zonder zone is een tool die lokale tijd heeft weggeschreven en de markering heeft weggelaten, en die waarden verschuiven zou elke tijdstempel van die tool met de tijdzone-offset verplaatsen
Geen enkele lezer kan de omgekeerde fout redden. Een stempel die als lokale tijd is geschreven en een Z draagt, ziet er exact goed uit, dus HotXLS, Excel en elke andere lezer die het formaat volgt verschuiven haar met de tijdzone-offset. Alleen de bewerkingstijd-codering en de $0E-plaatsing in .xls hebben een handtekening die een lezer kan opmerken
Testen tegen bytes die uw eigen code niet heeft geschreven
Elke valkuil hierboven doorstaat een opslag-daarna-heropen-controle, want een symmetrische fout is onzichtbaar voor een symmetrische test. De referentie moet ergens anders vandaan komen. Pak voor .xlsx het opgeslagen bestand uit en toets de letterlijke tekst van dcterms:created; voor .xls leest het Python-pakket olefile de SummaryInformation-stream onafhankelijk met get_metadata(), meldt de bewerkingstijd in seconden en ziet $0E als paginatelling, waardoor beide .xls-valkuilen tegelijk zichtbaar worden. De andere richting is een werkmap die Excel zelf heeft opgeslagen, uitgelezen via de API en vergeleken met wat Bestand > Info toont
uses
System.SysUtils, System.DateUtils;
procedure CheckExcelReference;
var
Book: TXLSXWorkbook;
Expected: TDateTime;
begin
// De waarde die Bestand > Info van Excel voor dit bestand op de testmachine toont
Expected := EncodeDate(2026, 1, 20) + EncodeTime(17, 0, 0, 0);
Book := TXLSXWorkbook.Create;
try
if Book.Open('excel-saved-reference.xlsx') <> 1 then
raise Exception.Create('Reference file missing');
// Eigen controle, geen HotXLS-API: sta één seconde toe voor afronding
if Abs(Book.Created - Expected) > OneSecond then
raise Exception.CreateFmt('Created reads as %s',
[DateTimeToStr(Book.Created)]);
finally
Book.Free;
end;
end;
Draai die suite op een machine die op een zone ver van UTC is ingesteld, met één testdatum aan elke kant van een zomertijdovergang. Een buildagent die op UTC blijft staan verbergt de tijdzone-offsetfout volledig, en één zomerse testdatum verbergt die van LocalFileTimeToFileTime; 20 januari en 1 juli in Central European Time vangen beide
Archiefsystemen, zoekindexen en audittrajecten sorteren op deze stempels, en een datum die een dag of acht ernaast zit richt meer schade aan dan een ontbrekende, omdat niemand haar in twijfel trekt. Met de HotXLS Delphi-spreadsheetcomponent zijn de tijdperkconstante, de property-ids en de zomertijd-bewuste UTC-conversie voor zowel .xls als .xlsx afgehandeld, dus applicatiecode wijst gewone lokale TDateTime-waarden toe en leest ze. Voor de rest van de propertyset, van titel en auteur tot aangepaste properties, behandelt het zusterstuk over Excel-documentproperties zetten in Delphi de overige velden