Como usar o IronXL com Claude Code

Curtis Chau
Curtis Chau
Atualizado: 15 de outubro de 2026

Uma exportação de contabilidade geral com um milhão de linhas de diário abre no Excel sem problemas e depois trava o trabalho de importação que precisa lê-lo. Em nossa máquina de teste, WorkBook.Load precisou de cerca de 26 segundos e 3 GB de memória para ler uma planilha de 60 MB daquele tamanho, e o contêiner em nosso cenário de teste limita o heap do .NET a 512 MB. A Anthropic disponibiliza o Claude Code para o terminal, para VS Code e IDEs JetBrains, para o desktop e para a web. Em cada um desses locais, o agente pode ler um repositório, alterar arquivos e executar comandos.

IronXL tem uma segunda maneira de acessar um arquivo XLSX. Esse leitor não pode lidar com várias entradas, desde fórmulas que nunca foram calculadas até arquivos .xls, e um agente que não foi informado sobre eles pode recorrer a WorkBook.Load ou a uma sobrecarga que bufferiza todo o arquivo silenciosamente. Este guia fornece ao Claude Code quatro prompts testados. Sonnet lida com as tarefas curtas, Opus projeta a referência em modo plano e um subagente de projeto somente leitura revisa o resultado.

Três dos quatro prompts começam com uma linha /model, e o modelo que ele seleciona permanece ativo até que você escolha outro. A página de configuração do modelo da Anthropic descreve o alias sonnet como a escolha para tarefas de codificação diárias e opus como a escolha para raciocínio complexo.

Início Rápido
NuGetInstalar com NuGet

PM > Install-Package IronXL.Excel

Instale o IronXL executando o comando acima no Console do Gerenciador de Pacotes NuGet, ou procure pelo pacote no Gerenciador de Pacotes NuGet.

Abra um terminal no repositório e inicie claude. Envie a linha /model como sua própria mensagem, depois envie o restante do bloco como a solicitação. Digitar @ antes de um caminho anexa esse arquivo, para que as notas da coluna cheguem ao agente antes que ele escreva qualquer código. Mencione as notas em vez da planilha, pois os 60 MB de XML compactado são para o código ler.

/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

Em nossas execuções, Claude Code também passou opções que marcam a primeira linha como cabeçalho, para que cada célula pudesse ser lida pelo nome da coluna. Um pico em gigabytes significa que o código carregou a planilha, e um pico acima de 600 MB significa que ela entregou ao IronXL um fluxo ou uma matriz de bytes.

StreamCell.Value mantém todos os números como um Double encaixotado, então uma conversão desse valor para decimal lança InvalidCastException, e Convert.ToDecimal com a cultura invariável é a correção. Todas as nossas execuções usaram Convert desde o início.



O que o Claude Code faz em um projeto Excel .NET?

Em um projeto Excel, Claude Code escreve os leitores do livro-razão e inicia cada um como um processo separado. Você descreve as planilhas e revisa os valores que retornam.

Como você configura o Claude Code?

Instale o Claude Code com o quickstart da Anthropic e faça login. Quando começa e responde, o ambiente está pronto.

Como você configura um projeto no qual o Claude Code possa trabalhar?

O repositório testado é um aplicativo de console .NET 9 com duas entradas, a planilha do livro-razão e um arquivo Markdown que descreve suas colunas e registra a limitação de heap de 512 MB do contêiner de produção.

Claude Code lê CLAUDE.md quando cada sessão é aberta. As regras nomeiam o guia de streaming por URL. O índice llms.txt do IronXL lista o guia, mas seu skill.md está fixado no IronXL 2026.8.1, uma versão anterior a StreamRows lançada em 2026.9.2. Nem esse arquivo nem llms-full.txt menciona StreamRows, então um agente que lê apenas esses arquivos aprende WorkBook.Load sozinho. Um subagente de projeto é um arquivo Markdown sob .claude/agents/ cujo frontmatter o nomeia, diz quando usá-lo, lista as ferramentas que pode chamar e escolhe seu modelo. Com o IronXL já referenciado pelo Quickstart, agora um único prompt escreve ambos os arquivos.

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 verifica .claude/agents/ em busca de novos arquivos, mas apenas quando essa pasta existia quando a sessão começou. Em um repositório onde esse prompt cria a pasta, reinicie com claude --continue antes do próximo prompt para que o subagente esteja disponível.

