La conversion de documents Word en images de haute qualité est une exigence fréquente pour la génération d’aperçus, la création de vignettes et les tableaux de bord de reporting. Aspose.OMR Cloud SDK for .NET fournit une bibliothèque puissante basée sur le cloud qui facilite la conversion de fichiers DOCX en images PNG depuis le code C#. Dans ce tutoriel, vous apprendrez comment convertir DOCX en PNG en C# en configurant le SDK, en écrivant un exemple complet asynchrone et en utilisant des appels cURL équivalents pour l’intégration REST. À la fin, vous serez capable de générer des PNG transparents à partir de n’importe quel DOCX avec seulement quelques lignes de code.
DOCX to PNG Workflow - Prérequis et configuration
Avant de commencer, assurez‑vous de disposer de ce qui suit :
- .NET 6.0 ou version ultérieure installé.
- Un compte Aspose Cloud avec des informations d’identification API (Client ID et Client Secret).
- Accès à Internet pour appeler le service Aspose OMR Cloud.
Installez le SDK via NuGet:
dotnet add package Aspise.OMR-Cloud
Téléchargez le dernier package et consultez les notes de version ici : Aspose.OMR Cloud SDK for .NET Download. Pour une utilisation détaillée de l’API, consultez la documentation officielle.
Vous devez configurer le SDK avec vos informations d’identification :
var config = new Configuration
{
BasePath = "https://api.aspose.cloud",
ApiKey = Environment.GetEnvironmentVariable("ASPOSE_OMR_API_KEY")
};
Avec la configuration en place, vous êtes prêt à démarrer le flux de travail de conversion.
Guide étape par étape pour convertir DOCX en PNG en C#
Étape 1 : Charger le document source
Ouvrez le fichier DOCX en tant que flux pour éviter de charger le fichier entier en mémoire.
using var inputStream = new FileStream(inputDocxPath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 81920, useAsync: true);
Étape 2 : Construire la requête de conversion
Créez une ConvertDocumentRequest et spécifiez PNG comme format de sortie. Les ConvertOptions vous permettent de définir un arrière-plan transparent et le DPI.
var conversionRequest = new ConvertDocumentRequest
{
InputFile = await ReadStreamFullyAsync(inputStream),
OutputFormat = "png",
Options = new ConvertOptions
{
TransparentBackground = true,
Dpi = 150
}
};
Étape 3 : appeler l’API de conversion
Appelez la méthode asynchrone pour effectuer la conversion.
byte[] pngResult = await omrApi.ConvertDocumentAsync(conversionRequest);
Étape 4 : Enregistrer le résultat PNG
Écrivez le tableau d’octets renvoyé dans un fichier sur le disque.
await File.WriteAllBytesAsync(outputPngPath, pngResult);
Console.WriteLine($"DOCX successfully converted to PNG: {outputPngPath}");
Étape 5: Gérer les exceptions
Capturez les erreurs d’API et d’E/S pour rendre le processus robuste.
catch (ApiException apiEx)
{
Console.Error.WriteLine($"Aspose OMR API error (Code {apiEx.ErrorCode}): {apiEx.Message}");
}
catch (IOException ioEx)
{
Console.Error.WriteLine($"File I/O error: {ioEx.Message}");
}
catch (Exception ex)
{
Console.Error.WriteLine($"Unexpected error: {ex.Message}");
}
Transformation de fichiers DOCX en PNG avec C# - Exemple de code complet
L’exemple suivant montre le processus complet de conversion de bout en bout.
using System;
using System.IO;
using System.Threading.Tasks;
using Aspose.OMR.Cloud.Sdk.Api;
using Aspose.OMR.Cloud.Sdk.Client;
using Aspose.OMR.Cloud.Sdk.Model;
class Program
{
static async Task Main(string[] args)
{
// -----------------------------------------------------------------
// Configuration – replace with your actual credentials/environment
// -----------------------------------------------------------------
var config = new Configuration
{
// Base URL for Aspose OMR Cloud API
BasePath = "https://api.aspose.cloud",
// API key (or JWT) – read from environment for security
ApiKey = Environment.GetEnvironmentVariable("ASPOSE_OMR_API_KEY")
};
// Initialize the OMR API client
var omrApi = new OMRApi(config);
// Input DOCX and output PNG paths (generic placeholders)
const string inputDocxPath = "input.docx";
const string outputPngPath = "output.png";
try
{
// -------------------------------------------------------------
// Stream the DOCX file – avoids loading the whole file into RAM
// -------------------------------------------------------------
using var inputStream = new FileStream(inputDocxPath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 81920, useAsync: true);
// -------------------------------------------------------------
// Build conversion request with transparent PNG option
// -------------------------------------------------------------
var conversionRequest = new ConvertDocumentRequest
{
// The SDK expects the document as a byte array; copy via stream efficiently
InputFile = await ReadStreamFullyAsync(inputStream),
OutputFormat = "png",
// Optional conversion settings
Options = new ConvertOptions
{
// Ensure PNG background is transparent
TransparentBackground = true,
// For large documents, limit DPI to balance quality/performance
Dpi = 150
}
};
// -------------------------------------------------------------
// Perform the conversion (async)
// -------------------------------------------------------------
byte[] pngResult = await omrApi.ConvertDocumentAsync(conversionRequest);
// -------------------------------------------------------------
// Write the resulting PNG to disk
// -------------------------------------------------------------
await File.WriteAllBytesAsync(outputPngPath, pngResult);
Console.WriteLine($"DOCX successfully converted to PNG: {outputPngPath}");
}
catch (ApiException apiEx)
{
// Handles errors returned by the Aspose OMR service
Console.Error.WriteLine($"Aspose OMR API error (Code {apiEx.ErrorCode}): {apiEx.Message}");
}
catch (IOException ioEx)
{
// Handles file‑system related errors
Console.Error.WriteLine($"File I/O error: {ioEx.Message}");
}
catch (Exception ex)
{
// Catch‑all for any other unexpected issues
Console.Error.WriteLine($"Unexpected error: {ex.Message}");
}
}
// -----------------------------------------------------------------
// Helper: reads a stream fully into a byte array without blocking UI
// -----------------------------------------------------------------
private static async Task<byte[]> ReadStreamFullyAsync(Stream stream)
{
if (stream is MemoryStream ms && ms.TryGetBuffer(out var buffer))
return buffer.Array;
using var memory = new MemoryStream();
await stream.CopyToAsync(memory);
return memory.ToArray();
}
}
Remarque : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour tous les chemins de fichiers et les valeurs de configuration pour qu’ils correspondent à votre environnement réel, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.
Conversion de documents Word en PNG via l’API REST à l’aide de cURL
Vous pouvez obtenir le même résultat avec des appels REST directs. Voici un flux de travail cURL typique.
- Obtenir un jeton d’accès (remplacez les espaces réservés par vos informations d’identification).
curl -X POST "https://api.aspose.cloud/connect/token" \
-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET"
- Téléverser le fichier DOCX vers le point de terminaison de stockage.
curl -X PUT "https://api.aspose.cloud/v4.0/words/storage/file/input.docx" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-T "input.docx"
- Demande de conversion en PNG (arrière-plan transparent activé).
curl -X POST "https://api.aspose.cloud/v4.0/omr/convert?outputFormat=png&transparentBackground=true&dpi=150" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/octet-stream" \
--data-binary "@input.docx" \
-o output.png
- Télécharger le PNG résultant (si vous avez utilisé un point de terminaison de travail séparé).
curl -X GET "https://api.aspose.cloud/v4.0/omr/result/output.png" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-o output.png
Pour plus de détails sur les paramètres de la requête, consultez la référence API.
Paramètres de sortie PNG : Options et paramètres
L’objet ConvertOptions vous permet d’ajuster finement la sortie PNG. Deux paramètres importants sont démontrés dans le code :
- TransparentBackground - Lorsqu’il est défini sur
true, le PNG généré n’a aucune couleur d’arrière‑plan, ce qui est utile pour les scénarios de superposition. - Dpi - Contrôle la résolution. Un DPI plus élevé produit des images plus nettes mais augmente l’utilisation de la mémoire. Pour la plupart des cas d’utilisation Web, 150 DPI offre un bon équilibre entre qualité et performances.
Si vous avez besoin d’un contrôle supplémentaire, comme la définition du niveau de compression ou du mode couleur, consultez la liste complète des options dans la référence API.
Optimisation des performances de conversion de gros DOCX
Lors de la conversion de gros fichiers DOCX, prenez en compte ces conseils :
- Diffuser l’entrée - L’utilisation de
FileStreamavec des lectures asynchrones maintient une faible consommation de mémoire. - Ajuster le DPI - Réduire le DPI (par exemple, à 100) diminue le temps de traitement et la taille du fichier de sortie.
- Réutiliser le client
OMRApi- Créez une instance unique et réutilisez‑la pour plusieurs conversions afin d’éviter des échanges répétés. - Exécuter les conversions de manière asynchrone - Exploitez
awaitpour garder le thread réactif, notamment dans les applications web ou UI.
Appliquer ces pratiques vous aide à convertir DOCX en PNG en C# de manière efficace, même pour les documents comportant de nombreuses pages ou des images haute résolution.
Conclusion
La conversion de DOCX en PNG en C# est simple avec le Aspose.OMR Cloud SDK for .NET. En suivant les étapes ci‑dessus, vous pouvez générer des PNG transparents, intégrer le processus dans des flux de travail côté serveur et optimiser les performances pour les gros fichiers. Le SDK est vendu sous licence commerciale ; vous pouvez consulter les tarifs sur la page du produit et obtenir une licence temporaire pour l’évaluation sur la page de licence temporaire. Commencez dès aujourd’hui à intégrer la conversion DOCX en PNG et améliorez les capacités de gestion de documents de votre application.
Questions fréquentes
-
Comment convertir DOCX en PNG en C# avec Aspose.OMR ?
Utilisez la méthode asynchroneConvertDocumentAsyncprésentée dans le code d’exemple. Le SDK gère l’ensemble du flux de travail de conversion de DOCX en PNG, y compris la prise en charge des arrière-plans transparents. -
Est-il possible de convertir DOCX en PNG dans .NET sans écrire de fichier temporaire ?
Oui. En diffusant le DOCX dans un tableau d’octets avecReadStreamFullyAsync, la conversion reste en mémoire, ce qui est idéal pour les scénarios cloud ou API. -
Puis-je personnaliser la sortie PNG, par exemple rendre le fond transparent ?
Absolument. DéfinissezTransparentBackground = truedans leConvertOptions. Cela vous permet de convertir DOCX en PNG sous .NET avec un fond transparent, idéal pour les cas d’utilisation d’incrustation. -
Quelles options de licence sont disponibles pour le Aspose.OMR Cloud SDK for .NET ?
Le SDK est disponible sous une licence commerciale. Les tarifs détaillés sont sur la page produit, et vous pouvez demander une licence d’évaluation temporaire depuis la page de licence temporaire.