I am trying to convert the value — – à, è, ì, ò, ù, À, È, Ì, Ò, Ù á, é, í, ó, ú, ý, Á, É, Í, Ó, Ú, Ý.
In the email I get it as ? ? à, è, ì, ò, ù, À, È, Ì, Ò, Ù á, é, í, ó, ú, ý, Á, É, Í, Ó, Ú, Ý

The code is as follows:

public string getHtml(int templateID, int incidentID, string userID, int IncidentNotificationID)
{
    TemplateID = templateID;
    IncidentID = incidentID;

    string htmlToReturn = "<h3>Please select a template to edit</h3>";
    try
    {
        if (templateID != -1)
        {
            XslTransformHelper(templateID);

            using (var transformedStream = CreateTransformMemoryStream(templateID,
                       GenerateXML(templateID, incidentID, userID, IncidentNotificationID)))
            {
                using (var streamToRead = new MemoryStream(transformedStream.GetBuffer()))
                {
                    streamToRead.Position = 0;
                    if (streamToRead.CanRead && streamToRead.CanSeek)
                    {
                        byte[] myBytes = new byte[Convert.ToInt32(streamToRead.Length)];
                        streamToRead.Read(myBytes, 0, Convert.ToInt32(streamToRead.Length));

                        streamToRead.Position = 0;
                        htmlToReturn = System.Text.Encoding.UTF8.GetString(myBytes);

                        htmlToReturn = htmlToReturn.Substring(htmlToReturn.IndexOf("<"));
                        htmlToReturn = ReplaceEmailBodyVariables(htmlToReturn);
                    }
                    else
                    {
                        throw new Exception("Stream read error while attempting to transform e-mail body. ");
                    }
                }
            }
        }
    }
    catch (Exception ex)
    {
        htmlToReturn = string.Empty;
        WriteLog($"Failed to generate TemplateID: {templateID.ToString()}. {ex.Message} ${ex.StackTrace}");
    }

    return htmlToReturn;
}

