Le traitement automatisé des factures consiste à lire les factures fournisseurs entrantes, à extraire les lignes de commande, à les valider par rapport aux bons de commande et à inscrire les résultats dans un classeur structuré exploitable par votre système financier. En pratique, il s'agit d'automatisation documentaire dans .NET où une instruction en langage naturel remplace le code de mappage de champs et de mise en page. Spire.Agent.Office est un SDK d'agent IA documentaire qui gère le langage ; une couche documentaire déterministe garantit des fichiers Excel et PDF réels et bien formés.

Navigation rapide

1. Pourquoi le traitement des factures est adapté à l'IA
2. Ce qu'un agent IA de facturation peut et ne peut pas faire
3. Scénarios courants de traitement des factures
4. Trois façons d'automatiser le traitement des factures dans .NET
5. Un exemple pratique : Extraire, valider et rapporter en C#
6. Pourquoi utiliser Spire.Agent.Office pour le traitement des factures par IA
7. FAQ

1. Pourquoi le traitement des factures est adapté à l'IA

Le travail sur les factures pour un développeur se résume à trois tâches répétitives : la lecture (extraction du fournisseur, de la date, des lignes de commande et des totaux à partir de documents arrivant sous forme de PDF, fichiers Word, feuilles Excel ou images numérisées), la vérification (rapprochement des factures avec les bons de commande et signalement des écarts) et la production (écriture des résultats dans un classeur structuré que votre système comptable peut consommer).

Pour les développeurs .NET, le défi n'est pas seulement de comprendre le contenu de la facture ; c'est de transformer des documents non structurés et multi-formats en flux de travail structurés et reproductibles que votre application peut gérer.

Trois propriétés rendent ces tâches idéales pour un modèle de langage plutôt que pour des règles écrites à la main :

• L'entrée est multi-format. Les factures entrantes arrivent sous forme de pièces jointes PDF, d'images numérisées, de documents Word ou de fichiers Excel, chacun avec une mise en page différente. Les règles gérant un format échouent sur le suivant ; un LLM lit le texte directement, quel que soit le type de fichier.
• La sortie est sous forme de document. Le livrable est un vrai .xlsx ou .pdf avec un formatage correct, pas un bloc de texte. C'est là qu'une couche documentaire prend tout son sens.
• Le volume change constamment. Intégrer 50 nouveaux fournisseurs ou examiner 200 factures par mois nécessite une solution basée sur la configuration, et non un recodage par fournisseur.

En pratique, l'extraction et la validation vont de pair : les équipes souhaitent que les factures soient résumées, les écarts signalés, et que de nouvelles factures soient générées à partir d'un modèle et de données structurées. Pour un aperçu approfondi de la conception d'un agent IA documentaire et de sa place dans un pipeline de contenu, consultez Agent IA pour le traitement documentaire : Qu'est-ce que c'est et comment ça fonctionne.

2. Ce qu'un agent IA de facturation peut et ne peut pas faire

La répartition des tâches : l'agent automatise la lecture, l'extraction et la validation (les heures qu'un employé comptable passerait), tandis qu'un réviseur humain assure la validation finale. Cette limite est ce qui rend l'outil utile et le processus défendable.

3. Scénarios courants de traitement des factures

Le traitement des factures couvre bien plus qu'une simple extraction ponctuelle. Le même modèle (une instruction, des fichiers de facture et des données de référence optionnelles) couvre les scénarios les plus recherchés par les équipes :

Chaque scénario repose sur la même architecture : une instruction en entrée, un vrai document en sortie.

4. Trois façons d'automatiser le traitement des factures dans .NET

Le point clé : un LLM ne peut pas lire une facture PDF sans une couche de traitement documentaire, et un SDK traditionnel ne peut pas comprendre une requête en langage naturel. Un agent IA documentaire combine les deux.

Cela ne veut pas dire que la voie traditionnelle est mauvaise. Pour des factures fixes et bien spécifiées qui changent rarement, un SDK déterministe est souvent le bon choix, et Spire.Office répond toujours à ce besoin. Si c'est votre situation, Générer des documents Word à partir de données Excel en C# démontre le flux de travail classique de génération de documents piloté par les données. L'agent gagne sa place lorsque les mises en page des fournisseurs, les formats d'entrée et les règles de validation changent assez souvent pour que le recodage devienne le goulot d'étranglement.

Pourquoi une API LLM brute ne suffit pas pour le traitement des factures

Appeler gpt-4 ou claude directement pour "extraire des données de cette facture" échoue de trois manières importantes en production :

1. Il ne peut pas lire ou écrire de manière fiable les fichiers Office. Les LLM voient du texte, pas la structure .xlsx et .pdf. Lire une facture PDF, garder un tableau de lignes intact, ou produire un classeur Excel valide nécessite généralement un pipeline d'extraction et de reconstruction séparé que vous devez construire vous-même.
2. Le formatage n'est pas garanti. Les rapports de factures comportent des en-têtes de colonne, des formats numériques et des remplissages conditionnels qui importent à l'équipe comptable. Un LLM brut renvoie du texte, et le formatage que vous perdez est exactement ce dont les services comptables se soucient.
3. Vous réimplémentez toute l'orchestration. La conception des prompts, le mappage des champs, la gestion des erreurs, les E/S de fichiers et la validation de la sortie deviennent votre code à posséder et à maintenir.

Un agent IA documentaire associe la compréhension du langage du modèle aux API documentaires déterministes : le modèle décide quoi extraire ou rapprocher, et la couche documentaire garantit que le fichier est réel et bien formé. C'est la différence entre une démo et un flux de travail qu'une équipe peut déployer.

5. Un exemple pratique : Extraire, valider et rapporter en C#

Voici une tâche que l'équipe comptable répète chaque mois : traiter les factures fournisseurs entrantes, extraire des données de formats disparates, valider par rapport aux bons de commande et produire un classeur structuré. L'implémentation utilise Spire.Agent.Office pour .NET, un agent IA qui traite les documents Word, Excel, PowerPoint et PDF via des instructions en langage naturel. L'exemple est conçu autour de ce flux de travail plutôt que copié d'un tutoriel ; les tutoriels officiels Démarrage et Révision de contrat IA en C# documentent la configuration de l'API étape par étape, tandis que cette section se concentre sur les modèles d'intégration C#.

1. Extraire les données de chaque facture dans la boîte de réception. Configurez l'agent une fois, puis lisez le dossier de réception et faites analyser chaque facture dans un tableau fusionné unique :

using System.IO;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Doc;
using Spire.Pdf;
using Spire.Xls;

AIOptions agentOptions = new AIOptions();
agentOptions.WorkDir = @"C:\ap-invoices\output";
agentOptions.SpireToken = spireToken;

string extractPrompt =
    "Lis chaque fichier de facture fournisseur dans la boîte de réception (PDF, Word, Excel ou images) et extrais " +
    "les informations de chaque fournisseur : nom de l'entreprise, numéro de facture, date d'émission, date d'échéance, lignes " +
    "de commande (description, quantité, prix unitaire, montant), sous-total, taxe et total. Fusionne les " +
    "résultats dans une seule feuille de calcul avec les colonnes : Fournisseur, NuméroFacture, DateÉmission, DateÉchéance, " +
    "Description, Quantité, PrixUnitaire, MontantLigne, SousTotal, Taxe, Total. Ignore les lignes d'en-tête " +
    "en double et enregistre en tant que classeur.";

Directory.CreateDirectory(@"C:\ap-invoices\output");

string[] invoiceFiles = Directory.GetFiles(@"C:\ap-invoices\inbox", "*.*");

L'agent gère le défi multi-format — les PDF, images numérisées, documents Word et fichiers Excel transitent tous par la même instruction sans code spécifique au format :

using (Workbook extracted = new Workbook())
{
    AIResult result = extracted.AI(agentOptions).ExecuteInstruction(
        extracted,
        extractPrompt,
        @"C:\ap-invoices\output\extracted.xlsx",
        invoiceFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"L'extraction a échoué : {result?.ErrorMessage}");
}

Appels API clés

• Workbook.AI(agentOptions) — attache le processeur documentaire IA à un objet classeur
• ExecuteInstruction(doc, instruction, savePath, attachments) — exécute l'extraction et écrit le classeur fusionné
• AIResult.Success / AIResult.ErrorMessage — vérifie le résultat et affiche les erreurs

Sortie

2. Valider par rapport aux bons de commande. Chargez le fichier extrait et énoncez la règle de rapprochement en anglais simple. L'agent ajoute une feuille Validation et laisse les données sources intactes :

using (Workbook validation = new Workbook())
{
    validation.LoadFromFile(@"C:\ap-invoices\output\extracted.xlsx");

    string[] poFiles = { @"C:\ap-invoices\data\purchase-orders.xlsx" };

    AIResult result = validation.AI(agentOptions).ExecuteInstruction(
        validation,
        "Ajoute une feuille 'Validation'. Compare chaque ligne de facture avec les bons de commande " +
        "dans les pièces jointes, signale les factures où le total diffère du bon de commande de plus de 5 %, " +
        "signale les lignes dont la description ne correspond pas au bon de commande. Surligne les écarts en rouge " +
        "et ajoute une colonne 'Raison' expliquant chaque écart. Laisse les feuilles de données originales inchangées.",
        @"C:\ap-invoices\output\validated.xlsx",
        poFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"La validation a échoué : {result?.ErrorMessage}");
}

La feuille Validation se place aux côtés des données sources, avec les lignes signalées, les remplissages rouges et la colonne Raison appliqués par l'instruction :

3. Rapporter. Composez le résumé de la section 5 et exportez-le. Le savePath choisit seul le format — .xlsx ici, .pdf pour la distribution :

using (Workbook report = new Workbook())
{
    report.LoadFromFile(@"C:\ap-invoices\output\validated.xlsx");

    AIResult result = report.AI(agentOptions).ExecuteInstruction(
        report,
        "Produis un rapport de traitement. Ajoute une feuille 'Résumé' au début avec un bloc KPI " +
        "(total des factures traitées, montant total, nombre d'écarts signalés, top fournisseur par " +
        "volume), un tableau de détails groupé par fournisseur, et un résumé des écarts. Formate-le pour l'impression " +
        "et enregistre le classeur terminé.",
        @"C:\ap-invoices\output\monthly-report.xlsx");

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"La génération du rapport a échoué : {result?.ErrorMessage}");
}

La feuille Résumé se place au début du classeur, prête pour l'impression ou l'exportation PDF :

Pourquoi c'est différent : SDK traditionnel vs Agent IA

La valeur de l'agent est plus claire côte à côte. Avec le SDK traditionnel, vous localisez chaque champ par chaîne d'en-tête, codez en dur chaque seuil de validation et écrivez chaque cellule une par une — et vous devez tout reconfigurer lorsqu'un fournisseur change sa mise en page ou que la règle change. Le croquis ci-dessous (simplifié pour l'illustration) montre la forme de ce travail :

// SDK traditionnel (illustratif) : chaque champ est localisé et extrait
// par chaîne d'en-tête, les seuils sont codés en dur, et la sortie est écrite cellule par cellule
foreach (string file in invoiceFiles)
{
    Workbook wb = new Workbook();
    wb.LoadFromFile(file);
    Worksheet sheet = wb.Worksheets[0];

    // Échoue dès qu'un fournisseur change "Total Due" en "Amount Payable".
    int totalCol = FindColumnByHeader(sheet, "Total Due");
    int vendorCol = FindColumnByHeader(sheet, "Vendor Name");

    for (int r = sheet.LastRow; r >= 2; r--)
    {
        double invoiceTotal = double.Parse(sheet.Range[r, totalCol].Text);
        double poTotal = GetPoTotal(sheet.Range[r, 1].Text);
        double diff = Math.Abs(invoiceTotal - poTotal) / poTotal;

        // Un seuil codé en dur ; un fournisseur de construction déclenche de fausses alertes.
        if (diff > 0.05) sheet.Range[r, totalCol].Style.Color = Color.Red;
    }
    // ... puis fusionner, puis valider, puis résumer -- des centaines de lignes par fournisseur et par mois.
}

L'agent IA remplace cette orchestration par une instruction :

validation.AI(agentOptions).ExecuteInstruction(
    validation,
    "Ajoute une feuille 'Validation'. Compare chaque ligne de facture avec les bons de commande " +
    "dans les pièces jointes, signale les factures où le total diffère du bon de commande de plus de 5 %, " +
    "signale les lignes dont la description ne correspond pas au bon de commande. Surligne les écarts en rouge " +
    "et ajoute une colonne 'Raison' expliquant chaque écart. Laisse les feuilles de données originales inchangées.",
    @"C:\ap-invoices\output\validated.xlsx",
    poFiles);

Les deux produisent le même classeur de validation. Là où le SDK développe un appel FindColumnByHeader pour chaque champ, une comparaison de seuil pour chaque règle et une écriture de cellule pour chaque remplissage, l'agent absorbe le même travail dans une seule instruction. Lorsqu'un fournisseur change sa mise en page ou que l'équipe financière change le seuil de variance, vous modifiez l'instruction, pas le code.

6. Pourquoi utiliser Spire.Agent.Office pour le traitement des factures par IA

La comparaison tripartite ci-dessus est délibérément neutre vis-à-vis du produit ; le même modèle fonctionne avec n'importe quel LLM capable. Là où Spire.Agent.Office gagne sa place pour les équipes .NET, c'est dans trois domaines spécifiques :

1. Traitement natif des factures multi-formats. Les PDF, documents Word, fichiers Excel et images numérisées sont des citoyens de première classe, pas des formats que vous ajoutez par-dessus. L'agent lit et extrait des quatre formats dans une seule instruction.
2. Le formatage est préservé. Les rapports de factures comportent des en-têtes de colonne, des formats numériques et des remplissages conditionnels qui doivent survivre au traitement. La couche documentaire de l'agent les garde intacts. Incluez "préserver la mise en page et le style du document original" dans votre instruction et la sortie reste fidèle au modèle.
3. Intégration .NET native. C'est un SDK C# qui s'intègre dans une application .NET existante. Aucun service de traitement documentaire séparé à construire ou à maintenir, aucune plomberie inter-services. L'exemple ci-dessus est toute la surface d'intégration.

Si vous utilisez déjà Spire.Office pour le traitement documentaire, l'agent est la couche suivante naturelle : le même objet Workbook gagne un processeur AI() qui transforme les instructions en flux de travail exécutés.

7. FAQ

Le traitement des factures par IA peut-il fonctionner avec des images numérisées ?

Oui. L'exemple d'extraction ci-dessus charge des fichiers d'images numérisées aux côtés de PDF et de documents Word, et l'agent lit et analyse chaque fichier dans son format natif. Pour les images numérisées sans couche de texte extractible, l'agent travaille directement avec le contenu de l'image. Si la qualité de numérisation est médiocre, envisagez d'exécuter l'OCR d'abord pour de meilleurs résultats.

Les données de facture peuvent-elles rester dans mon environnement ?

Oui, avec une nuance importante. Spire.Agent.Office s'exécute depuis votre propre application, donc le SDK, les modèles et le traitement documentaire restent dans votre environnement. Les fichiers de facture ne sont pas téléchargés vers un service documentaire tiers pour stockage ou conversion. Pour analyser le contenu de la facture, l'IA a besoin du texte pertinent, et il est envoyé au modèle pour traitement ; c'est une étape inhérente à tout flux de travail IA. Si vous déployez votre propre modèle sur votre réseau local, le contenu reste entièrement au sein de votre infrastructure. Si vous vous connectez via une API de modèle hébergée telle qu'OpenAI ou Azure OpenAI, le contenu pertinent est transmis à ce fournisseur sur le réseau selon votre configuration.

Puis-je utiliser mon propre modèle IA avec Spire.Agent.Office ?

Oui. Spire.Agent.Office prend en charge une intégration flexible des modèles IA et est compatible avec les infrastructures IA grand public, y compris les API de modèles hébergées et les modèles déployés en privé. Vous pouvez pointer l'agent vers votre propre point de terminaison. Consultez le tutoriel d'intégration pour les détails de configuration ; pour des questions sur les fournisseurs pris en charge dans votre déploiement, contactez votre équipe de compte à sales@e-iceblue.com.

Quel modèle Spire.Agent.Office utilise-t-il pour le traitement des factures ?

Spire.Agent.Office se connecte à un grand modèle de langage derrière une clé SpireToken. Vous décrivez la tâche d'extraction ou de validation en langage naturel, et l'agent orchestre les outils de traitement documentaire sous-jacents. Le modèle gère la compréhension ; la couche documentaire garantit le formatage et la fidélité du fichier.

Peut-il traiter les factures en lot ?

Oui. Une instruction appliquée à un dossier de fichiers de facture, et l'agent produit un classeur consolidé avec toutes les données extraites. L'extraction de champs et le rapprochement inter-documents sont pris en charge. Pour que l'agent récupère chaque facture, gardez le dossier de réception organisé et évitez les fichiers vides ; si le nombre de factures traitées ne correspond pas au nombre dans la boîte de réception, vérifiez d'abord la source des données.

L'IA modifiera-t-elle le formatage de mon classeur ?

Pas si vous le demandez. Incluez une phrase comme "préserver la mise en page, le style et les polices du document original" dans votre instruction ; le tutoriel officiel documente exactement ce correctif.

En quoi est-ce différent de l'utilisation d'une API LLM brute ?

Un LLM brut ne peut pas lire, modifier ou écrire de manière fiable des fichiers Word et Excel par lui-même ; il a besoin d'une couche de traitement documentaire. Un agent IA documentaire associe la compréhension du langage du LLM aux API documentaires déterministes, de sorte que la sortie est un fichier réel et bien formé.

Prêt à automatiser votre traitement des factures ?

L'extraction, la validation et la composition de rapports sont les moyens les plus rapides d'obtenir de la valeur : pointez l'agent vers la boîte de réception, décrivez les règles de traitement et obtenez un classeur structuré ou un PDF. Suivez le tutoriel Démarrage pour exécuter votre premier flux de travail de facture dans .NET.

Lectures complémentaires

• Présentation du produit Spire.Agent.Office -- SDK d'agent IA pour chaque format de document Office
• Agent IA pour le traitement documentaire : Qu'est-ce que c'est et comment ça fonctionne -- le concept d'agent IA documentaire expliqué
• Générer des documents Word à partir de données Excel en C# -- génération de documents pilotée par les données avec le SDK déterministe
• Révision de contrat IA en C# -- le même flux de travail d'agent appliqué aux documents Word et PDF

El procesamiento automatizado de facturas consiste en leer las facturas entrantes de los proveedores, extraer las partidas, validarlas con las órdenes de compra y escribir los resultados en un libro de trabajo estructurado que su sistema financiero pueda consumir. En la práctica, esto es automatización de documentos en .NET, donde una instrucción en lenguaje natural reemplaza el código de mapeo de campos y diseño. Spire.Agent.Office es un SDK de agente de IA para documentos que maneja el lenguaje; una capa documental determinista garantiza archivos Excel y PDF reales y bien formados.

Navegación rápida

1. Por qué el procesamiento de facturas es ideal para la IA
2. Qué puede y qué no puede hacer un agente de IA para facturas
3. Escenarios comunes de procesamiento de facturas
4. Tres formas de automatizar el procesamiento de facturas en .NET
5. Un ejemplo práctico: extraer, validar y generar informes en C#
6. Por qué usar Spire.Agent.Office para el procesamiento de facturas con IA
7. Preguntas frecuentes

1. Por qué el procesamiento de facturas es ideal para la IA

El trabajo con facturas en el mundo del desarrollo se resume en tres tareas repetitivas: lectura (extraer proveedor, fecha, partidas y totales de documentos que llegan como PDF, archivos Word, hojas de Excel o imágenes escaneadas), verificación (comparar facturas con órdenes de compra y marcar discrepancias) y producción (escribir los resultados en un libro de trabajo estructurado que su sistema contable pueda consumir).

