Comment utiliser IronXL avec Claude Code

Curtis Chau
Curtis Chau
Mis à jour : 15 octobre 2026

Un export de grand livre avec un million de lignes de journal s'ouvre dans Excel sans problème, puis bloque le travail d'importation qui doit le lire. Sur notre machine de test, WorkBook.Load avait besoin d'environ 26 secondes et 3 Go de mémoire pour lire un classeur de 60 Mo de cette taille, et le conteneur dans notre scénario de test limite le tas .NET à 512 Mo. Anthropic expédie Claude Code pour le terminal, pour VS Code et les IDE JetBrains, pour le bureau et pour le web. À chacun de ces endroits, l'agent peut lire un dépôt, modifier des fichiers et exécuter des commandes.

IronXL a un deuxième moyen d'accéder à un fichier XLSX. Ce lecteur ne peut pas gérer plusieurs entrées, allant des formules jamais calculées aux fichiers .xls, et un agent non informé de leur existence peut se rabattre sur WorkBook.Load ou sur une surcharge qui tamponne discrètement l'ensemble du fichier. Ce guide donne à Claude Code quatre invites testées. Sonnet gère les tâches courtes, Opus conçoit le benchmark en mode plan et un sous-agent en lecture seule révise le résultat.

Trois des quatre invites commencent par une ligne /model, et le modèle sélectionné reste actif jusqu'à ce que vous en choisissiez un autre. La page de configuration du modèle d'Anthropic décrit l'alias sonnet comme le choix pour les tâches de codage quotidiennes et opus comme le choix pour le raisonnement complexe.

Démarrage rapide
NuGetInstaller avec NuGet

PM > Install-Package IronXL.Excel

Installez IronXL en exécutant la commande ci-dessus dans la console du gestionnaire de packages NuGet, ou recherchez le package dans le gestionnaire de packages NuGet.

Ouvrez un terminal dans le dépôt et commencez claude. Envoyez la ligne /model comme son propre message, puis envoyez le reste du bloc comme la requête. Taper @ avant un chemin joint ce fichier, de sorte que les notes de colonne atteignent l'agent avant qu'il n'écrive du code. Mentionnez les notes plutôt que le classeur, car les 60 Mo de XML compressé sont destinés à être lus par le code.

/model sonnet

Add the IronXL.Excel NuGet package to LedgerScan.
Then read data/gl-2025.xlsx with it, without building a WorkBook.
The column notes are in @docs/ledger-export.md.
The license key is in the IRONXL_LICENSE_KEY environment variable. Don't print it.

Print every worksheet name first.
After that, make one forward-only pass over the Ledger sheet and print four figures:

- how many data rows the sheet holds
- the Amount total of the Posted rows
- how many seconds the pass took
- the peak working set of this process in megabytes
Text

Dans nos exécutions, Claude Code a également transmis des options qui marquent la première ligne comme en-tête, afin que chaque cellule puisse être lue par nom de colonne. Un pic en gigaoctets signifie que le code a chargé le classeur, et un pic au-dessus de 600 Mo signifie qu'il a remis un flux ou un tableau d'octets à IronXL.

StreamCell.Value maintient chaque nombre comme un Double encadré, donc un cast de cette valeur en décimal déclenche InvalidCastException, et Convert.ToDecimal avec la culture invariante est la réparation. Chacune de nos exécutions a utilisé Convert depuis le début.



Que fait Claude Code dans un projet Excel .NET ?

Dans un projet Excel, Claude Code écrit les lecteurs de grand livre et lance chacun comme un processus distinct. Vous décrivez les classeurs et examinez les chiffres qui reviennent.

Comment configurer Claude Code ?

Installez Claude Code avec le guide rapide d'Anthropic et connectez-vous. Quand il démarre et répond, l'environnement est prêt.

Comment configurer un projet dans lequel Claude Code peut travailler ?

