Trovalo, Correggilo, Convalidalo: Guida Completa all’API di Ricerca, Sostituzione e Link Interrotti di Aspose.Cells Cloud (.NET / Python / Java / cURL)

“Quale dei nostri 400 workbook di budget dice ancora Old Vendor Ltd?” “Sostituisci ogni segnaposto {{COMPANY}} in questo modello.” “Qualcuno dei nostri report collega ancora quel dominio che abbiamo ritirato lo scorso anno?” — tre domande molto diverse, una risposta comune: una chiamata REST che legge e riscrive i fogli di calcolo nel cloud, senza Excel installato da nessuna parte.

I problemi di contenuto dei fogli di calcolo compaiono in quasi tutti i codebase ad alta intensità di dati:

• Audit dei contenuti — individuare ogni cella, forma o collegamento ipertestuale che menziona un nome di prodotto deprecato, un vecchio indirizzo dell’ufficio o una entità legale obsoleta;
• Rendering del modello — riempire i token {{PLACEHOLDER}} nei fogli prima di inviare una cartella di lavoro a un cliente;
• Link rot — verificare che gli URL incorporati in una cartella di lavoro siano ancora risolvibili, prima che un lavoro di conformità o archiviazione lo approvi;
• Correzione di massa — correggere un errore di battitura o un valore di colonna scritto in modo errato su decine di fogli, o limitato a una sola regione di un foglio.

Le opzioni tradizionali — una libreria di scripting in esecuzione sul tuo computer, una macro Excel o un componente COM su un server Windows — implicano tutti che sei tu a ospitare e scalare la logica dei fogli di calcolo. Aspose.Cells Cloud la trasforma in un semplice REST: invia un file (o solo il nome del file), ricevi le corrispondenze — o un file corretto — indietro.

Questo post illustra le API esposte dal core SearchController nel microservizio Aspose.Cells Cloud (source: src/Aspose.Cells.Cloud.MicroService/Controllers/SearchController.cs), con esempi eseguibili in cURL e C# (.NET), oltre a note per gli utenti Python e Java.

1. Cosa può fare il SearchController?

SearchController copre tre famiglie di capacità, ciascuna disponibile in diversi ambiti:

E ogni famiglia è esposta in quattro ambiti, che è dove l’elenco degli endpoint diventa lungo:

In più, due endpoint bonus che esportano ogni elemento di testo in una cartella di lavoro — vedi §4:

Nota di implementazione: le rotte sono prefissate con v{version:apiVersion}/cells e questo controller è [ApiVersion("4.0")], quindi le chiamate live appaiono come https://api.aspose.cloud/v4.0/cells/.... Tutto in questo controller è un PUT — anche le ricerche in sola lettura — perché una ricerca è modellata come un’operazione inviata contro una risorsa, non un GET memorizzabile.

Le due modalità operative e perché sono importanti

Il controller decora ogni azione e il decoratore indica esattamente da dove proviene il file:

• [OnlineOperation] — senza stato. Carichi il workbook nel corpo della richiesta (multipart), il server lo elabora in memoria e nulla viene salvato nello storage cloud. Perfetto per “just tell me what’s in this file” e per la creazione di template in un’unica operazione.
• [CloudFileOperation] — basato su storage. Il server recupera {name} dallo storage cloud (facoltativamente sotto folder=), esegue il lavoro e — per le operazioni di sostituzione — scrive il risultato direttamente indietro. Nulla viene trasferito al tuo computer.

Quella singola distinzione, più i segmenti di route {worksheet} / {cellArea}, costituiscono l’intero modello mentale. Il resto di questo post è solo i dettagli.

2. I modelli di risposta che analizzerai effettivamente

Entrambe le famiglie di ricerca restituiscono una forma piccola, piatta e facile da collegare. Search restituisce SearchResponse:

{
  "Code": 200,
  "Status": "OK",
  "TextItems": [
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Q3 Forecast",
      "Position": "Cell:B7",
      "Content": "Old Vendor Ltd"
    },
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Q3 Forecast",
      "Position": "Shape:TextBox 3",
      "Content": "Prepared by Old Vendor Ltd"
    }
  ]
}