Para los desarrolladores de .NET, el desafío no es solo entender el contenido de la factura, sino convertir documentos no estructurados y multiformato en flujos de trabajo estructurados y repetibles que su aplicación pueda gestionar.

Tres propiedades hacen que estas tareas sean ideales para un modelo de lenguaje en lugar de reglas escritas a mano:

• La entrada es multiformato. Las facturas entrantes llegan como archivos adjuntos PDF, imágenes escaneadas, documentos de Word o archivos de Excel, cada uno con un diseño diferente. Las reglas que manejan un formato fallan con el siguiente; un LLM lee el texto directamente independientemente del tipo de archivo.
• La salida tiene forma de documento. El entregable es un archivo .xlsx o .pdf real con el formato correcto, no un bloque de texto. Aquí es donde una capa documental demuestra su valor.
• El volumen cambia constantemente. Incorporar 50 nuevos proveedores o revisar 200 facturas al mes requiere una solución basada en configuración, no en reprogramar por cada proveedor.

En la práctica, la extracción y la validación van de la mano: los equipos quieren que las facturas se resuman, que se marquen las discrepancias y que se generen nuevas facturas a partir de una plantilla y datos estructurados. Para obtener una visión más profunda de cómo se construye un agente de IA para documentos y dónde encaja en un flujo de trabajo de contenido, consulte Agente de IA para el procesamiento de documentos: qué es y cómo funciona.

2. Qué puede y qué no puede hacer un agente de IA para facturas

La división del trabajo: el agente automatiza la lectura, la extracción y la validación (las horas que un empleado de cuentas por pagar dedicaría), mientras que un revisor humano se encarga de la aprobación final. Ese límite es lo que mantiene la herramienta útil y el proceso defendible.

3. Escenarios comunes de procesamiento de facturas

El procesamiento de facturas abarca más que la extracción puntual. El mismo patrón (una instrucción, archivos de factura y datos de referencia opcionales) cubre los escenarios que los equipos buscan con más frecuencia:

Cada escenario sigue la misma arquitectura: una instrucción de entrada, un documento real de salida.

4. Tres formas de automatizar el procesamiento de facturas en .NET

El punto clave: un LLM no puede leer una factura PDF sin una capa de procesamiento de documentos, y un SDK tradicional no puede entender una solicitud en lenguaje natural. Un agente de IA para documentos combina ambos.

Esto no quiere decir que la ruta tradicional sea incorrecta. Para facturas fijas y bien especificadas que rara vez cambian, un SDK determinista suele ser la opción correcta, y Spire.Office sigue cubriendo esa necesidad. Si esa es su situación, Generar documentos de Word a partir de datos de Excel en C# demuestra el flujo de trabajo clásico de generación de documentos basado en datos. El agente se gana su lugar cuando los diseños de los proveedores, los formatos de entrada y las reglas de validación cambian con la frecuencia suficiente como para que la reprogramación se convierta en el cuello de botella.

Por qué una API de LLM sin procesar no es suficiente para el procesamiento de facturas

Llamar a gpt-4 o claude directamente para "extraer datos de esta factura" falla de tres maneras que importan en producción:

1. No puede leer ni escribir archivos de Office de forma fiable. Los LLM ven texto, no la estructura de .xlsx y .pdf. Leer una factura PDF, mantener intacta una tabla de partidas o producir un libro de trabajo de Excel válido suele requerir un pipeline de extracción y reconstrucción independiente que usted debe construir.
2. El formato no está garantizado. Los informes de facturas llevan encabezados de columna, formatos numéricos y rellenos condicionales que son importantes para el equipo de contabilidad. Un LLM sin procesar devuelve texto, y el formato que se pierde es exactamente lo que le importa a los departamentos de cuentas por pagar.
3. Usted reimplementa toda la orquestación. El diseño de prompts, el mapeo de campos, el manejo de errores, la E/S de archivos y la validación de salida se convierten en código que usted debe poseer y mantener.

Un agente de IA para documentos combina la comprensión del lenguaje del modelo con APIs documentales deterministas: el modelo decide qué extraer o comparar, y la capa documental garantiza que el archivo sea real y esté bien formado. Esa es la diferencia entre una demostración y un flujo de trabajo que un equipo puede implementar.

5. Un ejemplo práctico: extraer, validar y generar informes en C#

A continuación, una tarea que el equipo de cuentas por pagar repite cada mes: procesar facturas de proveedores entrantes, extraer datos de formatos dispares, validar con órdenes de compra y producir un libro de trabajo estructurado. La implementación utiliza Spire.Agent.Office para .NET, un agente de IA que procesa documentos de Word, Excel, PowerPoint y PDF mediante instrucciones en lenguaje natural. El ejemplo está diseñado en torno a ese flujo de trabajo; los tutoriales oficiales de Introducción y Revisión de contratos con IA en C# documentan la configuración de la API paso a paso, mientras que esta sección se centra en los patrones de integración en C#.

1. Extraer datos de cada factura en la bandeja de entrada. Configure el agente una vez, luego lea la carpeta de entrada y haga que cada factura se analice en una única tabla combinada:

using System.IO;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Doc;
using Spire.Pdf;
using Spire.Xls;

AIOptions agentOptions = new AIOptions();
agentOptions.WorkDir = @"C:\ap-invoices\output";
agentOptions.SpireToken = spireToken;

string extractPrompt =
    "Lee cada archivo de factura de proveedor en la bandeja de entrada (PDF, Word, Excel o imágenes) y extrae " +
    "la información de cada proveedor: nombre de la empresa, número de factura, fecha de emisión, fecha de vencimiento, partidas " +
    "(descripción, cantidad, precio unitario, importe), subtotal, impuestos y total. Combina los " +
    "resultados en una hoja de cálculo con columnas: Proveedor, NumeroFactura, FechaEmision, FechaVencimiento, " +
    "Descripcion, Cantidad, PrecioUnitario, ImporteLinea, Subtotal, Impuestos, Total. Omite las filas de encabezado " +
    "duplicadas y guarda como un libro de trabajo.";

Directory.CreateDirectory(@"C:\ap-invoices\output");

string[] invoiceFiles = Directory.GetFiles(@"C:\ap-invoices\inbox", "*.*");

El agente maneja el desafío multiformato: PDFs, imágenes escaneadas, documentos de Word y archivos de Excel fluyen a través de la misma instrucción sin código específico para cada formato:

using (Workbook extracted = new Workbook())
{
    AIResult result = extracted.AI(agentOptions).ExecuteInstruction(
        extracted,
        extractPrompt,
        @"C:\ap-invoices\output\extracted.xlsx",
        invoiceFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"La extracción falló: {result?.ErrorMessage}");
}

Llamadas clave a la API

• Workbook.AI(agentOptions): adjunta el procesador de documentos de IA a un objeto de libro de trabajo.
• ExecuteInstruction(doc, instruction, savePath, attachments): ejecuta la extracción y escribe el libro de trabajo combinado.
• AIResult.Success / AIResult.ErrorMessage: verifica el resultado y muestra errores.

Salida

2. Validar con órdenes de compra. Cargue el archivo extraído y establezca la regla de coincidencia en lenguaje sencillo. El agente añade una hoja de Validación y deja los datos de origen intactos:

using (Workbook validation = new Workbook())
{
    validation.LoadFromFile(@"C:\ap-invoices\output\extracted.xlsx");

    string[] poFiles = { @"C:\ap-invoices\data\purchase-orders.xlsx" };

    AIResult result = validation.AI(agentOptions).ExecuteInstruction(
        validation,
        "Añade una hoja de 'Validación'. Compara cada partida de factura con las órdenes de compra " +
        "en los archivos adjuntos, marca las facturas donde el total difiera de la orden de compra en más de un 5%, " +
        "marca las partidas cuya descripción no coincida con la orden de compra. Resalta las discrepancias en rojo " +
        "y añade una columna 'Motivo' explicando cada discrepancia. Deja las hojas de datos originales sin cambios.",
        @"C:\ap-invoices\output\validated.xlsx",
        poFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"La validación falló: {result?.ErrorMessage}");
}

La hoja de Validación aparece junto a los datos de origen, con las filas marcadas, rellenos rojos y la columna Motivo aplicada por la instrucción:

3. Informe. Componga el resumen de la sección 5 y expórtelo. El savePath por sí solo elige el formato: .xlsx aquí, .pdf para distribución:

using (Workbook report = new Workbook())
{
    report.LoadFromFile(@"C:\ap-invoices\output\validated.xlsx");

    AIResult result = report.AI(agentOptions).ExecuteInstruction(
        report,
        "Produce un informe de procesamiento. Añade una hoja de 'Resumen' al principio con un bloque de KPI " +
        "(total de facturas procesadas, importe total, recuento de discrepancias marcadas, proveedor principal por " +
        "volumen), una tabla de detalles agrupada por proveedor y un resumen de discrepancias. Dale formato para imprimir " +
        "y guarda el libro de trabajo finalizado.",
        @"C:\ap-invoices\output\monthly-report.xlsx");

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"La generación del informe falló: {result?.ErrorMessage}");
}

La hoja de Resumen se coloca al principio del libro de trabajo, lista para imprimir o exportar a PDF:

Por qué esto es diferente: SDK tradicional vs. Agente de IA

El valor del agente es más claro al compararlos. Con el SDK tradicional, usted localiza cada campo por cadena de encabezado, codifica cada umbral de validación y escribe cada celda una por una, y vuelve a ajustar todo cuando un proveedor cambia su diseño o la regla cambia. El esquema a continuación (simplificado para ilustración) muestra la forma de ese trabajo:

// SDK tradicional (ilustrativo): cada campo se localiza y extrae
// por cadena de encabezado, los umbrales están codificados y la salida se escribe celda por celda
foreach (string file in invoiceFiles)
{
    Workbook wb = new Workbook();
    wb.LoadFromFile(file);
    Worksheet sheet = wb.Worksheets[0];

    // Falla en el momento en que un proveedor cambia "Total Due" por "Amount Payable".
    int totalCol = FindColumnByHeader(sheet, "Total Due");
    int vendorCol = FindColumnByHeader(sheet, "Vendor Name");

    for (int r = sheet.LastRow; r >= 2; r--)
    {
        double invoiceTotal = double.Parse(sheet.Range[r, totalCol].Text);
        double poTotal = GetPoTotal(sheet.Range[r, 1].Text);
        double diff = Math.Abs(invoiceTotal - poTotal) / poTotal;

        // Un umbral codificado; un proveedor de construcción dispara falsas alarmas.
        if (diff > 0.05) sheet.Range[r, totalCol].Style.Color = Color.Red;
    }
    // ... luego combinar, luego validar, luego resumen -- cientos de líneas por proveedor y por mes.
}

El agente de IA reemplaza esa orquestación con una instrucción:

validation.AI(agentOptions).ExecuteInstruction(
    validation,
    "Añade una hoja de 'Validación'. Compara cada partida de factura con las órdenes de compra " +
    "en los archivos adjuntos, marca las facturas donde el total difiera de la orden de compra en más de un 5%, " +
    "marca las partidas cuya descripción no coincida con la orden de compra. Resalta las discrepancias en rojo " +
    "y añade una columna 'Motivo' explicando cada discrepancia. Deja las hojas de datos originales sin cambios.",
    @"C:\ap-invoices\output\validated.xlsx",
    poFiles);

Ambos producen el mismo libro de trabajo de validación. Donde el SDK hace crecer una llamada FindColumnByHeader para cada campo, una comparación de umbral para cada regla y una escritura de celda para cada relleno, el agente absorbe el mismo trabajo en una instrucción. Cuando un proveedor cambia su diseño o el equipo financiero cambia el umbral de varianza, usted edita la instrucción, no el código.

6. Por qué usar Spire.Agent.Office para el procesamiento de facturas con IA

La comparación tripartita anterior es deliberadamente neutral respecto al producto; el mismo patrón funciona con cualquier LLM capaz. Donde Spire.Agent.Office se gana su lugar para los equipos de .NET es en tres áreas específicas:

1. Procesamiento nativo de facturas multiformato. Los archivos PDF, documentos de Word, archivos de Excel e imágenes escaneadas son ciudadanos de primera clase, no formatos que se añaden. El agente lee y extrae de los cuatro formatos en una sola instrucción.
2. Se conserva el formato. Los informes de facturas llevan encabezados de columna, formatos numéricos y rellenos condicionales que deben sobrevivir al procesamiento. La capa documental del agente los mantiene intactos. Incluya "conservar el diseño y estilo original del documento" en su instrucción y la salida se mantendrá fiel a la plantilla.
3. Integración nativa en .NET. Es un SDK de C# que se integra en una aplicación .NET existente. No hay que construir ni mantener un servicio de procesamiento de documentos separado, ni fontanería entre servicios. El ejemplo anterior es toda la superficie de integración.

Si ya utiliza Spire.Office para el procesamiento de documentos, el agente es la siguiente capa natural: el mismo objeto Workbook obtiene un procesador AI() que convierte las instrucciones en flujos de trabajo ejecutados.

7. Preguntas frecuentes

¿Puede el procesamiento de facturas por IA trabajar con imágenes escaneadas?

Sí. El ejemplo de extracción anterior carga archivos de imagen escaneados junto con archivos PDF y documentos de Word, y el agente lee y analiza cada archivo en su formato nativo. Para imágenes escaneadas sin una capa de texto extraíble, el agente trabaja directamente con el contenido de la imagen. Si la calidad del escaneo es baja, considere ejecutar OCR primero para obtener mejores resultados.

¿Pueden los datos de las facturas permanecer dentro de mi entorno?

Sí, con un matiz importante. Spire.Agent.Office se ejecuta desde su propia aplicación, por lo que el SDK, las plantillas y el procesamiento de documentos permanecen dentro de su entorno. Los archivos de factura no se cargan en un servicio de documentos de terceros para su almacenamiento o conversión. Para analizar el contenido de la factura, la IA necesita el texto relevante, y este se envía al modelo para su procesamiento; ese es un paso inherente de cualquier flujo de trabajo de IA. Si usted despliega su propio modelo en su red local, el contenido permanece totalmente dentro de su infraestructura. Si se conecta a través de una API de modelo alojada como OpenAI o Azure OpenAI, el contenido relevante se transmite a ese proveedor a través de la red según su configuración.

¿Puedo usar mi propio modelo de IA con Spire.Agent.Office?

Sí. Spire.Agent.Office admite una integración flexible de modelos de IA y es compatible con la infraestructura de IA convencional, incluidos los modelos alojados por API y los modelos desplegados de forma privada. Puede apuntar el agente a su propio endpoint. Consulte el tutorial de integración para obtener detalles de configuración; para preguntas sobre qué proveedores son compatibles en su despliegue, contacte a su equipo de cuenta en sales@e-iceblue.com.

¿Qué modelo utiliza Spire.Agent.Office para el procesamiento de facturas?

Spire.Agent.Office se conecta a un modelo de lenguaje grande detrás de una clave SpireToken. Usted describe la tarea de extracción o validación en lenguaje natural, y el agente orquesta las herramientas de procesamiento de documentos subyacentes. El modelo se encarga de la comprensión; la capa documental garantiza el formato y la fidelidad del archivo.

¿Puede procesar facturas por lotes?

Sí. Una instrucción aplicada a una carpeta de archivos de factura, y el agente produce un libro de trabajo consolidado con todos los datos extraídos. Se admite tanto la extracción de campos como la comparación entre documentos. Para que el agente recoja cada factura, mantenga la carpeta de entrada organizada y evite archivos vacíos; si el número de facturas procesadas no coincide con el recuento de la bandeja de entrada, verifique primero la fuente de datos.

¿Cambiará la IA el formato de mi libro de trabajo?

No si usted lo especifica. Incluya una frase como "conservar el diseño, estilo y fuentes originales del documento" en su instrucción; el tutorial oficial documenta esta solución exacta.

¿En qué se diferencia esto de usar una API de LLM sin procesar?

Un LLM sin procesar no puede leer, editar ni escribir archivos de Word y Excel de forma fiable por sí solo; necesita una capa de procesamiento de documentos. Un agente de IA para documentos combina la comprensión del lenguaje del LLM con APIs documentales deterministas, por lo que la salida es un archivo real y bien formado.

¿Listo para automatizar el procesamiento de sus facturas?

La extracción, la validación y la composición de informes son los lugares más rápidos para obtener valor: apunte el agente a la bandeja de entrada, describa las reglas de procesamiento y obtenga un libro de trabajo estructurado o un PDF. Siga el tutorial de Introducción para ejecutar su primer flujo de trabajo de facturas en .NET.

Lecturas adicionales

• Descripción general del producto Spire.Agent.Office: SDKs de agente de IA para cada formato de documento de Office
• Agente de IA para el procesamiento de documentos: qué es y cómo funciona: se explica el concepto de agente de IA para documentos
• Generar documentos de Word a partir de datos de Excel en C#: generación de documentos basada en datos con el SDK determinista
• Revisión de contratos con IA en C#: el mismo flujo de trabajo de agente aplicado a documentos de Word y PDF

Automatisierte Rechnungsverarbeitung bedeutet, eingehende Lieferantenrechnungen zu lesen, Positionen zu extrahieren, sie mit Bestellungen abzugleichen und die Ergebnisse in eine strukturierte Arbeitsmappe zu schreiben, die von Ihrem Finanzsystem verarbeitet werden kann. In der Praxis handelt es sich um Dokumentenautomatisierung in .NET, bei der eine natürlichsprachliche Anweisung den Code für Feldzuordnungen und Layouts ersetzt. Spire.Agent.Office ist ein Dokumenten-KI-Agent-SDK, das die sprachliche Verarbeitung übernimmt; eine deterministische Dokumentenebene garantiert dabei echte, wohlgeformte Excel- und PDF-Dateien.

Schnellnavigation

1. Warum sich die Rechnungsverarbeitung für KI eignet
2. Was ein KI-Rechnungsagent leisten kann und was nicht
3. Häufige Szenarien der Rechnungsverarbeitung
4. Drei Wege zur Automatisierung der Rechnungsverarbeitung in .NET
5. Ein praktisches Beispiel: Extrahieren, Validieren und Berichten in C#
6. Warum Spire.Agent.Office für die KI-Rechnungsverarbeitung verwenden?
7. FAQ

1. Warum sich die Rechnungsverarbeitung für KI eignet

Die Arbeit mit Rechnungen besteht für Entwickler aus drei repetitiven Aufgaben: Lesen (Extrahieren von Lieferant, Datum, Positionen und Summen aus Dokumenten, die als PDF, Word-Datei, Excel-Tabelle oder gescanntes Bild eingehen), Prüfen (Abgleich von Rechnungen mit Bestellungen und Kennzeichnung von Diskrepanzen) und Erstellen (Schreiben der Ergebnisse in eine strukturierte Arbeitsmappe für das Buchhaltungssystem).

Für .NET-Entwickler besteht die Herausforderung nicht nur darin, den Inhalt der Rechnung zu verstehen, sondern unstrukturierte Dokumente in verschiedenen Formaten in strukturierte, wiederholbare Workflows zu verwandeln, die Ihre Anwendung steuern kann.

Drei Eigenschaften machen diese Aufgaben ideal für ein Sprachmodell anstelle von manuell geschriebenen Regeln:

• Der Input ist in verschiedenen Formaten. Eingehende Rechnungen kommen als PDF-Anhänge, gescannte Bilder, Word-Dokumente oder Excel-Dateien an – jedes mit einem anderen Layout. Regeln, die ein Format behandeln, versagen beim nächsten; ein LLM liest Text direkt, unabhängig vom Dateityp.
• Der Output hat Dokumentenform. Das Ergebnis ist eine echte .xlsx- oder .pdf-Datei mit korrekter Formatierung, kein Text-Blob. Hier zahlt sich eine Dokumentenebene aus.
• Das Volumen ändert sich ständig. Das Onboarding von 50 neuen Lieferanten oder die Prüfung von 200 Rechnungen pro Monat erfordert eine konfigurationsbasierte Lösung, keine Neucodierung pro Lieferant.

In der Praxis gehen Extraktion und Validierung Hand in Hand: Teams möchten Rechnungen zusammengefasst und Diskrepanzen markiert haben, sowie neue Rechnungen aus einer Vorlage und strukturierten Daten generiert bekommen. Für einen tieferen Einblick, wie ein Dokumenten-KI-Agent aufgebaut ist und wo er in eine Content-Pipeline passt, siehe KI-Agent für die Dokumentenverarbeitung: Was er ist und wie er funktioniert.

2. Was ein KI-Rechnungsagent leisten kann und was nicht

Die Arbeitsteilung: Der Agent automatisiert das Lesen, Extrahieren und Validieren (die Zeit, die ein Buchhaltungsmitarbeiter aufwenden würde), während ein menschlicher Prüfer die endgültige Freigabe erteilt. Diese Grenze macht das Tool nützlich und den Prozess nachvollziehbar.

3. Häufige Szenarien der Rechnungsverarbeitung

Die Rechnungsverarbeitung umfasst mehr als nur eine einmalige Extraktion. Dasselbe Muster (eine Anweisung, Rechnungsdateien und optionale Referenzdaten) deckt die Szenarien ab, nach denen Teams am häufigsten suchen:

Jedes Szenario folgt derselben Architektur: Eine Anweisung rein, ein echtes Dokument raus.

4. Drei Wege zur Automatisierung der Rechnungsverarbeitung in .NET

Der entscheidende Punkt: Ein LLM kann eine PDF-Rechnung nicht ohne eine Dokumentenverarbeitungsebene lesen, und ein traditionelles SDK kann keine natürlichsprachliche Anfrage verstehen. Ein Dokumenten-KI-Agent kombiniert beides.

Das bedeutet nicht, dass der traditionelle Weg falsch ist. Für feste, gut spezifizierte Rechnungen, die sich selten ändern, ist ein deterministisches SDK oft die richtige Wahl, und Spire.Office erfüllt diesen Bedarf weiterhin. Wenn dies Ihre Situation ist, zeigt Generieren von Word-Dokumenten aus Excel-Daten in C# den klassischen datengesteuerten Dokumentengenerierungs-Workflow. Der Agent ist dann sinnvoll, wenn sich Lieferantenlayouts, Eingabeformate und Validierungsregeln so oft ändern, dass die Neucodierung zum Engpass wird.

Warum eine Raw LLM API für die Rechnungsverarbeitung nicht ausreicht

Das direkte Aufrufen von gpt-4 oder claude, um "Daten aus dieser Rechnung zu extrahieren", scheitert in drei Punkten, die in der Produktion wichtig sind:

1. Es kann Office-Dateien nicht zuverlässig lesen oder schreiben. LLMs sehen Text, nicht die .xlsx- und .pdf-Struktur. Das Lesen einer PDF-Rechnung, das Beibehalten einer Positionstabelle oder das Erstellen einer gültigen Excel-Arbeitsmappe erfordert normalerweise eine separate Extraktions- und Rekonstruktions-Pipeline, die Sie selbst bauen müssen.
2. Formatierung ist nicht garantiert. Rechnungsberichte enthalten Spaltenüberschriften, Zahlenformate und bedingte Formatierungen, die für das Buchhaltungsteam wichtig sind. Ein Raw LLM liefert Text zurück, und die Formatierung, die Sie verlieren, ist genau das, worauf es den AP-Abteilungen ankommt.
3. Sie implementieren die gesamte Orchestrierung neu. Prompt-Design, Feldzuordnung, Fehlerbehandlung, Datei-I/O und Output-Validierung werden zu Ihrem Code, den Sie besitzen und warten müssen.

Ein Dokumenten-KI-Agent paart das Sprachverständnis des Modells mit deterministischen Dokumenten-APIs: Das Modell entscheidet, was extrahiert oder abgeglichen werden soll, und die Dokumentenebene garantiert, dass die Datei echt und wohlgeformt ist. Das ist der Unterschied zwischen einer Demo und einem Workflow, den ein Team produktiv einsetzen kann.

5. Ein praktisches Beispiel: Extrahieren, Validieren und Berichten in C#

Nachfolgend eine Aufgabe, die das AP-Team jeden Monat wiederholt: Eingehende Lieferantenrechnungen verarbeiten, Daten aus nicht übereinstimmenden Formaten extrahieren, gegen Bestellungen validieren und eine strukturierte Arbeitsmappe erstellen. Die Implementierung verwendet Spire.Agent.Office für .NET, einen KI-Agenten, der Word-, Excel-, PowerPoint- und PDF-Dokumente durch natürlichsprachliche Anweisungen verarbeitet. Das Beispiel ist um diesen Workflow herum konzipiert; die offiziellen Erste Schritte und KI-Vertragsprüfung in C# Tutorials dokumentieren die API-Einrichtung Schritt für Schritt, während sich dieser Abschnitt auf die C#-Integrationsmuster konzentriert.

1. Daten aus jeder Rechnung im Posteingang extrahieren. Konfigurieren Sie den Agenten einmal, lesen Sie dann den Posteingangsordner und lassen Sie jede Rechnung in eine einzige zusammengeführte Tabelle parsen:

using System.IO;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Doc;
using Spire.Pdf;
using Spire.Xls;

AIOptions agentOptions = new AIOptions();
agentOptions.WorkDir = @"C:\ap-invoices\output";
agentOptions.SpireToken = spireToken;

string extractPrompt =
    "Lies jede Lieferantenrechnungsdatei im Posteingang (PDF, Word, Excel oder Bilder) und extrahiere " +
    "die Informationen jedes Lieferanten: Firmenname, Rechnungsnummer, Ausstellungsdatum, Fälligkeitsdatum, " +
    "Positionen (Beschreibung, Menge, Einzelpreis, Betrag), Zwischensumme, Steuer und Gesamtbetrag. Führe die " +
    "Ergebnisse in einem Arbeitsblatt zusammen mit den Spalten: Lieferant, Rechnungsnummer, Ausstellungsdatum, Fälligkeitsdatum, " +
    "Beschreibung, Menge, Einzelpreis, Zeilenbetrag, Zwischensumme, Steuer, Gesamtbetrag. Überspringe doppelte Kopfzeilen " +
    "und speichere als Arbeitsmappe.";

Directory.CreateDirectory(@"C:\ap-invoices\output");

string[] invoiceFiles = Directory.GetFiles(@"C:\ap-invoices\inbox", "*.*");

Der Agent bewältigt die Herausforderung der verschiedenen Formate – PDFs, gescannte Bilder, Word-Dokumente und Excel-Dateien fließen alle durch dieselbe Anweisung ohne formatspezifischen Code:

