Flujos de salida – C# MemoryStream

Flujos de salida – Output Streams – C#

En las operaciones de conversión, normalmente guardamos el resultado de la renderización en el archivo. Sin embargo, en algunos casos, es posible que necesite almacenar el resultado en la memoria o enviarlo a un almacenamiento remoto. Puede hacerlo fácilmente implementando la interfaz especializada ICreateStreamProvider y usándola como parámetro de entrada para el convertidor. Esta interfaz representa una devolución de llamada que se utiliza cuando se requiere un nuevo flujo de salida.

Nota: Es posible que se invoque varias veces cuando se requieren varios flujos de salida. El escenario en el que este caso es posible es renderizar HTML en el conjunto de archivos de imagen.

Clase MemoryStreamProvider

La biblioteca Aspose.HTML C# permite realizar la clase MemoryStreamProvider como una implementación personalizada de la interfaz ICreateStreamProvider. La clase MemoryStreamProvider proporciona objetos C# MemoryStream como flujos de salida para escribir datos, que se pueden almacenar en la memoria como un flujo.

El uso de C# MemoryStream ayuda a evitar las latencias comúnmente asociadas con la lectura o escritura de archivos en un disco. Además, debido a que el contenido de un MemoryStream permanece en la memoria, no se utiliza el espacio físico del disco. El código C# siguiente es un ejemplo de la aplicación que utiliza ICreateStreamProvider para almacenar el resultado de la representación en la memoria y descargarlo en el archivo más tarde:

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 (var stream in Streams)
            stream.Dispose();
    }
}

Veamos las partes principales de la clase MemoryStreamProvider:

1. Propiedad Streams. Se crea una lista de objetos MemoryStream durante la representación del documento. Estos objetos almacenarán los datos que se escriben en los flujos de salida.
2. Implementación de los métodos GetStream(). Los métodos GetStream() crean nuevos objetos MemoryStream, los agregan a la lista Streams y los devuelven como flujos de salida.
3. Implementación del método ReleaseStream(). El método ReleaseStream() libera un objeto Stream lleno de datos. En esta implementación, el método está vacío. Aún así, puede personalizarlo para realizar operaciones como vaciar la transmisión en un disco duro o liberar cualquier recurso asociado con la transmisión.
4. Implementación del método Dispose(). Se llama a este método para liberar cualquier recurso retenido por la clase MemoryStreamProvider. Esta implementación elimina todos los objetos MemoryStream en la lista Streams usando un bucle foreach.

C# MemoryStream a archivo

El siguiente código C# demuestra cómo utilizar la clase MemoryStreamProvider y la biblioteca Aspose.HTML for .NET para convertir un documento HTML de varias páginas a JPG y guardar la imagen en un archivo. Veamos el ejemplo donde se realizan los siguientes pasos:

1. Cree una nueva instancia de la clase MemoryStreamProvider. Se utilizará como flujo de salida para el proceso de conversión.
2. Inicialice un documento HTML utilizando la clase HTMLDocument.
3. Utilice el constructor ImageSaveOptions() para configurar las opciones de guardado de la imagen, como ImageFormat – JPEG (en este caso).
4. Llame al método ConvertHTML(document, options, provider) para convertir el objeto HTMLDocument en una imagen usando las opciones de guardar y MemoryStreamProvider.
5. Utilice el bucle foreach para iterar sobre cada objeto MemoryStream en la propiedad Streams del objeto streamProvider. Cada MemoryStream representa una página del documento HTML convertido.
6. Llame al método memory.Seek() en el flujo de memoria para establecer la posición al principio. Esto garantiza que todo el contenido de la transmisión se copiará en el archivo de salida.
7. Utilice el método File.Create() dentro del bucle para crear un archivo de salida para la página actual.
8. Utilice el método memory.CopyTo() para copiar el contenido del flujo de memoria al objeto FileStream, que representa el archivo de salida.
9. Después de procesar cada página, el contador de páginas se incrementa para realizar un seguimiento del número de página de los nombres de los archivos de salida.

// Create an instance of MemoryStreamProvider
using (var streamProvider = new MemoryStreamProvider())
{                
    // Prepare HTML code
    var 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 var 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
        var page = 1;
        foreach (var 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 ofrece Convertidores en línea gratuitos para convertir archivos HTML, XHTML, MHTML, EPUB, XML y Markdown a una variedad de formatos populares. Puede convertir fácilmente HTML a PDF, HTML a JPG, SVG a PDF, MHTML a PDF o MD a HTML. Simplemente seleccione un archivo, elija el formato a convertir y listo. ¡Es rápido y completamente gratis!