Unicode til Quoted-Printable

Moskus · 28. februar 2007

Jeg fikk etter hvert til å sende epost via en SMTP-server uten å bruke System.Net.Mail.

https://www.diskusjon.no/index.php?showtopic=721616

Er det noen som vet hvordan jeg kan lage en "Unicode to Quoted-Printable converter" uten å måtte kalle eksterne prosesser? Har funnet mange VBscript men lite som kan kjøre på en Pocket PC...

Moskus · 1. mars 2007

Ingen som har gjort noe slik? Ikke litt engang?

Manfred · 1. mars 2007

Jeg sitter og lurer på hvorfor du skal gjøre det uten System.Net.Mail jeg, egentlig... Og nei, jeg har ikke gjort det litt en gang

Moskus · 1. mars 2007

Fordi programmet skal kjøre på en Pocket PC eller Smartphone, og der har MS (med sin uendelige visdom) fjernet System.Net.Mail...

wolf5 · 7. mars 2007

Tja. Dersom det ikke finnes noe i .Net så skal det vel være mulig å konvertere ved hjelp av cdosys.dll (kan brukes til å generere .mhtml filer som da inneholder en seksjon med quoted-printable).

Ta en titt her: http://www.codeproject.com/aspnet/aspnethtml2mht.asp

...
 'Make the html part of the document
 iBp = mainBody.AddBodyPart()
 iBp.ContentMediaType = "text/html"
 iBp.ContentTransferEncoding = "quoted-printable"
 stm = iBp.GetDecodedContentStream
 stm.WriteText(html)
 stm.Flush()
...

Vet ikke om cdosys.dll er standard på smartphones/pocketPC. Men om det er så har du kanskje en løsning her.

Endret 7. mars 2007 av wolf5

Moskus · 7. mars 2007

Det var en utmerket idé, men DLL'en mangler dessverre...

Nåja, jeg får vel bare lese standarden, og kode fra Ascii selv. :s

wolf5 · 7. mars 2007

+ med litt google fant jeg: http://www.aspemporium.com/classes_src.aspx?cid=6

using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Security;

namespace mimelib
{
/// <summary>
/// <para>
/// Robust and fast implementation of Quoted Printable
/// Multipart Internet Mail Encoding (MIME) which encodes every 
/// character, not just "special characters" for transmission over 
/// SMTP.
/// </para>
/// <para>
/// More information on the quoted-printable encoding can be found
/// here: http://www.freesoft.org/CIE/RFC/1521/6.htm
/// </para>
/// </summary>
/// <remarks>
/// <para>
/// detailed in: RFC 1521
/// </para>
/// <para>
/// more info: http://www.freesoft.org/CIE/RFC/1521/6.htm
/// </para>
/// <para>
/// The QuotedPrintable class encodes and decodes strings and files
/// that either were encoded or need encoded in the Quoted-Printable
/// MIME encoding for Internet mail. The encoding methods of the class
/// use pointers wherever possible to guarantee the fastest possible 
/// encoding times for any size file or string. The decoding methods 
/// use only the .NET framework classes.
/// </para>
/// <para>
/// The Quoted-Printable implementation
/// is robust which means it encodes every character to ensure that the
/// information is decoded properly regardless of machine or underlying
/// operating system or protocol implementation. The decode can recognize
/// robust encodings as well as minimal encodings that only encode special
/// characters and any implementation in between. Internally, the
/// class uses a regular expression replace pattern to decode a quoted-
/// printable string or file.
/// </para>
/// </remarks>
/// <example>
/// This example shows how to quoted-printable encode an html file and then
/// decode it.
/// <code>
/// string encoded = QuotedPrintable.EncodeFile(
///  @"C:\WEBS\wwwroot\index.html"
///  );
/// 
/// string decoded = QuotedPrintable.Decode(encoded);
/// 
/// Console.WriteLine(decoded);
/// </code>
/// </example>
public class QuotedPrintable
{
 private QuotedPrintable()
 {
 }

 /// <summary>
 /// Gets the maximum number of characters per quoted-printable
 /// line as defined in the RFC minus 1 to allow for the =
 /// character (soft line break).
 /// </summary>
 /// <remarks>
 /// (Soft Line Breaks): The Quoted-Printable encoding REQUIRES 
 /// that encoded lines be no more than 76 characters long. If 
 /// longer lines are to be encoded with the Quoted-Printable 
 /// encoding, 'soft' line breaks must be used. An equal sign 
 /// as the last character on a encoded line indicates such a 
 /// non-significant ('soft') line break in the encoded text.
 /// </remarks>
 public const int RFC_1521_MAX_CHARS_PER_LINE = 75;

 /// <summary>
 /// Encodes a very large string into the Quoted-Printable
 /// encoding for transmission via SMTP
 /// </summary>
 /// <param name="toencode">
 /// the very large string to encode
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ObjectDisposedException">
 /// A problem occurred while attempting to read the encoded 
 /// string.
 /// </exception>
 /// <exception cref="OutOfMemoryException">
 /// There is insufficient memory to allocate a buffer for the
 /// returned string. 
 /// </exception>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <exception cref="ArgumentOutOfRangeException">
 /// The charsperline argument is less than or equal to 0.
 /// </exception>
 /// <remarks>
 /// This method encodes a large string into the quoted-printable
 /// encoding and then properly formats it into lines of 76 characters
 /// using the <see cref="FormatEncodedString"/> method.
 /// </remarks>
 public static string Encode(string toencode)
 {
 	return Encode(toencode, RFC_1521_MAX_CHARS_PER_LINE);
 }

 /// <summary>
 /// Encodes a very large string into the Quoted-Printable
 /// encoding for transmission via SMTP
 /// </summary>
 /// <param name="toencode">
 /// the very large string to encode
 /// </param>
 /// <param name="charsperline">
 /// the number of chars per line after encoding
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ObjectDisposedException">
 /// A problem occurred while attempting to read the encoded 
 /// string.
 /// </exception>
 /// <exception cref="OutOfMemoryException">
 /// There is insufficient memory to allocate a buffer for the
 /// returned string. 
 /// </exception>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <exception cref="ArgumentOutOfRangeException">
 /// The charsperline argument is less than or equal to 0.
 /// </exception>
 /// <remarks>
 /// This method encodes a large string into the quoted-printable
 /// encoding and then properly formats it into lines of 
 /// charsperline characters using the <see cref="FormatEncodedString"/> 
 /// method.
 /// </remarks>
 public static string Encode(string toencode, int charsperline)
 {
 	if (toencode == null)
   throw new ArgumentNullException();

 	if (charsperline <= 0)
   throw new ArgumentOutOfRangeException();

 	string line, encodedHtml = "";
 	StringReader sr = new StringReader(toencode);
 	try
 	{
   while((line=sr.ReadLine())!=null)
   	encodedHtml += EncodeSmallLine(line);

   return FormatEncodedString(encodedHtml, charsperline);
 	}
 	finally
 	{
   sr.Close();
   sr = null;
 	}
 }

 /// <summary>
 /// Encodes a file's contents into a string using
 /// the Quoted-Printable encoding.
 /// </summary>
 /// <param name="filepath">
 /// The path to the file to encode.
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ObjectDisposedException">
 /// A problem occurred while attempting to encode the 
 /// string.
 /// </exception>
 /// <exception cref="OutOfMemoryException">
 /// There is insufficient memory to allocate a buffer for the
 /// returned string. 
 /// </exception>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <exception cref="FileNotFoundException">
 /// The file was not found.
 /// </exception>
 /// <exception cref="SecurityException">
 /// The caller does not have the required permission to open
 /// the file specified in filepath.
 /// </exception>
 /// <exception cref="UnauthorizedAccessException">
 /// filepath is read-only or a directory.
 /// </exception>
 /// <remarks>
 /// This method encodes a file's text into the quoted-printable
 /// encoding and then properly formats it into lines of 76 characters
 /// using the <see cref="FormatEncodedString"/> method.
 /// </remarks>
 public static string EncodeFile(string filepath)
 {
 	return EncodeFile(filepath, RFC_1521_MAX_CHARS_PER_LINE);
 }

 /// <summary>
 /// Encodes a file's contents into a string using
 /// the Quoted-Printable encoding.
 /// </summary>
 /// <param name="filepath">
 /// The path to the file to encode.
 /// </param>
 /// <param name="charsperline">
 /// the number of chars per line after encoding
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ObjectDisposedException">
 /// A problem occurred while attempting to encode the 
 /// string.
 /// </exception>
 /// <exception cref="OutOfMemoryException">
 /// There is insufficient memory to allocate a buffer for the
 /// returned string. 
 /// </exception>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <exception cref="FileNotFoundException">
 /// The file was not found.
 /// </exception>
 /// <exception cref="SecurityException">
 /// The caller does not have the required permission to open
 /// the file specified in filepath.
 /// </exception>
 /// <exception cref="UnauthorizedAccessException">
 /// filepath is read-only or a directory.
 /// </exception>
 /// <remarks>
 /// This method encodes a file's text into the quoted-printable
 /// encoding and then properly formats it into lines of 
 /// charsperline characters using the <see cref="FormatEncodedString"/> 
 /// method.
 /// </remarks>
 public static string EncodeFile(string filepath, int charsperline)
 {
 	if (filepath == null)
   throw new ArgumentNullException();

 	string encodedHtml = "", line;
 	FileInfo f = new FileInfo(filepath);
 	
 	if (! f.Exists)
   throw new FileNotFoundException();

 	StreamReader sr = f.OpenText();
 	try
 	{
   while((line=sr.ReadLine())!=null)
   	encodedHtml += EncodeSmallLine(line);

   return FormatEncodedString(encodedHtml, charsperline);
 	}
 	finally
 	{
   sr.Close();
   sr = null;
   f = null;
 	}
 }

 /// <summary>
 /// Encodes a small string into the Quoted-Printable encoding
 /// for transmission via SMTP. The string is not split
 /// into lines of X characters like the string that the 
 /// Encode method returns.
 /// </summary>
 /// <param name="s">
 /// The string to encode.
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <remarks>
 /// This method encodes a small string into the quoted-printable
 /// encoding. The resultant encoded string has NOT been separated
 /// into lined results using the <see cref="FormatEncodedString"/>
 /// method.
 /// </remarks>
 public unsafe static string EncodeSmall(string s)
 {
 	if (s == null)
   throw new ArgumentNullException();

 	string result = "";
 	fixed (char* pChar = s)
 	{
   char* pCurrent = pChar;
   do
   {
   	int code = (*pCurrent);
   	result += String.Format("={0}", code.ToString("X2"));
   	pCurrent++;
   }
   while (*pCurrent != 0);
 	}
 	return result;
 }

 /// <summary>
 /// Encodes a small string with an appended newline into the 
 /// Quoted-Printable encoding for transmission via SMTP. The 
 /// string is not split into lines of X characters like the 
 /// string that the Encode or the EncodeFile methods return.
 /// </summary>
 /// <param name="s">
 /// The string to encode.
 /// </param>
 /// <returns>The Quoted-Printable encoded string</returns>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <remarks>
 /// This method encodes a small string into the quoted-printable
 /// encoding. The resultant encoded string has NOT been separated
 /// into lined results using the <see cref="FormatEncodedString"/>
 /// method.
 /// </remarks>
 public static string EncodeSmallLine(string s)
 {
 	if (s == null)
   throw new ArgumentNullException();

 	return EncodeSmall(s + "\r\n");
 }

 /// <summary>
 /// Formats a quoted-printable string into lines equal to maxcharlen,
 /// following all protocol rules such as byte stuffing. This method is
 /// called automatically by the Encode method and the EncodeFile method.
 /// </summary>
 /// <param name="qpstr">
 /// the quoted-printable encoded string.
 /// </param>
 /// <param name="maxcharlen">
 /// the number of chars per line after encoding.
 /// </param>
 /// <returns>
 /// The properly formatted Quoted-Printable encoded string in lines of
 /// 76 characters as defined by the RFC.</returns>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <remarks>
 /// Formats a quoted-printable encoded string into lines of
 /// maxcharlen characters for transmission via SMTP.
 /// </remarks>
 public unsafe static string FormatEncodedString(string qpstr, int maxcharlen)
 {
 	if (qpstr == null)
   throw new ArgumentNullException();

 	string strout = "";
 	StringWriter qpsw = new StringWriter();
 	try
 	{
   fixed(char* pChr = qpstr)
   {
   	char* pCurrent = pChr;
   	int i = 0;
   	do
   	{
     strout += pCurrent->ToString();
     i++;
     if (i==maxcharlen)
     {
     	qpsw.WriteLine("{0}=", strout);
     	qpsw.Flush();

     	i=0;
     	strout = "";
     }
     pCurrent++;
   	}
   	while(*pCurrent != 0);
   }
   qpsw.WriteLine(strout);
   qpsw.Flush();

   return qpsw.ToString();
 	}
 	finally
 	{
   qpsw.Close();
   qpsw = null;
 	}
 }

 static string HexDecoderEvaluator(Match m)
 {
 	string hex = m.Groups[2].Value;
 	int iHex = Convert.ToInt32(hex, 16);
 	char c = (char) iHex;
 	return c.ToString();
 }

 static string HexDecoder(string line)
 {
 	if (line == null)
   throw new ArgumentNullException();

 	//parse looking for =XX where XX is hexadecimal
 	Regex re = new Regex(
   "(\\=([0-9A-F][0-9A-F]))", 
   RegexOptions.IgnoreCase
 	);
 	return re.Replace(line, new MatchEvaluator(HexDecoderEvaluator));
 }

 /// <summary>
 /// decodes an entire file's contents into plain text that 
 /// was encoded with quoted-printable.
 /// </summary>
 /// <param name="filepath">
 /// The path to the quoted-printable encoded file to decode.
 /// </param>
 /// <returns>The decoded string.</returns>
 /// <exception cref="ObjectDisposedException">
 /// A problem occurred while attempting to decode the 
 /// encoded string.
 /// </exception>
 /// <exception cref="OutOfMemoryException">
 /// There is insufficient memory to allocate a buffer for the
 /// returned string. 
 /// </exception>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <exception cref="IOException">
 /// An I/O error occurs, such as the stream being closed.
 /// </exception>  
 /// <exception cref="FileNotFoundException">
 /// The file was not found.
 /// </exception>
 /// <exception cref="SecurityException">
 /// The caller does not have the required permission to open
 /// the file specified in filepath.
 /// </exception>
 /// <exception cref="UnauthorizedAccessException">
 /// filepath is read-only or a directory.
 /// </exception>
 /// <remarks>
 /// Decodes a quoted-printable encoded file into a string
 /// of unencoded text of any size.
 /// </remarks>
 public static string DecodeFile(string filepath)
 {
 	if (filepath == null)
   throw new ArgumentNullException();

 	string decodedHtml = "", line;
 	FileInfo f = new FileInfo(filepath);

 	if (! f.Exists)
   throw new FileNotFoundException();

 	StreamReader sr = f.OpenText();
 	try
 	{
   while((line=sr.ReadLine())!=null)
   	decodedHtml += Decode(line);

   return decodedHtml;
 	}
 	finally
 	{
   sr.Close();
   sr = null;
   f = null;
 	}
 }

 /// <summary>
 /// Decodes a Quoted-Printable string of any size into 
 /// it's original text.
 /// </summary>
 /// <param name="encoded">
 /// The encoded string to decode.
 /// </param>
 /// <returns>The decoded string.</returns>
 /// <exception cref="ArgumentNullException">
 /// A string is passed in as a null reference.
 /// </exception>
 /// <remarks>
 /// Decodes a quoted-printable encoded string into a string
 /// of unencoded text of any size.
 /// </remarks>
 public static string Decode(string encoded)
 {
 	if (encoded == null)
   throw new ArgumentNullException();

 	string line;
 	StringWriter sw = new StringWriter();
 	StringReader sr = new StringReader(encoded);
 	try
 	{
   while((line=sr.ReadLine())!=null)
   {
   	if (line.EndsWith("="))
     sw.Write(HexDecoder(line.Substring(0, line.Length-1)));
   	else
     sw.WriteLine(HexDecoder(line));

   	sw.Flush();
   }
   return sw.ToString();
 	}
 	finally
 	{
   sw.Close();
   sr.Close();
   sw = null;
   sr = null;
 	}
 }
}
}

Moskus · 7. mars 2007

Tydelig noe feil med tegnsettingen der, da alle "oversettere feilet", men jeg prøver allikevel! Takker og bukker!

Logg inn

Unicode til Quoted-Printable

Anbefalte innlegg

Moskus

Lenke til kommentar

Videoannonse

Moskus

Lenke til kommentar

Manfred

Lenke til kommentar

Moskus

Lenke til kommentar

wolf5

Lenke til kommentar

Moskus

Lenke til kommentar

wolf5

Lenke til kommentar

Moskus

Lenke til kommentar

Opprett en konto eller logg inn for å kommentere

Opprett konto

Logg inn

Hvem er aktive 0 medlemmer