La ricerca di collegamenti interrotti restituisce BrokenLinksResponse:

{
  "Code": 200,
  "Status": "OK",
  "BrokenLinks": [
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Links",
      "Position": "Hyperlink:Sheet1!B4",
      "LinkAddress": "https://retired-domain.example.com/report"
    }
  ]
}

Due cose meritano di essere evidenziate subito:

1. Position è una posizione contrassegnata, non solo un indirizzo di cella. È prefissata con Cell:, Hyperlink: o Shape:, che è il modo in cui un elenco piatto singolo può indicarti che tipo di elemento corrisposto. Quel tag è la differenza tra “fix cell B7” e “fix the text box sitting over B7”.
2. Entrambi i modelli sono auto‑descrittivi per la segnalazione — Filename e Worksheet vengono restituiti in ogni elemento, così una scansione attraverso molti workbook può essere concatenata in una singola tabella di audit senza post‑processing.

3. Due cose di cui hai bisogno prima di iniziare

1. Registra un account gratuito sul Aspose Cloud Dashboard e crea un’Applicazione per ottenere un Client ID e un Client Secret (gli SDK scambiano questi per un JWT automaticamente — non è necessario creare manualmente le intestazioni di autenticazione).
2. Installa l’SDK per il linguaggio di tua scelta:

<!-- .NET -->
<PackageReference Include="Aspere.Cells-Cloud" Version="25.x" />

# Python
pip install asposecellscloud

<!-- Java (Maven) — note: NOT on Maven Central, so the Aspose repo below is required -->
<repositories>
    <repository>
        <id>AsposeJavaAPI</id>
        <name>Aspose Java API</name>
        <url>https://repository.aspose.cloud/repo/</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-cells-cloud</artifactId>
    <version>26.8</version>
</dependency>

Nessun SDK richiesto? Tutto è plain REST, quindi cURL funziona altrettanto bene (vedi sotto). La famiglia di ricerca/sostituzione/link rotti è anch’essa raggiungibile tramite modelli di richiesta SDK tipizzati — SearchSpreadsheetContentRequest, ReplaceContentInRemoteRangeRequest e simili — che è ciò che gli snippet C# sotto utilizzano.

4. Scenario A: Cerca un file locale online (nulla salvato)

Questo è PUT /v4.0/cells/search/content — carica la cartella di lavoro, ricevi le corrispondenze. Nessuno storage cloud, nessuna pulizia, nessuna copia lasciata indietro.

① cURL

# 1) First, get a token
curl -X POST "https://api.aspose.cloud/connect/token" \
  -d "grant_type=client_credentials" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET"

# 2) Find "Old Vendor Ltd" anywhere in a local workbook
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "ignoringCase=true" \
  -F "file=@Book1.xlsx"

Restringi a un foglio, o a una regione di un foglio, con altri due parametri di query:

# Only "Q3 Forecast", only the range A1:F40
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "worksheet=Q3 Forecast" \
  --data-urlencode "cellArea=A1:F40" \
  -F "file=@Book1.xlsx"

② C# / .NET

using Aspose.Cells.Cloud.SDK.Api;
using Aspose.Cells.Cloud.SDK.Request;

var cellsApi = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

// Local file, whole workbook
var request = new SearchSpreadsheetContentRequest(
    spreadsheet:  "C:/audit/Book1.xlsx",   // local file path
    searchText:   "Old Vendor Ltd",
    ignoringCase: true);

SearchResponse response = cellsApi.SearchSpreadsheetContent(request);

foreach (var item in response.TextItems)
{
    Console.WriteLine($"{item.Worksheet} | {item.Position} | {item.Content}");
}

// Same call, scoped to one sheet and one range
var scoped = new SearchSpreadsheetContentRequest(
    spreadsheet:  "C:/audit/Book1.xlsx",
    searchText:   "Old Vendor Ltd",
    ignoringCase: true,
    sheetname:    "Q3 Forecast",
    cellarea:     "A1:F40");

I modelli di richiesta espongono anche password (apri una cartella di lavoro protetta) e regoin (impostazione di regione/locale) — gli stessi parametri opzionali che vedrai nelle varianti cloud-storage come storageName. Nota che il SDK .NET mantiene l’ortografia regoin; il SDK Python chiama le stesse due impostazioni password e region.

③ Python / Java

Il SDK Python avvolge la stessa famiglia di endpoint, con i campi del modello di richiesta mappati a quelli C# uno a uno ma in snake_case:

from asposecellscloud.apis.cells_api import CellsApi
from asposecellscloud.requests import (
    SearchSpreadsheetContentRequest,
    SearchContentInRemoteRangeRequest,
)

instance = CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")

# Local upload — returned items carry Worksheet / Position / Content
local = instance.search_spreadsheet_content(
    SearchSpreadsheetContentRequest(
        "Book1.xlsx", "Old Vendor Ltd",
        ignoring_case=True, worksheet="Q3 Forecast", cell_area="A1:F40"))

# Range-scoped search of a file already in cloud storage
remote = instance.search_content_in_remote_range(
    SearchContentInRemoteRangeRequest(
        "Book1.xlsx", "Q3 Forecast", "A1:F40", "Old Vendor Ltd",
        ignoring_case=True, folder="Reports"))

for item in remote.text_items:
    print(item.worksheet, item.position, item.content)

Il Java SDK segue la stessa forma con gli oggetti Request costruiti tramite i setter:

import com.aspose.cloud.cells.api.CellsApi;
import com.aspose.cloud.cells.model.SearchResponse;
import com.aspose.cloud.cells.request.SearchContentInRemoteRangeRequest;

public class SearchDemo {
    public static void main(String[] args) throws Exception {
        CellsApi api = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

SearchContentInRemoteRangeRequest req = new SearchContentInRemoteRangeRequest();
        req.setName("Book1.xlsx");
        req.setWorksheet("Q3 Forecast");
        req.setCellArea("A1:F40");
        req.setSearchText("Old Vendor Ltd");
        req.setIgnoringCase(true);
        req.setFolder("Reports");

SearchResponse response = api.searchContentInRemoteRange(req);
        response.getTextItems().forEach(i ->
            System.out.println(i.getWorksheet() + " | " + i.getPosition() + " | " + i.getContent()));
    }
}

Se utilizzi REST grezzo, il cURL sopra è il contratto completo — il campo multipart deve semplicemente contenere il nome file, poiché il servizio ricava il nome della cartella di lavoro (e quindi il suo formato) da esso.

5. Scenario B: Cerca un file che è già presente nello storage cloud

Quando la cartella di lavoro è già in Aspose Cloud Storage, salta completamente il download — il servizio la legge dove si trova:

# Whole workbook
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "ignoringCase=true" \
  --data-urlencode "folder=Reports"

# Just one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd"

# Just one range of one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/ranges/A1:F40/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd"

// Whole workbook in storage
var response = cellsApi.SearchContentInRemoteSpreadsheet(
    new SearchContentInRemoteSpreadsheetRequest(
        name:         "Book1.xlsx",
        searchText:   "Old Vendor Ltd",
        ignoringCase: true,
        folder:       "Reports"));

// One worksheet
var sheetHits = cellsApi.SearchContentInRemoteWorksheet(
    new SearchContentInRemoteWorksheetRequest(
        name:       "Book1.xlsx",
        sheetname:  "Q3 Forecast",
        searchText: "Old Vendor Ltd",
        folder:     "Reports"));

// One range
var rangeHits = cellsApi.SearchContentInRemoteRange(
    new SearchContentInRemoteRangeRequest(
        name:        "Book1.xlsx",
        sheetname:   "Q3 Forecast",
        cellArea:    "A1:F40",
        searchText:  "Old Vendor Ltd",
        ignoringCase: true,
        folder:      "Reports"));

