如何将offcie 2003文档（.doc、.xls、.ppt）转换成mht文档

using System;
using System.Collections;
using System.IO;
using System.Text;
using Microsoft.HtmlTrans;

namespace MSOfficeHelper
{
    public class Conversion
    {
        //字符串的编码
        protected static Encoding encoding = Encoding.Default;
        //用于创建IHtmlTrLoadBalancer的remoting对象的url

        protected static string strServiceUrl = System.Configuration.ConfigurationSettings.AppSettings["OfficeHtmlViewService"];

        public static void ConvertMHT(string inputfile, string outputfile)
        {
            //通过url(strServiceUrl)获取一个IHtmlTrLoadBalancer的remoting对象
            IHtmlTrLoadBalancer htmlTrLoadBalancer =
                (IHtmlTrLoadBalancer) System.Activator.GetObject(
                    typeof (IHtmlTrLoadBalancer), strServiceUrl);
            //用输入文件名(inputfile)作为一个任务的任务标示(strTask)
            string strTask = inputfile;

            //根据任务标示(strTask)新建一个任务并获取任务的url(strLauncherUri)
            string strLauncherUri = htmlTrLoadBalancer.StrGetLauncher(strTask);

            //通过任务的url(strLauncherUri)获取一个IHtmlTrLauncher的remoting对象(htmlTrLauncher),
            //并用这个对象来执行该任务
            IHtmlTrLauncher htmlTrLauncher =
                (IHtmlTrLauncher) System.Activator.GetObject(typeof (IHtmlTrLauncher), strLauncherUri);

            //接下来是把输入文件(inputfile)的内容读入一个byte数组(bFile)
            byte[] bFile = null;
            FileStream fsInputMht = null;
            BinaryReader bwInputMht = null;
            try
            {
                fsInputMht = new FileStream(inputfile, FileMode.Open);
                bwInputMht = new BinaryReader(fsInputMht, encoding);
                bFile = new byte[fsInputMht.Length];
                for (long i = 0; i < bFile.LongLength; i++)
                    bFile[i] = bwInputMht.ReadByte();
                bwInputMht.Close();
                fsInputMht.Close();

            }
            catch (Exception ex)
            {
                bwInputMht.Close();
                fsInputMht.Close();
                throw ex;
            }

            //CHICreateHtml通过office文档创建HTML文件及其附件
            //CHICreateHtml(
            //string strLauncherUri,　　　　　　　　 任务的url
            //byte[] rgbFile,　　　　　　　　　　　　 office文档的二进制内容
            //Microsoft.HtmlTrans.BrowserType bt, 使用浏览类型,该参数是一个枚举类型
            //string strReqFile,　　　　　　　　　　 office文档的路径/url
            //string strTaskName,　　　　　　　　　　 任务标示名,HTML转换服务器根据其跟踪该请求
            //int timeout,　　　　　　　　　　　　　　　　 转换超时时间，如果网络状况较差,建议值设大点
            //bool fReturnFileBits　　　　　　　　　 是否返回二进制内容,分别保存在CreateHtmlInfo的rgbMainFile属性和rgrgbThicketFiles属性中
            //);
            CreateHtmlInfo chi = htmlTrLauncher.CHICreateHtml(strLauncherUri, bFile,
                                                              BrowserType.BT_IE4, inputfile, strTask, 200, true);

            //结束转换任务
            htmlTrLoadBalancer.LauncherTaskCompleted(strLauncherUri, strTask);

            //在转换HTML文件的过程中没有错误,并且存在主文件,执行以下代码
            if (chi.ce == CreationErrorType.CE_NONE && chi.fHasMainFile)
            {
                FileStream fsOutputMht = null;
                BinaryWriter bwOutputMht = null;
                try
                {
                    fsOutputMht = new FileStream(outputfile, FileMode.Create);
                    bwOutputMht = new BinaryWriter(fsOutputMht, encoding);
                    //将HTML文件及其附件转换为MHTML文件
                    byte[] bMHTMLBody = CreateMHTMLBody(chi);
                    string temp = System.Text.Encoding.Default.GetString(bMHTMLBody);

                    StringBuilder sb = new StringBuilder();

                    foreach (char c in temp.ToCharArray())
                    {
                        string t = c.ToString();
                        if ((uint) c > 500)
                        {
                            t = "&#" + ((uint) c).ToString() + ";";
                        }

                        sb.Append(t);
                    }

                    bMHTMLBody = Encoding.ASCII.GetBytes(sb.ToString());

                    bwOutputMht.Write(bMHTMLBody);
                    bwOutputMht.Close();
                    fsOutputMht.Close();
                    return;
                }
                catch (Exception ex)
                {
                    bwOutputMht.Close();
                    fsOutputMht.Close();
                    throw ex;
                }
            }
            return;
        }

        //MHTML文件头信息
        protected static string MIME =
            "MIME-Version: 1.0" + Environment.NewLine +
                "Content-Type: multipart/related; boundary=\"{0}\"" + Environment.NewLine +
                Environment.NewLine;

        //MHTML各个文件的头信息
        protected static string HEADER =
            Environment.NewLine + "--{0}" + Environment.NewLine +
                "Content-Location: {1}" + Environment.NewLine +
                "Content-Transfer-Encoding: {2}" + Environment.NewLine +
                "Content-Type: {3}" + Environment.NewLine +
                Environment.NewLine;

        //定义MHTML中各文件之间的分隔符
        protected static string BOUNDARY = "Define_It_Youself";
        //MHTML主文件的URL
        protected static string LOCATION = string.Format(@"file:///c:/{0}/",Guid.NewGuid());

        private static byte[] CreateMHTMLBody(CreateHtmlInfo creatHtmlInfo)
        {
            //将回车换行符进行编码并存储在字节数组中
            byte[] bNewLine = Encoding.UTF8.GetBytes(Environment.NewLine);
            //将3D进行编码并存储在字节数组中
            byte[] bAfterEquals = encoding.GetBytes("3D");
            //'='的byte值为61
            byte bEquals = 61;
            //MHTML文件的长度
            long lMHTMLBodyLength = 0;
            //从零开始的字节偏移量
            long lOffset = 0;
            //根据BOUNDARY的定义形成MTHML文件的头信息
            string strMIME = string.Format(MIME, BOUNDARY);
            //将头信息进行编码并存储在字节数组中
            byte[] bMIME = encoding.GetBytes(strMIME);
            //MHTML文件的长度增加bMIME.LongLength
            lMHTMLBodyLength += bMIME.LongLength;

            //根据信息定义主文件的头信息
            string strMainHeader = string.Format(HEADER,
                                                 BOUNDARY,
                                                 LOCATION + creatHtmlInfo.strMainFileName,
                                                 TransferEncoding.QUOTED_PRINTABLE,
                                                 ContentType.TEXT_HTML);

            byte[] bMainHeader = encoding.GetBytes(strMainHeader);
            lMHTMLBodyLength += bMainHeader.LongLength;

            //建立一个动态临时数组
            ArrayList alTempArray = new ArrayList();

            //主文件的正文部分所有的"="替换成"=3D"
            for (int i = 0; i < creatHtmlInfo.rgbMainFile.Length; i ++)
            {
                alTempArray.Add(creatHtmlInfo.rgbMainFile[i]);
                if (creatHtmlInfo.rgbMainFile[i] == bEquals)
                {
                    alTempArray.Add(bAfterEquals[0]);
                    alTempArray.Add(bAfterEquals[1]);
                }
            }
            //获取新的主文件的正文部分并存储在字节数组中
            byte[] bMainBody = new byte[alTempArray.Count];
            alTempArray.CopyTo(bMainBody);
            lMHTMLBodyLength += bMainBody.LongLength;
            alTempArray.Clear();

            //申明存储MHTML附件的正文内容字节数组,该数组为一个二维数组
            byte[][] bThicketContent = null;
            //申明存储MHTML附件的头信息字节数组
            string[] strThicketHeaders = null;
            //如果MHTML存在附件则执行以下代码
            if (creatHtmlInfo.fHasThicket)
            {
                bThicketContent = new byte[creatHtmlInfo.rgrgbThicketFiles.Length][];
                strThicketHeaders = new string[creatHtmlInfo.rgrgbThicketFiles.Length];
                for (int i = 0; i < strThicketHeaders.Length; i++)
                {
                    //定义附件的头信息
                    string strLocation = LOCATION +
                        creatHtmlInfo.strThicketFolderName + "/" +
                        creatHtmlInfo.rgstrThicketFileNames[i];
                    string strTransferEncoding = TransferEncoding.GetTransferEncodingByFileName
                        (creatHtmlInfo.rgstrThicketFileNames[i]);
                    string strContentType = ContentType.GetContentTypeByFileName
                        (creatHtmlInfo.rgstrThicketFileNames[i]);
                    strThicketHeaders[i] = string.Format(HEADER,
                                                         BOUNDARY,
                                                         strLocation,
                                                         strTransferEncoding,
                                                         strContentType);
                    byte[] bThicketHeader = encoding.GetBytes(strThicketHeaders[i]);

                    StringBuilder strBase64ThicketBody = new StringBuilder();
                    byte[] bThicketBody = null;
                    //如果附件二进制文件,那么用BASE64编码
                    if (strTransferEncoding ==
                        TransferEncoding.BASE64)
                    {
                        //首先将字节数组里的内容转换为Base64编码的字符串
                        strBase64ThicketBody.Append(
                            Convert.ToBase64String(creatHtmlInfo.rgrgbThicketFiles[i]));
                        //然后将字符串进行编码存储在新的字节数组中
                        bThicketBody = encoding.GetBytes(strBase64ThicketBody.ToString());
                        //每76个字节,加入一个换行符
                        int BUFFER_SIZE = 76;
                        for (int j = 0; j < bThicketBody.Length; j++)
                        {
                            alTempArray.Add(bThicketBody[j]);
                            if (j%BUFFER_SIZE == BUFFER_SIZE - 1)
                            {
                                alTempArray.Add(bNewLine[0]);
                                alTempArray.Add(bNewLine[1]);
                            }
                        }
                        bThicketBody = new byte[alTempArray.Count];
                        alTempArray.CopyTo(bThicketBody);
                        alTempArray.Clear();
                    }
                        //如果附件是以明文编码,那么明文编码,并将附件正文部分所有的"="替换成"=3D"
                    else
                    {
                        for (int j = 0; j < creatHtmlInfo.rgrgbThicketFiles[i].Length; j++)
                        {
                            alTempArray.Add(creatHtmlInfo.rgrgbThicketFiles[i][j]);
                            if (creatHtmlInfo.rgrgbThicketFiles[i][j] == bEquals)
                            {
                                alTempArray.Add(bAfterEquals[0]);
                                alTempArray.Add(bAfterEquals[1]);
                            }
                        }
                        bThicketBody = new byte[alTempArray.Count];
                        alTempArray.CopyTo(bThicketBody);
                        alTempArray.Clear();
                    }


                    //如中htm文件则进行添加base操作
                    string ext = Path.GetExtension(creatHtmlInfo.rgstrThicketFileNames[i]).ToLower();
                    if (ext == ".htm")
                    {
                        string body = Encoding.Default.GetString(bThicketBody);

                        int start = body.IndexOf("<link");

                        if (start > -1)
                        {
                            body =
                                body.Insert(
                                    start,
                                    string.Format(
                                        "\r\n<![if IE]>\r\n"
                                            + "<base href=3D\"{0}\"\r\n"
                                            + "id=3D\"webarch_temp_base_tag\">\r\n"
                                            + "<![endif]>\r\n",
                                        LOCATION + creatHtmlInfo.strThicketFolderName + @"/" + creatHtmlInfo.rgstrThicketFileNames[i]
                                        )
                                    );
                        }

                        byte[] data = Encoding.Default.GetBytes(body);
                        bThicketBody = new byte[data.Length];

                        data.CopyTo(bThicketBody, 0);
                    }
                    //将附件中的头信息字节数组和正文的字节数组合并存储在bThicketContent[i]中,
                    //并在lMHTMLBodyLength增加相应的长度
                    bThicketContent[i] = new byte[bThicketHeader.LongLength + bThicketBody.LongLength + bNewLine.LongLength];
                    Array.Copy(
                        bThicketHeader,
                        0,
                        bThicketContent[i],
                        0,
                        bThicketHeader.LongLength);
                    Array.Copy(
                        bThicketBody,
                        0,
                        bThicketContent[i],
                        bThicketHeader.LongLength,
                        bThicketBody.LongLength);
                    Array.Copy(
                        bNewLine,
                        0,
                        bThicketContent[i],
                        bThicketHeader.LongLength + bThicketBody.LongLength,
                        bNewLine.LongLength);
                    lMHTMLBodyLength += bThicketContent[i].LongLength;
                }
            }
            //MHTML文件结束分割符的存储在字节数组中
            byte[] bEndBoundary = encoding.GetBytes(
                Environment.NewLine + "--" + BOUNDARY + "--" + Environment.NewLine);
            lMHTMLBodyLength += bEndBoundary.LongLength;

            //新建一个数组,该数组用于存储MHTML文件的所有内容
            byte[] bMHTMLBody = new byte[lMHTMLBodyLength];
            //将所有的内容全部合并,并存储在数组bMHTMLBody中
            Array.Copy(bMIME, 0, bMHTMLBody, lOffset, bMIME.LongLength);
            lOffset += bMIME.LongLength;
            Array.Copy(bMainHeader, 0, bMHTMLBody, lOffset, bMainHeader.LongLength);
            lOffset += bMainHeader.LongLength;
            Array.Copy(bMainBody, 0, bMHTMLBody, lOffset, bMainBody.LongLength);
            lOffset += bMainBody.LongLength;
            if (bThicketContent != null)
                for (int i = 0; i < bThicketContent.Length; i++)
                {
                    Array.Copy(
                        bThicketContent[i],
                        0,
                        bMHTMLBody,
                        lOffset,
                        bThicketContent[i].LongLength);
                    lOffset += bThicketContent[i].LongLength;
                }
            Array.Copy(bEndBoundary, 0, bMHTMLBody, lOffset, bEndBoundary.LongLength);

            return bMHTMLBody;
        }
    }

    //根据不同的文件后缀名定义编码方式
    class TransferEncoding
    {
        public const string QUOTED_PRINTABLE = "quoted-printable";
        public const string BASE64 = "base64";

        public static string GetTransferEncodingByFileName(string fileName)
        {
            string strRusult = string.Empty;
            string strExtension = fileName.Remove(0, fileName.LastIndexOf(".")).ToUpper();
            switch (strExtension)
            {
                    //以下文件名在MTHML文件中都将以明文的形式编码
                default:
                case ".HTM":
                case ".HTML":
                case ".XML":
                    strRusult = TransferEncoding.QUOTED_PRINTABLE;
                    break;
                    //以下文件名在MHTML文件中都将以BASE64编码形式出现
                case ".JPG":
                case ".JEPG":
                case ".PNG":
                case ".MSO":
                case ".EMZ":
                case ".GIF":
                case ".WMF":
                case ".WMZ":
                case ".CSS":
                    strRusult = TransferEncoding.BASE64;
                    break;
            }
            return strRusult;
        }
    }

    //根据不同的后缀名定义文件内容的类型
    class ContentType
    {
        public const string TEXT_HTML = "text/html; charset=\"us-ascii\"";
        public const string APPLICATION_XMSO = "application/x-mso";
        public const string IMAGE_XEMZ = "image/x-emz";
        public const string IMAGE_GIF = "image/gif";
        public const string TEXT_CSS = "text/css";
        public const string TEXT_XML = "text/xml; charset=\"utf-8\"";
        public const string IMAGE_XWMF = "image/x-wmf";
        public const string IMAGE_PNG = "image/png";
        public const string IMAGE_JPEG = "image/jpeg";
        public const string TEXT_JS = "application/javascript; charset=\"us-ascii\"";
        public const string IMAGE_WMZ = "image/x-wmz";


