A Microsoft criou o Word para servir como um processador de texto. Inicialmente disponível sob o nome Multi-Tool Word para sistemas Xenix, foi introduzido em 25 de outubro de 1983. Versões subsequentes foram desenvolvidas para uma ampla gama de sistemas operacionais, como SCO Unix (1990), Microsoft Windows (1989), Atari ST (1988), OS/2 (1989), AT&T UNIX PC (1985), PCs da IBM rodando DOS (1983), Apple Macintosh rodando o Classic macOS (1985), macOS (2001), navegadores web (2010), iOS (2014), e Android (2015). O Wine pode ser usado para rodar versões mais antigas do Microsoft Word no Linux.

Versões comerciais do Word podem ser licenciadas como uma aplicação independente ou como um componente do Microsoft 365, que pode ser comprado como licença perpétua ou como parte de uma assinatura do Microsoft 365. Neste artigo, vamos manipular documentos do Word usando C# com a ajuda dos assemblies de interoperabilidade da Microsoft e explorar como o IronXL nos ajuda a editar documentos do Excel.

How To Manipulate Word Document Using C#

1. Realize um novo projeto de Visual Studio.
2. Configure a biblioteca necessária para ler documentos do Word.
3. Para manipular um documento do Word, carregue um arquivo existente ou crie um novo arquivo.
4. Edite os dados do documento e analise o arquivo.
5. Livre-se de todos os objetos que foram criados.

O que é Microsoft Interop

Programas escritos em C# ou VB.NET podem criar ou abrir documentos Word (DOC, DOCX e RTF) com Interoperabilidade do Microsoft Word. No entanto, tem muitas desvantagens quando usado em projetos.

Discutiremos problemas frequentes que você pode encontrar ao usar Microsoft Office Interop (Automação do Word) a partir de C# ou VB.NET neste artigo.

Por exemplo:

• Cada PC cliente necessário para automação de palavras precisa ser licenciado para o Microsoft Word.
• No PC de cada cliente, deve ser instalada a mesma versão do Microsoft Word.
• O Word usa alguns megabytes de RAM para carregar arquivos diferentes e DLLs em segundo plano quando a automação é utilizada.
• A API do Microsoft Word é acessada através de um objeto COM. Podem surgir problemas ao chamar um objeto COM de código gerido, como conversões de tipo, exigindo um invólucro COM, e pobre integração com .NET Framework.

Criando um novo projeto no Visual Studio

É necessário iniciar o Visual Studio e criar um projeto .NET antes de usar a biblioteca Interop. O Visual Studio é compatível com qualquer versão, embora a mais recente seja recomendada. Dependendo das suas necessidades, você pode desenvolver um modelo de projeto ou uma aplicação que se assemelhe ao Windows Forms. Usarei o Aplicativo de Console neste caso por simplicidade.

Configurar Detalhes do Projeto

Em seguida, forneça a localização e o nome do projeto.

Criar um Novo Arquivo de Projeto usando o .NET Framework

Usando o menu suspenso Framework, você pode escolher um .NET Framework. O Dot.NET Framework 4.7 será utilizado para este projeto. A próxima ação é pressionar o botão "Criar".

Após a aplicação ter gerado a solução, você pode inserir o código e construir ou executar o programa acessando o arquivo Program.cs.

Agora que a biblioteca Microsoft.Office.Interop.Word foi adicionada, podemos testar o código.

Instalar Biblioteca Interop

O próximo reparo requer a instalação da biblioteca Interop. Digite o seguinte comando no Console do Gerenciador de Pacotes NuGet para realizar isso:

Install-Package Microsoft.Office.Interop.Word

Outra maneira de encontrar o pacote "Interop" é usar o Gerenciador de Pacotes NuGet. Entre todos os pacotes NuGet relacionados ao Interop, podemos selecionar o pacote necessário para download desta lista.

Uma vez que você tenha instalado todas as bibliotecas necessárias, você pode então começar a editar arquivos DOCX.

Manipular Documentos Word Existentes usando Interop

Para usar o Microsoft Word, você deve primeiro criar uma instância de Microsoft.Office.Interop.Word.Application. A comunicação de documentos Word ocorrerá nesta instância. O próximo passo é criar uma nova instância de documento Word usando a propriedade Documents da instância Microsoft.Office.Interop.Word.Application que acabamos de criar. Como visto no trecho de código C# abaixo, isso nos permite manipular documentos Word programaticamente:

using System;
using Microsoft.Office.Interop.Word;

