XSLT transformations with .Net

-
How the transformation works with .Net.

Using .Net and C# you can do XSL transformations using XslCompiledTransform(). As input to the XSLT engine we use an XSLT sheet, settings (optional), parameters (optional), an XML source and the output path.

Note: Please note that if you need to use XSLT 2.0 or XPath 2.0 you should use a third party XSLT engine.

   1:  // C# code - using .Net 4.0
   2:   
   3:  // We want to enable document() functions and script() inside the XSLT code. 
          In order to allow this in using .Net we include this in the settings. 
          This gives us a bit more power as far as .Net XSLT support goes.
   4:  var settings = new XsltSettings(true, true);
   5:   
   6:  // This is the XSLT engine object
   7:  var xslTransform = new XslCompiledTransform();
   8:   
   9:  // We load the XSLT and settings to the engine.
  10:  xslTransform.Load(XSLTSheetPath, settings, new XmlUrlResolver());
  11:   
  12:  // As there is no way of generating e.g. date objects inside XSLT 1.0 
          (the only one supported by .Net) we do this outside the code and include 
          it as a parameter.
  13:  // Argument list (Params)
  14:  var xslArg = new XsltArgumentList();
  15:  // Grabbing current DateTime
  16:  DateTime time = DateTime.Now;
  17:  // Create a parameter which represents the current date and time.
  18:  xslArg.AddParam("date", "", time.ToString("s"));

 Now, as we create the result file we want the transformed output to populate, we apply the source XML, 
arguments (params) and XML writer to the XSLT engines Transform() function. This is when/where the 
transforation is performed and the end of any C#/.Net involvement for now.

 
   1:  // Transform the file.
   2:  using (XmlWriter w = XmlWriter.Create(XMLResultPath))
   3:  {
   4:      xslTransform.Transform(XMLSourcePath, xslArg, w);
   5:  }
   6:   
   7:  // The entire transforming class could look like this:
   8:  using System;
   9:  using System.Diagnostics;
  10:  using System.Globalization;
  11:  using System.Xml;
  12:  using System.Xml.Xsl;
  13:   
  14:  namespace XSLTGenerator
  15:  {
  16:      class XMLTransformer
  17:      {
  18:          public void TransformXmlUsingXSLT(string XMLSourcePath, 
                   string XSLTSheetPath, string XSDSchemaPath, string XMLResultPath)
  19:          {
  20:              try
  21:              {
  22:                  // Creating settings to enable document() and script()
  23:                  var settings = new XsltSettings(true, true);
  24:   
  25:                  var xslTransform = new XslCompiledTransform();
  26:   
  27:                  // Load XSLT stylesheet
  28:                  xslTransform.Load(XSLTSheetPath, settings, new XmlUrlResolver());
  29:   
  30:                  // Create the XsltArgumentList.
  31:                  var xslArg = new XsltArgumentList();
  32:                  
  33:                  DateTime time = DateTime.Now;
  34:                  
  35:                  // Create a parameter which represents the current date and time.
  36:                  xslArg.AddParam("date", "", time.ToString("s"));
  37:                  // Create a parameter for GUID
  38:                  xslArg.AddParam("id", "", new Guid().ToString());
  39:   
  40:                  // Transform the file.
  41:                  using (XmlWriter w = XmlWriter.Create(XMLResultPath))
  42:                  {
  43:                      xslTransform.Transform(XMLSourcePath, xslArg, w);
  44:                  }
  45:              }
  46:              catch (Exception e)
  47:              {
  48:                  Debug.WriteLine(e.Message);
  49:              }
  50:          }
  51:      }
  52:  }

 The next entry will create some basic building blocks 


Comments

Post a Comment

Popular posts from this blog

Power Pages Manifest Explained related to Collaborative Development and ALM

-
In the Microsoft Power Pages, understanding the nuances of configuration files like the `manifest.yml` and environment-specific manifests (e.g., `dev.crm4.dynamics.com-manifest.yml`) is crucial. These files play a significant role in managing and deploying Power Pages sites, particularly in collaborative and ALM contexts. Understanding the Manifest.yml File First of all, always refer to the official documentation on how the power platform cli tool is supported. Creation and Usage Creation : The manifest.yml is generated through the pac powerpages download command. It serves as a snapshot of the Power Pages site's configuration, capturing details like page templates, form settings, and access permissions. Example: When you run this command, it creates a manifest.yml file that includes details of all the components such as web forms, entity lists, and site settings configured in the Power Pages site. Usage : The pac powerpages upload command utilizes the manifest.yml file to updat...
Read more

Exploring the Power of Variables in Liquid and Power Pages

-
Covering the basics - Variables As a templating language, Liquid offers a rich collection of possibilities for web developers and designers, bringing Dynamics business data to the web. Variables in Liquid enable us to display dynamic content and enable us to implement a certain level of custom logic as well. We'll have a look at some examples on how to work with variables. Variable Assignment In Liquid, variables can be assigned values using the {% assign %} tag. For example, let's assign the value "Hello, Nerd!" to the variable greeting: {% assign greeting = 'Hello, Nerd!' %} Variable Output Once a variable is assigned a value, it can be outputted using the {{ }} syntax. To display the value of greeting, we can use: {{ greeting }} Assigning Site Settings Liquid is powerfull enough to allow you to assign values from site settings to variables. For example, if you need the site setting for inactivity for ...
Read more

Designing and programming - Part 2

-
This part of the series will handle the creative part of the cycle. You might loosely categorize the steps of the design process in three different stages. First is the creative methods - this stage contains methods that drives the design project forward adding new ideas and features to the design. However, systemizing the ideas and filtering them is also part of this stage. The next stage contains different methods of implementation. This is where the ideas meet the matter - where ideas become code and components. You get the idea:) The third and last stage is perhaps the most crucial one. This is where you test and evaluate your results. It is now that you have to decide whether the implementations meet with the requirements and visions of the design. The outcome of this stage will determent if the prototype is ready for some real world testing, also called a beta. Anyways, after clearing that up, the creative stage is what this part of the series will be all about. The Creati...
Read more