        public static string GetContentTypeByFileName(string fileName)
        {
            string strExtension = fileName.Remove(0, fileName.LastIndexOf(".")).ToUpper();
            switch (strExtension)
            {
                    //以下文件名在MHTML文件中的类型是text/html; charset="us-ascii"
                case ".HTM":
                case ".HTML":
                    return ContentType.TEXT_HTML;
                    //以下文件名在MHTML文件中的类型是application/x-mso
                case ".MSO":
                    return ContentType.APPLICATION_XMSO;
                    //以下文件名在MHTML文件中的类型是image/x-emz
                case ".EMZ":
                    return ContentType.IMAGE_XEMZ;
                    //以下文件名在MHTML文件中的类型是image/gif
                case ".GIF":
                    return ContentType.IMAGE_GIF;
                    //以下文件名在MHTML文件中的类型是text/css
                case ".CSS":
                    return ContentType.TEXT_CSS;
                    //以下文件名在MHTML文件中的类型是text/xml; charset="utf-8"
                case ".XML":
                    return ContentType.TEXT_XML;
                    //以下文件名在MHTML文件中的类型是image/x-wmf
                case ".WMF":
                    return ContentType.IMAGE_XWMF;
                    //以下文件名在MHTML文件中的类型是image/png
                case ".PNG":
                    return ContentType.IMAGE_PNG;
                    //以下文件名在MHTML文件中的类型是image/jpeg
                case ".JPG":
                case ".JEPG":
                    return ContentType.IMAGE_JPEG;

                case ".JS":
                    return ContentType.TEXT_JS;

                case ".WMZ":
                    return ContentType.IMAGE_WMZ;
            }
            return string.Empty;
        }
    }

}