Le dépôt testé est une application console .NET 9 avec deux entrées, le classeur de grand livre et un fichier Markdown qui décrit ses colonnes et enregistre la limite de tas de 512 Mo du conteneur de production.

Claude Code lit CLAUDE.md à l'ouverture de chaque session. Les règles nomment le guide de streaming par URL. L'index llms.txt d'IronXL répertorie le guide, mais son skill.md est épinglé à IronXL 2026.8.1, une version avant que StreamRows ne soit expédiée en 2026.9.2. Ni ce fichier ni llms-full.txt ne mentionne StreamRows, donc un agent qui ne lit que ces fichiers apprend WorkBook.Load seul. Un sous-agent de projet est un fichier Markdown sous .claude/agents/ dont la frontmatter le nomme, indique quand l'utiliser, répertorie les outils qu'il peut appeler et choisit son modèle. Avec IronXL déjà référencé par le guide rapide, une seule invite écrit maintenant les deux fichiers.

This repo needs a CLAUDE.md at its root, with a section named Large workbooks.
Write it so every later session starts from these rules:

- IronXL.Excel stays on the version LedgerScan.csproj references now.
- Read workbooks under data/ with WorkBook.StreamRows and a file path, never a Stream or byte[].
- Use WorkBook.Load in a test or benchmark that compares it with StreamRows.
- Outside those, use WorkBook.Load only when the file is .xls, has a password or must be edited.
- Any StreamCell can be null on a sparse row.
- Convert StreamCell.Value with Convert. Don't cast it.
- Memory and time figures come from a separate child process, one per reader.
- A long command runs in the foreground until it exits, never as a background task.
- The license key comes from IRONXL_LICENSE_KEY and nowhere else. Don't print it.
- The reference is https://ironsoftware.com/excel/csharp/how-to/stream-large-excel-files/.

Then create .claude/agents/stream-auditor.md, a project subagent that runs on sonnet.
Give it Read, Grep and Glob and no other tools, and a description that says when to use it.
It checks C# changes against that section and against IronXL.xml in the local NuGet cache.
It replies with the file, the line and the rule broken, and it edits nothing.
Text

Claude Code surveille .claude/agents/ pour de nouveaux fichiers, mais uniquement lorsque ce dossier existait au démarrage de la session. Dans un dépôt où cette invite crée le dossier, redémarrez avec claude --continue avant l'invite suivante pour que le sous-agent soit disponible.

Réglez la licence avant la première lecture. Sans clé, les appels de streaming et de nom de feuille lancent LicensingException dès qu'ils sont appelés, avant que le fichier ne soit ouvert. Vérifiez License.IsLicensed au démarrage. La page Clés de licence IronXL couvre l'obtention et le stockage d'une clé.

Quelles sont les configurations d'IronXL à inclure dans CLAUDE.md ?

Pour un CLAUDE.md écrit à la main, le bloc ci-dessous contient la même section.

## Large workbooks

- Keep IronXL.Excel on the version LedgerScan.csproj references now.
- Read workbooks under data/ with WorkBook.StreamRows and a file path, never a Stream or byte[].
- WorkBook.Load is fine in a test or benchmark that compares it with StreamRows.
- Anywhere else, use WorkBook.Load only when the file is .xls, has a password or must be edited.
- Any StreamCell can be null on a sparse row.
- Convert StreamCell.Value with Convert. Don't cast it.
- Take memory and time figures from a separate child process, one per reader.
- Run a long command in the foreground until it exits, never as a background task.
- Read the license key from IRONXL_LICENSE_KEY and nowhere else, and never print it.
- The reference is https://ironsoftware.com/excel/csharp/how-to/stream-large-excel-files/
Markdown

Pourquoi les grands fichiers Excel ont-ils besoin de streaming en C# ?

