Convertir plantilla a HTML – Ejemplos de C#

Aspose.HTML for .NET ofrece un conjunto de métodos ConvertTemplate() que se utilizan para convertir una plantilla HTML en un documento HTML. Los métodos toman varios parámetros, como la ruta al archivo de plantilla, la fuente de datos y las opciones de carga, y devuelven un documento HTML. La plantilla HTML es una pieza de código HTML que contiene marcadores de posición para datos dinámicos. Estos marcadores de posición se denominan expresiones y están encerrados entre llaves dobles, como esta: {{expresión}}. La fuente de datos proporciona los valores reales para estas expresiones. El método ConvertTemplate() sustituye las expresiones de la plantilla con valores de la fuente de datos, generando un documento HTML completo. Este método se puede utilizar con varios tipos de fuentes de datos, como XML y JSON.

Este artículo describe cómo convertir plantillas a HTML en ejemplos de C# utilizando la biblioteca Aspose.HTML for .NET.

Convierta una plantilla a HTML con una sola línea de código

Una vez que haya preparado una plantilla HTML, puede convertirla a HTML en su aplicación C# literalmente con una sola línea de código. Para hacer esto, debe pasar los parámetros requeridos al método ConvertTemplate(sourcePath, data, options, outputPath).

// Convert template to HTML
Converter.ConvertTemplate(
    Path.Combine(DataDir, "template.html"),
    new TemplateData(Path.Combine(DataDir, "data-source.json")),
    new TemplateLoadOptions(),
    Path.Combine(OutputDir, "template-with-single-line.html")
);

Convertir plantilla a HTML

Usemos el método ConvertTemplate(HTMLDocument, TemplateData, TemplateLoadOptions, string) para convertir una plantilla HTML en un documento HTML real. El método toma cuatro parámetros:

1. El objeto HTMLDocument se utiliza como fuente para la plantilla.
2. El objeto TemplateData contiene los datos que se utilizarán para completar la plantilla.
3. El objeto TemplateLoadOptions proporciona opciones para cargar la plantilla.
4. Se utiliza un parámetro string para especificar la ruta completa del archivo HTML como resultado de la conversión de salida.

El método utiliza la información de estos parámetros para generar un documento HTML.

// Prepare a path to an HTML source file
var sourcePath = Path.Combine(DataDir, "template.html");

// Prepare a path to an xml template data file
var templateDataPath = Path.Combine(DataDir, "templateData.xml");

// Define TemplateData object instance
var templateData = new TemplateData(templateDataPath);

// Prepare a path to the result file
var resultPath = Path.Combine(OutputDir, "result.html");

// Define default TemplateLoadOptions object
var options = new TemplateLoadOptions();

// Initialize an HTML document as conversion source
var document = new HTMLDocument(sourcePath, new Configuration());

// Convert template to HTML
Converter.ConvertTemplate(document, templateData, options, resultPath);

// Clear resources
document.Dispose();

El código crea una instancia de la clase HTMLDocument y utiliza el método Converter.ConvertTemplate() para convertir un archivo de plantilla (template.html) en un documento HTML utilizando un archivo de origen de datos (templateData. xml). El método toma cuatro parámetros: el objeto HTMLDocument, el objeto TemplateData creado usando el archivo fuente de datos, el objeto TemplateLoadOptions y la ruta del archivo para el documento HTML resultante. El documento HTML resultante se guarda en la ruta del archivo especificada (result.html). Después de la conversión, se elimina el objeto “documento”.

Convertir plantilla a HTML sobre la marcha

Si tu caso implica especificar datos y crear una plantilla sobre la marcha, debes seguir algunos pasos:

1. Prepare una plantilla HTML y guárdela en un archivo. El método ConvertTemplate() toma la ruta del archivo de plantilla como parámetro (sourcePath).
2. Prepare una fuente de datos JSON y XML y guárdela en un archivo. El constructor TemplateData() toma la ruta a este archivo de datos y crea un objeto de datos (“datos”) para el método ConvertTemplate().
3. Inicialice una instancia de la clase TemplateLoadOptions para determinar si los nombres de la plantilla y del elemento de datos coinciden, independientemente de si son mayúsculas o no (options).
4. Invoque el método ConvertTemplate() y pásele sourcePath, data, options y outputPath. OutputPath es una ruta para guardar archivos de plantilla llenos de datos.

// Prepare a path to JSON data source file
string jsonPath = Path.Combine(OutputDir, "data-source.json");

// Prepare a JSON data source and save it to the file
var data = @"{
    ""FirstName"": ""John"",
    ""LastName"": ""Doe"",
    ""Address"": {
        ""City"": ""Dallas"",
        ""Street"": ""Austin rd."",
        ""Number"": ""200""
        }
    }";
File.WriteAllText(jsonPath, data);

// Prepare a path to an HTML Template file
string sourcePath = Path.Combine(OutputDir, "template.html");

// Prepare an HTML Template and save it to the file
var template = @"
    <table border=1>
        <tr>
            <th>Person</th>
            <th>Address</th>
        </tr>
        <tr>
            <td>{{FirstName}} {{LastName}}</td>
            <td>{{Address.Street}} {{Address.Number}}, {{Address.City}}</td>
        </tr>
    </table>
    ";
File.WriteAllText(sourcePath, template);

// Prepare a path to the output file (data-filled template file)
string outputPath = Path.Combine(OutputDir, "template-output.html");

// Invoke Converter.ConvertTemplate in order to populate 'template.html' with the data source from 'data-source.json' file
Converter.ConvertTemplate(sourcePath, new TemplateData(jsonPath), new TemplateLoadOptions(), outputPath);

Aspose.HTML ofrece Convertidores gratuitos en línea 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!