Ajuste a licença antes da primeira leitura. Sem chave, as chamadas de transmissão e nome da planilha lançam LicensingException no momento em que são chamadas, antes de o arquivo ser aberto. Verifique License.IsLicensed na inicialização. A página Chaves de Licença IronXL cobre a obtenção e o armazenamento de uma chave.

Quais configurações do IronXL pertencem ao CLAUDE.md?

Para um CLAUDE.md escrito à mão, o bloco abaixo contém a mesma seção.

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

Por que arquivos grandes do Excel precisam de streaming em C#?

WorkBook.Load constrói todo o livro em memória, com cada célula, estilo e fórmula disponíveis para acesso e edição aleatória. Esse modelo custa muito mais do que o arquivo. WorkBook.StreamRows lê o XML da planilha em ordem e mantém uma linha de cada vez, o que é suficiente para importações, totais e validação. Os valores abaixo provêm de nossa calibração no livro de testes, um arquivo XLSX de 60 MB com 1.000.000 de linhas, dez colunas e uma descrição distinta em cada linha. Cada leitor foi executado em seu próprio processo, três vezes, e a tabela mostra a mediana.

LeitorTempoPrimeira linhaConjunto de trabalho máximoLimite de heap de 512 MB
StreamRows com um caminho de arquivo10.6 s1.0 s178 MBTerminado a 178 MB
StreamRows com um fluxo10.6 s1.6 s641 MBMemória insuficiente em 1.5 s
StreamRows com uma matriz de bytes10.4 s1.5 s628 MBMemória insuficiente em 1.6 s
WorkBook.Load com um caminho de arquivo26.4 s23.7 s3,072 MBFalhou em 1.2 s

Todos os quatro leitores produziram os mesmos 60 totais Postados por região e mês.

O valor do leitor de caminho depende do texto no arquivo. Um arquivo XLSX mantém cada string distinta uma vez, em uma tabela de strings compartilhada, e uma tabela com muitas entradas torna o fluxo mais pesado e mais lento de iniciar. Com 500.000 linhas, uma planilha que repete 258 strings transmitidas em um pico de 81 MB com sua primeira linha após 0.22 segundos, e uma planilha cujas descrições eram todas distintas precisou de 130 MB e 0.58 segundos. A instalação de um milhão de linhas carrega pouco mais de um milhão de strings distintas.

Qual sobrecarga de StreamRows você deve usar?

Apenas as sobrecargas que aceitam um caminho de arquivo. StreamRows tem nove sobrecargas, uma para cada emparelhamento de uma entrada de caminho, fluxo ou matriz de bytes com um índice de planilha, um nome de planilha ou StreamReadOptions. As sobrecargas de caminho lêem o pacote do disco uma parte de cada vez. A documentação que acompanha as sobrecargas de fluxo explica que eles copiam o fluxo em um buffer privado antes de analisar, para que o IronXL nunca feche um fluxo que o chamador possui, e chama essa cópia de "não o caminho de baixa memória". O guia de transmissão traça a mesma linha em sua tabela de sobrecarga.

A documentação XML para as sobrecargas de matriz de bytes ainda as descreve como uma "leitura de baixa memória", mas com a instalação de 60 MB, as sobrecargas de fluxo e matriz de bytes ambas atingiram o pico em mais de dez vezes o tamanho do arquivo no disco. Um manipulador de upload que recebe o arquivo como um fluxo deve salvá-lo em um arquivo temporário e transmitir o caminho.

Como você pede um benchmark de streaming?

Peça a comparação completa em um só prompt e deixe o Opus planejar. Após a linha /model opus, alterne o modo de permissão com Shift+Tab até que a barra de status mostre o modo plano ativado, depois envie a solicitação. O modo plano permite que o Claude Code leia arquivos e execute comandos de shell, e não edita nenhum arquivo de origem até que você aprove o plano.

/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

Cada parte do prompt fecha uma lacuna que permitiria que os números parecessem melhores do que são.

  1. Três leitores para um arquivo: com o leitor FileStream no estilo de upload no conjunto, o benchmark testa a escolha da sobrecarga tanto quanto a transmissão comparada ao carregamento.
  2. O limite de heap no ambiente do filho: DOTNET_GCHeapHardLimit define a quantidade máxima de memória que o coletor de lixo pode comprometer, como uma contagem de bytes em hexadecimal, então 0x20000000 é 512 MB. Um leitor que excede falha em seu próprio processo, e o banco registra o código de saída em vez de travar.
  3. Os totais devem concordar: um leitor que é rápido e errado falha o comando.
  4. O subagente fecha a vez: @agent-stream-auditor nomeia o subagente do projeto diretamente, então Claude Code delega a revisão a esse subagente.
Dicas: Aceite o plano uma vez que ele mostre de onde o processo filho obtém seu ambiente e onde os totais são comparados. Um plano que define o limite de heap no processo pai limita todos os leitores, incluindo o próprio banco.

O prompt detalha como o leitor de carregamento percorre a planilha, porque a linha de base de carregamento completo tem uma armadilha própria. WorkSheet.RowCount custa tempo a cada leitura, e na planilha de um milhão de linhas carregadas, uma chamada levou 33.5 milissegundos. Um loop que lê RowCount a cada passagem paga esse custo cada vez, o que resulta em cerca de nove horas para esta planilha. Ler a contagem uma vez antes do loop reduziu todo o percurso sobre as células carregadas para 1.8 segundos. WorkSheet.PhysicalColumnCount custa muito mais. No livro-razão carregado, uma chamada levou de 45 a 50 segundos e aumentou o processo de 3 GB para 6.7 GB, enquanto o ColumnCount retornou as mesmas 10 colunas em cerca de um décimo de segundo. Enumerar WorkSheet.Rows não evita o custo. Foram necessários 8 segundos para 50.000 linhas carregadas e 61 segundos para 100.000, e na planilha de um milhão de linhas, não atingiu a linha 100.000 após 15 minutos.

Como você mede o uso de memória por leitor?

Execute cada leitor em seu próprio processo, porque o conjunto de trabalho máximo é uma marca d'água alta para o processo inteiro e nunca diminui. Em uma sonda, um único processo carregou a planilha e depois executou o leitor de caminho, e Process.PeakWorkingSet64 informou 3.047 MB para o fluxo, que é o valor de carregamento. Processos separados mantiveram os dois valores separados.

A página de configurações do coletor de lixo da Microsoft observa que o .NET aplica 75% do limite de memória de um contêiner por padrão, então um limite de 512 MB corresponde a um contêiner limitado a cerca de 683 MB. Sob esse limite, os leitores de fluxo e matriz de bytes pararam com "Memória insuficiente." em todas as três repetições de calibração. O carregamento completo falhou duas vezes com a mesma mensagem e uma vez com FileLoadException e "Não foi possível carregar o Excel do fluxo fornecido. O fluxo tornou-se ilegível durante a análise, o que pode indicar memória insuficiente para o tamanho do arquivo."

Quais são os limites de StreamRows?

StreamRows lê valores de uma planilha XLSX em ordem e não faz mais nada. O guia de transmissão lista os limites, e a tabela abaixo registra o que o IronXL 2026.10.1 fez com cada um em nossas sondas.

EntradaStreamRowsWorkBook.Load
arquivo .xlsOLE2NotOfficeXmlFileExceptionCarrega
.xlsx com uma senhaOLE2NotOfficeXmlFileExceptionCarrega com WorkBook.Load e uma senha, caso contrário, ArgumentNullException
Arquivo CSVZipException "Não foi possível encontrar o diretório central"Carrega
Fórmula com um resultado em cacheResultado em cache, IsFormula verdadeiroFórmula e valor
Fórmula salva sem um resultadoTipo Blank, Valor nulo, IsFormula verdadeiroCalcula o valor
Caminho ausenteZipException "EOF no cabeçalho" na primeira linhaFileNotFoundException
Nome de planilha ausenteArgumentException "Planilha 'Razão' não foi encontrada." na primeira linhaNão aplicável

As exceções nas três primeiras linhas vêm de bibliotecas embutidas no IronXL sob nomes de namespace que contêm um identificador gerado, então nenhuma cláusula de captura pode nomeá-las. Capture Exception em torno da primeira enumeração, ou verifique o arquivo antes de transmiti-lo. Um arquivo .xls e um arquivo .xlsx criptografado ambos começam com a assinatura OLE2, os bytes D0 CF 11 E0. Verifique File.Exists antes da primeira chamada também. Em nossa sonda, transmitir um caminho que não existia criou um arquivo de zero bytes lá, e uma posterior WorkBook.Load desse caminho retornou uma planilha com uma planilha vazia ao invés de um erro.