WorkBook.Load construit le classeur complet en mémoire, avec chaque cellule, style et formule disponibles pour un accès aléatoire et une édition. Ce modèle coûte bien plus que le fichier. WorkBook.StreamRows lit l'XML de la feuille de calcul dans l'ordre et garde une ligne à la fois, ce qui est suffisant pour les importations, les totaux et la validation. Les chiffres ci-dessous proviennent de notre étalonnage sur le classeur de test, un fichier XLSX de 60 Mo avec 1 000 000 de lignes, dix colonnes et une description distincte sur chaque ligne. Chaque lecteur a fonctionné dans son propre processus, trois fois, et le tableau montre la médiane.

LecteurTempsPremière ligneEnsemble de travail en picLimite de tas de 512 Mo
StreamRows avec un chemin de fichier10,6 s1,0 s178 MoTerminé à 178 Mo
StreamRows avec un flux10,6 s1,6 s641 MoMémoire insuffisante à 1,5 s
StreamRows avec un tableau d'octets10,4 s1,5 s628 MoMémoire insuffisante à 1,6 s
WorkBook.Load avec un chemin de fichier26,4 s23,7 s3 072 MoÉchec en 1,2 s

Les quatre lecteurs ont produit les mêmes 60 totaux publiés par région et par mois.

La figure du lecteur de chemin dépend du texte dans le fichier. Un fichier XLSX conserve chaque chaîne distincte une fois dans une table de chaînes partagées, et une table avec de nombreuses entrées alourdit et ralentit le flux de démarrage. À 500 000 lignes, un classeur qui répète 258 chaînes a atteint un pic de 81 Mo avec sa première ligne après 0,22 secondes, et un classeur dont les descriptions étaient toutes distinctes a nécessité 130 Mo et 0,58 secondes. Le classeur de test d'un million de lignes contient un peu plus d'un million de chaînes distinctes.

Quel surcharge de StreamRows devez-vous utiliser ?

Seules les surcharges qui prennent un chemin de fichier. StreamRows a neuf surcharges, une pour chaque pairage d'une entrée de chemin, de flux ou de tableau d'octets avec un index de feuille, un nom de feuille ou StreamReadOptions. Les surcharges de chemin lisent le paquet depuis le disque une partie à la fois. La documentation livrée avec les surcharges de flux explique qu'ils copient le flux dans un tampon privé avant de l'analyser, afin qu'IronXL ne ferme jamais un flux appartenant à l'appelant, et appelle cette copie "pas le chemin à faible mémoire". Le guide de streaming trace la même ligne dans son tableau de surcharge.

La documentation XML pour les surcharges de tableau d'octets les décrit encore comme une "lecture à faible mémoire", mais avec le classeur de test de 60 Mo, les surcharges de flux et de tableau d'octets ont toutes deux atteint un pic à plus de dix fois la taille du fichier sur disque. Un gestionnaire d'upload qui reçoit le fichier sous forme de flux devrait le sauvegarder dans un fichier temporaire et streamer le chemin.

Comment inciter à un benchmark de streaming ?

Demandez la comparaison complète en une seule sollicitation et laissez Opus la planifier. Après la ligne /model opus, cyclez le mode de permission avec Shift+Tab jusqu'à ce que la barre de statut montre que le mode plan est activé, puis envoyez la demande. Le mode plan permet à Claude Code de lire les fichiers et d'exécuter des commandes shell, et il n'édite aucun fichier source tant que vous n'approuvez pas le plan.

/model opus

Plan a reader benchmark for data/gl-2025.xlsx under Ledger/, then build it.

I want three readers behind one interface.
Each one returns Posted Amount totals keyed by Region and the calendar month of PostedOn.

- PathStreamReader passes the file path to WorkBook.StreamRows.
- UploadStreamReader opens a FileStream and passes that stream, as an upload handler would.
- FullLoadReader calls WorkBook.Load and indexes cells with GetCellAt.

FullLoadReader reads WorkSheet.RowCount and ColumnCount once each, before its loops.
It never touches PhysicalColumnCount.

Add a bench command to Program.cs that does this:

1. Start this program again as a child process for each reader, with no memory limit.
2. Do the same with DOTNET_GCHeapHardLimit=0x20000000 in the child's environment.
3. Record exit code, wall-clock seconds, seconds until the first data row, and peak working set.
4. Write out/bench.csv with one line per reader and limit.
5. Write out/totals.csv from the path reader.
6. Fail the command if a reader that exited cleanly differs from the path reader on any total.

Run the bench, then ask @agent-stream-auditor to review Ledger/ and Program.cs.
Show me out/bench.csv and what the auditor found.
Text

Chaque partie de la sollicitation comble un écart qui permettrait aux chiffres de paraître meilleurs qu'ils ne le sont.

  1. Trois lecteurs pour un fichier : avec le lecteur de type upload FileStream dans l'ensemble, le benchmark teste le choix de surcharge ainsi que le streaming par rapport au chargement.
  2. La limite de tas dans l'environnement de l'enfant : DOTNET_GCHeapHardLimit fixe la mémoire maximale que le ramasse-miettes peut allouer, sous forme d'un décompte d'octets en hexadécimal, donc 0x20000000 correspond à 512 Mo. Un lecteur qui dépasse cette limite échoue dans son propre processus, et le banc note le code de sortie au lieu de planter.
  3. Les totaux doivent être d'accord : un lecteur qui est rapide et erroné échoue au commande.
  4. Le sous-agent clôt le tour : @agent-stream-auditor nomme directement le sous-agent du projet, donc Claude Code délègue la révision à ce sous-agent.
Conseils: Acceptez le plan une fois qu'il montre où le processus enfant obtient son environnement et où les totaux sont comparés. Un plan qui fixe la limite de tas sur le processus parent limite chaque lecteur, le banc lui-même inclus.

La solicitatin décrit comment le lecteur de chargement parcourt la feuille, car la ligne de base du chargement complet a son propre piège. WorkSheet.RowCount coûte du temps à chaque lecture, et sur la feuille chargée d'un million de lignes un appel a pris 33,5 millisecondes. Une boucle qui lit RowCount à chaque passage paie ce coût à chaque fois, ce qui se traduit par environ neuf heures pour cette feuille. Lire le nombre une fois avant la boucle a réduit le passage complète sur les cellules chargées à 1,8 secondes. WorkSheet.PhysicalColumnCount coûte beaucoup plus. Sur le grand livre chargé un appel a pris entre 45 et 50 secondes et a élevé le processus de 3 Go à 6,7 Go, tandis que ColumnCount a renvoyé les mêmes 10 colonnes en environ un dixième de seconde. Énumérer WorkSheet.Rows n'évite pas le coût. Il a fallu 8 secondes pour 50 000 lignes chargées et 61 secondes pour 100 000, et sur la feuille d'un million de lignes elle n'avait pas atteint la ligne 100 000 après 15 minutes.

Comment mesurez-vous l'utilisation de la mémoire par lecteur ?

Exécutez chaque lecteur dans son propre processus, car l'ensemble de travail en pic est un niveau d'eau élevé pour l'ensemble du processus et ne redescend jamais. Dans une sonde, un seul processus a chargé le classeur puis a exécuté le lecteur de chemin, et Process.PeakWorkingSet64 a signalé 3 047 Mo pour le flux, ce qui est la valeur du chargement. Des processus distincts ont maintenu les deux chiffres séparés.

La page de paramètres du ramasse-miettes de Microsoft note que .NET applique par défaut 75 % de la limite de mémoire d'un conteneur, donc une limite de 512 Mo correspond à un conteneur limité à environ 683 Mo. Sous cette limite, les lecteurs de flux et de tableau d'octets se sont arrêtés avec "Mémoire insuffisante." dans toutes les trois répétitions de l'étalonnage. Le chargement complet a échoué deux fois avec le même message et une fois avec FileLoadException et "Could not load Excel from given Stream. Le flux est devenu illisible pendant l'analyse, ce qui peut indiquer une mémoire insuffisante pour la taille du fichier."