From above method it goes to

 private void XslTransformHelper(int templateID)
 {
     var parameters = new[] { new SqlParameter("@TemplateID", templateID) };
     string sql =
         "SELECT (SELECT ISNULL(ParameterValue, '~/xsl') FROM SystemParameter WITH(NOLOCK) WHERE ParameterName = 'XslPath') AS XslPath, ISNULL(FileName, '') AS FileName, ISNULL(DynamicTemplateFlag, 0) AS DynamicTemplateFlag FROM Template WITH(NOLOCK) WHERE TemplateID = @TemplateID";
     var myFile = string.Empty;
     var db = new BaseDAL();
     var systemXSLPath = string.Empty;
     var dynamicTemplateFlag = string.Empty;

     try
     {
         using (var reader = db.ExecuteSQLReader(sql, parameters))
         {
             if (reader.Read())
             {
                 systemXSLPath = System.Web.Hosting.HostingEnvironment.MapPath(reader["XslPath"].ToString());
                 myFile = Path.Combine(
                     System.Web.Hosting.HostingEnvironment.MapPath(reader["XslPath"].ToString()),
                     reader["FileName"].ToString());
                 dynamicTemplateFlag = reader["DynamicTemplateFlag"].ToString();
             }
         }

         if (dynamicTemplateFlag != "1")
         {
             myXSLTransform.Load(myFile);
             return;
         }

         byte[] bytes = myXSLEncoder.GetBytes(getXSLFileString(templateID, systemXSLPath));
         using (var myXslMemoryStream = new MemoryStream(bytes))
         {
             using (var reader = XmlReader.Create(myXslMemoryStream))
             {
                 myXSLTransform.Load(reader, null, myXSLResolver);
             }
         }
     }
     catch (Exception ex)
     {
         var additionalInfo = new NameValueCollection
         {
             { "ErrorCode", "XSLT" }, { "ErrorMessage", ex.Message }
         };
         throw new Elegrity.EIF.ElegrityException("Transformer unable to instantiate.", additionalInfo);
     }
 }

  private string getXSLFileString(int templateID, string systemXSLPath)
  {
      var myFile = string.Empty;
      var db = new BaseDAL();
      var xslTemplate = string.Empty;
      var xslTemplateCSSImport = string.Empty;
      var xslTemplateCSSCall = string.Empty;
      var xslTemplateImport = string.Empty;
      StringBuilder xslTemplateCall = new StringBuilder();
      var importTag = string.Empty;
      var callTemplateTag = string.Empty;
      var headerText = string.Empty;
      var footerText = string.Empty;
      var xslFileName = string.Empty;
      var templateBody = string.Empty;
      var dfPKey = IncidentID > 0 ? IncidentID : SubjectID;

      DataTable drTemplateXSLBody = null;
      try
      {
          Hashtable htable = new Hashtable();
          htable.Add("@TemplateID", templateID);
          drTemplateXSLBody = new BaseDAL().ExecuteStoredProcDataTable(ref htable, "spGetTemplateXSL");

          //Create import tags and call-template tags
          for (int i = 0; i < drTemplateXSLBody.Rows.Count; i++)
          {
              //Reset Variables
              importTag = "";
              callTemplateTag = "";
              headerText = "";
              footerText = "";
              xslFileName = "";
              templateBody = "";
              int.TryParse(drTemplateXSLBody.Rows[i]["DFFormID"].ToString(), out int dfFormID);

              //Check if subnode is a Dynamic Form
              if (dfFormID > 0)
              {
                  headerText = drTemplateXSLBody.Rows[i]["HeaderText"].ToString();
                  footerText = drTemplateXSLBody.Rows[i]["FooterText"].ToString();

                  if (!string.IsNullOrEmpty(headerText))
                  {
                      xslTemplateCall.Append($"<p class="headerText">{headerText}</p>");
                  }

                  //make call to get rendered Dynamic Form HTML with Header and Footer Text
                  HelperResponse dfTemplateResponse = _adapter.GetEmailTemplateHtmlString(dfFormID, dfPKey);
                  if (dfTemplateResponse.IsSuccess == false)
                  {
                      throw new Exception(dfTemplateResponse.ResponseXml);
                  }
                  else
                  {
                      xslTemplateCall.Append(dfTemplateResponse.ResponseXml);
                  }

                  if (!string.IsNullOrEmpty(footerText))
                  {
                      xslTemplateCall.Append($"<p class="footerText">{footerText}</p>");
                  }
              }
              else
              {
                  //Set Variables
                  xslFileName = drTemplateXSLBody.Rows[i].ItemArray[0].ToString();

                  importTag = "<xsl:import href="" + systemXSLPath + "\" + xslFileName + ".xsl"/>";
                  callTemplateTag = "<xsl:call-template name="" + xslFileName + ""></xsl:call-template>";

                  if (drTemplateXSLBody.Rows[i].ItemArray[1].ToString() != "" &&
                      drTemplateXSLBody.Rows[i].ItemArray[1].ToString() != null)
                  {
                      headerText =
                          $"<p class="headerText {xslFileName}"><xsl:value-of disable-output-escaping="yes" select="rootXML/DynamicTemplateNodeXML/{xslFileName}_HeaderText"/></p>";
                  }

                  if (drTemplateXSLBody.Rows[i].ItemArray[2].ToString() != "" &&
                      drTemplateXSLBody.Rows[i].ItemArray[2].ToString() != null)
                  {
                      footerText =
                          $"<p class="footerText {xslFileName}"><xsl:value-of disable-output-escaping="yes" select="rootXML/DynamicTemplateNodeXML/{xslFileName}_FooterText"/></p>";
                  }

                  //Add TemplateBody to Template
                  if (xslFileName == "Dynamic_TemplateBody")
                  {
                      if (drTemplateXSLBody.Rows[i].ItemArray[3].ToString() != "" &&
                          drTemplateXSLBody.Rows[i].ItemArray[3].ToString() != null)
                      {
                          templateBody =
                              $"<p class="{xslFileName}"><xsl:value-of disable-output-escaping="yes" select="rootXML/DynamicTemplateNodeXML/{xslFileName}_TemplateBody"/></p>";
                          xslTemplateCall.Append(headerText).Append(templateBody).Append(footerText);
                      }
                  }
                  //This is NOT the Template Body Text subnode
                  else
                  {
                      //Add SubNode to XSL Template
                      xslTemplateImport += importTag;
                      xslTemplateCall.Append(headerText).Append(callTemplateTag).Append(footerText);
                  }
              }
          }

          //Combine Strings to create XSL Template
          xslTemplate =
              "<?xml version="1.0"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">"
              + xslTemplateImport + " <xsl:template match="/"><html><head>"
              + "</head><body>" + xslTemplateCall + "</body></html></xsl:template></xsl:stylesheet>";
      }
      catch (Exception ex)
      {
          //Throw an ElegrityException from data reader...
          NameValueCollection additionalInfo = new NameValueCollection();
          additionalInfo.Add("ErrorCode", "XSLT");
          additionalInfo.Add("ErrorMessage", ex.Message);
          throw new ElegrityException("getXSLFileString() Method Failed getting the Template XSL String",
              additionalInfo);
      }

      return xslTemplate;
  }

In the xslTemplate variable value is as follows,

<?xml version="1.0"?>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">


<xsl:template match="/">


<html>

<head/>


<body>



<table class="em-col">

<tr>

<td class="w-60">— – à, è, ì, ò, ù, À, È, Ì, Ò, Ù á, é, í, ó, ú, ý, Á, É, Í, Ó, Ú, Ý</td>

</tr>

</table>

</div>

</body>

</html>

</xsl:template>

</xsl:stylesheet>

But, in the end, the htmlToReturn variable in getHtml() returns the following

<html><head /><body><table class="em-col"><tr><td class="w-60">? ? à, è, ì, ò, ù, À, È, Ì, Ò, Ù á, é, í, ó, ú, ý, Á, É, Í, Ó, Ú, Ý</td></tr></table></div></body></html>

Can anyone help with this?