Flux de sortie – C# MemoryStream

Flux de sortie – C#

Lors des opérations de conversion, nous enregistrons normalement le résultat du rendu dans le fichier. Toutefois, dans certains cas, il peut être nécessaire de stocker le résultat en mémoire ou de l’envoyer vers un stockage distant. Vous pouvez facilement le faire en mettant en œuvre l’interface spécialisée ICreateStreamProvider et en l’utilisant comme paramètre d’entrée du convertisseur. Cette interface représente un rappel qui est utilisé lorsqu’un nouveau flux de sortie est requis.

Note: Elle peut être invoquée plusieurs fois lorsque plusieurs flux de sortie sont nécessaires. Le scénario dans lequel ce cas est possible est le rendu HTML vers l’ensemble des fichiers images.

Classe MemoryStreamProvider

La bibliothèque Aspose.HTML C# permet de réaliser la classe MemoryStreamProvider en tant qu’implémentation personnalisée de l’interface ICreateStreamProvider. La classe MemoryStreamProvider fournit des objets C# MemoryStream comme flux de sortie pour l’écriture de données, qui peuvent être stockées en mémoire sous forme de flux.

L’utilisation d’un MemoryStream C# permet d’éviter les temps de latence généralement associés à la lecture ou à l’écriture de fichiers sur un disque. En outre, comme le contenu d’un MemoryStream reste en mémoire, l’espace physique sur le disque n’est pas utilisé.

// How to capture output in memory using a custom stream provider

class MemoryStreamProvider : ICreateStreamProvider
{
    // List of MemoryStream objects created during the document rendering
    public List<MemoryStream> Streams { get; } = new List<MemoryStream>();

    public Stream GetStream(string name, string extension)
    {
        // This method is called when only one output stream is required, for instance for XPS, PDF or TIFF formats
        MemoryStream result = new MemoryStream();
        Streams.Add(result);
        return result;
    }

    public Stream GetStream(string name, string extension, int page)
    {
        // This method is called when the creation of multiple output streams are required. For instance, during the rendering HTML to list of image files (JPG, PNG, etc.)
        MemoryStream result = new MemoryStream();
        Streams.Add(result);
        return result;
    }

    public void ReleaseStream(Stream stream)
    {
        // Here you can release the stream filled with data and, for instance, flush it to the hard-drive
    }

    public void Dispose()
    {
        // Releasing resources
        foreach (MemoryStream stream in Streams)
            stream.Dispose();
    }
}

Examinons les principaux éléments de la classe MemoryStreamProvider :

1. propriété Streams. Une liste d’objets MemoryStream est créée pendant le rendu du document. Ces objets stockeront les données écrites dans les flux de sortie.
2. Implémentation des méthodes GetStream(). Les méthodes GetStream() créent de nouveaux objets MemoryStream, les ajoutent à la liste des flux et les renvoient en tant que flux de sortie.
3. Implémentation de la méthode ReleaseStream(). La méthode ReleaseStream() libère un objet Stream rempli de données. Dans cette implémentation, la méthode est vide. Cependant, vous pouvez la personnaliser pour effectuer des opérations telles que la vidange du flux sur un disque dur ou la libération de toutes les ressources associées au flux.
4. Implémentation de la méthode Dispose(). Cette méthode est appelée pour libérer toutes les ressources détenues par la classe MemoryStreamProvider. Cette implémentation se débarrasse de tous les objets MemoryStream de la liste Streams en utilisant une boucle foreach.

C# MemoryStream vers un fichier

Le code C# suivant montre comment utiliser la classe MemoryStreamProvider et la bibliothèque Aspose.HTML for .NET pour convertir un document HTML de plusieurs pages en JPG et enregistrer l’image dans un fichier. Examinons l’exemple dans lequel les étapes suivantes sont exécutées :

1. Créer une nouvelle instance de la classe MemoryStreamProvider. Elle sera utilisée comme flux de sortie pour le processus de conversion.
2. Initialiser un document HTML en utilisant la classe HTMLDocument.
3. Utilisez le constructeur ImageSaveOptions() pour configurer les options d’enregistrement de l’image, comme le ImageFormat – JPEG (dans ce cas).
4. Appelez la méthode ConvertHTML(document, options, provider) pour convertir l’objet HTMLDocument en image à l’aide des options d’enregistrement et du MemoryStreamProvider.
5. Utilisez la boucle foreach pour itérer sur chaque objet MemoryStream dans la propriété Streams de l’objet streamProvider. Chaque MemoryStream représente une page du document HTML converti.
6. Appelez la méthode memory.Seek() sur le flux de mémoire pour fixer la position au début. Cela permet de s’assurer que tout le contenu du flux sera copié dans le fichier de sortie.
7. Utilisez la méthode File.Create() à l’intérieur de la boucle pour créer un fichier de sortie pour la page en cours.
8. Utilisez la méthode memory.CopyTo() pour copier le contenu du flux de mémoire dans l’objet FileStream, qui représente le fichier de sortie.
9. Après le traitement de chaque page, le compteur de pages est incrémenté afin de conserver la trace du numéro de page pour les noms de fichiers de sortie.

// Convert HTML to JPEG in C# using output memory streams for writing data

// Create an instance of MemoryStreamProvider
using (MemoryStreamProvider streamProvider = new MemoryStreamProvider())
{
    // Prepare HTML code
    string code = @"<style>
                div { page-break-after: always; }
                </style>
                <div style='border: 1px solid red; width: 300px'>First Page</div>
                <div style='border: 1px solid red; width: 300px'>Second Page</div>
                <div style='border: 1px solid red; width: 300px'>Third Page</div>
             ";
    // Initialize an HTML document from the HTML code
    using HTMLDocument document = new HTMLDocument(code, ".");
    {
        // Convert HTML to Image by using the MemoryStreamProvider
        Converter.ConvertHTML(document, new ImageSaveOptions(ImageFormat.Jpeg), streamProvider);

        // Get access to the memory stream that contains the result data
        int page = 1;
        foreach (MemoryStream memory in streamProvider.Streams)
        {
            memory.Seek(0, SeekOrigin.Begin);

            // Flush the result data to the output file
            using (FileStream fs = File.Create(Path.Combine(OutputDir, "page_" + page + ".jpg")))
            {
                memory.CopyTo(fs);
            }
            page++;
        }
    }
}

Aspose.HTML propose des Convertisseurs gratuits en ligne pour convertir des fichiers HTML, XHTML, MHTML, EPUB, XML et Markdown dans une variété de formats populaires. Vous pouvez facilement convertir HTML en PDF, HTML en JPG, SVG en PDF, MHTML en PDF, ou MD en HTML Il vous suffit de sélectionner un fichier, de choisir le format à convertir, et le tour est joué. C’est rapide et entièrement gratuit !