Quelles sont les limites de StreamRows ?

StreamRows lit les valeurs d'une feuille de calcul XLSX dans l'ordre et ne fait rien d'autre. Le guide de streaming liste les limites, et le tableau ci-dessous enregistre ce que IronXL 2026.10.1 a fait avec chacun dans nos sondes.

EntréeStreamRowsWorkBook.Load
fichier .xlsOLE2NotOfficeXmlFileExceptionCharge
.xlsx avec un mot de passeOLE2NotOfficeXmlFileExceptionCharge avec WorkBook.Load et un mot de passe, sinon ArgumentNullException
Fichier CSVZipException "Impossible de trouver le répertoire central"Charge
Formule avec un résultat mis en cacheRésultat mis en cache, IsFormula vraiFormule et valeur
Formule enregistrée sans résultatType Blank, Valeur null, IsFormula vraiCalcule la valeur
Chemin manquantZipException "EOF dans l'en-tête" sur la première ligneFileNotFoundException
Nom de feuille manquantArgumentException "Feuille 'Ledger' non trouvée." sur la première ligneSans objet

Les exceptions dans les trois premières lignes proviennent de bibliothèques intégrées dans IronXL sous des noms d'espace de noms contenant un identifiant généré, donc aucune clause de capture ne peut les nommer. Capturez Exception autour de la première énumération, ou vérifiez le fichier avant de le streamer. Un fichier .xls et un fichier .xlsx crypté commencent tous deux par la signature OLE2, les octets D0 CF 11 E0. Vérifiez File.Exists avant le premier appel également. Dans notre sonde, streamer un chemin qui n'existait pas a créé un fichier de zéro octet à cet endroit, et un WorkBook.Load ultérieur de ce chemin a retourné un classeur avec une feuille vide à la place d'une erreur.

La ligne de formule compte le plus pour les fichiers générés. Excel enregistre le dernier résultat calculé à côté de chaque formule, et le flux renvoie ce résultat. Un classeur écrit par un script, ou par IronXL lui-même sans un appel à EvaluateAll avant l'enregistrement, enregistre la formule seule, et le flux voit alors une cellule vide. WorkBook.Load calcule ces formules lorsque les cellules sont lues, donc un total qui correspond sous le classeur chargé et revient comme zéro du flux pointe vers ce cas. Le guide de formule couvre EvaluateAll.

Trois petits détails affectent les valeurs streamées.

  • Les lignes sont dispersées : une cellule vide est absente des cellules de la ligne, et l'indexeur retourne null pour elle. TryGetCell retourne vrai pour une colonne connue même lorsque la cellule elle-même est null.
  • Les numéros de ligne restent à leur position de feuille : RowNumber est basé sur zéro, donc la ligne de feuille 2 arrive comme 1, et une ligne de feuille vide est sautée sans renuméroter les lignes après elle.
  • Les dates arrivent tapées : une cellule de date rapporte le type Date avec un DateTime comme sa valeur, tandis que son texte contient la chaîne formatée, qui était 4-27-25 pour le format de date du classeur d'essai.

Pour un classeur suffisamment petit pour être chargé, lecturer les fichiers XLSX et sélectionner des plages permettent un accès cellule par cellule.

Comment traitez-vous les valeurs d'erreur Excel en streaming ?

Un grand livre enregistré depuis Excel peut contenir des valeurs d'erreur, telles que le #N/A qu'une recherche échouée laisse derrière elle. Le flux signale une telle cellule avec le type Error et le texte de l'erreur, "#N/A" ou "#DIV/0!", comme une chaîne dans sa valeur, et son indicateur de formule est vrai quand l'erreur est le résultat mis en cache d'une formule. Convert.ToDecimal ne peut pas analyser cette chaîne et lance FormatException. Dans notre sonde, une copie du grand livre avec #N/A dans la cellule Amount de sa dernière ligne, ligne de feuille 1 000 001, a lancé après 17,3 secondes de lecture et n'a imprimé aucun total.

WorkBook.Load lit les cellules d'erreur sans lancer. Une erreur enregistrée revient avec le code d'erreur comme une valeur Byte, 42 pour #N/A et 7 pour #DIV/0!, et le texte de la cellule affiche le même nombre. DecimalValue retourne 0 pour chaque cellule d'erreur, et IsError est vrai. Sur un grand livre de 2 000 lignes avec trois montants d'erreur sur les lignes affichées, un lecteur de chargement qui a sommé DecimalValue s'est trouvé être de 26 556,59 moins sans avertissement. Un qui a converti la valeur brute a compté les deux erreurs enregistrées comme 42 et 7, puis a lancé FormatException sur l'erreur de formule.

Testez le type avant la conversion. Convertissez un Amount uniquement lorsque son type est StreamCellType.Number, et enregistrez toute autre cellule avec sa ligne, comme l'échantillon du guide de streaming le fait avec son cas StreamCellType.Error. Avec ce contrôle, le passage d'un million de lignes s'est terminé en 17,6 secondes et a signalé une cellule, I1000001. Son total publié de 8 304 532 586,40 est de 5 081,52 en dessous du fichier propre, le montant que cette ligne détenait avant l'entrée de l'erreur. Un lecteur de chargement teste IsError d'abord. Imprimez les cellules signalées à côté du total, afin qu'un total faible puisse être retracé jusqu'à ses lignes.

Comment revenez-vous à WorkBook.Load ?

Donnez à Claude Code le deuxième fichier et demandez-lui de comparer les deux lecteurs dessus. Avant la dernière sollicitation, notre exécution de test a ajouté un classeur de 40 000 lignes généré par un script. Sa seule feuille s'appelle Ajustements, un titre et une ligne vide se trouvent au-dessus de l'en-tête, et chaque cellule Amount contient une formule sans résultat enregistré.

/model sonnet

Finance added data/gl-2025-q4-adjustments.xlsx.
A Python script of theirs writes it instead of Excel.
It has one sheet, with a title block above the header row.

1. Run PathStreamReader over it and compare its Posted totals with FullLoadReader's.
2. Where they disagree, count the stream's Amount cells per Type, IsFormula and Value combination.
3. If some cells give the stream no figure, fall back to WorkBook.Load for that workbook alone.
4. Print which reader produced each total. data/gl-2025.xlsx keeps streaming.
5. Add the adjustments file to the bench as a second workbook.
6. For that workbook, compare every reader with the fallback totals.
7. Don't fail the bench when a stream reader's totals differ there.
8. Run the bench again, wait for it to exit, then read out/bench.csv.
9. Ask the stream-auditor subagent to review the files this turn changed and nothing else.

Tell me the adjustments total and which reader it came from.
Text

Dans notre étalonnage, le fichier casse un lecteur écrit pour le grand livre de trois façons. Demander la feuille Ledger lance ArgumentException. Avec le HeaderRowIndex par défaut de 0, le titre devient le seul nom d'en-tête et l'indexeur de colonne Amount lance "Colonne d'en-tête inconnue : 'Amount'." Avec l'index d'en-tête défini à 2, les 40 000 cellules Amount reviennent toutes comme des formules vides, et le total diffusé affiché est 0.

Que devriez-vous vérifier avant de faire confiance à un code IronXL généré ?

Complétez ces deux vérifications dans cet ordre après chaque changement.

  • La construction réussit : recherchez chaque membre dans la référence API et relancez à partir d'une nouvelle construction Release.
  • Le pic est celui du lecteur de chemin : lisez chaque pic par rapport aux seuils sous l'invite de démarrage rapide.

Qu'est-ce que les messages ont produit lors d'une réelle exécution ?