using (Workbook extracted = new Workbook())
{
    AIResult result = extracted.AI(agentOptions).ExecuteInstruction(
        extracted,
        extractPrompt,
        @"C:\ap-invoices\output\extracted.xlsx",
        invoiceFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Extraktion fehlgeschlagen: {result?.ErrorMessage}");
}

Wichtige API-Aufrufe

• Workbook.AI(agentOptions) — verbindet den KI-Dokumentenprozessor mit einem Arbeitsmappenobjekt
• ExecuteInstruction(doc, instruction, savePath, attachments) — führt die Extraktion aus und schreibt die zusammengeführte Arbeitsmappe
• AIResult.Success / AIResult.ErrorMessage — überprüft das Ergebnis und zeigt Fehler an

Output

2. Abgleich mit Bestellungen. Laden Sie die extrahierte Datei und formulieren Sie die Abgleichregel in einfachem Deutsch. Der Agent fügt ein Validierung-Blatt hinzu und lässt die Quelldaten unberührt:

using (Workbook validation = new Workbook())
{
    validation.LoadFromFile(@"C:\ap-invoices\output\extracted.xlsx");

    string[] poFiles = { @"C:\ap-invoices\data\purchase-orders.xlsx" };

    AIResult result = validation.AI(agentOptions).ExecuteInstruction(
        validation,
        "Füge ein 'Validierung'-Blatt hinzu. Vergleiche jede Rechnungsposition mit den Bestellungen " +
        "in den Anhängen, markiere Rechnungen, bei denen die Summe um mehr als 5 % von der Bestellung abweicht, " +
        "markiere Positionen, deren Beschreibung nicht mit der Bestellung übereinstimmt. Hebe Diskrepanzen rot hervor " +
        "und füge eine 'Grund'-Spalte hinzu, die jede Diskrepanz erklärt. Lass die ursprünglichen Datenblätter unverändert.",
        @"C:\ap-invoices\output\validated.xlsx",
        poFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Validierung fehlgeschlagen: {result?.ErrorMessage}");
}

Das Validierung-Blatt landet neben den Quelldaten, mit den markierten Zeilen, roten Füllungen und der Grund-Spalte, die durch die Anweisung angewendet wurden:

3. Bericht. Erstellen Sie die Zusammenfassung aus Abschnitt 5 und exportieren Sie sie. Allein der savePath wählt das Format – .xlsx hier, .pdf für die Verteilung:

using (Workbook report = new Workbook())
{
    report.LoadFromFile(@"C:\ap-invoices\output\validated.xlsx");

    AIResult result = report.AI(agentOptions).ExecuteInstruction(
        report,
        "Erstelle einen Verarbeitungsbericht. Füge vorne ein 'Zusammenfassung'-Blatt mit einem KPI-Block " +
        "(Anzahl verarbeiteter Rechnungen, Gesamtbetrag, Anzahl markierter Diskrepanzen, Top-Lieferant nach " +
        "Volumen), einer Detailtabelle gruppiert nach Lieferant und einer Diskrepanz-Zusammenfassung hinzu. Formatiere es für den Druck " +
        "und speichere die fertige Arbeitsmappe.",
        @"C:\ap-invoices\output\monthly-report.xlsx");

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Berichtserstellung fehlgeschlagen: {result?.ErrorMessage}");
}

Das Zusammenfassung-Blatt landet am Anfang der Arbeitsmappe, bereit für den Druck oder PDF-Export:

Warum das anders ist: Traditionelles SDK vs. KI-Agent

Der Wert des Agenten ist im direkten Vergleich am deutlichsten. Mit dem traditionellen SDK lokalisieren Sie jedes Feld per Header-String, hardcodieren jeden Validierungsschwellenwert und schreiben jede Zelle einzeln – und müssen alles neu anpassen, wenn ein Lieferant sein Layout ändert oder sich die Regel ändert. Die Skizze unten (vereinfacht zur Veranschaulichung) zeigt die Form dieser Arbeit:

// Traditionelles SDK (illustrativ): Jedes Feld wird lokalisiert und extrahiert
// per Header-String, Schwellenwerte sind hardcodiert, und Output wird Zelle für Zelle geschrieben
foreach (string file in invoiceFiles)
{
    Workbook wb = new Workbook();
    wb.LoadFromFile(file);
    Worksheet sheet = wb.Worksheets[0];

    // Scheitert in dem Moment, in dem ein Lieferant "Total Due" in "Amount Payable" ändert.
    int totalCol = FindColumnByHeader(sheet, "Total Due");
    int vendorCol = FindColumnByHeader(sheet, "Vendor Name");

    for (int r = sheet.LastRow; r >= 2; r--)
    {
        double invoiceTotal = double.Parse(sheet.Range[r, totalCol].Text);
        double poTotal = GetPoTotal(sheet.Range[r, 1].Text);
        double diff = Math.Abs(invoiceTotal - poTotal) / poTotal;

        // Ein hardcodierter Schwellenwert; ein Bauunternehmer löst Fehlalarme aus.
        if (diff > 0.05) sheet.Range[r, totalCol].Style.Color = Color.Red;
    }
    // ... dann zusammenführen, dann validieren, dann zusammenfassen -- hunderte Zeilen pro Lieferant und Monat.
}

Der KI-Agent ersetzt diese Orchestrierung durch eine einzige Anweisung:

validation.AI(agentOptions).ExecuteInstruction(
    validation,
    "Füge ein 'Validierung'-Blatt hinzu. Vergleiche jede Rechnungsposition mit den Bestellungen " +
    "in den Anhängen, markiere Rechnungen, bei denen die Summe um mehr als 5 % von der Bestellung abweicht, " +
    "markiere Positionen, deren Beschreibung nicht mit der Bestellung übereinstimmt. Hebe Diskrepanzen rot hervor " +
    "und füge eine 'Grund'-Spalte hinzu, die jede Diskrepanz erklärt. Lass die ursprünglichen Datenblätter unverändert.",
    @"C:\ap-invoices\output\validated.xlsx",
    poFiles);

Beide erzeugen dieselbe Validierungs-Arbeitsmappe. Wo das SDK einen FindColumnByHeader-Aufruf für jedes Feld, einen Schwellenwertvergleich für jede Regel und ein Zellschreiben für jede Füllung wachsen lässt, absorbiert der Agent dieselbe Arbeit in eine Anweisung. Wenn ein Lieferant sein Layout ändert oder das Finanzteam den Varianzschwellenwert anpasst, bearbeiten Sie die Anweisung, nicht den Code.

6. Warum Spire.Agent.Office für die KI-Rechnungsverarbeitung verwenden?

Der obige Drei-Wege-Vergleich ist bewusst produktneutral; dasselbe Muster funktioniert mit jedem leistungsfähigen LLM. Wo Spire.Agent.Office für .NET-Teams seinen Platz findet, sind drei spezifische Bereiche:

1. Native Multi-Format-Rechnungsverarbeitung. PDFs, Word-Dokumente, Excel-Dateien und gescannte Bilder sind Bürger erster Klasse, keine Formate, die man nachträglich anflanscht. Der Agent liest und extrahiert aus allen vier Formaten in einer einzigen Anweisung.
2. Formatierung bleibt erhalten. Rechnungsberichte enthalten Spaltenüberschriften, Zahlenformate und bedingte Formatierungen, die die Verarbeitung überleben müssen. Die Dokumentenebene des Agenten hält sie intakt. Fügen Sie "Behalte das ursprüngliche Dokumentlayout und Styling bei" in Ihre Anweisung ein, und der Output bleibt der Vorlage treu.
3. Native .NET-Integration. Es ist ein C#-SDK, das in eine bestehende .NET-Anwendung integriert wird. Kein separater Dokumentenverarbeitungsdienst, der gebaut oder gewartet werden muss, keine Cross-Service-Verkabelung. Das obige Beispiel ist die gesamte Integrationsfläche.

Wenn Sie Spire.Office bereits für die Dokumentenverarbeitung nutzen, ist der Agent die natürliche nächste Schicht: Dasselbe Workbook-Objekt erhält einen AI()-Prozessor, der Anweisungen in ausgeführte Workflows verwandelt.

7. FAQ

Kann KI-Rechnungsverarbeitung mit gescannten Bildern arbeiten?

Ja. Das Extraktionsbeispiel oben lädt gescannte Bilddateien zusammen mit PDFs und Word-Dokumenten, und der Agent liest und analysiert jede Datei in ihrem nativen Format. Für gescannte Bilder ohne extrahierbare Textebene arbeitet der Agent direkt mit dem Bildinhalt. Wenn die Scanqualität schlecht ist, ziehen Sie für beste Ergebnisse eine vorherige OCR in Betracht.

Können Rechnungsdaten in meiner Umgebung bleiben?

Ja, mit einer wichtigen Nuance. Spire.Agent.Office läuft von Ihrer eigenen Anwendung aus, daher bleiben das SDK, Vorlagen und die Dokumentenverarbeitung in Ihrer Umgebung. Rechnungsdateien werden nicht zur Speicherung oder Konvertierung an einen Dokumentendienst eines Drittanbieters hochgeladen. Um den Rechnungsinhalt zu analysieren, benötigt die KI den relevanten Text, und dieser wird zur Verarbeitung an das Modell gesendet; das ist ein inhärenter Schritt jedes KI-Workflows. Wenn Sie Ihr eigenes Modell in Ihrem lokalen Netzwerk bereitstellen, bleibt der Inhalt vollständig innerhalb Ihrer Infrastruktur. Wenn Sie sich über eine gehostete Modell-API wie OpenAI oder Azure OpenAI verbinden, wird der relevante Inhalt gemäß Ihrer Konfiguration über das Netzwerk an diesen Anbieter übertragen.

Kann ich mein eigenes KI-Modell mit Spire.Agent.Office verwenden?

Ja. Spire.Agent.Office unterstützt eine flexible KI-Modellintegration und ist mit gängiger KI-Infrastruktur kompatibel, einschließlich gehosteter Modell-APIs und privat bereitgestellter Modelle. Sie können den Agenten auf Ihren eigenen Endpunkt verweisen. Siehe das Integrationstutorial für Details zur Einrichtung; bei Fragen, welche Anbieter in Ihrer Bereitstellung unterstützt werden, kontaktieren Sie Ihr Account-Team unter sales@e-iceblue.com.

Welches Modell verwendet Spire.Agent.Office für die Rechnungsverarbeitung?

Spire.Agent.Office verbindet sich mit einem großen Sprachmodell hinter einem SpireToken-Schlüssel. Sie beschreiben die Extraktions- oder Validierungsaufgabe in natürlicher Sprache, und der Agent orchestriert die zugrunde liegenden Dokumentenverarbeitungstools. Das Modell übernimmt das Verständnis; die Dokumentenebene garantiert Formatierung und Dateitreue.

Kann es Rechnungen in Stapeln verarbeiten?

Ja. Eine Anweisung, die auf einen Ordner mit Rechnungsdateien angewendet wird, und der Agent erstellt eine konsolidierte Arbeitsmappe mit allen extrahierten Daten. Sowohl Feldextraktion als auch dokumentübergreifender Abgleich werden unterstützt. Damit der Agent jede Rechnung aufnimmt, halten Sie den Posteingangsordner organisiert und vermeiden Sie leere Dateien; wenn die Anzahl der verarbeiteten Rechnungen nicht mit der Anzahl im Posteingang übereinstimmt, prüfen Sie zuerst die Datenquelle.

Wird die KI die Formatierung meiner Arbeitsmappe ändern?

Nicht, wenn Sie es nicht wollen. Fügen Sie einen Satz wie "Behalte das ursprüngliche Dokumentlayout, Styling und die Schriftarten bei" in Ihre Anweisung ein; das offizielle Tutorial dokumentiert genau diese Lösung.

Wie unterscheidet sich das von der Verwendung einer Raw LLM API?

Ein Raw LLM kann Word- und Excel-Dateien nicht zuverlässig selbst lesen, bearbeiten oder schreiben; es benötigt eine Dokumentenverarbeitungsebene. Ein Dokumenten-KI-Agent paart das Sprachverständnis des LLM mit deterministischen Dokumenten-APIs, sodass das Ergebnis eine echte, wohlgeformte Datei ist.

Bereit, Ihre Rechnungsverarbeitung zu automatisieren?

Extraktion, Validierung und Berichtserstellung sind die schnellsten Bereiche, um Mehrwert zu erzielen: Verweisen Sie den Agenten auf den Posteingang, beschreiben Sie die Verarbeitungsregeln und erhalten Sie eine strukturierte Arbeitsmappe oder PDF. Folgen Sie dem Erste Schritte Tutorial, um Ihren ersten Rechnungsworkflow in .NET auszuführen.

Weiterführende Literatur

• Spire.Agent.Office Produktübersicht -- KI-Agent-SDKs für jedes Office-Dokumentformat
• KI-Agent für die Dokumentenverarbeitung: Was er ist und wie er funktioniert -- das Konzept des Dokumenten-KI-Agenten erklärt
• Generieren von Word-Dokumenten aus Excel-Daten in C# -- datengesteuerte Dokumentengenerierung mit dem deterministischen SDK
• KI-Vertragsprüfung in C# -- derselbe Agenten-Workflow angewendet auf Word- und PDF-Dokumente

Автоматизированная обработка счетов означает чтение входящих счетов от поставщиков, извлечение позиций, их сверку с заказами на поставку и запись результатов в структурированную книгу, которую может использовать ваша финансовая система. На практике это автоматизация документов в .NET, где инструкции на естественном языке заменяют код для сопоставления полей и настройки макетов. Spire.Agent.Office — это SDK ИИ-агента для работы с документами, который берет на себя обработку языка, а детерминированный уровень работы с документами гарантирует получение корректных файлов Excel и PDF.

Быстрая навигация

1. Почему обработка счетов подходит для ИИ
2. Что может и чего не может ИИ-агент для счетов
3. Типичные сценарии обработки счетов
4. Три способа автоматизации обработки счетов в .NET
5. Пример работы: извлечение, проверка и отчетность на C#
6. Почему стоит использовать Spire.Agent.Office для обработки счетов с ИИ
7. Часто задаваемые вопросы (FAQ)

1. Почему обработка счетов подходит для ИИ

Работа со счетами в мире разработки — это три повторяющиеся задачи: чтение (извлечение поставщика, даты, позиций и итоговых сумм из документов, поступающих в виде PDF, файлов Word, таблиц Excel или сканированных изображений), проверка (сверка счетов с заказами на поставку и выявление расхождений) и создание (запись результатов в структурированную книгу для бухгалтерской системы).

Для .NET-разработчиков проблема заключается не только в понимании содержания счета, но и в превращении неструктурированных документов в различных форматах в структурированные, воспроизводимые рабочие процессы.

Три свойства делают эти задачи идеальными для языковой модели, а не для жестко заданных правил:

• Входные данные имеют разные форматы. Входящие счета приходят как вложения PDF, сканированные изображения, документы Word или файлы Excel — каждый со своим макетом. Правила, работающие для одного формата, ломаются на другом; LLM же читает текст напрямую, независимо от типа файла.
• Выходные данные имеют форму документа. Результатом является реальный файл .xlsx или .pdf с правильным форматированием, а не просто набор текста. Именно здесь уровень работы с документами оправдывает себя.
• Объем постоянно меняется. Привлечение 50 новых поставщиков или проверка 200 счетов в месяц требует решения, управляемого конфигурацией, а не переписывания кода под каждого поставщика.

На практике извлечение и проверка идут рука об руку: командам нужно, чтобы счета были суммированы, расхождения отмечены, а новые счета создавались на основе шаблона и структурированных данных. Более подробно о том, как устроен ИИ-агент для документов и где он вписывается в конвейер обработки контента, см. в статье ИИ-агент для обработки документов: что это и как работает.

2. Что может и чего не может ИИ-агент для счетов

Разделение труда: агент автоматизирует чтение, извлечение и проверку (то, на что бухгалтер тратит часы), а человек-рецензент берет на себя финальное утверждение. Эта граница делает инструмент полезным, а процесс — обоснованным.

3. Типичные сценарии обработки счетов

Обработка счетов охватывает не только разовое извлечение данных. Один и тот же шаблон (инструкция, файлы счетов и опциональные справочные данные) покрывает большинство сценариев, которые ищут команды:

Каждый сценарий имеет одну и ту же архитектуру: инструкция на входе, реальный документ на выходе.

4. Три способа автоматизации обработки счетов в .NET

Ключевой момент: LLM не может прочитать PDF-счет без уровня обработки документов, а традиционный SDK не может понять запрос на естественном языке. ИИ-агент для документов объединяет и то, и другое.

Это не значит, что традиционный путь неверен. Для фиксированных счетов, которые редко меняются, детерминированный SDK часто является правильным выбором, и Spire.Office по-прежнему закрывает эту потребность. Если это ваш случай, статья Генерация документов Word из данных Excel на C# демонстрирует классический рабочий процесс генерации документов на основе данных. Агент же выигрывает, когда макеты поставщиков, форматы ввода и правила проверки меняются настолько часто, что переписывание кода становится «бутылочным горлышком».

Почему Raw LLM API недостаточно для обработки счетов

Вызов gpt-4 или claude напрямую с командой "извлеки данные из этого счета" проваливается в трех аспектах, важных для продакшена:

1. Невозможность надежно читать или писать файлы Office. LLM видят текст, а не структуру .xlsx и .pdf. Чтение PDF-счета, сохранение таблицы позиций или создание валидной книги Excel обычно требует отдельного конвейера извлечения и реконструкции, который вам придется строить самостоятельно.
2. Отсутствие гарантии форматирования. Отчеты по счетам содержат заголовки столбцов, форматы чисел и условное форматирование, которые важны для бухгалтерии. Raw LLM возвращает текст, и потеря форматирования — это именно то, что критично для отделов расчетов с поставщиками.
3. Необходимость реализации всей оркестрации. Дизайн промптов, сопоставление полей, обработка ошибок, ввод-вывод файлов и проверка вывода становятся вашим кодом, который нужно поддерживать.

ИИ-агент для документов сочетает языковое понимание модели с детерминированными API документов: модель решает, что извлечь или сверить, а уровень документов гарантирует, что файл будет реальным и корректно сформированным. В этом разница между демо-версией и рабочим процессом, который можно внедрить.

5. Пример работы: извлечение, проверка и отчетность на C#

Ниже приведена задача, которую бухгалтерия повторяет каждый месяц: обработка входящих счетов, извлечение данных из форматов, сверка с заказами на поставку и создание структурированной книги. Реализация использует Spire.Agent.Office для .NET — ИИ-агента, который обрабатывает документы Word, Excel, PowerPoint и PDF с помощью инструкций на естественном языке. Пример сфокусирован на этом рабочем процессе. Официальные руководства Getting Started и AI Contract Review in C# описывают настройку API пошагово, а этот раздел фокусируется на шаблонах интеграции C#.

1. Извлечение данных из каждого счета во входящих. Настройте агента один раз, затем прочитайте папку входящих, чтобы каждый счет был разобран в единую объединенную таблицу:

using System.IO;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Doc;
using Spire.Pdf;
using Spire.Xls;

AIOptions agentOptions = new AIOptions();
agentOptions.WorkDir = @"C:\ap-invoices\output";
agentOptions.SpireToken = spireToken;

string extractPrompt =
    "Прочитай каждый файл счета поставщика во входящих (PDF, Word, Excel или изображения) и извлеки " +
    "информацию: название компании, номер счета, дату выпуска, срок оплаты, позиции " +
    "(описание, количество, цена за единицу, сумма), промежуточный итог, налог и общую сумму. Объедини " +
    "результаты в один лист со столбцами: Supplier, InvoiceNumber, IssueDate, DueDate, " +
    "Description, Quantity, UnitPrice, LineAmount, Subtotal, Tax, Total. Пропускай дублирующиеся заголовки " +
    "и сохрани как книгу.";

Directory.CreateDirectory(@"C:\ap-invoices\output");

string[] invoiceFiles = Directory.GetFiles(@"C:\ap-invoices\inbox", "*.*");

Агент справляется с задачей работы с разными форматами — PDF, сканы, Word и Excel проходят через одну и ту же инструкцию без специфического кода для каждого формата:

using (Workbook extracted = new Workbook())
{
    AIResult result = extracted.AI(agentOptions).ExecuteInstruction(
        extracted,
        extractPrompt,
        @"C:\ap-invoices\output\extracted.xlsx",
        invoiceFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Ошибка извлечения: {result?.ErrorMessage}");
}

Ключевые вызовы API

• Workbook.AI(agentOptions) — прикрепляет ИИ-процессор документов к объекту книги
• ExecuteInstruction(doc, instruction, savePath, attachments) — запускает извлечение и записывает объединенную книгу
• AIResult.Success / AIResult.ErrorMessage — проверяет результат и выводит ошибки

Результат

2. Проверка по заказам на поставку (PO). Загрузите извлеченный файл и укажите правило сверки на простом языке. Агент добавит лист Validation, оставив исходные данные нетронутыми:

using (Workbook validation = new Workbook())
{
    validation.LoadFromFile(@"C:\ap-invoices\output\extracted.xlsx");

    string[] poFiles = { @"C:\ap-invoices\data\purchase-orders.xlsx" };

    AIResult result = validation.AI(agentOptions).ExecuteInstruction(
        validation,
        "Добавь лист 'Validation'. Сравни каждую позицию счета с заказами на поставку " +
        "в вложениях, отметь счета, где общая сумма отличается от PO более чем на 5%, " +
        "отметь позиции, описание которых не совпадает с PO. Выдели расхождения красным " +
        "и добавь столбец 'Reason' с объяснением каждого расхождения. Оставь исходные листы данных без изменений.",
        @"C:\ap-invoices\output\validated.xlsx",
        poFiles);

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Ошибка проверки: {result?.ErrorMessage}");
}

Лист Validation появляется рядом с исходными данными, с отмеченными строками, красной заливкой и столбцом Reason, примененными согласно инструкции:

3. Отчетность. Составьте сводку из раздела 5 и экспортируйте её. Параметр savePath определяет формат — .xlsx для редактирования или .pdf для распространения:

using (Workbook report = new Workbook())
{
    report.LoadFromFile(@"C:\ap-invoices\output\validated.xlsx");

    AIResult result = report.AI(agentOptions).ExecuteInstruction(
        report,
        "Создай отчет об обработке. Добавь лист 'Summary' в начало с блоком KPI " +
        "(всего обработано счетов, общая сумма, количество расхождений, топ-поставщик по " +
        "объему), детальной таблицей по поставщикам и сводкой расхождений. Отформатируй для печати " +
        "и сохрани готовую книгу.",
        @"C:\ap-invoices\output\monthly-report.xlsx");

    if (result == null || !result.Success)
        throw new InvalidOperationException(
            $"Ошибка генерации отчета: {result?.ErrorMessage}");
}

Лист Summary размещается в начале книги, готовый к печати или экспорту в PDF:

В чем разница: традиционный SDK против ИИ-агента

Ценность агента наиболее очевидна при сравнении. С традиционным SDK вы ищете каждое поле по заголовку, жестко прописываете каждый порог проверки и пишете данные ячейка за ячейкой — и перенастраиваете всё это, когда поставщик меняет макет или меняется правило. Скетч ниже (упрощенно) показывает масштаб этой работы:

// Традиционный SDK (иллюстрация): каждое поле находится и извлекается
// по строке заголовка, пороги жестко закодированы, вывод пишется по ячейкам
foreach (string file in invoiceFiles)
{
    Workbook wb = new Workbook();
    wb.LoadFromFile(file);
    Worksheet sheet = wb.Worksheets[0];

    // Ломается, как только поставщик меняет "Total Due" на "Amount Payable".
    int totalCol = FindColumnByHeader(sheet, "Total Due");
    int vendorCol = FindColumnByHeader(sheet, "Vendor Name");

    for (int r = sheet.LastRow; r >= 2; r--)
    {
        double invoiceTotal = double.Parse(sheet.Range[r, totalCol].Text);
        double poTotal = GetPoTotal(sheet.Range[r, 1].Text);
        double diff = Math.Abs(invoiceTotal - poTotal) / poTotal;

        // Один жесткий порог; поставщик стройматериалов вызывает ложные срабатывания.
        if (diff > 0.05) sheet.Range[r, totalCol].Style.Color = Color.Red;
    }
    // ... затем объединение, затем проверка, затем сводка — сотни строк на поставщика и месяц.
}

ИИ-агент заменяет эту оркестрацию одной инструкцией:

validation.AI(agentOptions).ExecuteInstruction(
    validation,
    "Добавь лист 'Validation'. Сравни каждую позицию счета с заказами на поставку " +
    "в вложениях, отметь счета, где общая сумма отличается от PO более чем на 5%, " +
    "отметь позиции, описание которых не совпадает с PO. Выдели расхождения красным " +
    "и добавь столбец 'Reason' с объяснением каждого расхождения. Оставь исходные листы данных без изменений.",
    @"C:\ap-invoices\output\validated.xlsx",
    poFiles);

Оба подхода дают одну и ту же книгу проверки. Там, где SDK требует вызова FindColumnByHeader для каждого поля, сравнения порогов для каждого правила и записи ячеек, агент поглощает эту работу в одну инструкцию. Когда поставщик меняет макет или финансовый отдел меняет порог допустимых отклонений, вы редактируете инструкцию, а не код.

6. Почему стоит использовать Spire.Agent.Office для обработки счетов

Сравнение выше нейтрально; тот же паттерн работает с любой способной LLM. Spire.Agent.Office выигрывает для .NET-команд в трех областях:

1. Нативная обработка счетов в разных форматах. PDF, Word, Excel и сканированные изображения — это первоклассные граждане, а не форматы, которые нужно "прикручивать". Агент читает и извлекает данные из всех четырех форматов одной инструкцией.
2. Сохранение форматирования. Отчеты по счетам содержат заголовки, форматы чисел и условное форматирование, которые должны пережить обработку. Уровень документов агента сохраняет их в целости. Добавьте "сохранить исходный макет и стиль документа" в инструкцию, и результат останется верным шаблону.
3. Нативная интеграция с .NET. Это C# SDK, который встраивается в существующее приложение .NET. Никаких отдельных сервисов обработки документов, никакой сложной "сантехники" между сервисами. Пример выше — это вся поверхность интеграции.

Если вы уже используете Spire.Office для обработки документов, агент станет естественным следующим слоем: тот же объект Workbook получает процессор AI(), который превращает инструкции в исполняемые рабочие процессы.

7. Часто задаваемые вопросы (FAQ)

Может ли ИИ обрабатывать сканированные изображения?

Да. Пример извлечения выше загружает сканированные изображения вместе с PDF и Word, и агент читает и анализирует каждый файл в его нативном формате. Для сканов без текстового слоя агент работает напрямую с содержимым изображения. Если качество скана низкое, для лучших результатов рекомендуется сначала выполнить OCR.

Могут ли данные счетов оставаться внутри моего окружения?

Да, с одним важным нюансом. Spire.Agent.Office работает из вашего приложения, поэтому SDK, шаблоны и обработка документов остаются в вашем контуре. Файлы счетов не загружаются в сторонний сервис для хранения или конвертации. Для анализа содержимого ИИ нужны соответствующие текстовые данные, которые передаются модели — это неотъемлемый шаг любого ИИ-процесса. Если вы развернете свою модель в локальной сети, контент останется полностью внутри вашей инфраструктуры. Если вы подключаетесь через API (например, OpenAI или Azure OpenAI), данные передаются провайдеру согласно вашей конфигурации.

Могу ли я использовать свою модель с Spire.Agent.Office?

Да. Spire.Agent.Office поддерживает гибкую интеграцию моделей и совместим с основной ИИ-инфраструктурой, включая API и частные модели. Вы можете направить агента на свой эндпоинт. Подробности см. в руководстве по интеграции; по вопросам поддержки конкретных провайдеров обращайтесь в отдел продаж по адресу sales@e-iceblue.com.

Какую модель использует Spire.Agent.Office?

Spire.Agent.Office подключается к большой языковой модели через ключ SpireToken. Вы описываете задачу на естественном языке, а агент оркестрирует инструменты обработки документов. Модель отвечает за понимание, а уровень документов гарантирует форматирование и точность файла.

Можно ли обрабатывать счета пакетно?

Да. Одна инструкция применяется к папке с файлами, и агент создает одну консолидированную книгу со всеми данными. Поддерживается как извлечение полей, так и сверка между документами.

Изменит ли ИИ форматирование моей книги?

Не если вы этого не захотите. Добавьте фразу вроде "сохранить исходный макет, стили и шрифты" в инструкцию; официальное руководство документирует это решение.

Чем это отличается от использования Raw LLM API?

Raw LLM не может надежно читать, редактировать или писать файлы Word и Excel самостоятельно; ему нужен уровень обработки документов. ИИ-агент для документов объединяет понимание языка LLM с детерминированными API документов, поэтому на выходе вы получаете реальный, корректный файл.

Готовы автоматизировать обработку счетов?

Извлечение, проверка и составление отчетов — это самые быстрые способы получить пользу: направьте агента на папку входящих, опишите правила обработки и получите структурированную книгу или PDF. Следуйте руководству Getting Started, чтобы запустить свой первый рабочий процесс в .NET.

Дополнительное чтение

• Обзор продукта Spire.Agent.Office -- SDK ИИ-агентов для всех форматов Office
• ИИ-агент для обработки документов: что это и как работает -- концепция ИИ-агента для документов
• Генерация документов Word из данных Excel на C# -- генерация документов с помощью детерминированного SDK
• ИИ-проверка контрактов на C# -- тот же рабочий процесс агента для Word и PDF

Resumo rápido (TL;DR):

• Um ou alguns hiperlinks: Clique com o botão direito no texto vinculado e selecione Remover Hiperlink.

• Todos os hiperlinks em um documento:

  • Windows: Pressione Ctrl + A e, em seguida, Ctrl + Shift + F9.

  • Mac: Pressione Cmd + A e, em seguida, Cmd + Shift + F9. Se a tecla F9 estiver atribuída a uma função do sistema macOS, use Cmd + Fn + Shift + F9 ou pressione Cmd + 6.

• Sem o Word instalado: Use o Word para a Web para remover hiperlinks em um navegador.

• Vários arquivos do Word: Use processamento em lote com C# para remover hiperlinks automaticamente.

Hiperlinks são úteis para compartilhar sites, referências e outros recursos em um documento do Word. Mas, ao preparar um documento para impressão, publicação ou reutilização, esses links podem tornar-se desnecessários — ou deixar uma formatação que você não deseja mais.

Este guia mostra como remover hiperlinks no Word, desde a remoção de links individuais e de todos os links no Microsoft Word até a automação da limpeza em vários arquivos DOCX com C#.

O que você aprenderá:

• Remover um hiperlink no Microsoft Word
• Remover todos os hiperlinks de um documento do Word de uma só vez
• Remover hiperlinks do Word Online
• Excluir hiperlinks em lote de documentos do Word com C#
• Bônus: Impedir que o Word crie hiperlinks automaticamente
• Coisas a verificar após remover hiperlinks do Word
• Perguntas frequentes

Remover um hiperlink no Microsoft Word

Ideal para: Remover um ou poucos hiperlinks sem afetar o restante do conteúdo do documento.

Se apenas um pequeno número de links precisar ser removido, o comando nativo do Word Remover Hiperlink é a opção mais segura e direta. Ele remove o destino clicável, mantendo o texto exibido no local.

Este método é especialmente útil em documentos que contêm sumários, citações, referências cruzadas ou outros campos dinâmicos, pois apenas o hiperlink selecionado é afetado.

Instruções passo a passo

1. Abra o documento no Microsoft Word.

2. Localize o hiperlink que deseja remover.

3. Clique com o botão direito no texto vinculado.

4. Selecione Remover Hiperlink.

   

Resultado: O texto selecionado permanece no documento, mas não é mais clicável.

⚡ Dica: Se você quiser excluir tanto o hiperlink quanto o texto exibido, selecione o texto e pressione Delete ou Backspace.

Remover todos os hiperlinks de um documento do Word de uma só vez

Ideal para: Remover rapidamente muitos hiperlinks de um documento do Word relativamente simples.

Remover dezenas de links um por um é demorado. O Word oferece um atalho de teclado que pode remover hiperlinks do conteúdo selecionado em uma única operação.

Remover todos os hiperlinks no Windows

1. Pressione Ctrl + A para selecionar todo o conteúdo do documento. Você também pode selecionar manualmente apenas a seção que deseja processar.

2. Pressione Ctrl + Shift + F9.

Remover todos os hiperlinks no Mac

1. Pressione Cmd + A para selecionar o conteúdo do documento.

2. Pressione Cmd + Shift + F9.
   ⚡ Dica: Se o seu Mac usa F9 para uma função do sistema ou de mídia, use Cmd + Fn + Shift + F9 ou pressione Cmd + 6 para executar o comando UnlinkFields do Word sem depender da tecla F9.

Resultado: Todos os hiperlinks selecionados são convertidos em texto simples, preservando a redação original.

⚠️ Importante: Verifique os campos dinâmicos antes de usar este atalho

O atalho Ctrl + Shift + F9 não é um comando específico para hiperlinks. É o comando geral do Word para Desvincular Campo.

Isso significa que outros campos incluídos na seleção também podem ser convertidos em texto estático. Eles podem incluir:

• Sumários gerados automaticamente

• Referências cruzadas

• Campos de citação

• Outros campos dinâmicos do Word

Para relatórios, teses, manuais ou outros documentos que dependem de campos dinâmicos, salve um backup antes de usar o atalho. Observe também que o Ctrl + A normalmente seleciona o texto principal do documento. Hiperlinks em cabeçalhos e rodapés podem precisar ser tratados separadamente.

Remover hiperlinks do Word Online

Ideal para: Remoção ocasional de hiperlinks quando a versão desktop do Microsoft Word não está disponível.

Se você não tem o Word instalado, pode abrir seu documento no Word para a Web para editar hiperlinks diretamente em um navegador. Isso é conveniente para um pequeno número de links e não requer instalação de software.

Opção A: Barra de ferramentas pop-up (Mais rápido)

1. Clique no texto com hiperlink.

2. Clique no ícone Desvincular (um elo de corrente com um pequeno "X") no lado direito da barra de ferramentas pop-up.

   

Opção B: Menu de clique com o botão direito

1. Clique com o botão direito no texto com hiperlink.

2. Selecione Remover Hiperlink no menu de contexto.

Não consegue remover um hiperlink no Word para a Web?

Alguns links no Word para a Web podem aparecer cinza ou não ser editáveis. Causas comuns incluem:

• Controle de Alterações: O link foi criado ou editado enquanto o Controle de Alterações estava ativado.

• Links de vários parágrafos: O link abrange vários parágrafos e foi criado na versão desktop do Word.

Solução: Clique em Abrir no Aplicativo da Área de Trabalho (localizado no menu suspenso Edição na faixa de opções superior) e remova os links no Word desktop.

Excluir hiperlinks em lote de documentos do Word com C#

Ideal para: Desenvolvedores que automatizam o processamento de documentos em backend, limpam arquivos importados ou processam grandes coleções de documentos do Word.

Métodos manuais tornam-se ineficientes quando a mesma limpeza precisa ser aplicada em muitos arquivos do Word. Isso é comum ao processar documentos importados, preparar relatórios para publicação ou arquivamento, ou limpar arquivos gerados por outro sistema.

Nesses casos, a remoção de hiperlinks pode ser incorporada a um fluxo de trabalho em C#. O exemplo a seguir usa o Spire.Doc for .NET para remover hiperlinks em lote de vários arquivos DOCX sem exigir que o Microsoft Word esteja instalado.

Passo 1: Instalar a biblioteca .NET Word

Instale o Spire.Doc for .NET via NuGet usando o Console do Gerenciador de Pacotes ou a CLI do .NET.

Console do Gerenciador de Pacotes NuGet:

Install-Package Spire.Doc

CLI do .NET:

dotnet add package Spire.Doc

Após a instalação, os namespaces necessários podem ser referenciados diretamente no seu projeto C#.

Passo 2: Escrever código C# para remover hiperlinks em lote de arquivos DOCX

O exemplo a seguir verifica uma pasta de entrada em busca de arquivos .docx, identifica campos de hiperlink em cada documento, remove os campos de hiperlink preservando o texto exibido e salva os arquivos processados em uma pasta de saída separada.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Criar a pasta de saída se ela não existir
            Directory.CreateDirectory(outputFolder);

            // Processar todos os arquivos DOCX na pasta de entrada
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Ignorar arquivos temporários do Word
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Criar uma instância de Document
                Document doc = new Document();

                // Carregar um documento do Word
                doc.LoadFromFile(inputFile);

                // Encontrar todos os hiperlinks
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // Achatar todos os hiperlinks
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Salvar o documento processado
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Processado: {Path.GetFileName(inputFile)}");
            }
        }

        // Obter todos os hiperlinks do corpo do documento
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Achatar um campo de hiperlink mantendo seu texto exibido
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Remover o marcador de fim de campo
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Remover o código de campo e o separador
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Definir o texto do hiperlink retido como preto e remover o sublinhado
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Definir o texto do hiperlink retido como preto sem sublinhado
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Passo 3: Executar o programa

Atualize os caminhos das pastas de entrada e saída, coloque os arquivos DOCX na pasta de entrada e execute o aplicativo. As cópias limpas serão salvas na pasta de saída com seus nomes de arquivo originais.

Para um lote grande, teste o programa em alguns documentos representativos primeiro.

Saída:

⚠️ Nota técnica: Este trecho de código C# tem como alvo parágrafos de corpo de nível superior. Se seus documentos contiverem hiperlinks aninhados em tabelas, caixas de texto ou cabeçalhos/rodapés, a lógica de travessia deve ser estendida para verificar esses elementos filhos recursivamente.

O código também redefine o texto do hiperlink retido para preto e remove seu sublinhado. Se você precisar apenas alterar a cor ou remover o sublinhado de hiperlinks sem remover os links, você pode modificar a formatação do hiperlink separadamente.

Bônus: Impedir que o Word crie hiperlinks automaticamente

Se o problema real é que o Word continua transformando URLs e endereços de e-mail em links enquanto você digita, você pode desativar a criação automática de hiperlinks em vez de removê-los repetidamente depois.

No Word para Windows

1. Clique em Arquivo no canto superior esquerdo e escolha Opções na parte inferior da barra lateral.

2. Selecione a categoria Revisão de Texto no painel esquerdo.

3. Clique no botão Opções de AutoCorreção... próximo ao topo.

4. Mude para a guia AutoFormatação ao Digitar.

5. Desmarque a caixa ao lado de Caminhos da Internet e de rede com hiperlinks.

6. Clique em OK para aplicar.

No Word para Mac

1. Clique em Word na barra de menu superior da Apple e selecione Preferências.

2. Abra a ferramenta AutoCorreção na seção Autor.

3. Mude para a guia AutoFormatação ao Digitar.

4. Desmarque Caminhos da Internet e de rede com hiperlinks.

Alterar essa configuração impede que o Word formate links futuros enquanto você digita. Isso não afetará nem limpará hiperlinks que já estão salvos dentro do seu documento atual.

Coisas a verificar após remover hiperlinks do Word

Remover hiperlinks geralmente é simples, mas vale a pena verificar alguns detalhes depois, especialmente formatação, campos dinâmicos e links em áreas separadas do documento.

• Verifique a cor do texto e sublinhados: Se o texto permanecer azul ou sublinhado, defina a cor da fonte como Automática ou combine com o texto ao redor e, em seguida, remova o sublinhado, se necessário.

• Verifique os campos dinâmicos: Se você usou o atalho Ctrl + Shift + F9, verifique seu Sumário, referências cruzadas e citações. Certifique-se de que não foram convertidos acidentalmente em texto simples não atualizável.

• Verifique cabeçalhos e rodapés: O Ctrl + A não seleciona texto dentro de cabeçalhos e rodapés. Clique duas vezes dentro dessas áreas específicas manualmente para limpar os links ocultos restantes.

Perguntas frequentes

P: Remover um hiperlink exclui o texto de exibição?

R: Não. O comando Remover Hiperlink remove o link enquanto mantém o texto exibido no local.

P: Como posso remover o sublinhado azul sem quebrar o link?

R: Destaque o hiperlink, vá para a guia Página Inicial, defina a cor da fonte como Automática ou combine com o texto ao redor e, em seguida, clique no botão Sublinhado (ou pressione Ctrl + U) para desativar o sublinhado.

P: Como removo um hiperlink de uma imagem no Word?

R: Clique com o botão direito na imagem com hiperlink e selecione Remover Hiperlink. Em fluxos de trabalho de documentos automatizados, hiperlinks de imagem também podem ser gerenciados programaticamente.

P: Posso remover hiperlinks do Word sem instalar o Word?

R: Sim. Você pode abrir e editar o arquivo em um navegador usando o Word para a Web. Para vários arquivos, você também pode usar C# com uma biblioteca de software como o Spire.Doc para automatizar a remoção.

Considerações finais

Escolher a melhor maneira de remover hiperlinks depende do seu contexto de edição. Para edições manuais rápidas, os comandos nativos e atalhos de teclado do Word são ideais. Para fluxos de trabalho de documentos automatizados ou grandes coleções de arquivos DOCX, a automação via script C# oferece uma solução confiável e escalável.

요약 (TL;DR):

• 하나 또는 소수의 하이퍼링크: 링크된 텍스트를 마우스 오른쪽 버튼으로 클릭하고 하이퍼링크 제거를 선택합니다.

• 문서 내 모든 하이퍼링크:

  • Windows: Ctrl + A를 누른 다음 Ctrl + Shift + F9를 누릅니다.

  • Mac: Cmd + A를 누른 다음 Cmd + Shift + F9를 누릅니다. F9가 macOS 시스템 기능으로 할당된 경우 Cmd + Fn + Shift + F9를 사용하거나 Cmd + 6을 누릅니다.

• Word가 설치되지 않은 경우: 웹용 Word(Word for the web)를 사용하여 브라우저에서 하이퍼링크를 제거합니다.

• 여러 개의 Word 파일: C# 일괄 처리를 사용하여 자동으로 하이퍼링크를 제거합니다.

하이퍼링크는 Word 문서에서 웹사이트, 참조 자료 및 기타 리소스를 공유하는 데 유용합니다. 하지만 문서를 인쇄, 게시 또는 재사용하기 위해 준비할 때는 이러한 링크가 불필요해지거나 원치 않는 서식이 남을 수 있습니다.

이 가이드에서는 Microsoft Word에서 개별 및 모든 링크를 제거하는 방법부터 C#을 사용하여 여러 DOCX 파일의 정리를 자동화하는 방법까지, Word에서 하이퍼링크를 제거하는 방법을 설명합니다.

학습 내용:

• Microsoft Word에서 하이퍼링크 제거하기
• Word 문서의 모든 하이퍼링크 한 번에 제거하기
• Word Online에서 하이퍼링크 제거하기
• C#을 사용하여 Word 문서에서 하이퍼링크 일괄 삭제하기
• 보너스: Word가 자동으로 하이퍼링크를 생성하지 않도록 설정하기
• Word 하이퍼링크 제거 후 확인해야 할 사항
• 자주 묻는 질문(FAQ)

Microsoft Word에서 하이퍼링크 제거하기

용도: 다른 문서 콘텐츠에 영향을 주지 않고 하나 또는 소수의 하이퍼링크를 제거할 때 적합합니다.

제거해야 할 링크 수가 적은 경우, Word의 내장된 하이퍼링크 제거 명령이 가장 안전하고 간단한 옵션입니다. 이 명령은 표시된 텍스트는 그대로 유지하면서 클릭 가능한 대상만 제거합니다.

이 방법은 목차, 인용, 상호 참조 또는 기타 동적 필드가 포함된 문서에서 선택한 하이퍼링크에만 영향을 주므로 특히 유용합니다.

단계별 지침

1. Microsoft Word에서 문서를 엽니다.

2. 제거하려는 하이퍼링크를 찾습니다.

3. 링크된 텍스트를 마우스 오른쪽 버튼으로 클릭합니다.

4. 하이퍼링크 제거를 선택합니다.

   

결과: 선택한 텍스트는 문서에 그대로 남지만 더 이상 클릭할 수 없습니다.

⚡ 팁: 하이퍼링크와 표시된 텍스트를 모두 삭제하려면 텍스트를 선택한 후 Delete 또는 Backspace 키를 누르세요.

Word 문서의 모든 하이퍼링크 한 번에 제거하기

용도: 비교적 단순한 Word 문서에서 많은 하이퍼링크를 빠르게 제거할 때 적합합니다.

수십 개의 링크를 하나씩 제거하는 것은 시간이 많이 걸립니다. Word는 선택한 콘텐츠에서 하이퍼링크를 한 번에 제거할 수 있는 키보드 단축키를 제공합니다.

Windows에서 모든 하이퍼링크 제거

1. Ctrl + A를 눌러 문서의 모든 내용을 선택합니다. 처리하려는 섹션만 수동으로 선택할 수도 있습니다.

2. Ctrl + Shift + F9를 누릅니다.

Mac에서 모든 하이퍼링크 제거

1. Cmd + A를 눌러 문서 내용을 선택합니다.

2. Cmd + Shift + F9를 누릅니다.
   ⚡ 팁: Mac에서 F9를 시스템 또는 미디어 기능으로 사용하는 경우 Cmd + Fn + Shift + F9를 사용하거나, Cmd + 6을 눌러 F9 키를 사용하지 않고 Word의 필드 연결 해제(UnlinkFields) 명령을 실행하세요.

결과: 선택한 모든 하이퍼링크가 원래의 문구는 유지한 채 일반 텍스트로 변환됩니다.

⚠️ 중요: 이 단축키를 사용하기 전에 동적 필드를 확인하세요

Ctrl + Shift + F9는 하이퍼링크 전용 명령이 아닙니다. 이는 Word의 일반적인 필드 연결 해제 명령입니다.

즉, 선택 영역에 포함된 다른 필드도 정적 텍스트로 변환될 수 있습니다. 여기에는 다음이 포함될 수 있습니다:

• 자동 생성된 목차

• 상호 참조

• 인용 필드

• 기타 동적 Word 필드

보고서, 논문, 매뉴얼 또는 동적 필드에 의존하는 기타 문서의 경우, 단축키를 사용하기 전에 백업을 저장하십시오. 또한 Ctrl + A는 일반적으로 기본 문서 텍스트만 선택한다는 점에 유의하십시오. 머리글과 바닥글의 하이퍼링크는 별도로 처리해야 할 수 있습니다.

Word Online에서 하이퍼링크 제거하기

용도: 데스크톱 버전의 Microsoft Word를 사용할 수 없을 때 가끔 하이퍼링크를 제거해야 하는 경우에 적합합니다.

Word가 설치되어 있지 않은 경우, 웹용 Word(Word for the Web)에서 문서를 열어 브라우저에서 직접 하이퍼링크를 편집할 수 있습니다. 이는 소수의 링크를 처리할 때 편리하며 소프트웨어 설치가 전혀 필요하지 않습니다.

옵션 A: 팝업 도구 모음 (가장 빠름)

1. 하이퍼링크가 걸린 텍스트를 클릭합니다.

2. 팝업 도구 모음 오른쪽에 있는 연결 해제 아이콘(작은 "X"가 있는 체인 링크)을 클릭합니다.

   

옵션 B: 마우스 오른쪽 버튼 메뉴

1. 하이퍼링크가 걸린 텍스트를 마우스 오른쪽 버튼으로 클릭합니다.

2. 컨텍스트 메뉴에서 하이퍼링크 제거를 선택합니다.

웹용 Word에서 하이퍼링크를 제거할 수 없나요?

웹용 Word의 일부 링크는 회색으로 표시되거나 편집할 수 없을 수 있습니다. 일반적인 원인은 다음과 같습니다:

• 변경 내용 추적: 변경 내용 추적 기능이 활성화된 상태에서 링크가 생성되거나 편집되었습니다.

• 여러 단락에 걸친 링크: 링크가 여러 단락에 걸쳐 있으며 Word 데스크톱 버전에서 생성되었습니다.

해결 방법: 상단 리본의 편집 드롭다운 메뉴에 있는 데스크톱 앱에서 열기를 클릭하고 데스크톱 Word에서 링크를 제거하십시오.

C#을 사용하여 Word 문서에서 하이퍼링크 일괄 삭제하기

용도: 백엔드 문서 처리를 자동화하거나, 가져온 파일을 정리하거나, 대량의 Word 문서를 처리하는 개발자에게 적합합니다.

많은 Word 파일에 동일한 정리 작업을 적용해야 할 경우 수동 방법은 비효율적입니다. 이는 가져온 문서를 처리하거나, 게시 또는 보관을 위해 보고서를 준비하거나, 다른 시스템에서 생성된 파일을 정리할 때 흔히 발생합니다.

이러한 경우 C# 워크플로에 하이퍼링크 제거 기능을 통합할 수 있습니다. 다음 예제는 Spire.Doc for .NET을 사용하여 Microsoft Word를 설치하지 않고도 여러 DOCX 파일에서 하이퍼링크를 일괄 제거하는 방법을 보여줍니다.

1단계: .NET Word 라이브러리 설치

패키지 관리자 콘솔 또는 .NET CLI를 사용하여 NuGet을 통해 Spire.Doc for .NET을 설치합니다.

NuGet 패키지 관리자 콘솔:

Install-Package Spire.Doc

.NET CLI:

dotnet add package Spire.Doc

설치 후 필요한 네임스페이스를 C# 프로젝트에서 직접 참조할 수 있습니다.

2단계: DOCX 파일에서 하이퍼링크를 일괄 제거하는 C# 코드 작성

다음 예제는 입력 폴더에서 .docx 파일을 검색하여 각 문서의 하이퍼링크 필드를 식별하고, 표시된 텍스트는 유지하면서 하이퍼링크 필드를 제거한 다음, 처리된 파일을 별도의 출력 폴더에 저장합니다.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // 출력 폴더가 없으면 생성
            Directory.CreateDirectory(outputFolder);

            // 입력 폴더의 모든 DOCX 파일 처리
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // 임시 Word 파일 건너뛰기
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Document 인스턴스 생성
                Document doc = new Document();

                // Word 문서 로드
                doc.LoadFromFile(inputFile);

                // 모든 하이퍼링크 찾기
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // 모든 하이퍼링크 평탄화(제거)
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // 처리된 문서 저장
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"처리 완료: {Path.GetFileName(inputFile)}");
            }
        }

        // 문서 본문에서 모든 하이퍼링크 가져오기
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // 표시된 텍스트를 유지하면서 하이퍼링크 필드 평탄화
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // 필드 끝 마커 제거
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // 필드 코드 및 구분 기호 제거
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // 유지된 하이퍼링크 텍스트를 검은색으로 설정하고 밑줄 제거
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // 유지된 하이퍼링크 텍스트를 밑줄 없는 검은색으로 설정
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

