Aplicar fórmulas de planilha de gráfico nas apresentações usando C++
Visão geral
Os gráficos do PowerPoint geralmente armazenam seus dados de origem em uma planilha incorporada. No Aspose.Slides for C++, você pode acessar essa planilha por meio da planilha de dados do gráfico, gravar valores de entrada, atribuir fórmulas a células, calcular as fórmulas suportadas e usar as células calculadas como dados do gráfico.
Este artigo explica todo o fluxo de trabalho de fórmulas: criar um gráfico, preencher sua planilha, atribuir fórmulas no estilo A1 ou R1C1, recalculá‑las, ler os valores calculados, conectar essas células a uma série de gráfico e salvar a apresentação. Também descreve a sintaxe de fórmulas suportada, o subconjunto de funções incorporado, valores em cache, fórmulas não suportadas e erros específicos de planilhas.
Planilhas de Gráficos e Fórmulas
Uma planilha de gráfico contém as categorias, nomes de séries e valores usados por um gráfico. No PowerPoint, você pode inspecionar a planilha abrindo o editor de dados do gráfico:
No Aspose.Slides, a planilha é exposta por meio da interface IChartDataWorkbook. Use IChartDataCell::set_Formula para fórmulas no estilo A1 e IChartDataCell::set_R1C1Formula para fórmulas no estilo R1C1. Após alterar células de entrada ou fórmulas, chame IChartDataWorkbook::CalculateFormulas para recalcular as fórmulas suportadas e atualizar os valores correspondentes das células.
Uma célula calculada ainda expõe seu resultado por meio de IChartDataCell::get_Value. Isso é importante quando você precisa inspecionar o resultado de uma fórmula no código ou usar a célula como ponto de dados do gráfico.
Criar um Gráfico e Calcular Fórmulas da Planilha
O exemplo a seguir demonstra um fluxo de trabalho de ponta a ponta. Ele cria um gráfico de colunas agrupadas, limpa os dados de exemplo, grava valores trimestrais de receita e despesa, calcula o lucro com fórmulas, lê os resultados, usa as células calculadas como valores do gráfico e salva a apresentação.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDataLabelCollection.h>
#include <DOM/Chart/IDataLabelFormat.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
#include <system/string.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Export;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 600.0f, 350.0f);
auto chartData = chart->get_ChartData();
auto workbook = chartData->get_ChartDataWorkbook();
const int32_t worksheetIndex = 0;
chartData->get_Series()->Clear();
chartData->get_Categories()->Clear();
workbook->Clear(worksheetIndex);
auto category1 = workbook->GetCell(worksheetIndex, u"A2", ObjectExt::Box<String>(u"Q1"));
auto category2 = workbook->GetCell(worksheetIndex, u"A3", ObjectExt::Box<String>(u"Q2"));
auto category3 = workbook->GetCell(worksheetIndex, u"A4", ObjectExt::Box<String>(u"Q3"));
workbook->GetCell(worksheetIndex, u"B1", ObjectExt::Box<String>(u"Revenue"));
workbook->GetCell(worksheetIndex, u"C1", ObjectExt::Box<String>(u"Expenses"));
workbook->GetCell(worksheetIndex, u"D1", ObjectExt::Box<String>(u"Profit"));
workbook->GetCell(worksheetIndex, u"B2")->set_Value(ObjectExt::Box<double>(120.0));
workbook->GetCell(worksheetIndex, u"C2")->set_Value(ObjectExt::Box<double>(80.0));
workbook->GetCell(worksheetIndex, u"B3")->set_Value(ObjectExt::Box<double>(150.0));
workbook->GetCell(worksheetIndex, u"C3")->set_Value(ObjectExt::Box<double>(95.0));
workbook->GetCell(worksheetIndex, u"B4")->set_Value(ObjectExt::Box<double>(135.0));
workbook->GetCell(worksheetIndex, u"C4")->set_Value(ObjectExt::Box<double>(110.0));
auto profit1 = workbook->GetCell(worksheetIndex, u"D2");
auto profit2 = workbook->GetCell(worksheetIndex, u"D3");
auto profit3 = workbook->GetCell(worksheetIndex, u"D4");
profit1->set_Formula(u"B2-C2");
profit2->set_Formula(u"B3-C3");
profit3->set_Formula(u"B4-C4");
workbook->CalculateFormulas();
auto q1Profit = profit1->get_Value(); // 40
auto q2Profit = profit2->get_Value(); // 55
auto q3Profit = profit3->get_Value(); // 25
chartData->get_Categories()->Add(category1);
chartData->get_Categories()->Add(category2);
chartData->get_Categories()->Add(category3);
auto profitSeries = chartData->get_Series()->Add(workbook->GetCell(worksheetIndex, u"D1"), chart->get_Type());
profitSeries->get_DataPoints()->AddDataPointForBarSeries(profit1);
profitSeries->get_DataPoints()->AddDataPointForBarSeries(profit2);
profitSeries->get_DataPoints()->AddDataPointForBarSeries(profit3);
profitSeries->get_Labels()->get_DefaultDataLabelFormat()->set_ShowValue(true);
presentation->Save(u"chart-formulas.pptx", SaveFormat::Pptx);
Os pontos de dados do gráfico referenciam D2:D4, portanto o gráfico usa os valores de lucro calculados. Não há chamada separada de atualização do gráfico neste fluxo de trabalho: recalcule a planilha primeiro, depois use ou salve os dados do gráfico que apontam para as células calculadas.
Usar Fórmulas no Estilo A1
A notação A1 identifica colunas com letras e linhas com números. Atribua expressões no estilo A1 através de IChartDataCell::set_Formula.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 500.0f, 300.0f);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
workbook->GetCell(0, u"C3")->set_Value(ObjectExt::Box<int32_t>(10));
workbook->GetCell(0, u"F2")->set_Value(ObjectExt::Box<int32_t>(2));
workbook->GetCell(0, u"G2")->set_Value(ObjectExt::Box<int32_t>(3));
workbook->GetCell(0, u"H2")->set_Value(ObjectExt::Box<int32_t>(4));
auto cell = workbook->GetCell(0, u"A2");
cell->set_Formula(u"C3+SUM(F2:H2)");
workbook->CalculateFormulas();
auto value = cell->get_Value(); // 19
Formas de referência A1 comuns são:
| Referência | Relativa | Absoluta | Mista |
|---|---|---|---|
| Célula | A2 |
$A$2 |
A$2, $A2 |
| Linha | 2:2 |
$2:$2 |
— |
| Coluna | A:A |
$A:$A |
— |
| Intervalo | A2:C4 |
$A$2:$C$4 |
A$2:$C4, $A2:C$4 |
Referências relativas podem mudar quando uma fórmula é movida ou copiada por uma aplicação de planilha. Referências absolutas mantêm ambas as coordenadas fixas, enquanto referências mistas fixam apenas uma linha ou uma coluna.
Usar Fórmulas no Estilo R1C1
A notação R1C1 identifica linhas e colunas numericamente. Referências relativas usam deslocamentos entre colchetes. Atribua essa sintaxe através de IChartDataCell::set_R1C1Formula.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 500.0f, 300.0f);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
workbook->GetCell(0, u"B2")->set_Value(ObjectExt::Box<int32_t>(12));
workbook->GetCell(0, u"C2")->set_Value(ObjectExt::Box<int32_t>(5));
auto cell = workbook->GetCell(0, u"D2");
cell->set_R1C1Formula(u"RC[-2]-RC[-1]");
workbook->CalculateFormulas();
auto value = cell->get_Value(); // 7
Formas de referência R1C1 comuns são:
| Referência | Relativa | Absoluta | Mista |
|---|---|---|---|
| Célula | R[2]C[3] |
R2C3 |
R2C[3], R[2]C3 |
| Linha | R[2] |
R2 |
— |
| Coluna | C[3] |
C3 |
— |
| Intervalo | R[2]C[3]:R[5]C[7] |
R2C3:R5C7 |
R2C3:R[5]C[7], R[2]C3:R5C[7] |
Por exemplo, na célula D2, RC[-2] significa a célula na mesma linha duas colunas à esquerda (B2).
Constantes e Operadores de Fórmula
O avaliador de fórmulas incorporado suporta valores lógicos, literais numéricos, cadeias de texto, valores de erro de planilha, operadores aritméticos e operadores de comparação.
Constantes e Literais
| Tipo | Exemplos | Observações |
|---|---|---|
| Lógico | TRUE, FALSE |
Pode ser usado diretamente em expressões lógicas como A2=TRUE. |
| Numérico | 1, 0.5, .3, 1E-2 |
Notação comum e científica são suportadas. |
| Texto | "abc", "2/3/2020 12:00" |
Literais de texto são delimitados por aspas duplas dentro da fórmula. |
| Resultado de erro | #DIV/0!, #N/A, #REF! |
Uma fórmula válida pode avaliar para um valor de erro de planilha em vez de um resultado normal. |
Este exemplo usa vários tipos de constantes:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 500.0f, 300.0f);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
workbook->GetCell(0, u"A2")->set_Value(ObjectExt::Box<bool>(false));
workbook->GetCell(0, u"B2")->set_Formula(u"A2=TRUE");
workbook->GetCell(0, u"C2")->set_Formula(u"1+0.5");
workbook->GetCell(0, u"D2")->set_Formula(u".3*1E-2");
workbook->GetCell(0, u"E2")->set_Formula(u"\"abc\"");
workbook->GetCell(0, u"F2")->set_Formula(u"2/0");
workbook->CalculateFormulas();
auto logicalValue = workbook->GetCell(0, u"B2")->get_Value(); // Falso
auto numericValue = workbook->GetCell(0, u"C2")->get_Value(); // 1.5
auto scientificValue = workbook->GetCell(0, u"D2")->get_Value(); // 0.003
auto stringValue = workbook->GetCell(0, u"E2")->get_Value(); // abc
auto errorValue = workbook->GetCell(0, u"F2")->get_Value(); // #DIV/0!
Operadores Aritméticos
| Operador | Significado | Exemplo |
|---|---|---|
+ |
Adição ou sinal positivo | 2+3 |
- |
Subtração ou negação | 2-3, -3 |
* |
Multiplicação | 2*3 |
/ |
Divisão | 2/3 |
% |
Percentual | 30% |
^ |
Exponenciação | 2^3 |
Use parênteses para tornar a ordem de avaliação explícita, por exemplo (A2+B2)*C2.
Operadores de Comparação
Expressões de comparação retornam valores lógicos.
| Operador | Significado | Exemplo |
|---|---|---|
= |
Igual a | A2=3 |
<> |
Diferente de | A2<>3 |
> |
Maior que | A2>3 |
>= |
Maior ou igual a | A2>=3 |
< |
Menor que | A2<3 |
<= |
Menor ou igual a | A2<=3 |
Funções Predefinidas Suportadas
O Aspose.Slides inclui um avaliador de fórmulas incorporado para planilhas de gráficos, mas não é um motor de cálculo completo do Excel. O conjunto de funções documentado está limitado às funções abaixo. Não presuma que uma função arbitrária do Excel possa ser recalculada por IChartDataWorkbook::CalculateFormulas.
| Função | Propósito ou forma suportada | Exemplo |
|---|---|---|
ABS |
Valor absoluto | ABS(A2) |
AVERAGE |
Média aritmética | AVERAGE(B2:B5) |
CEILING |
Arredonda um número para cima até um múltiplo | CEILING(A2,5) |
CHOOSE |
Seleciona um valor por índice | CHOOSE(A2,"Low","High") |
CONCAT |
Junta valores de texto | CONCAT(A2,B2) |
CONCATENATE |
Junta valores de texto | CONCATENATE(A2," ",B2) |
DATE |
Cria um valor de data usando o sistema de datas 1900 | DATE(2026,8,19) |
DAYS |
Retorna o número de dias entre datas | DAYS(B2,A2) |
FIND |
Localiza um texto dentro de outro | FIND("-",A2) |
FINDB |
Busca de texto orientada a bytes | FINDB("a",A2) |
IF |
Resultado condicional | IF(A2>0,A2,0) |
INDEX |
Forma de referência | INDEX(A2:C4,2,3) |
LOOKUP |
Forma vetorial | LOOKUP(A2,B2:B5,C2:C5) |
MATCH |
Forma vetorial | MATCH(A2,B2:B5,0) |
MAX |
Valor máximo | MAX(B2:B5) |
SUM |
Soma valores | SUM(B2:B5) |
VLOOKUP |
Procura vertical | VLOOKUP(A2,B2:D10,3,FALSE) |
As restrições mostradas na tabela são significativas: INDEX é documentado na forma de referência, enquanto LOOKUP e MATCH são documentados em suas formas vetoriais. DATE usa o sistema de datas 1900. Recursos e funções não listados aqui devem ser tratados como não suportados pelo avaliador de fórmulas do Aspose.Slides, salvo documentação separada.
Calcular Fórmulas com Cultura Preferida
Algumas funções da planilha interpretam texto conforme regras específicas de cultura. Isso é especialmente importante para funções destinadas a idiomas que utilizam conjuntos de caracteres de byte duplo (DBCS). Para calcular essas fórmulas corretamente, crie LoadOptions, configure ISpreadsheetOptions::set_PreferredCulture por meio de LoadOptions::set_SpreadsheetOptions, e então carregue a apresentação.
O exemplo a seguir seleciona a cultura japonesa, abre uma apresentação com as opções de carga configuradas e chama IChartDataWorkbook::CalculateFormulas para cada planilha de gráfico:
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShape.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/LoadOptions.h>
#include <DOM/Presentation.h>
#include <DOM/SpreadsheetOptions.h>
#include <system/globalization/culture_info.h>
#include <system/object_ext.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace System;
using namespace System::Globalization;
auto japaneseCulture = CultureInfo::GetCultureInfo(u"ja-JP");
auto spreadsheetOptions = MakeObject<SpreadsheetOptions>();
spreadsheetOptions->set_PreferredCulture(japaneseCulture);
auto loadOptions = MakeObject<LoadOptions>();
loadOptions->set_SpreadsheetOptions(spreadsheetOptions);
auto presentation = MakeObject<Presentation>(u"presentation.pptx", loadOptions);
for (int32_t slideIndex = 0; slideIndex < presentation->get_Slides()->get_Count(); slideIndex++)
{
auto slide = presentation->get_Slide(slideIndex);
for (int32_t shapeIndex = 0; shapeIndex < slide->get_Shapes()->get_Count(); shapeIndex++)
{
auto shape = slide->get_Shape(shapeIndex);
if (ObjectExt::Is<IChart>(shape))
{
auto chart = ExplicitCast<IChart>(shape);
chart->get_ChartData()->get_ChartDataWorkbook()->CalculateFormulas();
}
}
}
A cultura preferida faz parte da configuração de carregamento da apresentação, portanto especifique-a antes de criar a instância de Presentation. Use a cultura esperada pelas fórmulas da planilha; por exemplo, use ja-JP para fórmulas que devem seguir regras de cálculo DBCS japonesas.
Recalculação e Valores em Cache
Arquivos de planilha geralmente armazenam tanto a fórmula quanto seu último valor calculado. O Aspose.Slides pode, portanto, ler um valor em cache de IChartDataCell::get_Value quando uma apresentação é carregada e os dados do gráfico relevantes não foram alterados.
Depois de alterar células de entrada ou fórmulas, não confie em um resultado antigo em cache. Chame IChartDataWorkbook::CalculateFormulas antes de ler valores calculados ou salvar dados de gráfico que dependam deles.
Para fórmulas fora do subconjunto suportado, o Aspose.Slides pode não conseguir analisar a fórmula ou estabelecer suas dependências. Se a planilha foi modificada, o valor em cache anterior não pode mais ser considerado confiável. Nessa situação, ler o valor de uma célula com dados não suportados pode gerar CellUnsupportedDataException.
Se o seu gráfico depender de funções do Excel que o Aspose.Slides não avalia, calcule essas fórmulas com um motor de planilha que as suporte e grave os valores resultantes de volta na planilha do gráfico. Não substitua fórmulas não suportadas por valores adivinhados.
Tratar Erros de Fórmula
Existem dois tipos diferentes de problemas a distinguir.
Uma fórmula pode ser válida, mas produzir um resultado de erro de planilha, como #DIV/0!, #N/A, #NAME?, #NULL!, #NUM!, #REF! ou #VALUE!. Nesse caso, o token de erro é um resultado de célula e pode ser retornado por IChartDataCell::get_Value.
Uma fórmula também pode falhar ao ser analisada, referenciada, em suas dependências ou por não ser suportada. O Aspose.Slides fornece exceções específicas de planilha para esses casos: CellInvalidFormulaException, CellInvalidReferenceException, CellCircularReferenceException e CellUnsupportedDataException.
Quando as fórmulas provêm de modelos ou entrada do usuário, trate essas exceções ao redor da recalculação e do acesso ao valor:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Spreadsheet/CellCircularReferenceException.h>
#include <Spreadsheet/CellInvalidFormulaException.h>
#include <Spreadsheet/CellInvalidReferenceException.h>
#include <Spreadsheet/CellUnsupportedDataException.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Spreadsheet;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 500.0f, 300.0f);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
auto cell = workbook->GetCell(0, u"A2");
cell->set_Formula(u"SUM(B2:B5)");
try
{
workbook->CalculateFormulas();
auto value = cell->get_Value();
}
catch (CellInvalidFormulaException&)
{
// Tratar uma fórmula inválida.
}
catch (CellInvalidReferenceException&)
{
// Tratar uma referência de célula inválida.
}
catch (CellCircularReferenceException&)
{
// Tratar uma referência circular.
}
catch (CellUnsupportedDataException&)
{
// Tratar dados de planilha não suportados.
}
Limitações Práticas
O suporte a fórmulas em planilhas de gráficos destina‑se a um subconjunto definido de cálculos de planilha, não à compatibilidade total com o Excel. Mantenha essas restrições em mente ao projetar um fluxo de trabalho de relatórios:
- Use apenas as constantes, operadores, referências e funções documentadas quando precisar que o Aspose.Slides recalcule fórmulas.
- Recalcule após alterar células das quais os resultados das fórmulas dependem.
- Considere os valores em cache de apresentações carregadas como instantâneos, não como substitutos da recalculação após edições.
- Teste fórmulas de modelos existentes antes de confiar em seus valores calculados, especialmente se usarem funções fora da lista documentada.
- Para fórmulas que exigem um motor de cálculo completo de planilha, calcule-as externamente e, em seguida, atualize a planilha do gráfico com os valores resultantes.
Perguntas Frequentes
Qual é a diferença entre set_Formula e set_R1C1Formula?
IChartDataCell::set_Formula armazena uma expressão no estilo A1, como B2-C2. IChartDataCell::set_R1C1Formula armazena uma expressão no estilo R1C1, como RC[-2]-RC[-1]. Use a notação que melhor corresponde à forma como você gera ou copia as fórmulas.
Preciso ler a própria célula ou seu valor após a cálculo?
IChartDataWorkbook::GetCell retorna um IChartDataCell. Para obter o resultado calculado, leia o valor desse IChartDataCell::get_Value após a recalculação.
Quando devo chamar CalculateFormulas?
Chame IChartDataWorkbook::CalculateFormulas depois de alterar valores de entrada ou fórmulas e antes de depender dos resultados calculados. Isso atualiza os valores das fórmulas que o avaliador incorporado suporta.
O Aspose.Slides suporta todas as funções do Excel?
Não. O avaliador incorporado suporta um subconjunto documentado de funções. Funções fora desse subconjunto não devem ser presumidas como recalculáveis corretamente. Se for necessária compatibilidade completa com fórmulas do Excel, execute o cálculo com um motor de planilha adequado e grave os valores finais na planilha do gráfico.
O que acontece se uma apresentação carregada contiver uma fórmula não suportada?
Se os dados do gráfico não foram alterados, a planilha pode ainda conter um valor em cache calculado anteriormente. Após a modificação dos dados relacionados, esse valor em cache pode não ser mais válido. Acessar uma célula cuja fórmula não pode ser tratada pode gerar CellUnsupportedDataException.
Os valores de erro de fórmula são os mesmos que exceções C++?
Não. Um resultado como #DIV/0! é um valor de planilha produzido por um cálculo válido. Exceções como CellInvalidFormulaException ou CellCircularReferenceException indicam que a fórmula não pode ser processada normalmente.
Um gráfico é atualizado automaticamente quando uma célula de fórmula muda?
Uma série de gráfico pode referenciar células da planilha. Recalcule a planilha primeiro, depois salve ou renderize a apresentação. Se os pontos de dados do gráfico referenciam as células calculadas, o gráfico usará esses valores atualizados; nenhum método de atualização de gráfico separado é necessário para este fluxo de trabalho.
Gráficos podem usar uma planilha Excel externa?
Sim, os dados do gráfico podem ser configurados para usar uma planilha externa por meio da API de dados de gráfico. Contudo, o fluxo de trabalho de cálculo de fórmulas descrito neste artigo refere‑se à planilha de dados do gráfico e ao subconjunto de fórmulas avaliado pelo Aspose.Slides. Não presuma que IChartDataWorkbook::CalculateFormulas forneça recalculação completa de fórmulas arbitrárias em um arquivo XLSX externo.
Posso usar fórmulas que referenciam outra planilha ou outra pasta de trabalho?
Referências no estilo Excel podem existir em planilhas de gráficos, mas a avaliação de fórmulas é limitada ao analisador e ao conjunto de funções suportados. Se uma referência cruzada ou externa for essencial, valide essa fórmula exata com a versão do Aspose.Slides que você utiliza. Para fluxos de trabalho que exigem ampla compatibilidade de referência do Excel, calcule a planilha externamente e grave os valores resolvidos de volta nos dados do gráfico.
As strings de fórmula devem começar com =?
Os exemplos da API Aspose.Slides atribuem expressões como B2-C2 ou SUM(B2:B5) sem um = inicial. Usar essa forma mantém as fórmulas geradas consistentes com os exemplos documentados da API.