Perché tre endpoint invece di uno? Perché il percorso trasporta lo scope. L’endpoint dell’intero workbook accetta un nome e una query; l’endpoint del foglio di lavoro accetta un segmento di foglio; l’endpoint dell’intervallo accetta un foglio di lavoro e un segmento di intervallo. È una forma REST pulita e memorizzabile nella cache — e significa che i parametri “narrow my search” (worksheet, cellArea) esistono solo sull’endpoint del file locale, il che è utile ricordare quando si porta una chiamata da uno scope all’altro.

6. Scenario C: Ottieni tutti gli elementi di testo in una cartella di lavoro

A volte non hai un termine di ricerca — vuoi l’inventario. Gli endpoint all-textitems restituiscono ogni elemento di testo nella cartella di lavoro, così puoi confrontare due revisioni, creare un glossario di traduzione o alimentare un indicizzatore:

# File cloud — tutti gli elementi di testo
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/content/all-textitems" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

# Caricamento locale — tutti gli elementi di testo
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content/all-textitems" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@Book1.xlsx"

La risposta è la stessa busta SearchResponse, con Content popolato per ogni stringa di cella, didascalia di collegamento ipertestuale e testo di forma nel file. Questo è il primitivo “grep the whole workbook”.

7. Scenario D: Sostituisci — e i due risultati molto diversi

Replace è dove l’API si divide in due, e la divisione è deliberata:

① Sostituisci in una cartella di lavoro locale, trasmetti il risultato in streaming

curl -X PUT "https://api.aspose.cloud/v4.0/cells/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText={{COMPANY}}" \
  --data-urlencode "replaceText=Northwind Traders" \
  -F "file=@template.xlsx" \
  -o template-rendered.xlsx

using Aspose.Cells.Cloud.SDK.Request;

var request = new ReplaceSpreadsheetContentRequest(
    spreadsheet: "C:/templates/template.xlsx",
    searchText:  "{{COMPANY}}",
    replaceText: "Northwind Traders");

// Option A: get the corrected workbook as a Stream
using Stream corrected = cellsApi.ReplaceSpreadsheetContent(request);
using var outFile = File.Create("C:/templates/template-rendered.xlsx");
corrected.CopyTo(outFile);

// Option B: let the SDK write it for you (.NET overload with an output path)
// cellsApi.ReplaceSpreadsheetContent(request, "C:/templates/template-rendered.xlsx");

Sono disponibili anche due parametri di ambito — sheetname e cellarea — così puoi rendere i segnaposto in un foglio senza toccare il resto del modello.

② Sostituisci in una cartella di lavoro cloud, salva in loco

# Whole workbook, saved back to storage
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

# One worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

# One range
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/ranges/A1:F40/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

// Whole workbook — result saved back into cloud storage
cellsApi.ReplaceContentInRemoteSpreadsheet(
    new ReplaceContentInRemoteSpreadsheetRequest(
        name:        "Book1.xlsx",
        searchText:  "Old Vendor Ltd",
        replaceText: "Northwind Traders",
        folder:      "Reports"));

// Range-scoped
cellsApi.ReplaceContentInRemoteRange(
    new ReplaceContentInRemoteRangeRequest(
        name:        "Book1.xlsx",
        searchText:  "Old Vendor Ltd",
        replaceText: "Northwind Traders",
        worksheet:   "Q3 Forecast",
        cellarea:    "A1:F40",
        folder:      "Reports"));

La sostituzione in loco è distruttiva per progettazione. Le varianti cloud sovrascrivono {name} — non viene creata una copia di backup. Per flussi di lavoro con forte audit, mantieni una copia revisionata (ad es. carica prima Book1-2026-09-11.xlsx, poi sostituisci) o usa la variante di caricamento locale e conserva lo stream restituito tu stesso.

8. Scenario E: Trova i collegamenti interrotti prima che lo faccia qualcun altro