3단계: 프로그램 실행

입력 및 출력 폴더 경로를 업데이트하고, DOCX 파일을 입력 폴더에 넣은 다음 애플리케이션을 실행합니다. 정리된 복사본이 원래 파일 이름으로 출력 폴더에 저장됩니다.

대량으로 처리하기 전에 몇 개의 대표 문서에서 프로그램을 먼저 테스트하십시오.

결과:

⚠️ 기술 참고 사항: 이 C# 코드 조각은 최상위 본문 단락을 대상으로 합니다. 문서에 표, 텍스트 상자 또는 머리글/바닥글 내에 중첩된 하이퍼링크가 포함된 경우, 해당 자식 요소를 재귀적으로 스캔하도록 탐색 로직을 확장해야 합니다.

또한 이 코드는 유지된 하이퍼링크 텍스트를 검은색으로 재설정하고 밑줄을 제거합니다. 링크를 제거하지 않고 하이퍼링크의 색상을 변경하거나 밑줄을 제거하기만 하면 되는 경우, 하이퍼링크 서식을 별도로 수정할 수 있습니다.

보너스: Word가 자동으로 하이퍼링크를 생성하지 않도록 설정하기

진정한 문제가 Word가 입력할 때마다 URL과 이메일 주소를 링크로 계속 변환하는 것이라면, 나중에 반복적으로 제거하는 대신 자동 하이퍼링크 생성을 비활성화할 수 있습니다.

