"What file formats does GroupDocs.Editor support?"

"GroupDocs.Editor handles over 30 formats, including DOCX, RTF, TXT, HTML, PDF, and ODT. See the full list in the official documentation."

"Can I try GroupDocs.Editor before purchasing?"

"Yes, you can get a free trial [here](https://releases.groupdocs.com/)."

"Is there any support if I encounter issues?"

"Absolutely—visit the support forum [here](https://forum.groupdocs.com/c/editor/20) for help from the community and the product team."

"How do I obtain a temporary license for evaluation?"

"Request a temporary license [here](https://purchase.groupdocs.com/temporary-license/)."

"Where can I purchase the full version of GroupDocs.Editor?"

"You can buy the full version [here](https://purchase.groupdocs.com/buy)."

Reemplazar texto en documento y guardar – GroupDocs.Editor .NET

Introducción

Si necesita replace text in document de forma programática, GroupDocs.Editor para .NET le brinda una forma limpia y de alto rendimiento de hacerlo. En este tutorial recorreremos la carga de un archivo Word, el intercambio de una cadena y luego guardar el resultado en varios formatos populares como RTF, DOCM y texto plano. Ya sea que esté construyendo un servicio de automatización de documentos o añadiendo una función de corrección rápida a una herramienta interna, los pasos a continuación le permitirán estar en marcha en minutos.

Respuestas rápidas

¿Cuál es la forma más sencilla de reemplazar texto? Cargue el archivo con Editor, modifique el HTML y llame a Save en el EditableDocument.
¿A qué formatos puedo guardar? RTF, DOCM y TXT son compatibles de forma nativa.
¿Necesito una instalación completa de Office? No – GroupDocs.Editor funciona completamente del lado del servidor.
¿Qué versiones de .NET se requieren? .NET Framework 4.6.1 o posterior, .NET Core 3.1 +, .NET 5/6 son compatibles.
¿Es obligatoria una licencia para producción? Sí, una licencia comercial elimina los límites de evaluación; hay una prueba gratuita disponible.

¿Qué es “replace text in document”?

“Replace text in document” se refiere a encontrar programáticamente una cadena específica dentro de un archivo y sustituirla por contenido nuevo sin edición manual. Esta operación es esencial para actualizaciones masivas, plantillas o generación de documentos impulsada por datos. Permite a los desarrolladores automatizar la personalización de documentos, aplicar cambios regulatorios en múltiples archivos e integrar la generación de contenido dinámico dentro de flujos de trabajo más amplios.

¿Por qué usar GroupDocs.Editor para .NET?

GroupDocs.Editor soporta más de 30 formatos de entrada y salida—incluidos DOCX, RTF, TXT, HTML, PDF y ODT—mientras procesa archivos de hasta 500 MB sin cargar todo el documento en memoria. La API se ejecuta en Windows, Linux y macOS, brindándole flexibilidad multiplataforma y una tasa de éxito del 99.9 % en diseños complejos, según pruebas internas.

Requisitos previos

Entorno de desarrollo: Visual Studio (cualquier edición reciente).
.NET Framework: 4.6.1 o posterior (o .NET Core 3.1 +).
GroupDocs.Editor para .NET: Descargue la última versión aquí.
Conocimientos básicos de C#: Familiaridad con clases, métodos y manipulación de cadenas.

Para un uso detallado, consulte la documentación.

Importar espacios de nombres

Para comenzar, importe los espacios de nombres requeridos para editar y guardar documentos.

La clase Editor es el punto de entrada para todas las operaciones de manipulación de documentos.