Il controllo dei collegamenti è la funzionalità nascosta qui — è il tipo di cosa che è noiosa da scrivere da soli e imbarazzante da saltare. Tutti e quattro gli ambiti sono disponibili; la variante di file locale è il controllo di sanità più rapido:

# Local workbook, whole file
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@Book1.xlsx"

# Cloud workbook, whole file
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

# Cloud workbook, one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Links/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

var broken = cellsApi.SearchSpreadsheetBrokenLinks(
    new SearchSpreadsheetBrokenLinksRequest(
        spreadsheet: "C:/audit/Book1.xlsx"));

foreach (var link in broken.BrokenLinks)
{
    Console.WriteLine($"{link.Worksheet} {link.Position} -> {link.LinkAddress}");
}

Il risultato è un elenco su cui puoi agire direttamente: ogni voce indica il foglio, la posizione e il LinkAddress incriminato.

9. Cosa viene effettivamente scansionato? (i dettagli di implementazione che cambiano le tue aspettative)

Questa è la parte che separa un’integrazione funzionante da una sorprendente. Leggendo WorkbookExtension.cs, una ricerca attraversa tre tipi distinti di elementi in ogni foglio di lavoro:

Ecco i comportamenti da conoscere prima di progettare intorno a loro:

Vengono ricercate solo le celle di tipo stringa. La scansione filtra su CellValueType.IsString. Una cella contenente un numero, una data o un booleano viene ignorata — quindi una ricerca per 2025 non corrisponderà a una cella formattata come data il cui valore seriale è 2025. Le celle le cui formule restituiscono testo sono corrispondenti, poiché il loro tipo di valore è stringa.

La sensibilità al maiuscolo/minuscolo è l’unica opzione di corrispondenza. ignoringCase passa tra il confronto InvariantCultureIgnoreCase e InvariantCulture — nient’altro. Non c’è modalità parola intera, regex o “corrispondi all’intero valore della cella”, nonostante quello che la documentazione API generata potrebbe suggerire. Se ti servono queste semantiche, recupera l’inventario all-textitems e filtralo sul tuo lato.

Replace è una sostituzione semplice, sensibile al maiuscolo/minuscolo e letterale. Il flag ignoringCase di Search non ha alcun equivalente in Replace — il percorso di replace non ha alcun parametro di insensibilità al caso. Inoltre i due percorsi di codice differiscono internamente: una sostituzione dell’intero foglio di lavoro delega al metodo Worksheet.Replace(...) del motore, mentre una sostituzione limitata a un intervallo itera l’intervallo e riscrive ogni cella di tipo stringa con cell.StringValue.Replace(...). Conseguenza pratica: la sostituzione limitata a un intervallo tocca solo le celle stringa, ed è letterale, non basata su pattern.

Le corrispondenze dei collegamenti ipertestuali riportano l’indirizzo, non la didascalia. Quando una ricerca corrisponde al testo visualizzato di un collegamento ipertestuale, il Content restituito è ancora hyperlink.Address. Se stai generando un report “found it here”, attendi l’URL — la didascalia non viene restituita.

Il controllo dei collegamenti interrotti considera solo http:// e https://. I collegamenti mailto: , i percorsi di file locali e gli ancoraggi interni #Sheet1!A1 vengono completamente ignorati — non vengono mai testati, quindi non appariranno mai nei risultati. Scansiona anche i collegamenti ipertestuali collegati a forme così come alle celle, che è esattamente dove i collegamenti morti tendono a nascondersi. Nota che un Position di collegamento interrotto è costruito dal hyperlink.Area grezzo (non dal più amichevole Area.ToRangName() usato dagli endpoint di ricerca), quindi non presumere che le due famiglie rendano le posizioni in modo identico — analizza la coppia Worksheet + LinkAddress se ti serve una chiave stabile.