Word for Windows의 경우

1. 왼쪽 상단 모서리에 있는 파일을 클릭한 다음 사이드바 하단의 옵션을 선택합니다.

2. 왼쪽 창에서 언어 교정 범주를 선택합니다.

3. 상단 근처의 자동 고침 옵션... 버튼을 클릭합니다.

4. 입력할 때 자동 서식 탭으로 전환합니다.

5. 인터넷과 네트워크 경로를 하이퍼링크로 설정 옆의 확인란을 선택 해제합니다.

6. 확인을 클릭하여 적용합니다.

Word for Mac의 경우

1. 상단 Apple 메뉴 막대에서 Word를 클릭하고 기본 설정을 선택합니다.

2. 작성 섹션 아래의 자동 고침 도구를 엽니다.

3. 입력할 때 자동 서식 탭으로 전환합니다.

4. 인터넷과 네트워크 경로를 하이퍼링크로 설정의 선택을 취소합니다.

이 설정을 변경하면 Word가 입력하는 향후 링크를 서식 지정하는 것을 중단합니다. 현재 문서 내에 이미 저장된 하이퍼링크는 건드리거나 정리하지 않습니다.

Word 하이퍼링크 제거 후 확인해야 할 사항

하이퍼링크 제거는 일반적으로 간단하지만, 특히 서식, 동적 필드 및 별도의 문서 영역에 있는 링크와 관련하여 나중에 확인해야 할 몇 가지 세부 사항이 있습니다.

• 텍스트 색상 및 밑줄 확인: 텍스트가 여전히 파란색이거나 밑줄이 그어져 있는 경우, 글꼴 색상을 자동으로 설정하거나 주변 텍스트와 일치시킨 다음 필요한 경우 밑줄을 제거하십시오.

• 동적 필드 확인: Ctrl + Shift + F9 단축키를 사용한 경우 목차, 상호 참조 및 인용을 확인하십시오. 실수로 업데이트할 수 없는 일반 텍스트로 변환되지 않았는지 확인하십시오.

• 머리글 및 바닥글 확인: Ctrl + A는 머리글과 바닥글 내부의 텍스트를 선택하지 않습니다. 남아 있는 숨겨진 링크를 지우려면 이러한 특정 영역 내부를 수동으로 두 번 클릭하십시오.

자주 묻는 질문(FAQ)

Q: 하이퍼링크를 제거하면 표시된 텍스트도 삭제되나요?

A: 아니요. 하이퍼링크 제거 명령은 표시된 텍스트는 그대로 유지하면서 링크만 제거합니다.

Q: 링크를 끊지 않고 파란색 밑줄만 제거하려면 어떻게 해야 하나요?

A: 하이퍼링크를 강조 표시하고 홈 탭으로 이동하여 글꼴 색상을 자동으로 설정하거나 주변 텍스트와 일치시킨 다음, 밑줄 버튼을 클릭(또는 Ctrl + U 누르기)하여 밑줄을 끕니다.

Q: Word에서 이미지의 하이퍼링크를 제거하려면 어떻게 해야 하나요?

A: 하이퍼링크가 걸린 이미지를 마우스 오른쪽 버튼으로 클릭하고 하이퍼링크 제거를 선택합니다. 자동화된 문서 워크플로에서는 이미지 하이퍼링크도 프로그래밍 방식으로 관리할 수 있습니다.

Q: Word를 설치하지 않고도 Word에서 하이퍼링크를 제거할 수 있나요?

A: 네. 웹용 Word를 사용하여 브라우저에서 파일을 열고 편집할 수 있습니다. 여러 파일의 경우 Spire.Doc과 같은 소프트웨어 라이브러리와 C#을 사용하여 제거를 자동화할 수도 있습니다.

최종 생각

하이퍼링크를 제거하는 가장 좋은 방법은 편집 상황에 따라 다릅니다. 빠른 수동 편집의 경우 Word의 내장 명령과 키보드 단축키가 이상적입니다. 자동화된 문서 워크플로나 대량의 DOCX 파일 컬렉션의 경우, C# 스크립트 자동화가 안정적이고 확장 가능한 솔루션을 제공합니다.

Sintesi rapida (TL;DR):

• Uno o pochi collegamenti: Fai clic con il tasto destro sul testo collegato e seleziona Rimuovi collegamento ipertestuale.

• Tutti i collegamenti in un documento:

  • Windows: Premi Ctrl + A, quindi Ctrl + Shift + F9.

  • Mac: Premi Cmd + A, quindi Cmd + Shift + F9. Se F9 è assegnato a una funzione di sistema di macOS, usa Cmd + Fn + Shift + F9 o premi Cmd + 6.

• Word non installato: Usa Word per il web per rimuovere i collegamenti ipertestuali in un browser.

• Più file Word: Usa l'elaborazione in blocco con C# per rimuovere i collegamenti ipertestuali automaticamente.

I collegamenti ipertestuali sono utili per condividere siti web, riferimenti e altre risorse in un documento Word. Tuttavia, quando prepari un documento per la stampa, la pubblicazione o il riutilizzo, tali collegamenti possono diventare superflui o lasciare una formattazione non desiderata.

Questa guida mostra come rimuovere i collegamenti ipertestuali in Word, dalla rimozione di singoli collegamenti o di tutti i collegamenti in Microsoft Word, fino all'automazione della pulizia su più file DOCX con C#.

Cosa imparerai:

• Rimuovere un collegamento ipertestuale in Microsoft Word
• Rimuovere tutti i collegamenti ipertestuali in un documento Word contemporaneamente
• Rimuovere collegamenti ipertestuali da Word Online
• Eliminazione in blocco di collegamenti ipertestuali da documenti Word con C#
• Bonus: Impedire a Word di creare collegamenti ipertestuali automaticamente
• Cose da controllare dopo aver rimosso i collegamenti ipertestuali di Word
• Domande frequenti

Rimuovere un collegamento ipertestuale in Microsoft Word

Ideale per: Rimuovere uno o pochi collegamenti ipertestuali senza influire sugli altri contenuti del documento.

Se è necessario rimuovere solo un numero limitato di collegamenti, il comando integrato di Word Rimuovi collegamento ipertestuale è l'opzione più sicura e diretta. Rimuove la destinazione cliccabile mantenendo il testo visualizzato al suo posto.

Questo metodo è particolarmente utile nei documenti contenenti indici, citazioni, riferimenti incrociati o altri campi dinamici, poiché viene influenzato solo il collegamento ipertestuale selezionato.

Istruzioni passo dopo passo

1. Apri il documento in Microsoft Word.

2. Individua il collegamento ipertestuale che desideri rimuovere.

3. Fai clic con il tasto destro sul testo collegato.

4. Seleziona Rimuovi collegamento ipertestuale.

   

Risultato: Il testo selezionato rimane nel documento, ma non è più cliccabile.

⚡ Suggerimento: Se desideri eliminare sia il collegamento ipertestuale che il testo visualizzato, seleziona il testo e premi Canc o Backspace.

Rimuovere tutti i collegamenti ipertestuali in un documento Word contemporaneamente

Ideale per: Rimuovere rapidamente molti collegamenti ipertestuali da un documento Word relativamente semplice.

Rimuovere decine di collegamenti uno per uno richiede tempo. Word fornisce una scorciatoia da tastiera in grado di eliminare i collegamenti ipertestuali dal contenuto selezionato in un'unica operazione.

Rimuovere tutti i collegamenti ipertestuali su Windows

1. Premi Ctrl + A per selezionare tutto il contenuto del documento. Puoi anche selezionare manualmente solo la sezione che desideri elaborare.

2. Premi Ctrl + Shift + F9.

Rimuovere tutti i collegamenti ipertestuali su Mac

1. Premi Cmd + A per selezionare il contenuto del documento.

2. Premi Cmd + Shift + F9.
   ⚡ Suggerimento: Se il tuo Mac usa F9 per una funzione di sistema o multimediale, usa Cmd + Fn + Shift + F9, oppure premi Cmd + 6 per eseguire il comando UnlinkFields di Word senza fare affidamento sul tasto F9.

Risultato: Tutti i collegamenti ipertestuali selezionati vengono convertiti in testo normale preservando la dicitura originale.

⚠️ Importante: Controlla i campi dinamici prima di usare questa scorciatoia

Ctrl + Shift + F9 non è un comando specifico per i collegamenti ipertestuali. È il comando generale di Word Scollega campo.

Ciò significa che anche altri campi inclusi nella selezione possono essere convertiti in testo statico. Questi possono includere:

• Indici generati automaticamente

• Riferimenti incrociati

• Campi di citazione

• Altri campi dinamici di Word

Per report, tesi, manuali o altri documenti che si basano su campi dinamici, salva una copia di backup prima di utilizzare la scorciatoia. Nota inoltre che Ctrl + A seleziona normalmente il testo principale del documento. I collegamenti ipertestuali in intestazioni e piè di pagina potrebbero dover essere gestiti separatamente.

Rimuovere collegamenti ipertestuali da Word Online

Ideale per: Rimozione occasionale di collegamenti ipertestuali quando la versione desktop di Microsoft Word non è disponibile.

Se non hai Word installato, puoi aprire il tuo documento in Word per il Web per modificare i collegamenti ipertestuali direttamente in un browser. È comodo per un piccolo numero di collegamenti e non richiede l'installazione di alcun software.

Opzione A: La barra degli strumenti pop-up (più veloce)

1. Fai clic sul testo con collegamento ipertestuale.

2. Fai clic sull'icona Scollega (un anello di catena con una piccola "X") sul lato destro della barra degli strumenti pop-up.

   

Opzione B: Il menu del tasto destro

1. Fai clic con il tasto destro sul testo con collegamento ipertestuale.

2. Seleziona Rimuovi collegamento ipertestuale dal menu contestuale.

Non riesci a rimuovere un collegamento ipertestuale in Word per il Web?

Alcuni collegamenti in Word per il Web potrebbero apparire grigi o non modificabili. Le cause comuni includono:

• Revisioni: Il collegamento è stato creato o modificato mentre la funzione Revisioni era attiva.

• Collegamenti su più paragrafi: Il collegamento si estende su più paragrafi ed è stato creato nella versione desktop di Word.

Soluzione: Fai clic su Apri nell'app desktop (situato nel menu a discesa Modifica sulla barra multifunzione in alto) e rimuovi i collegamenti in Word desktop.

Eliminazione in blocco di collegamenti ipertestuali da documenti Word con C#

Ideale per: Sviluppatori che automatizzano l'elaborazione dei documenti lato server, puliscono file importati o elaborano grandi raccolte di documenti Word.

I metodi manuali diventano inefficienti quando la stessa pulizia deve essere applicata a molti file Word. Questo è comune durante l'elaborazione di documenti importati, la preparazione di report per la pubblicazione o l'archiviazione, o la pulizia di file generati da un altro sistema.

In questi casi, la rimozione dei collegamenti ipertestuali può essere integrata in un flusso di lavoro C#. L'esempio seguente utilizza Spire.Doc for .NET per rimuovere in blocco i collegamenti ipertestuali da più file DOCX senza richiedere l'installazione di Microsoft Word.

Passaggio 1: Installare la libreria .NET Word

Installa Spire.Doc for .NET tramite NuGet usando la Console di Gestione pacchetti o la CLI .NET.

Console di Gestione pacchetti NuGet:

Install-Package Spire.Doc

CLI .NET:

dotnet add package Spire.Doc

Dopo l'installazione, i namespace richiesti possono essere referenziati direttamente nel tuo progetto C#.

Passaggio 2: Scrivere il codice C# per rimuovere in blocco i collegamenti ipertestuali dai file DOCX

L'esempio seguente scansiona una cartella di input alla ricerca di file .docx, identifica i campi dei collegamenti ipertestuali in ogni documento, rimuove i campi dei collegamenti mantenendo il testo visualizzato e salva i file elaborati in una cartella di output separata.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Crea la cartella di output se non esiste
            Directory.CreateDirectory(outputFolder);

            // Elabora tutti i file DOCX nella cartella di input
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Salta i file Word temporanei
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Crea un'istanza di Document
                Document doc = new Document();

                // Carica un documento Word
                doc.LoadFromFile(inputFile);

                // Trova tutti i collegamenti ipertestuali
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // Appiattisci tutti i collegamenti ipertestuali
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Salva il documento elaborato
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Elaborato: {Path.GetFileName(inputFile)}");
            }
        }

        // Ottieni tutti i collegamenti ipertestuali dal corpo del documento
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Appiattisci un campo di collegamento ipertestuale mantenendo il testo visualizzato
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Rimuovi il marcatore di fine campo
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Rimuovi il codice di campo e il separatore
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Imposta il testo del collegamento ipertestuale mantenuto su nero e rimuovi la sottolineatura
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Imposta il testo del collegamento ipertestuale mantenuto su nero senza sottolineatura
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Passaggio 3: Eseguire il programma

Aggiorna i percorsi delle cartelle di input e output, inserisci i file DOCX nella cartella di input ed esegui l'applicazione. Le copie pulite verranno salvate nella cartella di output con i nomi file originali.

Per un lotto di grandi dimensioni, testa prima il programma su alcuni documenti rappresentativi.

Output:

⚠️ Nota tecnica: Questo snippet C# punta ai paragrafi del corpo di primo livello. Se i tuoi documenti contengono collegamenti ipertestuali annidati all'interno di tabelle, caselle di testo o intestazioni/piè di pagina, la logica di attraversamento dovrebbe essere estesa per scansionare tali elementi figlio in modo ricorsivo.

Il codice reimposta anche il testo del collegamento ipertestuale mantenuto su nero e rimuove la sottolineatura. Se hai solo bisogno di cambiare il colore o rimuovere la sottolineatura dai collegamenti ipertestuali senza rimuovere i collegamenti stessi, puoi modificare la formattazione del collegamento ipertestuale separatamente.

Bonus: Impedire a Word di creare collegamenti ipertestuali automaticamente

Se il vero problema è che Word continua a trasformare URL e indirizzi email in collegamenti mentre scrivi, puoi disabilitare la creazione automatica dei collegamenti ipertestuali invece di rimuoverli ripetutamente in seguito.

In Word per Windows

1. Fai clic su File nell'angolo in alto a sinistra, quindi scegli Opzioni in fondo alla barra laterale.

2. Seleziona la categoria Strumenti di correzione dal riquadro sinistro.

3. Fai clic sul pulsante Opzioni correzione automatica... vicino alla parte superiore.

4. Passa alla scheda Formattazione automatica durante la digitazione.

5. Deseleziona la casella accanto a Percorsi Internet e di rete con collegamenti ipertestuali.

6. Fai clic su OK per applicare.

In Word per Mac

1. Fai clic su Word nella barra dei menu Apple in alto e seleziona Preferenze.

2. Apri lo strumento Correzione automatica nella sezione Creazione.

3. Passa alla scheda Formattazione automatica durante la digitazione.

4. Deseleziona Percorsi Internet e di rete con collegamenti ipertestuali.

La modifica di questa impostazione impedisce a Word di formattare i collegamenti futuri mentre scrivi. Non toccherà o pulirà i collegamenti ipertestuali già salvati all'interno del documento corrente.

Cose da controllare dopo aver rimosso i collegamenti ipertestuali di Word

La rimozione dei collegamenti ipertestuali è solitamente semplice, ma vale la pena controllare alcuni dettagli in seguito, specialmente la formattazione, i campi dinamici e i collegamenti in aree separate del documento.

• Controlla il colore del testo e le sottolineature: Se il testo rimane blu o sottolineato, imposta il colore del carattere su Automatico o abbinalo al testo circostante, quindi rimuovi la sottolineatura se necessario.

• Verifica i campi dinamici: Se hai utilizzato la scorciatoia Ctrl + Shift + F9, controlla l'indice, i riferimenti incrociati e le citazioni. Assicurati che non siano stati accidentalmente convertiti in testo normale non aggiornabile.

• Controlla intestazioni e piè di pagina: Ctrl + A non seleziona il testo all'interno di intestazioni e piè di pagina. Fai doppio clic manualmente all'interno di queste aree specifiche per eliminare i collegamenti nascosti rimanenti.

Domande frequenti

D: La rimozione di un collegamento ipertestuale elimina il testo visualizzato?

R: No. Il comando Rimuovi collegamento ipertestuale rimuove il collegamento mantenendo il testo visualizzato al suo posto.

D: Come posso rimuovere la sottolineatura blu senza interrompere il collegamento?

R: Evidenzia il collegamento ipertestuale, vai alla scheda Home, imposta il colore del carattere su Automatico o abbinalo al testo circostante, quindi fai clic sul pulsante Sottolineato (o premi Ctrl + U) per disattivare la sottolineatura.

D: Come rimuovo un collegamento ipertestuale da un'immagine in Word?

R: Fai clic con il tasto destro sull'immagine con collegamento ipertestuale e seleziona Rimuovi collegamento ipertestuale. Nei flussi di lavoro documentali automatizzati, i collegamenti ipertestuali delle immagini possono anche essere gestiti a livello di programmazione.

D: Posso rimuovere i collegamenti ipertestuali da Word senza installare Word?

R: Sì. Puoi aprire e modificare il file in un browser utilizzando Word per il web. Per più file, puoi anche utilizzare C# con una libreria software come Spire.Doc per automatizzare la rimozione.

Considerazioni finali

Scegliere il modo migliore per rimuovere i collegamenti ipertestuali dipende dal tuo contesto di modifica. Per modifiche manuali rapide, i comandi integrati e le scorciatoie da tastiera di Word sono ideali. Per flussi di lavoro documentali automatizzati o grandi raccolte di file DOCX, l'automazione tramite script C# fornisce una soluzione affidabile e scalabile.

Résumé rapide (TL;DR) :

• Un ou quelques liens : Faites un clic droit sur le texte lié et sélectionnez Supprimer le lien hypertexte.

• Tous les liens d'un document :

  • Windows : Appuyez sur Ctrl + A, puis sur Ctrl + Maj + F9.

  • Mac : Appuyez sur Cmd + A, puis sur Cmd + Maj + F9. Si F9 est assigné à une fonction système macOS, utilisez Cmd + Fn + Maj + F9 ou appuyez sur Cmd + 6.

• Word non installé : Utilisez Word pour le web dans un navigateur pour supprimer les liens.

• Plusieurs fichiers Word : Utilisez le traitement par lots en C# pour supprimer les liens automatiquement.

Les liens hypertextes sont utiles pour partager des sites web, des références et d'autres ressources dans un document Word. Mais lorsque vous préparez un document pour l'impression, la publication ou la réutilisation, ces liens peuvent devenir inutiles, ou laisser une mise en forme que vous ne souhaitez plus conserver.

Ce guide explique comment supprimer les liens hypertextes dans Word, de la suppression de liens individuels ou globaux dans Microsoft Word à l'automatisation du nettoyage sur plusieurs fichiers DOCX avec C#.

Ce que vous allez apprendre :

• Supprimer un lien hypertexte dans Microsoft Word
• Supprimer tous les liens hypertextes d'un document Word en une fois
• Supprimer les liens hypertextes dans Word Online
• Supprimer par lots les liens hypertextes des documents Word avec C#
• Bonus : Empêcher Word de créer des liens hypertextes automatiquement
• Points à vérifier après la suppression des liens hypertextes
• Questions fréquemment posées

Supprimer un lien hypertexte dans Microsoft Word