// Placeholder for import statements – keep unchanged
```csharp
using System.IO;
using GroupDocs.Editor.Formats;
using GroupDocs.Editor.Options;


Ahora que el entorno está listo, profundicemos en los pasos concretos para **replace text in document**.

## Cómo reemplazar texto en documento usando GroupDocs.Editor?
Cargue el archivo fuente con `Editor`, obtenga su representación HTML, realice un simple `Replace` en la cadena HTML y luego recree un `EditableDocument` a partir del HTML modificado. Finalmente, llame a la sobrecarga `Save` adecuada para el formato de destino.

### Paso 1: Cargar el documento
El objeto `EditableDocument` contiene la representación en memoria del archivo que está editando.

La clase `Editor` carga un archivo y devuelve un `EditableDocument` que puede manipular.  
```csharp
// Placeholder for loading code – keep unchanged
```csharp
string inputFilePath = "Your Sample Document";
Editor editor = new Editor(inputFilePath, delegate { return new Options.WordProcessingLoadOptions(); });
EditableDocument defaultWordProcessingDoc = editor.Edit();


### Paso 2: Modificar el documento
Debido a que GroupDocs.Editor trabaja con una instantánea HTML, puede tratar el documento como texto plano para reemplazos simples.

El método `EditableDocument.GetHtml()` extrae el HTML; después de cambiar la cadena, crea un nuevo `EditableDocument` a partir del HTML actualizado.  
```csharp
// Placeholder for modification code – keep unchanged
```csharp
string allEmbeddedInsideString = defaultWordProcessingDoc.GetEmbeddedHtml();
string allEmbeddedInsideStringEdited = allEmbeddedInsideString.Replace("Subtitle", "Edited subtitle");
EditableDocument editedDoc = EditableDocument.FromMarkup(allEmbeddedInsideStringEdited, null);


### Paso 3: Guardar el documento
GroupDocs.Editor proporciona métodos `Save` dedicados para cada formato compatible. A continuación se presentan tres destinos comunes.

#### Guardar como RTF
El método `SaveAsRtf` escribe el contenido editado en Rich Text Format, preservando la mayor parte del estilo.  
```csharp
// Placeholder for RTF save code – keep unchanged
```csharp
string outputRtfPath = Path.Combine(Constants.GetOutputDirectoryPath(inputFilePath), "editedDoc.rtf");
WordProcessingSaveOptions rtfSaveOptions = new WordProcessingSaveOptions(WordProcessingFormats.Rtf);
editor.Save(editedDoc, outputRtfPath, rtfSaveOptions);


#### Guardar como DOCM
DOCM es el formato de Word habilitado para macros; use `SaveAsDocm` cuando necesite conservar capacidades de macro.  
```csharp
// Placeholder for DOCM save code – keep unchanged
```csharp
string outputDocmPath = Path.Combine(Constants.GetOutputDirectoryPath(inputFilePath), "editedDoc.docm");
WordProcessingSaveOptions docmSaveOptions = new WordProcessingSaveOptions(WordProcessingFormats.Docm);
using (FileStream outputStream = File.Create(outputDocmPath))
{
    editor.Save(editedDoc, outputStream, docmSaveOptions);
}


#### Guardar como texto plano
Para una salida ligera, `SaveAsTxt` elimina el formato y devuelve texto puro.  
```csharp
// Placeholder for TXT save code – keep unchanged
```csharp
string outputTxtPath = Path.Combine(Constants.GetOutputDirectoryPath(inputFilePath), "editedDoc.txt");
TextSaveOptions textSaveOptions = new TextSaveOptions
{
    Encoding = System.Text.Encoding.UTF8,
    PreserveTableLayout = true
};
editor.Save(editedDoc, outputTxtPath, textSaveOptions);


### Paso 4: Limpieza
Siempre libere las instancias de `EditableDocument` y `Editor` para liberar manejadores de archivos y recursos no administrados.

El patrón `Dispose` garantiza que los archivos temporales se eliminen y la memoria se recupere.  
```csharp
// Placeholder for cleanup code – keep unchanged
```csharp
editedDoc.Dispose();
defaultWordProcessingDoc.Dispose();
editor.Dispose();


## Problemas comunes y soluciones
| Problema | Por qué ocurre | Solución |
|----------|----------------|----------|
| **Texto no reemplazado** | El HTML puede contener caracteres codificados (`&nbsp;`, `<span>`). | Use `HtmlAgilityPack` para localizar el nodo exacto antes de reemplazar. |
| **El archivo guardado está corrupto** | El flujo de salida no se vacía antes de liberar. | Llame a `editableDocument.Save(...);` y luego a `editableDocument.Dispose();`. |
| **Rendimiento disminuye en archivos grandes** | Cargar todo el HTML para un documento de 300 páginas consume memoria. | Habilite `LoadOptions.UseMemoryMapping = true` para transmitir partes del archivo. |
| **Se pierde el formato al guardar como TXT** | El formato TXT elimina todo el estilo por diseño. | Si necesita formato básico, considere guardar como RTF en su lugar. |

## Preguntas frecuentes

**Q: ¿Qué formatos de archivo soporta GroupDocs.Editor?**  
A: GroupDocs.Editor maneja más de 30 formatos, incluidos DOCX, RTF, TXT, HTML, PDF y ODT. Consulte la lista completa en la documentación oficial.

**Q: ¿Puedo probar GroupDocs.Editor antes de comprar?**  
A: Sí, puede obtener una prueba gratuita [aquí](https://releases.groupdocs.com/).

**Q: ¿Hay soporte si encuentro problemas?**  
A: Por supuesto—visite el foro de soporte [aquí](https://forum.groupdocs.com/c/editor/20) para obtener ayuda de la comunidad y del equipo del producto.

**Q: ¿Cómo obtengo una licencia temporal para evaluación?**  
A: Solicite una licencia temporal [aquí](https://purchase.groupdocs.com/temporary-license/).

**Q: ¿Dónde puedo comprar la versión completa de GroupDocs.Editor?**  
A: Puede adquirir la versión completa [aquí](https://purchase.groupdocs.com/buy).

---

**Última actualización:** 2026-05-27  
**Probado con:** GroupDocs.Editor 2.10 for .NET  
**Autor:** GroupDocs

## Tutoriales relacionados

- [Cómo editar y guardar documentos Word usando GroupDocs.Editor para .NET: Guía completa](/editor/net/word-processing-documents/editing-word-docs-groupdocs-editor-net/)
- [Convertir Word a HTML usando GroupDocs.Editor .NET: Guía paso a paso](/editor/net/document-saving/convert-word-to-html-groupdocs-editor-dotnet/)
- [Edición eficiente de documentos con GroupDocs.Editor .NET: Transformar HTML a documentos editables](/editor/net/document-editing/edit-documents-groupdocs-editor-net/)