Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronWord
  2. Blog IronWord
  3. Usando IronWord
  4. csharp-ler-documento-word-com-formatação
USANDO IRONWORD

Como ler um documento do Word com formatação em C#

Curtis Chau
Curtis Chau
Atualizado:

Documentos do Microsoft Word frequentemente contêm formatações ricas, como fontes, estilos e vários elementos que os tornam visualmente atraentes. IronWord é uma biblioteca poderosa da Iron Software que possui uma API intuitiva de Documento Word e Docx para C# e VB.NET. Não é necessário instalar o Microsoft Office ou Word Interop para construir, editar e exportar documentos Word. O IronWord suporta totalmente .NET 8, 7, 6, Framework, Core e Azure. Isso significa que a biblioteca não requer o Word instalado na máquina e lê os arquivos de forma independente. Se você está trabalhando com C# e precisa ler documentos do Word enquanto preserva sua formatação, este tutorial irá guiá-lo através do processo usando a biblioteca IronWord.

Como (em C#) Ler Documento Word Com Formatação

  1. Instale a biblioteca IronWord para ler documentos do Word.
  2. Carregue 'sample.docx', o documento Word de entrada usando a classe WordDocument da biblioteca IronWord.
  3. Leia os parágrafos com formatação usando um documento Word carregado.
  4. Mostre os dados extraídos com informações de formatação na saída do console.

Pré-requisitos

  1. Visual Studio: Certifique-se de ter o Visual Studio ou qualquer outro ambiente de desenvolvimento C# instalado.
  2. Gerenciador de Pacotes NuGet: Certifique-se de que pode usar o NuGet para gerenciar pacotes em seu projeto

Passo 1: Crie um Novo Projeto C

Crie um novo aplicativo de console C# ou use um projeto existente onde deseja ler documentos Word.

Selecione o modelo de aplicativo de console e clique em próximo.

Como Ler Documento Word Com Formatação em C#: Figura 1 - Criando um novo projeto C#

Clique no botão 'Próximo' para fornecer o nome da solução, nome do projeto e caminho para o código.

Como Ler Documento Word Com Formatação em C#: Figura 2 - Configurando o novo projeto

Então selecione a versão desejada do .NET. A melhor prática é sempre selecionar a última versão disponível, embora se o seu projeto tiver requisitos específicos, use a versão necessária do .NET.

Como Ler Documento Word Com Formatação em C#: Figura 3 - Escolhendo o tipo necessário de versão .NET

Passo 2: Instale a Biblioteca IronWord

Abra seu projeto C# e instale a biblioteca IronWord usando o Console do Gerenciador de Pacotes NuGet:

Install-Package IronWord

O pacote NuGet também pode ser instalado usando o Gerenciador de Pacotes NuGet do Visual Studio, como mostrado abaixo.

Como Ler Documento Word Com Formatação em C#: Figura 4 - Instalando IronWord através do gerenciador de pacotes NuGet

Passo 3: Leia o Documento Word com Formatação

Para ler um arquivo Word, primeiro precisamos criar um novo documento e depois adicionar algum conteúdo nele conforme abaixo.

Como Ler Documento Word Com Formatação em C#: Figura 5 - Documento de amostra criado

Agora salve o arquivo no diretório do projeto e altere as propriedades do arquivo para copiá-lo para o diretório de saída.

Como Ler Documento Word Com Formatação em C#: Figura 6 - Como as propriedades do arquivo devem se parecer

Agora adicione o trecho de código abaixo ao arquivo program.cs:

using IronWord;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through each paragraph in the Word document
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract Formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
using IronWord;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through each paragraph in the Word document
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract Formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
Imports Microsoft.VisualBasic
Imports IronWord

Friend Class Program
	Shared Sub Main()
		Try
			' Load existing docx
			Dim sampleDoc = New WordDocument("sample.docx")
			Dim paragraphs = sampleDoc.Paragraphs

			' Iterate through each paragraph in the Word document
			For Each paragraph In paragraphs
				Dim textRun = paragraph.FirstTextRun
				Dim text = textRun.Text ' Read text content

				' Extract Formatting details if available
				If textRun.Style IsNot Nothing Then
					Dim fontSize = textRun.Style.FontSize ' Font size
					Dim isBold = textRun.Style.IsBold
					Console.WriteLine($vbTab & "Text: {text}, FontSize: {fontSize}, Bold: {isBold}")
				Else
					' Print text without formatting details
					Console.WriteLine($vbTab & "Text: {text}")
				End If
			Next paragraph
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

O código acima lê o documento Word usando o método construtor da classe WordDocument da biblioteca IronWord.

Saída

Como Ler Documento Word Com Formatação em C#: Figura 7 - Saída do console do código anterior

Explicação

  1. Abra o Documento Word: Carregue o documento Word usando WordDocument do IronWord.
  2. Iterar Pelos Parágrafos e Execuções: Use loops aninhados para iterar através dos parágrafos e execuções. Execuções representam porções de texto com formatação específica.
  3. Extrair Texto e Formatação: Extraia o conteúdo de texto de cada execução e verifique as propriedades de formatação. Neste exemplo, demonstramos como extrair o tamanho da fonte e a formatação em negrito.
  4. Tratar Exceções: Um bloco try-and-catch é usado para tratar quaisquer exceções e imprimi-las.

O arquivo carregado pode ser usado para imprimir documentos, também podemos alterar a cor da fonte no objeto de estilo.

Ler Tabelas de Arquivos Word

Também podemos ler tabelas de documentos do Word. Adicione o trecho de código abaixo ao programa.

using IronWord;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");

            // Read Tables
            var tables = sampleDoc.Tables;
            foreach (var table in tables)
            {
                var rows = table.Rows;
                foreach (var row in rows)
                {
                    foreach (var cell in row.Cells)
                    {
                        var contents = cell.Contents;
                        contents.ForEach(x => Console.WriteLine(x));
                        // Print cell contents
                    }                    
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
using IronWord;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");

            // Read Tables
            var tables = sampleDoc.Tables;
            foreach (var table in tables)
            {
                var rows = table.Rows;
                foreach (var row in rows)
                {
                    foreach (var cell in row.Cells)
                    {
                        var contents = cell.Contents;
                        contents.ForEach(x => Console.WriteLine(x));
                        // Print cell contents
                    }                    
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
Imports IronWord

Friend Class Program
	Shared Sub Main()
		Try
			' Load existing docx
			Dim sampleDoc = New WordDocument("sample.docx")

			' Read Tables
			Dim tables = sampleDoc.Tables
			For Each table In tables
				Dim rows = table.Rows
				For Each row In rows
					For Each cell In row.Cells
						Dim contents = cell.Contents
						contents.ForEach(Sub(x) Console.WriteLine(x))
						' Print cell contents
					Next cell
				Next row
			Next table
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

Aqui estamos usando a propriedade Tables na classe WordDocument para buscar todas as tabelas no documento, então iterar através delas e imprimir os conteúdos.

Adicionar Estilo ao Texto Existente

Podemos adicionar novas informações de estilo a um documento Word existente usando a biblioteca IronWord, conforme mostrado no trecho de código abaixo.

using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through paragraphs
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract Formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }

            // Change the formatting of the text
            var style = new TextStyle()
            {
                FontFamily = "Caveat",
                FontSize = 72,
                TextColor = new IronColor(System.Drawing.Color.Blue), // Blue color
                IsBold = true,
                IsItalic = true,
                IsUnderline = true,
                IsSuperscript = false,
                IsStrikethrough = true,
                IsSubscript = false
            };
            paragraphs[1].FirstTextRun.Style = style;

            // Save the document with the new style applied
            sampleDoc.SaveAs("sample2.docx");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        try
        {
            // Load existing docx
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through paragraphs
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract Formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }

            // Change the formatting of the text
            var style = new TextStyle()
            {
                FontFamily = "Caveat",
                FontSize = 72,
                TextColor = new IronColor(System.Drawing.Color.Blue), // Blue color
                IsBold = true,
                IsItalic = true,
                IsUnderline = true,
                IsSuperscript = false,
                IsStrikethrough = true,
                IsSubscript = false
            };
            paragraphs[1].FirstTextRun.Style = style;

            // Save the document with the new style applied
            sampleDoc.SaveAs("sample2.docx");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
Imports Microsoft.VisualBasic
Imports IronWord
Imports IronWord.Models

Friend Class Program
	Shared Sub Main()
		Try
			' Load existing docx
			Dim sampleDoc = New WordDocument("sample.docx")
			Dim paragraphs = sampleDoc.Paragraphs

			' Iterate through paragraphs
			For Each paragraph In paragraphs
				Dim textRun = paragraph.FirstTextRun
				Dim text = textRun.Text ' Read text content

				' Extract Formatting details if available
				If textRun.Style IsNot Nothing Then
					Dim fontSize = textRun.Style.FontSize ' Font size
					Dim isBold = textRun.Style.IsBold
					Console.WriteLine($vbTab & "Text: {text}, FontSize: {fontSize}, Bold: {isBold}")
				Else
					' Print text without formatting details
					Console.WriteLine($vbTab & "Text: {text}")
				End If
			Next paragraph

			' Change the formatting of the text
			Dim style = New TextStyle() With {
				.FontFamily = "Caveat",
				.FontSize = 72,
				.TextColor = New IronColor(System.Drawing.Color.Blue),
				.IsBold = True,
				.IsItalic = True,
				.IsUnderline = True,
				.IsSuperscript = False,
				.IsStrikethrough = True,
				.IsSubscript = False
			}
			paragraphs(1).FirstTextRun.Style = style

			' Save the document with the new style applied
			sampleDoc.SaveAs("sample2.docx")
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

Aqui estamos criando um(a) TextStyle e adicionando ao objeto parágrafo existente.

Adicionar Novo Conteúdo Estilizado ao Documento Word

Podemos adicionar novo conteúdo a um documento Word carregado, conforme mostrado no trecho de código abaixo.

using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        try
        {
            // Load Word Document
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through paragraphs
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract the formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }

            // Add TextRun with Style to Paragraph
            TextRun blueTextRun = new TextRun();
            blueTextRun.Text = "Add text using IronWord";
            blueTextRun.Style = new TextStyle()
            {
                FontFamily = "Caveat",
                FontSize = 72,
                TextColor = new IronColor(System.Drawing.Color.Blue), // Blue color
                IsBold = true,
                IsItalic = true,
                IsUnderline = true,
                IsSuperscript = false,
                IsStrikethrough = true,
                IsSubscript = false
            };
            paragraphs[1].AddTextRun(blueTextRun);

            // Add New Content to the Word file and save
            Paragraph newParagraph = new Paragraph();
            TextRun newTextRun = new TextRun("New Add Information");
            newParagraph.AddTextRun(newTextRun);

            // Configure the text with different styles
            TextRun introText = new TextRun("This is an example paragraph with italic and bold styling.");
            TextStyle italicStyle = new TextStyle()
            {
                IsItalic = true
            };
            TextRun italicText = new TextRun("Italic example sentence.", italicStyle);
            TextStyle boldStyle = new TextStyle()
            {
                IsBold = true
            };
            TextRun boldText = new TextRun("Bold example sentence.", boldStyle);

            // Add the styled text to the paragraph
            newParagraph.AddTextRun(introText);
            newParagraph.AddTextRun(italicText);
            newParagraph.AddTextRun(boldText);

            // Save the modified document
            sampleDoc.SaveAs("sample2.docx");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        try
        {
            // Load Word Document
            var sampleDoc = new WordDocument("sample.docx");
            var paragraphs = sampleDoc.Paragraphs;

            // Iterate through paragraphs
            foreach (var paragraph in paragraphs)
            {
                var textRun = paragraph.FirstTextRun;
                var text = textRun.Text; // Read text content

                // Extract the formatting details if available
                if (textRun.Style != null)
                {
                    var fontSize = textRun.Style.FontSize; // Font size
                    var isBold = textRun.Style.IsBold;
                    Console.WriteLine($"\tText: {text}, FontSize: {fontSize}, Bold: {isBold}");
                }
                else
                {
                    // Print text without formatting details
                    Console.WriteLine($"\tText: {text}");
                }
            }

            // Add TextRun with Style to Paragraph
            TextRun blueTextRun = new TextRun();
            blueTextRun.Text = "Add text using IronWord";
            blueTextRun.Style = new TextStyle()
            {
                FontFamily = "Caveat",
                FontSize = 72,
                TextColor = new IronColor(System.Drawing.Color.Blue), // Blue color
                IsBold = true,
                IsItalic = true,
                IsUnderline = true,
                IsSuperscript = false,
                IsStrikethrough = true,
                IsSubscript = false
            };
            paragraphs[1].AddTextRun(blueTextRun);

            // Add New Content to the Word file and save
            Paragraph newParagraph = new Paragraph();
            TextRun newTextRun = new TextRun("New Add Information");
            newParagraph.AddTextRun(newTextRun);

            // Configure the text with different styles
            TextRun introText = new TextRun("This is an example paragraph with italic and bold styling.");
            TextStyle italicStyle = new TextStyle()
            {
                IsItalic = true
            };
            TextRun italicText = new TextRun("Italic example sentence.", italicStyle);
            TextStyle boldStyle = new TextStyle()
            {
                IsBold = true
            };
            TextRun boldText = new TextRun("Bold example sentence.", boldStyle);

            // Add the styled text to the paragraph
            newParagraph.AddTextRun(introText);
            newParagraph.AddTextRun(italicText);
            newParagraph.AddTextRun(boldText);

            // Save the modified document
            sampleDoc.SaveAs("sample2.docx");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}
Imports Microsoft.VisualBasic
Imports IronWord
Imports IronWord.Models

Friend Class Program
	Shared Sub Main()
		Try
			' Load Word Document
			Dim sampleDoc = New WordDocument("sample.docx")
			Dim paragraphs = sampleDoc.Paragraphs

			' Iterate through paragraphs
			For Each paragraph In paragraphs
				Dim textRun = paragraph.FirstTextRun
				Dim text = textRun.Text ' Read text content

				' Extract the formatting details if available
				If textRun.Style IsNot Nothing Then
					Dim fontSize = textRun.Style.FontSize ' Font size
					Dim isBold = textRun.Style.IsBold
					Console.WriteLine($vbTab & "Text: {text}, FontSize: {fontSize}, Bold: {isBold}")
				Else
					' Print text without formatting details
					Console.WriteLine($vbTab & "Text: {text}")
				End If
			Next paragraph

			' Add TextRun with Style to Paragraph
			Dim blueTextRun As New TextRun()
			blueTextRun.Text = "Add text using IronWord"
			blueTextRun.Style = New TextStyle() With {
				.FontFamily = "Caveat",
				.FontSize = 72,
				.TextColor = New IronColor(System.Drawing.Color.Blue),
				.IsBold = True,
				.IsItalic = True,
				.IsUnderline = True,
				.IsSuperscript = False,
				.IsStrikethrough = True,
				.IsSubscript = False
			}
			paragraphs(1).AddTextRun(blueTextRun)

			' Add New Content to the Word file and save
			Dim newParagraph As New Paragraph()
			Dim newTextRun As New TextRun("New Add Information")
			newParagraph.AddTextRun(newTextRun)

			' Configure the text with different styles
			Dim introText As New TextRun("This is an example paragraph with italic and bold styling.")
			Dim italicStyle As New TextStyle() With {.IsItalic = True}
			Dim italicText As New TextRun("Italic example sentence.", italicStyle)
			Dim boldStyle As New TextStyle() With {.IsBold = True}
			Dim boldText As New TextRun("Bold example sentence.", boldStyle)

			' Add the styled text to the paragraph
			newParagraph.AddTextRun(introText)
			newParagraph.AddTextRun(italicText)
			newParagraph.AddTextRun(boldText)

			' Save the modified document
			sampleDoc.SaveAs("sample2.docx")
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

Aqui estamos criando novos objetos TextRun e Paragraph com informações de estilo e adicionando-os ao documento Word carregado.

Licenciamento (Teste Gratuito Disponível)

Obtenha sua chave de licença de teste gratuita do IronWord. Esta chave precisa ser colocada em appsettings.json.

{
    "IronWord.LicenseKey": "IRONWORD.MYLICENSE.KEY.TRIAL"
}

Forneça seu e-mail para obter uma licença de avaliação. Após enviar seu ID de e-mail, a chave será entregue por e-mail.

Como Ler Documento Word Com Formatação em C#: Figura 8 - Formulário de teste enviado com sucesso

Conclusão

IronWord fornece uma maneira conveniente de ler documentos do Word com formatação em C#. Estenda o código fornecido com base em seus requisitos específicos e na complexidade dos documentos com os quais você está trabalhando. Este tutorial serve como um ponto de partida para integrar IronWord em suas aplicações C# para processamento de documentos Word.

Perguntas frequentes

Como posso ler documentos do Word com formatação em C#?

Para ler documentos do Word com formatação em C#, utilize a biblioteca IronWord. Comece instalando o IronWord através do Gerenciador de Pacotes NuGet. Carregue o documento utilizando a classe WordDocument e itere pelos parágrafos para extrair o texto e os detalhes de formatação.

Quais são os passos para configurar um projeto C# para leitura de documentos do Word?

Para configurar um projeto C# para leitura de documentos do Word, instale o Visual Studio ou outro ambiente de desenvolvimento C#. Use o Gerenciador de Pacotes NuGet para adicionar o IronWord ao seu projeto. Carregue os documentos do Word com a classe WordDocument para acessar seu conteúdo.

Como posso lidar com exceções ao ler documentos do Word em C#?

Ao ler documentos do Word em C# usando o IronWord, trate as exceções implementando blocos try-catch em torno do seu código de processamento de documentos. Isso ajudará a gerenciar erros em tempo de execução e garantirá um comportamento robusto do aplicativo.

É possível ler tabelas de documentos do Word usando C#?

Sim, você pode ler tabelas de documentos do Word usando o IronWord em C#. Acesse as tabelas através da propriedade ` Tables da classe WordDocument e itere pelos dados da tabela conforme necessário.

Como posso modificar os estilos de texto em um documento do Word usando C#?

Modifique os estilos de texto em um documento do Word usando o IronWord, criando um objeto TextStyle e aplicando-o a trechos de texto ou parágrafos específicos. Isso permite personalizar fontes, tamanhos e outros atributos de estilo.

É possível adicionar conteúdo novo a documentos do Word em C#?

Sim, você pode adicionar conteúdo novo a documentos do Word usando o IronWord em C#. Crie objetos TextRun e Paragraph para adicionar conteúdo formatado ao documento antes de salvar as alterações.

Como faço para salvar as alterações feitas em um documento do Word usando C#?

Após editar um documento do Word usando o IronWord, salve as alterações chamando o método Save na instância WordDocument . Especifique o caminho do arquivo para criar um novo documento com as modificações aplicadas.

Preciso ter o Microsoft Office instalado para processar documentos do Word em C#?

Não, você não precisa ter o Microsoft Office instalado para processar documentos do Word em C# usando o IronWord. A biblioteca funciona independentemente do Microsoft Office, permitindo que você trabalhe diretamente com arquivos do Word.

Quais versões do .NET são compatíveis com uma biblioteca de processamento de texto?

O IronWord é compatível com uma ampla gama de versões do .NET, incluindo .NET 8, 7, 6, Framework, Core e Azure. Isso garante que ele atenda a diversos requisitos e ambientes de projeto.

Como posso obter uma licença de avaliação para uma biblioteca de processamento de texto em C#?

Para obter uma licença de avaliação do IronWord, visite o site da Iron Software e forneça seu endereço de e-mail. Você receberá uma chave de licença de avaliação por e-mail, que poderá adicionar ao seu arquivo appsettings.json .

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim