Como Converter Documentos do Word para o Formato OOXML Strict Programaticamente

Você precisa converter um documento do Word para o formato OOXML Strict, mas não pode usar a caixa de diálogo Salvar Como para cada arquivo. OOXML Strict é a versão ISO do formato Office Open XML, que garante compatibilidade entre plataformas e conformidade para arquivamento de longo prazo. Este artigo explica como automatizar a conversão usando macros VBA, PowerShell com o Open XML SDK e o modelo de objeto COM do Office. Você aprenderá o código exato e as etapas para converter documentos únicos ou em lote sem intervenção manual.

O Que é OOXML Strict e Por Que Converter Programaticamente

OOXML Strict é a versão padrão ISO 29500:2008 do formato Office Open XML. O formato .docx padrão no Word usa uma variante transitória que inclui recursos binários legados que não fazem parte do padrão ISO. OOXML Strict remove esses elementos legados, produzindo um arquivo totalmente compatível com o padrão internacional.

Converter programaticamente é necessário quando você precisa processar centenas ou milhares de arquivos. A conversão manual através de Arquivo > Salvar Como > Procurar > Tipo de arquivo > Documento do Word (docx) com a opção “Strict” selecionada é impraticável para trabalhos em lote. A automação também garante uma saída consistente — cada arquivo convertido usa as mesmas configurações, reduzindo erros humanos.

Pré-requisitos para Cada Método

O método VBA requer o Word instalado na máquina. O método PowerShell requer o Open XML SDK 2.5 para Microsoft Office, que pode ser instalado via NuGet ou pelo Centro de Download da Microsoft. O método COM também requer o Word instalado, mas é executado fora da interface gráfica do Word, sendo útil para automação no lado do servidor onde não há sessão interativa.

Método 1: Converter Usando uma Macro VBA

Este método funciona dentro do Word. Você executa uma macro que salva o documento atual no formato OOXML Strict. A macro usa a constante wdFormatXMLStrictDocument, que tem valor 24.

1. Abra o Editor Visual Basic
   Pressione Alt+F11. No Project Explorer, clique duas vezes em ThisDocument ou insira um novo módulo via Inserir > Módulo.
2. Cole a macro de conversão
   Copie e cole o seguinte código no módulo:
   Sub ConvertToOOXMLStrict()
Dim doc As Document
Set doc = ActiveDocument
Dim newName As String
newName = Replace(doc.FullName, ".docx", "_strict.docx")
doc.SaveAs2 FileName:=newName, FileFormat:=wdFormatXMLStrictDocument
End Sub
3. Execute a macro
   Pressione F5 enquanto o cursor está dentro da macro. Um novo arquivo chamado original_strict.docx é salvo na mesma pasta.
4. Converter em lote todos os documentos de uma pasta
   Use esta macro para processar todos os arquivos .docx em uma pasta:
   Sub BatchConvertToStrict()
Dim f As String, doc As Document
f = Dir("C:\Docs\docx")
Do While f <> ""
Set doc = Documents.Open("C:\Docs\" & f)
doc.SaveAs2 FileName:="C:\Docs\Strict\" & f, FileFormat:=wdFormatXMLStrictDocument
doc.Close
f = Dir
Loop
End Sub
   Altere os caminhos das pastas para corresponder ao seu ambiente.

Método 2: Converter Usando PowerShell e Open XML SDK

Este método não requer o Word instalado. Ele usa o namespace DocumentFormat.OpenXml.Packaging para alterar o formato do arquivo programaticamente. O SDK lê o documento, altera seu tipo de pacote para Strict e o salva.

1. Instale o Open XML SDK
   Execute este comando em um console PowerShell elevado:
   Install-Package OpenXmlSdk -ProviderName NuGet
   Alternativamente, baixe o SDK da Microsoft e instale manualmente.
2. Crie o script de conversão
   Salve o seguinte como ConvertToStrict.ps1:
   Add-Type -Path "C:\Program Files\Open XML SDK\V2.5\lib\DocumentFormat.OpenXml.dll"
$source = "C:\Docs\report.docx"
$destination = "C:\Docs\report_strict.docx"
$doc = [DocumentFormat.OpenXml.Packaging.WordprocessingDocument]::Open($source, $false)
$doc.ChangeDocumentType([DocumentFormat.OpenXml.WordprocessingDocumentType]::Strict)
$doc.SaveAs($destination)
$doc.Dispose()
3. Execute o script
   Abra o PowerShell como Administrador e execute:
   powershell -ExecutionPolicy Bypass -File ConvertToStrict.ps1
   O arquivo de saída é salvo no caminho de destino.
4. Converter em lote todos os arquivos .docx de uma pasta
   Envolva a conversão em um loop:
   $files = Get-ChildItem "C:\Docs" -Filter docx
foreach ($f in $files) {
$doc = [DocumentFormat.OpenXml.Packaging.WordprocessingDocument]::Open($f.FullName, $false)
$doc.ChangeDocumentType([DocumentFormat.OpenXml.WordprocessingDocumentType]::Strict)
$out = Join-Path "C:\Docs\Strict" $f.Name
$doc.SaveAs($out)
$doc.Dispose()
}

Método 3: Converter Usando o Modelo de Objeto COM (Word Não Visível)

Este método usa a interface COM do Word, mas mantém o aplicativo oculto. É adequado para automação baseada em servidor onde você precisa dos recursos completos de renderização do Word, mas não deseja uma janela visível.

1. Crie um script PowerShell usando COM
   Salve o seguinte como ConvertViaCOM.ps1:
   $word = New-Object -ComObject Word.Application
$word.Visible = $false
$doc = $word.Documents.Open("C:\Docs\report.docx")
$doc.SaveAs2("C:\Docs\report_strict.docx", [Microsoft.Office.Interop.Word.WdSaveFormat]::wdFormatXMLStrictDocument)
$doc.Close()
$word.Quit()
2. Execute o script
   Execute no PowerShell:
   powershell -ExecutionPolicy Bypass -File ConvertViaCOM.ps1
   O Word abre brevemente em segundo plano, converte o arquivo e fecha.
3. Conversão em lote com COM
   Faça um loop por todos os arquivos .docx:
   $word = New-Object -ComObject Word.Application
$word.Visible = $false
$files = Get-ChildItem "C:\Docs" -Filter docx
foreach ($f in $files) {
$doc = $word.Documents.Open($f.FullName)
$out = Join-Path "C:\Docs\Strict" $f.Name
$doc.SaveAs2($out, [Microsoft.Office.Interop.Word.WdSaveFormat]::wdFormatXMLStrictDocument)
$doc.Close()
}
$word.Quit()

Erros Comuns de Conversão e Limitações

Erro “O formato do arquivo não é suportado” no método PowerShell SDK

Isso ocorre quando o arquivo de origem não é um arquivo .docx válido. O SDK só pode abrir pacotes baseados em OPC. Arquivos corrompidos ou salvos no formato .doc falharão. Verifique a extensão do arquivo e repare o documento primeiro usando o recurso Abrir e Reparar do Word.

Macro VBA falha com “Permissão negada”

A macro não pode gravar em um local somente leitura ou em uma pasta onde o usuário não tem permissões de gravação. Certifique-se de que a pasta de saída permita acesso de gravação. Use um caminho absoluto como C:\Users\SeuNome\Documents\Strict\ em vez de uma pasta protegida pelo sistema.

Método COM deixa processos Word.exe em execução

Se o script falhar antes de chamar $word.Quit(), um processo do Word permanece na memória. Sempre envolva as operações COM em um bloco try-catch-finally, ou use Stop-Process -Name WINWORD após a conclusão do script. Para scripts de produção, use o método System.Runtime.InteropServices.Marshal.ReleaseComObject para liberar corretamente o objeto COM.

Arquivos OOXML Strict abrem em versões antigas do Word

Word 2007 e anteriores não suportam OOXML Strict nativamente. Usuários com essas versões verão um aviso de compatibilidade ou podem não conseguir abrir o arquivo. Se a compatibilidade com versões anteriores for necessária, mantenha o formato .docx transitório.

VBA vs PowerShell vs COM: Comparação de Métodos de Automação

Item	Macro VBA	PowerShell + SDK	Objeto COM
Requer Word instalado	Sim	Não	Sim
Requer Open XML SDK	Não	Sim	Não
Executa headless (sem GUI)	Não (Word visível)	Sim	Sim
Velocidade de conversão em lote	Lenta (abre cada doc)	Rápida (sem carregar Word)	Moderada
Lida com formatação complexa	Fidelidade total	Pode perder alguns recursos	Fidelidade total
Melhor para	Arquivos únicos ad-hoc	Automação em servidor	Servidor com licença do Word

Agora você pode converter documentos do Word para o formato OOXML Strict programaticamente usando VBA, PowerShell com o Open XML SDK ou o modelo de objeto COM. Escolha o método que se adequa ao seu ambiente: VBA para uso interativo, SDK para servidores headless e COM quando a fidelidade total do Word for necessária em um servidor. Como próximo passo, teste cada método em um único arquivo antes de executar um lote. Uma dica avançada: use o método SDK para validar a saída verificando a propriedade DocumentType — ela deve retornar Strict após a conversão.