A linha da fórmula é a mais importante para arquivos gerados. O Excel armazena o último resultado calculado ao lado de cada fórmula, e o fluxo retorna esse resultado. Uma planilha escrita por um script, ou pelo próprio IronXL sem uma chamada para EvaluateAll antes de salvar, armazena apenas a fórmula, e então o fluxo vê uma célula vazia. WorkBook.Load calcula essas fórmulas quando as células são lidas, então um total que coincide sob a planilha carregada e retorna como zero do fluxo aponta para este caso. O guia de fórmulas cobre EvaluateAll.

Três detalhes menores afetam os valores transmitidos.

  • As linhas são esparsas: uma célula em branco está ausente das células da linha, e o indexador retorna nulo para ela. TryGetCell retorna verdadeiro para uma coluna conhecida mesmo quando a própria célula é nula.
  • Os números das linhas permanecem em sua posição na planilha: RowNumber começa em zero, então a linha 2 da planilha chega como 1, e uma linha de planilha em branco é pulada sem renumerar as linhas depois dela.
  • Datas são digitadas: uma célula de data relata o tipo Date com um DateTime como seu valor, enquanto seu texto contém a cadeia formatada, que foi 27/4/25 para o formato de data do book de testes.

Para uma planilha pequena o suficiente para carregar, ler arquivos XLSX e selecionar intervalos cobrem acesso célula a célula.

Como você lida com valores de erro do Excel ao transmitir?

Um livro-razão salvo do Excel pode conter valores de erro, como o #N/A que uma busca falhada deixa para trás. O fluxo relata tal célula com o tipo Erro e o texto do erro, "#N/A" ou "#DIV/0!", como uma string em seu valor, e sua bandeira de fórmula é verdadeira quando o erro é um resultado em cache de uma fórmula. Convert.ToDecimal não consegue analisar essa string e lança FormatException. Em nossa sondagem, uma cópia do livro-razão com #N/A na célula Valor de sua última linha, linha 1.000.001 da planilha, lançou um erro após 17.3 segundos de leitura e não imprimiu nenhum total.

WorkBook.Load lê células de erro sem lançar. Um erro armazenado retorna com o código de erro como um valor Byte, 42 para #N/A e 7 para #DIV/0!, e o texto da célula mostra o mesmo número. DecimalValue retorna 0 para cada célula de erro, e IsError é verdadeiro. Em um livro-razão de 2.000 linhas com três quantidades de erro em linhas Postadas, um leitor de carregamento que somou DecimalValue saiu 26.556,59 a menos sem um aviso. Um que converteu o valor bruto contou os dois erros armazenados como 42 e 7, depois lançou FormatException no erro de fórmula.

Teste o tipo antes da conversão. Converta um Valor apenas quando seu tipo for StreamCellType.Number, e registre qualquer outra célula com sua linha, como o exemplo do guia de transmissão faz com seu caso StreamCellType.Error. Com essa verificação, o percurso de um milhão de linhas terminou em 17.6 segundos e sinalizou uma célula, I1000001. Seu total Postado de 8.304.532.586,40 está 5.081,52 abaixo do arquivo limpo, o montante que essa linha continha antes do erro ocorrer. Um leitor de carregamento testa IsError primeiro. Imprima as células sinalizadas ao lado do total, para que um total baixo possa ser rastreado até suas linhas.

Como você recorre ao WorkBook.Load?

Dê ao Claude Code o segundo arquivo e peça para ele comparar os dois leitores nele. Antes do último prompt, nossa execução de teste adicionou uma planilha de 40.000 linhas gerada por um script. Sua única planilha se chama Ajustes, um título e uma linha em branco estão acima do cabeçalho, e cada célula de Valor contém uma fórmula sem resultado armazenado.

/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