Idéal pour : Supprimer un ou quelques liens sans affecter le reste du contenu du document.

Si seul un petit nombre de liens doit être supprimé, la commande intégrée Supprimer le lien hypertexte de Word est l'option la plus sûre et la plus directe. Elle supprime la destination cliquable tout en conservant le texte affiché.

Cette méthode est particulièrement utile dans les documents contenant des tables des matières, des citations, des renvois ou d'autres champs dynamiques, car seul le lien hypertexte sélectionné est affecté.

Instructions étape par étape

1. Ouvrez le document dans Microsoft Word.

2. Localisez le lien hypertexte que vous souhaitez supprimer.

3. Faites un clic droit sur le texte lié.

4. Sélectionnez Supprimer le lien hypertexte.

   

Résultat : Le texte sélectionné reste dans le document, mais n'est plus cliquable.

⚡ Conseil : Si vous souhaitez supprimer à la fois le lien hypertexte et le texte affiché, sélectionnez le texte et appuyez sur Suppr ou Retour arrière.

Supprimer tous les liens hypertextes d'un document Word en une fois

Idéal pour : Supprimer rapidement de nombreux liens d'un document Word relativement simple.

Supprimer des dizaines de liens un par un prend du temps. Word propose un raccourci clavier qui permet de supprimer les liens hypertextes du contenu sélectionné en une seule opération.

Supprimer tous les liens hypertextes sous Windows

1. Appuyez sur Ctrl + A pour sélectionner tout le contenu du document. Vous pouvez également sélectionner manuellement uniquement la section que vous souhaitez traiter.

2. Appuyez sur Ctrl + Maj + F9.

Supprimer tous les liens hypertextes sur Mac

1. Appuyez sur Cmd + A pour sélectionner le contenu du document.

2. Appuyez sur Cmd + Maj + F9.
   ⚡ Conseil : Si votre Mac utilise F9 pour une fonction système ou multimédia, utilisez Cmd + Fn + Maj + F9, ou appuyez sur Cmd + 6 pour exécuter la commande Supprimer le lien de Word sans dépendre de la touche F9.

Résultat : Tous les liens hypertextes sélectionnés sont convertis en texte brut tout en préservant le libellé original.

⚠️ Important : Vérifiez les champs dynamiques avant d'utiliser ce raccourci

Ctrl + Maj + F9 n'est pas une commande spécifique aux liens hypertextes. Il s'agit de la commande générale Supprimer le lien de Word.

Cela signifie que d'autres champs inclus dans la sélection peuvent également être convertis en texte statique. Il peut s'agir de :

• Tables des matières générées automatiquement

• Renvois

• Champs de citation

• Autres champs dynamiques Word

Pour les rapports, thèses, manuels ou autres documents reposant sur des champs dynamiques, enregistrez une copie de sauvegarde avant d'utiliser le raccourci. Notez également que Ctrl + A sélectionne normalement le texte principal du document. Les liens hypertextes dans les en-têtes et pieds de page peuvent devoir être traités séparément.

Supprimer les liens hypertextes dans Word Online

Idéal pour : Une suppression occasionnelle de liens lorsque la version de bureau de Microsoft Word n'est pas disponible.

Si vous n'avez pas Word installé, vous pouvez ouvrir votre document dans Word pour le Web pour modifier les liens hypertextes directement dans un navigateur. C'est pratique pour un petit nombre de liens et ne nécessite aucune installation de logiciel.

Option A : La barre d'outils contextuelle (la plus rapide)

1. Cliquez sur le texte lié.

2. Cliquez sur l'icône Supprimer le lien (un maillon de chaîne avec un petit "X") sur le côté droit de la barre d'outils contextuelle.

   

Option B : Le menu clic droit

1. Faites un clic droit sur le texte lié.

2. Sélectionnez Supprimer le lien hypertexte dans le menu contextuel.

Impossible de supprimer un lien hypertexte dans Word pour le Web ?

Certains liens dans Word pour le Web peuvent apparaître grisés ou être non modifiables. Les causes courantes incluent :

• Suivi des modifications : Le lien a été créé ou modifié alors que le suivi des modifications était activé.

• Liens sur plusieurs paragraphes : Le lien s'étend sur plusieurs paragraphes et a été créé dans la version de bureau de Word.

Solution : Cliquez sur Ouvrir dans l'application de bureau (situé dans le menu déroulant Modification sur le ruban supérieur) et supprimez les liens dans la version de bureau de Word.

Supprimer par lots les liens hypertextes des documents Word avec C#

Idéal pour : Les développeurs automatisant le traitement de documents en arrière-plan, nettoyant des fichiers importés ou traitant de grandes collections de documents Word.

Les méthodes manuelles deviennent inefficaces lorsque le même nettoyage doit être appliqué à de nombreux fichiers Word. C'est le cas lors du traitement de documents importés, de la préparation de rapports pour la publication ou l'archivage, ou du nettoyage de fichiers générés par un autre système.

Dans ces cas, la suppression des liens hypertextes peut être intégrée dans un flux de travail C#. L'exemple suivant utilise Spire.Doc for .NET pour supprimer par lots les liens hypertextes de plusieurs fichiers DOCX sans nécessiter l'installation de Microsoft Word.

Étape 1 : Installer la bibliothèque .NET Word

Installez Spire.Doc for .NET via NuGet en utilisant la console du gestionnaire de paquets ou l'interface CLI .NET.

Console du gestionnaire de paquets NuGet :

Install-Package Spire.Doc

CLI .NET :

dotnet add package Spire.Doc

Après l'installation, les espaces de noms requis peuvent être référencés directement dans votre projet C#.

Étape 2 : Écrire le code C# pour supprimer par lots les liens hypertextes des fichiers DOCX

L'exemple suivant analyse un dossier d'entrée à la recherche de fichiers .docx, identifie les champs de lien hypertexte dans chaque document, supprime ces champs tout en préservant le texte affiché, et enregistre les fichiers traités dans un dossier de sortie séparé.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Créer le dossier de sortie s'il n'existe pas
            Directory.CreateDirectory(outputFolder);

            // Traiter tous les fichiers DOCX dans le dossier d'entrée
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Ignorer les fichiers Word temporaires
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Créer une instance de Document
                Document doc = new Document();

                // Charger un document Word
                doc.LoadFromFile(inputFile);

                // Trouver tous les liens hypertextes
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // Aplatir tous les liens hypertextes
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Enregistrer le document traité
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Traité : {Path.GetFileName(inputFile)}");
            }
        }

        // Obtenir tous les liens hypertextes du corps du document
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Aplatir un champ de lien hypertexte tout en conservant son texte affiché
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Supprimer le marqueur de fin de champ
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Supprimer le code de champ et le séparateur
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Définir le texte du lien hypertexte conservé en noir et supprimer le soulignement
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Définir le texte du lien hypertexte conservé en noir sans soulignement
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Étape 3 : Exécuter le programme

Mettez à jour les chemins des dossiers d'entrée et de sortie, placez les fichiers DOCX dans le dossier d'entrée et exécutez l'application. Les copies nettoyées seront enregistrées dans le dossier de sortie avec leurs noms de fichiers d'origine.

Pour un lot important, testez d'abord le programme sur quelques documents représentatifs.

Sortie :

⚠️ Note technique : Cet extrait C# cible les paragraphes du corps de texte de niveau supérieur. Si vos documents contiennent des liens hypertextes imbriqués dans des tableaux, des zones de texte ou des en-têtes/pieds de page, la logique de parcours doit être étendue pour analyser ces éléments enfants de manière récursive.

Le code réinitialise également le texte du lien hypertexte conservé en noir et supprime son soulignement. Si vous avez seulement besoin de changer la couleur ou supprimer le soulignement des liens hypertextes sans supprimer les liens eux-mêmes, vous pouvez modifier la mise en forme du lien hypertexte séparément.

Bonus : Empêcher Word de créer des liens hypertextes automatiquement

Si le vrai problème est que Word transforme continuellement les URL et les adresses e-mail en liens au fur et à mesure que vous tapez, vous pouvez désactiver la création automatique de liens hypertextes au lieu de les supprimer à plusieurs reprises par la suite.

Dans Word pour Windows

1. Cliquez sur Fichier dans le coin supérieur gauche, puis choisissez Options en bas de la barre latérale.

2. Sélectionnez la catégorie Vérification dans le volet gauche.

3. Cliquez sur le bouton Options de correction automatique... près du haut.

4. Passez à l'onglet Lors de la frappe.

5. Décochez la case à côté de Chemins Internet et réseau par des liens hypertexte.

6. Cliquez sur OK pour appliquer.

Dans Word pour Mac

1. Cliquez sur Word dans la barre de menus Apple en haut et sélectionnez Préférences.

2. Ouvrez l'outil Correction automatique sous la section Auteur.

3. Passez à l'onglet Lors de la frappe.

4. Décochez Chemins Internet et réseau par des liens hypertexte.

La modification de ce paramètre empêche Word de mettre en forme les futurs liens au fur et à mesure que vous tapez. Cela ne touchera pas et ne nettoiera pas les liens hypertextes déjà enregistrés dans votre document actuel.

Points à vérifier après la suppression des liens hypertextes

La suppression des liens hypertextes est généralement simple, mais quelques détails méritent d'être vérifiés par la suite, notamment la mise en forme, les champs dynamiques et les liens dans les zones distinctes du document.

• Vérifiez la couleur du texte et les soulignements : Si le texte reste bleu ou souligné, définissez la couleur de police sur Automatique ou faites-la correspondre au texte environnant, puis supprimez le soulignement si nécessaire.

• Vérifiez les champs dynamiques : Si vous avez utilisé le raccourci Ctrl + Maj + F9, vérifiez votre table des matières, vos renvois et vos citations. Assurez-vous qu'ils n'ont pas été accidentellement convertis en texte brut non modifiable.

• Vérifiez les en-têtes et pieds de page : Ctrl + A ne sélectionne pas le texte à l'intérieur des en-têtes et pieds de page. Double-cliquez manuellement à l'intérieur de ces zones spécifiques pour effacer les liens cachés restants.

Questions fréquemment posées

Q : La suppression d'un lien hypertexte supprime-t-elle le texte affiché ?

A : Non. La commande Supprimer le lien hypertexte supprime le lien tout en conservant le texte affiché.

Q : Comment puis-je supprimer le soulignement bleu sans rompre le lien ?

A : Mettez en surbrillance le lien hypertexte, accédez à l'onglet Accueil, définissez la couleur de police sur Automatique ou faites-la correspondre au texte environnant, puis cliquez sur le bouton Souligner (ou appuyez sur Ctrl + U) pour désactiver le soulignement.

Q : Comment supprimer un lien hypertexte d'une image dans Word ?

A : Faites un clic droit sur l'image liée et sélectionnez Supprimer le lien hypertexte. Dans les flux de travail documentaires automatisés, les liens hypertextes d'images peuvent également être gérés par programmation.

Q : Puis-je supprimer des liens hypertextes de Word sans installer Word ?

A : Oui. Vous pouvez ouvrir et modifier le fichier dans un navigateur en utilisant Word pour le web. Pour plusieurs fichiers, vous pouvez également utiliser C# avec une bibliothèque logicielle comme Spire.Doc pour automatiser la suppression.

Réflexions finales

Le choix de la meilleure méthode pour supprimer des liens hypertextes dépend de votre contexte d'édition. Pour des modifications manuelles rapides, les commandes intégrées et les raccourcis clavier de Word sont idéaux. Pour des flux de travail documentaires automatisés ou de grandes collections de fichiers DOCX, l'automatisation par script C# offre une solution fiable et évolutive.

Resumen rápido (TL;DR):

• Uno o pocos hipervínculos: Haga clic derecho en el texto vinculado y seleccione Quitar hipervínculo.

• Todos los hipervínculos en un documento:

  • Windows: Presione Ctrl + A, luego Ctrl + Shift + F9.

  • Mac: Presione Cmd + A, luego Cmd + Shift + F9. Si F9 está asignado a una función del sistema macOS, use Cmd + Fn + Shift + F9 o presione Cmd + 6.

• Sin Word instalado: Use Word para la web para eliminar hipervínculos en un navegador.

• Múltiples archivos de Word: Use el procesamiento por lotes en C# para eliminar hipervínculos automáticamente.

Los hipervínculos son útiles para compartir sitios web, referencias y otros recursos en un documento de Word. Pero cuando prepara un documento para imprimir, publicar o reutilizar, esos enlaces pueden volverse innecesarios o dejar un formato que ya no desea.

Esta guía muestra cómo eliminar hipervínculos en Word, desde eliminar enlaces individuales y todos los enlaces en Microsoft Word hasta automatizar la limpieza en múltiples archivos DOCX con C#.

Lo que aprenderá:

• Eliminar un hipervínculo en Microsoft Word
• Eliminar todos los hipervínculos de un documento de Word a la vez
• Eliminar hipervínculos de Word Online
• Eliminar hipervínculos por lotes de documentos de Word con C#
• Bonus: Evitar que Word cree hipervínculos automáticamente
• Cosas que verificar después de eliminar hipervínculos de Word
• Preguntas frecuentes

Eliminar un hipervínculo en Microsoft Word

Ideal para: Eliminar uno o pocos hipervínculos sin afectar el resto del contenido del documento.

Si solo necesita eliminar una pequeña cantidad de enlaces, el comando integrado de Word Quitar hipervínculo es la opción más segura y directa. Elimina el destino clicable mientras mantiene el texto mostrado en su lugar.

Este método es especialmente útil en documentos que contienen tablas de contenido, citas, referencias cruzadas u otros campos dinámicos, ya que solo se ve afectado el hipervínculo seleccionado.

Instrucciones paso a paso

1. Abra el documento en Microsoft Word.

2. Localice el hipervínculo que desea eliminar.

3. Haga clic derecho sobre el texto vinculado.

4. Seleccione Quitar hipervínculo.

   

Resultado: El texto seleccionado permanece en el documento, pero ya no es clicable.

⚡ Consejo: Si desea eliminar tanto el hipervínculo como el texto mostrado, seleccione el texto y presione Suprimir o Retroceso en su lugar.

Eliminar todos los hipervínculos de un documento de Word a la vez

Ideal para: Eliminar rápidamente muchos hipervínculos de un documento de Word relativamente simple.

Eliminar docenas de enlaces uno por uno consume mucho tiempo. Word proporciona un atajo de teclado que puede eliminar hipervínculos del contenido seleccionado en una sola operación.

Eliminar todos los hipervínculos en Windows

1. Presione Ctrl + A para seleccionar todo el contenido del documento. También puede seleccionar manualmente solo la sección que desea procesar.

2. Presione Ctrl + Shift + F9.

Eliminar todos los hipervínculos en Mac

1. Presione Cmd + A para seleccionar el contenido del documento.

2. Presione Cmd + Shift + F9.
   ⚡ Consejo: Si su Mac usa F9 para una función del sistema o multimedia, use Cmd + Fn + Shift + F9 en su lugar, o presione Cmd + 6 para ejecutar el comando UnlinkFields de Word sin depender de la tecla F9.

Resultado: Todos los hipervínculos seleccionados se convierten en texto sin formato mientras se conserva la redacción original.

⚠️ Importante: Verifique los campos dinámicos antes de usar este atajo

Ctrl + Shift + F9 no es un comando específico para hipervínculos. Es el comando general de Word Desvincular campo.

Esto significa que otros campos incluidos en la selección también pueden convertirse en texto estático. Estos pueden incluir:

• Tablas de contenido generadas automáticamente

• Referencias cruzadas

• Campos de citas

• Otros campos dinámicos de Word

Para informes, tesis, manuales u otros documentos que dependen de campos dinámicos, guarde una copia de seguridad antes de usar el atajo. Tenga en cuenta también que Ctrl + A normalmente selecciona el texto principal del documento. Es posible que los hipervínculos en encabezados y pies de página deban manejarse por separado.

Eliminar hipervínculos de Word Online

Ideal para: Eliminación ocasional de hipervínculos cuando la versión de escritorio de Microsoft Word no está disponible.

Si no tiene Word instalado, puede abrir su documento en Word para la Web para editar hipervínculos directamente en un navegador. Esto es conveniente para una pequeña cantidad de enlaces y no requiere instalación de software.

Opción A: La barra de herramientas emergente (la más rápida)

1. Haga clic en el texto con hipervínculo.

2. Haga clic en el icono de desvincular (un eslabón de cadena con una pequeña "X") en el lado derecho de la barra de herramientas emergente.

   

Opción B: El menú de clic derecho

1. Haga clic derecho en el texto con hipervínculo.

2. Seleccione Quitar hipervínculo en el menú contextual.

¿No puede eliminar un hipervínculo en Word para la Web?

Algunos enlaces en Word para la Web pueden aparecer en gris o no ser editables. Las causas comunes incluyen:

• Control de cambios: El enlace se creó o editó mientras el Control de cambios estaba habilitado.

• Enlaces de varios párrafos: El enlace abarca varios párrafos y fue creado en la versión de escritorio de Word.

Solución: Haga clic en Abrir en la aplicación de escritorio (ubicado en el menú desplegable Edición en la cinta superior) y elimine los enlaces en el Word de escritorio.

Eliminar hipervínculos por lotes de documentos de Word con C#

Ideal para: Desarrolladores que automatizan el procesamiento de documentos en el backend, limpian archivos importados o procesan grandes colecciones de documentos de Word.

Los métodos manuales se vuelven ineficientes cuando se debe aplicar la misma limpieza en muchos archivos de Word. Esto es común al procesar documentos importados, preparar informes para publicar o archivar, o limpiar archivos generados por otro sistema.

En estos casos, la eliminación de hipervínculos puede incorporarse a un flujo de trabajo de C#. El siguiente ejemplo utiliza Spire.Doc for .NET para eliminar por lotes hipervínculos de múltiples archivos DOCX sin necesidad de tener instalado Microsoft Word.

Paso 1: Instalar la biblioteca de Word para .NET

Instale Spire.Doc for .NET a través de NuGet usando la Consola del Administrador de paquetes o la CLI de .NET.

Consola del Administrador de paquetes NuGet:

Install-Package Spire.Doc

CLI de .NET:

dotnet add package Spire.Doc

Después de la instalación, los espacios de nombres requeridos pueden ser referenciados directamente en su proyecto de C#.

Paso 2: Escribir código C# para eliminar hipervínculos por lotes de archivos DOCX

El siguiente ejemplo escanea una carpeta de entrada en busca de archivos .docx, identifica campos de hipervínculo en cada documento, elimina los campos de hipervínculo mientras conserva el texto mostrado y guarda los archivos procesados en una carpeta de salida separada.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Crear la carpeta de salida si no existe
            Directory.CreateDirectory(outputFolder);

            // Procesar todos los archivos DOCX en la carpeta de entrada
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Saltar archivos temporales de Word
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Crear una instancia de Document
                Document doc = new Document();

                // Cargar un documento de Word
                doc.LoadFromFile(inputFile);

                // Encontrar todos los hipervínculos
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // Aplanar todos los hipervínculos
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Guardar el documento procesado
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Procesado: {Path.GetFileName(inputFile)}");
            }
        }

        // Obtener todos los hipervínculos del cuerpo del documento
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Aplanar un campo de hipervínculo mientras se conserva su texto mostrado
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Eliminar el marcador de fin de campo
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Eliminar el código de campo y el separador
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Establecer el texto del hipervínculo retenido en negro y eliminar el subrayado
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Establecer el texto del hipervínculo retenido en negro sin subrayado
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Paso 3: Ejecutar el programa

Actualice las rutas de las carpetas de entrada y salida, coloque los archivos DOCX en la carpeta de entrada y ejecute la aplicación. Las copias limpias se guardarán en la carpeta de salida con sus nombres de archivo originales.