class Program
{
    static void Main()
    {
        try
        {
            // Create a new instance of Word Application
            var WordApp = new Microsoft.Office.Interop.Word.Application();
            // Open an existing document
            var WordDoc = WordApp.Documents.Open(@"d:/Demo.docx");
            // Edit the content of the first paragraph
            WordDoc.Paragraphs[1].Range.Text = "New text here...";
            // Save the edited document
            WordDoc.SaveAs(@"d:/NewDemo.docx");
            // Close the document
            WordDoc.Close();
            // Quit the Word application
            WordApp.Quit();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

using System;
using Microsoft.Office.Interop.Word;

class Program
{
    static void Main()
    {
        try
        {
            // Create a new instance of Word Application
            var WordApp = new Microsoft.Office.Interop.Word.Application();
            // Open an existing document
            var WordDoc = WordApp.Documents.Open(@"d:/Demo.docx");
            // Edit the content of the first paragraph
            WordDoc.Paragraphs[1].Range.Text = "New text here...";
            // Save the edited document
            WordDoc.SaveAs(@"d:/NewDemo.docx");
            // Close the document
            WordDoc.Close();
            // Quit the Word application
            WordApp.Quit();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

Imports System
Imports Microsoft.Office.Interop.Word

Friend Class Program
	Shared Sub Main()
		Try
			' Create a new instance of Word Application
			Dim WordApp = New Microsoft.Office.Interop.Word.Application()
			' Open an existing document
			Dim WordDoc = WordApp.Documents.Open("d:/Demo.docx")
			' Edit the content of the first paragraph
			WordDoc.Paragraphs(1).Range.Text = "New text here..."
			' Save the edited document
			WordDoc.SaveAs("d:/NewDemo.docx")
			' Close the document
			WordDoc.Close()
			' Quit the Word application
			WordApp.Quit()
		Catch ex As Exception
			Console.WriteLine(ex.ToString())
		End Try
	End Sub
End Class

Imports System
Imports Microsoft.Office.Interop.Word

Friend Class Program
	Shared Sub Main()
		Try
			' Create a new instance of Word Application
			Dim WordApp = New Microsoft.Office.Interop.Word.Application()
			' Open an existing document
			Dim WordDoc = WordApp.Documents.Open("d:/Demo.docx")
			' Edit the content of the first paragraph
			WordDoc.Paragraphs(1).Range.Text = "New text here..."
			' Save the edited document
			WordDoc.SaveAs("d:/NewDemo.docx")
			' Close the document
			WordDoc.Close()
			' Quit the Word application
			WordApp.Quit()
		Catch ex As Exception
			Console.WriteLine(ex.ToString())
		End Try
	End Sub
End Class

No código acima, podemos editar o documento Word em C#. Primeiro, criamos uma instância da aplicação Word usando Interop. O método Open é então usado para abrir um arquivo Word existente, convertendo-o em um objeto documento. Podemos então acessar as várias propriedades e métodos disponíveis para interagir com o documento. No exemplo, atualizamos o texto do primeiro parágrafo, usando a coleção Paragraphs e um índice para especificar qual parágrafo editar. Finalmente, as alterações são salvas com SaveAs, e o documento e a aplicação são devidamente fechados.

Alternativa da Biblioteca IronXL ao Interop

IronXL é uma alternativa ao Microsoft Interop que pode ser usada em programas .NET para manipular arquivos Excel. Enquanto o Microsoft Interop requer a interação com o Excel por meio dos assemblies Interop, IronXL oferece um método mais direto, eficaz e poderoso para manipular arquivos Excel programaticamente em contextos .NET.

Utilizar o IronXL em vez do Microsoft Interop tem várias vantagens, tais como:

• Desempenho e Eficiência de Recursos: Comparado ao Microsoft Interop, que depende da instalação do aplicativo Excel no computador, IronXL tem melhor desempenho e usa menos recursos porque não depende do aplicativo Excel.
• Facilidade de Uso e Simplicidade: IronXL fornece uma API mais fácil de usar que simplifica a leitura, escrita e manipulação de arquivos Excel sem as complicações que vêm com o Microsoft Interop.
• Compatibilidade e Dependência: O IronXL elimina dependências e problemas de compatibilidade que podem ocorrer com várias versões do Excel ou Office por não exigir a instalação do Microsoft Excel no computador.
• Independência de Plataforma: Ao contrário do Microsoft Interop, que pode estar mais associado a versões específicas do Microsoft Office, o IronXL oferece maior flexibilidade e facilidade de implantação em vários ambientes e plataformas.

Para desenvolvedores .NET que precisam operar com arquivos Excel programaticamente, IronXL é frequentemente uma opção melhor devido à sua facilidade de uso, velocidade e menor dependência de instalações de software de terceiros. A decisão entre IronXL e Microsoft Interop, contudo, pode ser influenciada pelas especificidades do projeto, pela infraestrutura já existente e pelo nível de experiência do usuário com cada biblioteca.

Ao decidir entre estas opções, sempre mantenha em mente os requisitos da sua aplicação. Confira este link para saber mais sobre a biblioteca IronXL.

Instalando a Biblioteca IronXL

Como a biblioteca IronXL é necessária para o próximo patch, instale-a. Para concluir isso, abra o Console do Gerenciador de Pacotes NuGet e digite o seguinte comando:

Install-Package IronWord

Procurar pelo pacote "IronXL" através do Gerenciador de Pacotes NuGet é uma escolha adicional. A partir desta lista de todos os pacotes NuGet vinculados ao IronXL, podemos selecionar o que precisarmos baixar.

Editando Documentos do Excel usando IronXL

Os dados podem ser exportados para os formatos XLSX ou XLS com apenas algumas linhas de código. O exemplo de código fonte a seguir mostra como os dados podem ser exportados de um arquivo Excel para um formato de tabela tabular simples:

using IronXL;

class Program
{
    static void Main()
    {
        // Load an existing Excel file
        var workbook = WorkBook.Load("Demo file.xlsx");
        // Access the first sheet or the sheet by name
        var ws = workbook.GetWorkSheet("Sheet1");
        // Read a value from a cell and output it to the console
        string address_val = ws["A1"].ToString();
        Console.WriteLine(address_val);
        // Modify a cell's value
        ws["A2"].Value = "Hello World";
        // Save the workbook to different formats
        workbook.SaveAs("export.xlsx");
        workbook.SaveAs("export.xls");
        workbook.WorkSheets[0].SaveAs("export.xls");
    }
}

using IronXL;

class Program
{
    static void Main()
    {
        // Load an existing Excel file
        var workbook = WorkBook.Load("Demo file.xlsx");
        // Access the first sheet or the sheet by name
        var ws = workbook.GetWorkSheet("Sheet1");
        // Read a value from a cell and output it to the console
        string address_val = ws["A1"].ToString();
        Console.WriteLine(address_val);
        // Modify a cell's value
        ws["A2"].Value = "Hello World";
        // Save the workbook to different formats
        workbook.SaveAs("export.xlsx");
        workbook.SaveAs("export.xls");
        workbook.WorkSheets[0].SaveAs("export.xls");
    }
}

Imports IronXL

Friend Class Program
	Shared Sub Main()
		' Load an existing Excel file
		Dim workbook = WorkBook.Load("Demo file.xlsx")
		' Access the first sheet or the sheet by name
		Dim ws = workbook.GetWorkSheet("Sheet1")
		' Read a value from a cell and output it to the console
		Dim address_val As String = ws("A1").ToString()
		Console.WriteLine(address_val)
		' Modify a cell's value
		ws("A2").Value = "Hello World"
		' Save the workbook to different formats
		workbook.SaveAs("export.xlsx")
		workbook.SaveAs("export.xls")
		workbook.WorkSheets(0).SaveAs("export.xls")
	End Sub
End Class

Imports IronXL

Friend Class Program
	Shared Sub Main()
		' Load an existing Excel file
		Dim workbook = WorkBook.Load("Demo file.xlsx")
		' Access the first sheet or the sheet by name
		Dim ws = workbook.GetWorkSheet("Sheet1")
		' Read a value from a cell and output it to the console
		Dim address_val As String = ws("A1").ToString()
		Console.WriteLine(address_val)
		' Modify a cell's value
		ws("A2").Value = "Hello World"
		' Save the workbook to different formats
		workbook.SaveAs("export.xlsx")
		workbook.SaveAs("export.xls")
		workbook.WorkSheets(0).SaveAs("export.xls")
	End Sub
End Class

O exemplo anterior carrega um arquivo Excel que já existe chamando a função Load, que recebe um argumento para o caminho e nome do arquivo. A importação do arquivo no objeto WorkBook está agora completa. As planilhas do Excel são então carregadas com a ajuda de GetWorkSheet, que nos permite carregar a planilha usando o nome da folha. O endereço do Excel foi então usado para ler o valor. Para saber mais sobre como ler arquivos Excel, clique aqui.

Podemos alterar os valores da planilha Excel utilizando o mesmo endereço do Excel. O documento Excel pode ser salvo como um arquivo XLSX ou XLS utilizando a função SaveAs que é oferecida pelo objeto WorkBook. Usando este processo, o arquivo inteiro é salvo no formato escolhido.

Além disso, podemos escolher uma planilha Excel específica utilizando seu valor de índice ou referindo-se a ela pelo nome. Em seguida, podemos exportar os dados da planilha Excel para um arquivo diferente usando a opção SaveAs. Clique neste link para saber mais sobre formatação e exportação de arquivos Excel.

Conclusão

Um dos complementos mais populares para o Excel é o IronXL. Não depende de nenhuma biblioteca externa adicional. Não é necessário instalar o Microsoft Excel porque ele é autônomo. Funciona através de uma multitude de canais. Isso contrasta com a biblioteca Interop, que precisa analisar o arquivo usando bibliotecas extras para editar documentos Word.

Uma solução completa para qualquer processo de programação utilizando documentos do Microsoft Excel é o IronXL. Cálculos, classificação de strings ou números, poda, adição, busca e substituição, mesclagem e desmesclagem, e armazenamento de arquivos são apenas algumas das muitas operações disponíveis. Não apenas os dados da planilha podem ser validados, mas você também pode construir novas formas de dados de célula. Facilita a leitura e escrita de arquivos, bem como o manuseio de dados do Excel.

Quando IronXL foi lançado pela primeira vez, custava $999. Como alternativa, os clientes podem optar por pagar uma taxa de assinatura anual para receber atualizações de software e suporte. Por uma taxa, o IronXL oferece segurança contra redistribuição não autorizada. Vá para a página de licenciamento do IronXL. Para saber mais sobre os produtos da Iron Software, confira aqui.