Em nossa calibração, o arquivo quebra um leitor escrito para o livro-razão de três maneiras. Pedir a planilha Ledger lança ArgumentException. Com o HeaderRowIndex padrão de 0, o título torna-se o único nome de cabeçalho e o indexador da coluna Valor lança "Coluna de cabeçalho desconhecida: 'Valor'." Com o índice de cabeçalho definido como 2, todas as 40.000 células de Valor retornam como fórmulas em branco, e o total Postado transmitido é 0.

O que você deve verificar antes de confiar no código gerado pelo IronXL?

Complete essas duas verificações em ordem após cada mudança.

  • A compilação passa: consulte cada membro na referência de API e reexecute a partir de uma nova compilação de liberação.
  • O pico é do leitor de caminho: leia cada pico em relação aos limites sob o prompt Quickstart.

O que os prompts produziram em uma execução real?

Os quatro prompts neste guia foram enviados para Claude Code em ordem, em uma única sessão, contra o repositório descrito acima. Uma resposta digitada aprovou o plano para o prompt 03. O prompt Quickstart não menciona versão, então a execução instalou IronXL.Excel 2026.10.5. A tabela de calibração usou 2026.10.1, e os tempos da execução são mais longos.

  • O leitor de caminho atingiu o pico em 177.3 MB sobre o livro-razão após o prompt 03 e em 253.4 MB após o prompt 04. O código do quarto prompt encontra a linha do cabeçalho com uma passagem StreamRows própria antes da leitura.
  • Na planilha de ajustes, o fluxo sinalizou 36.045 linhas Postadas com uma célula de Valor inútil. O fallback por planilha para um carregamento completo produziu 15 totais que somam 330.856.030,50, em um pico de 284.3 MB, e também ficou abaixo do limite de 512 MB.
  • Sob o limite, apenas o leitor de caminho terminou o livro-razão, em 253.1 MB. O leitor FileStream ficou sem memória em 556.1 MB, e o leitor de carregamento falhou em 531.0 MB.
  • Sem o limite, o banco final atingiu o pico em 689.1 MB para o leitor FileStream e 3.071,3 MB para o leitor de carregamento, que retornou sua primeira linha após 43.24 segundos, contra 1.35 segundos para o leitor de caminho. Todos os 60 totais concordaram.
  • A passagem Quickstart contou 1.000.000 de linhas com um total Postado de 8.304.537.667,92 em 19.32 segundos, em um pico de 180.96 MB.
  • O banco final executou 12 processos filhos, três leitores em dois livros de trabalho com e sem o limite, e saiu com o código 0. Uma nova compilação de liberação do código comprometido o reexecutou, e seus 60 totais do livro-razão e 15 de ajustes corresponderam aos valores que o gerador de livros de trabalho registrou.
  • Alguns passos foram executados de forma diferente da página. O plano do prompt 03 fechou com duas perguntas, e após a aprovação, o Claude Code seguiu suas próprias recomendações, um tempo limite de 300 segundos para cada filho e nenhuma alteração em CLAUDE.md. O subagente então relatou UploadStreamReader no prompt 03 e o fallback WorkBook.Load no prompt 04 como violando as regras CLAUDE.md, embora os prompts pedissem ambos. Claude Code passou cada descoberta e manteve as regras inalteradas, então adicione uma isenção para cada uma se a revisão deve voltar limpa. Cada banco executou em primeiro plano e ambas as revisões voltaram.
  • Uma execução anterior usou redação mais longa dos mesmos prompts. Lá, o subagente relatou WorkSheet.RowCount e ColumnCount como ausentes, embora IronXL.xml documente ambos sob Range, a classe da qual WorkSheet os herda. O modo automático nessa execução também recusou uma edição no arquivo de subagente no prompt 04 como auto-modificação, então planeje aprovar essas edições você mesmo. Antes disso, Claude Code iniciou duas vezes um banco como uma tarefa em segundo plano e terminou sua vez enquanto os filhos ainda estavam em execução. Na segunda dessas execuções, um loop de cabeçalho que testou PhysicalColumnCount a cada passagem também manteve o filho de carregamento ocupado após seu tempo limite de cinco minutos.

O registro de execução lista as versões, modelos, tempos e máquina de teste por trás deste guia e dos outros no conjunto.


Solução de problemas


Questões?

Se você tiver dúvidas, entre em contato com support@ironsoftware.com

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

Leia Mais

Pronto para começar?

Downloads no NuGet 2,393,101Versão:2026.11recém-lançado