Para un lote grande, pruebe primero el programa en algunos documentos representativos.

Resultado:

⚠️ Nota técnica: Este fragmento de C# se dirige a párrafos del cuerpo de nivel superior. Si sus documentos contienen hipervínculos anidados dentro de tablas, cuadros de texto o encabezados/pies de página, la lógica de recorrido debe extenderse para escanear esos elementos secundarios de forma recursiva.

El código también restablece el texto del hipervínculo retenido a negro y elimina su subrayado. Si solo necesita cambiar el color o eliminar el subrayado de los hipervínculos sin eliminar los enlaces, puede modificar el formato del hipervínculo por separado.

Bonus: Evitar que Word cree hipervínculos automáticamente

Si el problema real es que Word sigue convirtiendo URLs y direcciones de correo electrónico en enlaces mientras escribe, puede deshabilitar la creación automática de hipervínculos en lugar de eliminarlos repetidamente después.

En Word para Windows

1. Haga clic en Archivo en la esquina superior izquierda, luego elija Opciones en la parte inferior de la barra lateral.

2. Seleccione la categoría Revisión en el panel izquierdo.

3. Haga clic en el botón Opciones de autocorrección... cerca de la parte superior.

4. Cambie a la pestaña Autoformato mientras escribe.

5. Desmarque la casilla junto a Rutas de Internet y red con hipervínculos.

6. Haga clic en Aceptar para aplicar.

En Word para Mac

1. Haga clic en Word en la barra de menú superior de Apple y seleccione Preferencias.

2. Abra la herramienta Autocorrección en la sección Autoría.

3. Cambie a la pestaña Autoformato mientras escribe.

4. Desmarque Rutas de Internet y red con hipervínculos.

Cambiar esta configuración evita que Word formatee futuros enlaces mientras escribe. No tocará ni limpiará los hipervínculos que ya están guardados dentro de su documento actual.

Cosas que verificar después de eliminar hipervínculos de Word

Eliminar hipervínculos suele ser sencillo, pero vale la pena verificar algunos detalles después, especialmente el formato, los campos dinámicos y los enlaces en áreas separadas del documento.

• Verifique el color del texto y los subrayados: Si el texto permanece azul o subrayado, establezca el color de fuente en Automático o haga que coincida con el texto circundante, luego elimine el subrayado si es necesario.

• Verifique los campos dinámicos: Si utilizó el atajo Ctrl + Shift + F9, verifique su Tabla de contenido, referencias cruzadas y citas. Asegúrese de que no se hayan convertido accidentalmente en texto sin formato que no se puede actualizar.

• Verifique encabezados y pies de página: Ctrl + A no selecciona texto dentro de encabezados y pies de página. Haga doble clic dentro de estas áreas específicas manualmente para borrar los enlaces ocultos restantes.

Preguntas frecuentes

P: ¿Eliminar un hipervínculo borra el texto mostrado?

R: No. El comando Quitar hipervínculo elimina el enlace mientras mantiene el texto mostrado en su lugar.

P: ¿Cómo puedo eliminar el subrayado azul sin romper el enlace?

R: Resalte el hipervínculo, vaya a la pestaña Inicio, establezca el color de fuente en Automático o haga que coincida con el texto circundante, y luego haga clic en el botón Subrayado (o presione Ctrl + U) para desactivar el subrayado.

P: ¿Cómo elimino un hipervínculo de una imagen en Word?

R: Haga clic derecho en la imagen con hipervínculo y seleccione Quitar hipervínculo. En flujos de trabajo de documentos automatizados, los hipervínculos de imágenes también se pueden gestionar mediante programación.

P: ¿Puedo eliminar hipervínculos de Word sin instalar Word?

R: Sí. Puede abrir y editar el archivo en un navegador usando Word para la web. Para múltiples archivos, también puede usar C# con una biblioteca de software como Spire.Doc para automatizar la eliminación.

Reflexiones finales

Elegir la mejor manera de eliminar hipervínculos depende de su contexto de edición. Para ediciones manuales rápidas, los comandos integrados y los atajos de teclado de Word son ideales. Para flujos de trabajo de documentos automatizados o grandes colecciones de archivos DOCX, la automatización mediante scripts de C# proporciona una solución confiable y escalable.

Kurzzusammenfassung (TL;DR):

• Ein oder wenige Hyperlinks: Rechtsklick auf den verknüpften Text und Hyperlink entfernen wählen.

• Alle Hyperlinks in einem Dokument:

  • Windows: Strg + A drücken, dann Strg + Umschalt + F9.

  • Mac: Cmd + A drücken, dann Cmd + Umschalt + F9. Falls F9 einer macOS-Systemfunktion zugewiesen ist, verwenden Sie Cmd + Fn + Umschalt + F9 oder drücken Sie Cmd + 6.

• Kein Word installiert: Verwenden Sie Word für das Web, um Hyperlinks im Browser zu entfernen.

• Mehrere Word-Dateien: Verwenden Sie C#-Stapelverarbeitung, um Hyperlinks automatisch zu entfernen.

Hyperlinks sind nützlich, um Websites, Referenzen und andere Ressourcen in einem Word-Dokument zu teilen. Wenn Sie jedoch ein Dokument für den Druck, die Veröffentlichung oder zur Wiederverwendung vorbereiten, können diese Links unnötig werden – oder eine Formatierung hinterlassen, die Sie nicht mehr wünschen.

Dieser Leitfaden zeigt, wie Sie Hyperlinks in Word entfernen, vom Löschen einzelner oder aller Links in Microsoft Word bis hin zur Automatisierung der Bereinigung mehrerer DOCX-Dateien mit C#.

Was Sie lernen werden:

• Einen Hyperlink in Microsoft Word entfernen
• Alle Hyperlinks in einem Word-Dokument gleichzeitig entfernen
• Hyperlinks aus Word Online entfernen
• Stapelweises Löschen von Hyperlinks aus Word-Dokumenten mit C#
• Bonus: Automatische Erstellung von Hyperlinks in Word verhindern
• Was nach dem Entfernen von Word-Hyperlinks zu prüfen ist
• Häufig gestellte Fragen

Einen Hyperlink in Microsoft Word entfernen

Am besten geeignet für: Das Entfernen eines oder weniger Hyperlinks, ohne andere Dokumentinhalte zu beeinträchtigen.

Wenn nur eine kleine Anzahl von Links entfernt werden muss, ist der integrierte Befehl Hyperlink entfernen von Word die sicherste und einfachste Option. Er entfernt das klickbare Ziel, während der angezeigte Text erhalten bleibt.

Diese Methode ist besonders nützlich in Dokumenten, die Inhaltsverzeichnisse, Zitate, Querverweise oder andere dynamische Felder enthalten, da nur der ausgewählte Hyperlink betroffen ist.

Schritt-für-Schritt-Anleitung

1. Öffnen Sie das Dokument in Microsoft Word.

2. Suchen Sie den Hyperlink, den Sie entfernen möchten.

3. Klicken Sie mit der rechten Maustaste auf den verknüpften Text.

4. Wählen Sie Hyperlink entfernen.

   

Ergebnis: Der ausgewählte Text bleibt im Dokument, ist aber nicht mehr anklickbar.

⚡ Tipp: Wenn Sie sowohl den Hyperlink als auch den angezeigten Text löschen möchten, markieren Sie den Text und drücken Sie stattdessen Entf oder Rücktaste.

Alle Hyperlinks in einem Word-Dokument gleichzeitig entfernen

Am besten geeignet für: Das schnelle Entfernen vieler Hyperlinks aus einem relativ einfachen Word-Dokument.

Das Entfernen von Dutzenden von Links einzeln ist zeitaufwendig. Word bietet eine Tastenkombination, mit der Hyperlinks aus dem ausgewählten Inhalt in einem einzigen Vorgang entfernt werden können.

Alle Hyperlinks unter Windows entfernen

1. Drücken Sie Strg + A, um den gesamten Inhalt des Dokuments auszuwählen. Sie können auch manuell nur den Abschnitt auswählen, den Sie bearbeiten möchten.

2. Drücken Sie Strg + Umschalt + F9.

Alle Hyperlinks auf dem Mac entfernen

1. Drücken Sie Cmd + A, um den Dokumentinhalt auszuwählen.

2. Drücken Sie Cmd + Umschalt + F9.
   ⚡ Tipp: Wenn Ihr Mac F9 für eine System- oder Medienfunktion verwendet, verwenden Sie stattdessen Cmd + Fn + Umschalt + F9 oder drücken Sie Cmd + 6, um den Befehl Felder aufheben von Word auszuführen, ohne die F9-Taste zu verwenden.

Ergebnis: Alle ausgewählten Hyperlinks werden in normalen Text umgewandelt, wobei der ursprüngliche Wortlaut erhalten bleibt.

⚠️ Wichtig: Überprüfen Sie dynamische Felder, bevor Sie diese Tastenkombination verwenden

Strg + Umschalt + F9 ist kein spezifischer Befehl für Hyperlinks. Es ist der allgemeine Befehl von Word zum Aufheben der Verknüpfung von Feldern.

Das bedeutet, dass auch andere Felder, die in der Auswahl enthalten sind, in statischen Text umgewandelt werden können. Dazu gehören:

• Automatisch generierte Inhaltsverzeichnisse

• Querverweise

• Zitierfelder

• Andere dynamische Word-Felder

Erstellen Sie bei Berichten, Abschlussarbeiten, Handbüchern oder anderen Dokumenten, die auf dynamischen Feldern basieren, eine Sicherungskopie, bevor Sie die Tastenkombination verwenden. Beachten Sie auch, dass Strg + A normalerweise den Haupttext des Dokuments auswählt. Hyperlinks in Kopf- und Fußzeilen müssen möglicherweise separat behandelt werden.

Hyperlinks aus Word Online entfernen

Am besten geeignet für: Gelegentliches Entfernen von Hyperlinks, wenn die Desktop-Version von Microsoft Word nicht verfügbar ist.

Wenn Sie Word nicht installiert haben, können Sie Ihr Dokument in Word für das Web öffnen, um Hyperlinks direkt in einem Browser zu bearbeiten. Dies ist praktisch für eine kleine Anzahl von Links und erfordert keine Softwareinstallation.

Option A: Die Pop-up-Symbolleiste (am schnellsten)

1. Klicken Sie auf den verknüpften Text.

2. Klicken Sie auf das Symbol zum Aufheben der Verknüpfung (ein Kettenglied mit einem kleinen "X") auf der rechten Seite der Pop-up-Symbolleiste.

   

Option B: Das Rechtsklick-Menü

1. Klicken Sie mit der rechten Maustaste auf den verknüpften Text.

2. Wählen Sie Hyperlink entfernen aus dem Kontextmenü.

Kann ein Hyperlink in Word für das Web nicht entfernt werden?

Einige Links in Word für das Web können grau erscheinen oder nicht bearbeitbar sein. Häufige Ursachen sind:

• Änderungen nachverfolgen: Der Link wurde erstellt oder bearbeitet, während "Änderungen nachverfolgen" aktiviert war.

• Mehrabsatz-Links: Der Link erstreckt sich über mehrere Absätze und wurde in der Desktop-Version von Word erstellt.

Lösung: Klicken Sie auf In Desktop-App öffnen (im Dropdown-Menü Bearbeiten im oberen Menüband) und entfernen Sie die Links in der Desktop-Version von Word.

Stapelweises Löschen von Hyperlinks aus Word-Dokumenten mit C#

Am besten geeignet für: Entwickler, die die Dokumentverarbeitung im Backend automatisieren, importierte Dateien bereinigen oder große Sammlungen von Word-Dokumenten verarbeiten.

Manuelle Methoden werden ineffizient, wenn dieselbe Bereinigung auf viele Word-Dateien angewendet werden muss. Dies ist häufig der Fall bei der Verarbeitung importierter Dokumente, der Vorbereitung von Berichten für die Veröffentlichung oder Archivierung oder der Bereinigung von Dateien, die von einem anderen System generiert wurden.

In diesen Fällen kann das Entfernen von Hyperlinks in einen C#-Workflow integriert werden. Das folgende Beispiel verwendet Spire.Doc for .NET, um stapelweise Hyperlinks aus mehreren DOCX-Dateien zu entfernen, ohne dass Microsoft Word installiert sein muss.

Schritt 1: Die .NET Word-Bibliothek installieren

Installieren Sie Spire.Doc for .NET über NuGet unter Verwendung der Paket-Manager-Konsole oder der .NET CLI.

NuGet Paket-Manager-Konsole:

Install-Package Spire.Doc

.NET CLI:

dotnet add package Spire.Doc

Nach der Installation können die erforderlichen Namespaces direkt in Ihrem C#-Projekt referenziert werden.

Schritt 2: C#-Code zum stapelweisen Entfernen von Hyperlinks aus DOCX-Dateien schreiben

Das folgende Beispiel durchsucht einen Eingabeordner nach .docx-Dateien, identifiziert Hyperlink-Felder in jedem Dokument, entfernt die Hyperlink-Felder unter Beibehaltung des angezeigten Textes und speichert die verarbeiteten Dateien in einem separaten Ausgabeordner.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Erstellen Sie den Ausgabeordner, falls er nicht existiert
            Directory.CreateDirectory(outputFolder);

            // Verarbeiten Sie alle DOCX-Dateien im Eingabeordner
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Überspringen Sie temporäre Word-Dateien
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Erstellen Sie eine Document-Instanz
                Document doc = new Document();

                // Laden Sie ein Word-Dokument
                doc.LoadFromFile(inputFile);

                // Finden Sie alle Hyperlinks
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // Entfernen Sie alle Hyperlinks
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Speichern Sie das verarbeitete Dokument
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Verarbeitet: {Path.GetFileName(inputFile)}");
            }
        }

        // Holen Sie alle Hyperlinks aus dem Dokumentkörper
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Ein Hyperlink-Feld entfernen, während der angezeigte Text beibehalten wird
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Entfernen Sie den Feldendmarker
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Entfernen Sie den Feldcode und das Trennzeichen
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Setzen Sie den beibehaltenen Hyperlink-Text auf Schwarz und entfernen Sie die Unterstreichung
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Setzen Sie den beibehaltenen Hyperlink-Text auf Schwarz ohne Unterstreichung
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Schritt 3: Das Programm ausführen

Aktualisieren Sie die Pfade für den Eingabe- und Ausgabeordner, legen Sie die DOCX-Dateien in den Eingabeordner und führen Sie die Anwendung aus. Die bereinigten Kopien werden mit ihren ursprünglichen Dateinamen im Ausgabeordner gespeichert.

Testen Sie das Programm bei einer großen Menge zuerst an einigen repräsentativen Dokumenten.

Ausgabe:

⚠️ Technischer Hinweis: Dieser C#-Schnipsel zielt auf Haupttextabsätze ab. Wenn Ihre Dokumente Hyperlinks enthalten, die in Tabellen, Textfeldern oder Kopf-/Fußzeilen verschachtelt sind, sollte die Durchlauflogik erweitert werden, um diese untergeordneten Elemente rekursiv zu scannen.

Der Code setzt auch den beibehaltenen Hyperlink-Text auf Schwarz und entfernt dessen Unterstreichung. Wenn Sie nur die Farbe ändern oder die Unterstreichung von Hyperlinks entfernen möchten, ohne die Links selbst zu entfernen, können Sie die Hyperlink-Formatierung separat ändern.

Bonus: Automatische Erstellung von Hyperlinks in Word verhindern

Wenn das eigentliche Problem darin besteht, dass Word URLs und E-Mail-Adressen während der Eingabe ständig in Links umwandelt, können Sie die automatische Hyperlink-Erstellung deaktivieren, anstatt sie danach wiederholt zu entfernen.

In Word für Windows

1. Klicken Sie oben links auf Datei und wählen Sie dann unten in der Seitenleiste Optionen.

2. Wählen Sie die Kategorie Dokumentprüfung in der linken Leiste.

3. Klicken Sie oben auf die Schaltfläche AutoKorrektur-Optionen....

4. Wechseln Sie zur Registerkarte AutoFormat während der Eingabe.

5. Deaktivieren Sie das Kontrollkästchen neben Internet- und Netzwerkpfade durch Hyperlinks.

6. Klicken Sie auf OK, um die Änderung zu übernehmen.

In Word für Mac

1. Klicken Sie in der oberen Apple-Menüleiste auf Word und wählen Sie Einstellungen.

2. Öffnen Sie das Werkzeug AutoKorrektur unter dem Abschnitt "Erstellung".

3. Wechseln Sie zur Registerkarte AutoFormat während der Eingabe.

4. Deaktivieren Sie Internet- und Netzwerkpfade durch Hyperlinks.

Durch Ändern dieser Einstellung wird verhindert, dass Word zukünftige Links während der Eingabe formatiert. Bestehende Hyperlinks, die bereits in Ihrem aktuellen Dokument gespeichert sind, werden dadurch nicht verändert oder bereinigt.

Was nach dem Entfernen von Word-Hyperlinks zu prüfen ist

Das Entfernen von Hyperlinks ist normalerweise unkompliziert, aber einige Details sollten danach überprüft werden, insbesondere Formatierung, dynamische Felder und Links in separaten Dokumentbereichen.

• Textfarbe und Unterstreichungen prüfen: Wenn der Text blau bleibt oder unterstrichen ist, setzen Sie die Schriftfarbe auf Automatisch oder passen Sie sie an den umgebenden Text an und entfernen Sie bei Bedarf die Unterstreichung.

• Dynamische Felder verifizieren: Wenn Sie die Tastenkombination Strg + Umschalt + F9 verwendet haben, überprüfen Sie Ihr Inhaltsverzeichnis, Ihre Querverweise und Zitate. Stellen Sie sicher, dass diese nicht versehentlich in nicht aktualisierbaren normalen Text umgewandelt wurden.

• Kopf- und Fußzeilen prüfen: Strg + A wählt keinen Text innerhalb von Kopf- und Fußzeilen aus. Doppelklicken Sie manuell in diese spezifischen Bereiche, um verbleibende versteckte Links zu löschen.

Häufig gestellte Fragen

F: Löscht das Entfernen eines Hyperlinks den angezeigten Text?

A: Nein. Der Befehl Hyperlink entfernen löscht den Link, während der angezeigte Text erhalten bleibt.

F: Wie kann ich die blaue Unterstreichung entfernen, ohne den Link zu zerstören?

A: Markieren Sie den Hyperlink, gehen Sie zur Registerkarte Start, setzen Sie die Schriftfarbe auf Automatisch oder passen Sie sie an den umgebenden Text an und klicken Sie dann auf die Schaltfläche Unterstreichen (oder drücken Sie Strg + U), um die Unterstreichung zu deaktivieren.

F: Wie entferne ich einen Hyperlink von einem Bild in Word?

A: Klicken Sie mit der rechten Maustaste auf das verknüpfte Bild und wählen Sie Hyperlink entfernen. In automatisierten Dokument-Workflows können Bild-Hyperlinks auch programmgesteuert verwaltet werden.

F: Kann ich Hyperlinks aus Word entfernen, ohne Word zu installieren?

A: Ja. Sie können die Datei in einem Browser mit Word für das Web öffnen und bearbeiten. Für mehrere Dateien können Sie auch C# mit einer Softwarebibliothek wie Spire.Doc verwenden, um das Entfernen zu automatisieren.

Abschließende Gedanken

Die Wahl der besten Methode zum Entfernen von Hyperlinks hängt von Ihrem Bearbeitungskontext ab. Für schnelle manuelle Bearbeitungen sind die integrierten Befehle und Tastenkombinationen von Word ideal. Für automatisierte Dokument-Workflows oder große Sammlungen von DOCX-Dateien bietet die C#-Skriptautomatisierung eine zuverlässige und skalierbare Lösung.