“Broken” significa “inaccessibile”, non “codice di stato errato”. Il controllo invia una richiesta HTTP HEAD per ogni link e tratta qualsiasi risposta — inclusi 404 o 500 — come accessibile; segna un link come rotto solo quando la richiesta lancia (errore DNS, connessione rifiutata, errore TLS, timeout). Quindi considera l’output come “link che non è stato possibile contattare”. Se quello di cui hai realmente bisogno è “link che non restituiscono 2xx”, dovrai ricontrollare i valori LinkAddress restituiti tu stesso.

cellArea è accettato ma non applicato negli endpoint dei link rotti. L’implementazione BrokenLinks filtra solo per nome del foglio di lavoro; l’argomento cell-area viene passato ma non viene mai utilizzato. In pratica ciò significa che .../ranges/A1:F40/search/broken-links attualmente si comporta allo stesso modo di /worksheet/search/broken-links per lo stesso foglio di lavoro — i collegamenti vengono convalidati su tutto il foglio. Definisci l’ambito dei tuoi report di conseguenza (o filtra l’elenco restituito per posizione) invece di presumere che l’intervallo restringa il controllo.

Nessuno di questi è un ostacolo — è la differenza tra una funzionalità che “funziona nella demo” e una che si comporta in modo prevedibile in produzione.

10. Gestione degli errori e note operative

Il contratto che il controller documenta

Internamente, ogni azione avvolge il proprio lavoro in un helper (WorkbookElementOperation, UpdateWorkbookElementOperation, UpdateWorkbookElementOperationAndSave) che intercetta i fallimenti e li rilancia come una CellsApiException prefissata con il nome dell’operazione — per esempio SearchContentInRemoteRange Error Message: .... Quel nome dell’operazione è la stringa che vedrai nei tuoi log:

Parametri opzionali esposti dagli SDK

Oltre ai parametri documentati, tutti i modelli di richiesta cloud-storage includono le stesse tre impostazioni opzionali:

• password — apri una cartella di lavoro protetta da password (le ricerche non richiedono accesso in scrittura, quindi i file protetti in lettura funzionano bene);
• storageName — indirizza un cloud storage personalizzato/allegato invece di quello predefinito (Python: storage_name);
• regoin — l’impostazione di regione/locale usata quando si interpreta la cartella di lavoro (Python la chiama region).

Autenticazione

Tutti gli SDK si autenticano automaticamente con OAuth 2.0 client_credentials e un JWT; quando si utilizza cURL grezzo, chiamare /connect/token una volta prima (vedi §4, ①).

11. Perché Aspose.Cells Cloud per la ricerca e sostituzione?

• ✅ Zero dipendenze locali — no Office/Excel, no COM, no scripting host. Invocabile da qualsiasi linguaggio, su qualsiasi piattaforma (Linux, containers, serverless);
• ✅ Più profondo della ricerca testuale — cells, shapes e hyperlinks sono tutti obiettivi di corrispondenza di prima classe, che è esattamente dove i fogli di calcolo reali conservano il loro contenuto;
• ✅ Operazioni a livello di ambito — workbook / worksheet / range, così puoi correggere una regione di un foglio senza riscrivere un file da 50 MB;
• ✅ Nativo cloud o senza stato — i file già in storage non lo lasciano mai; le operazioni di caricamento locale non persistono nulla;
• ✅ Riscrittura ad alta fedeltà — le sostituzioni vengono applicate tramite il motore Aspose.Cells e ri-serializzate, così formule, stili, grafici e formattazione sopravvivono al round trip;
• ✅ Una forma coerente tra gli SDK — le interfacce cURL, .NET, Python e Java corrispondono 1:1, così il modello che copi da un linguaggio funziona negli altri.

Inizia subito: registrati sul Aspose Cloud Dashboard, crea un’Applicazione, inserisci le tue credenziali in uno qualsiasi degli snippet sopra e puntalo a uno dei tuoi workbook — avrai un audit dei contenuti funzionante in pochi minuti.

Ti è stato utile? Metti una stella, aggiungi ai segnalibri o condividilo — e raccontaci nei commenti per cosa stai usando la ricerca e sostituzione nei fogli di lavoro.