Les quatre sollicitations de ce guide ont été envoyées à Claude Code dans l'ordre, en une seule session, contre le dépôt décrit ci-dessus. Une réponse typée a approuvé le plan pour l'invite 03. L'invite de démarrage rapide ne nomme aucune version, donc l'exécution a installé IronXL.Excel 2026.10.5. Le tableau d'étalonnage utilisait 2026.10.1, et les temps d'exécution sont plus longs.

  • Le lecteur de chemin a atteint un pic de 177,3 Mo sur le grand livre après l'invite 03 et de 253,4 Mo après l'invite 04. Le code de la quatrième invite trouve la ligne d'en-tête avec un StreamRows passe avant la lecture.
  • Sur le classeur d'ajustements, le flux a signalé 36 045 lignes affichées avec une cellule Amount inutilisable. Le retour par classeur à un chargement complet a produit 15 totaux qui s'additionnent à 330 856 030,50, à un pic de 284,3 Mo, et il a également terminé sous la limite de 512 Mo.
  • Sous la limite, seul le lecteur de chemin a terminé le grand livre, à 253,1 Mo. Le lecteur FileStream a manqué de mémoire à 556,1 Mo, et le lecteur de chargement a échoué à 531,0 Mo.
  • Sans la limite, le banc final a atteint un pic de 689,1 Mo pour le lecteur FileStream et de 3 071,3 Mo pour le lecteur de chargement, qui a retourné sa première ligne après 43,24 secondes, contre 1,35 secondes pour le lecteur de chemin. Les 60 totaux concordaient tous.
  • Le passage de démarrage rapide a compté 1 000 000 de lignes avec un total affiché de 8 304 537 667,92 en 19,32 secondes, à un pic de 180,96 Mo.
  • Le banc final a exécuté 12 processus enfants, trois lecteurs sur deux classeurs avec et sans la limite, et s'est arrêté avec le code 0. Une nouvelle construction Release du code validé l'a relancé, et ses 60 totaux de grand livre et 15 ajustements ont correspondu aux valeurs enregistrées par le générateur de classeur.
  • Certaines étapes ont été exécutées différemment de la page. Le plan de l'invite 03 s'est clôturé avec deux questions, et après l'approbation Claude Code a suivi ses propres recommandations, un délai d'attente de 300 secondes pour chaque enfant et aucun changement à CLAUDE.md. Le sous-agent a ensuite signalé UploadStreamReader dans l'invite 03 et le retour WorkBook.Load dans l'invite 04 comme enfreignant les règles CLAUDE.md, bien que les sollicitations aient demandé les deux. Claude Code a transmis chaque constat et laissé les règles inchangées, donc ajoutez une exemption pour chacun si la révision doit revenir propre. Chaque banc a fonctionné au premier plan et les deux révisions sont revenues.
  • Une exécution antérieure a utilisé un libellé plus long des mêmes sollicitations. Là, le sous-agent a signalé WorkSheet.RowCount et ColumnCount comme manquants, bien que IronXL.xml documente les deux sous Range, la classe dont WorkSheet hérite. Le mode Auto dans cette exécution a également refusé une modification du fichier de sous-agent dans l'invite 04 comme auto-modification, donc prévoyez d'approuver de telles modifications vous-même. Avant cela, Claude Code a deux fois démarré un banc en tant que tâche d'arrière-plan et a terminé son tour alors que les enfants fonctionnaient encore. Dans la seconde de ces exécutions, une boucle d'en-tête qui testait PhysicalColumnCount à chaque passage a également maintenu l'enfant de chargement occupé au-delà de son délai d'attente de cinq minutes.

Le enregistrement de l'exécution répertorie les versions, les modèles, les temps et la machine de test derrière ce guide et les autres de l'ensemble.


Dépannage


Des questions ?

Si vous avez des questions, contactez support@ironsoftware.com

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.

Lire la suite

Prêt à commencer ?

Téléchargements NuGet 2,393,101Version :2026.11tout juste publié