Dotnet操作Word与Excel

最近写温泉街道门店管理系统，用到了Word和Excel操作，查了些资料并做了些修改，把两个类的代码放上：

 

using System;
using System.ComponentModel;
using System.Data;
using System.Windows.Forms;
using Word = Microsoft.Office.Interop.Word;

namespace StreetControlSystem.Office
{
    public class WordAdapt
    {
        private Word.ApplicationClass oWordApplic;
        private Word.Document oDoc;
        private const string strFileName = @"F:\";
        private const string PostfixForWord = @".doc";
        private const string PostfixForHtml = @".Html";

        #region 构造函数
        public WordAdapt()
        {
            oWordApplic = new Word.ApplicationClass();
        }
        #endregion

        public Word.Document Document
        {
            get
            {
                return this.oDoc;
            }
        }

        public Word.ApplicationClass Application
        {
            get
            {
                return this.oWordApplic;
            }
        }

        #region 私有方法

        /**/
        /// <summary>
        /// 设置Word文档是否可视
        /// </summary>
        /// <param name="InEnabled">boolean</param>
        private void SetVisible(Boolean InEnabled)
        {
            oWordApplic.Visible = InEnabled;
        }

        /**/
        /// <summary>
        /// 在垃圾回收时，在任务管理器中还存在当前操作的WORD的进程
        /// 查阅资料，必须在另一个方法中在调用GC才可以真正的清楚掉，当前的进程
        /// </summary>
        private void GCForQuit()
        {
            object missing = System.Reflection.Missing.Value;
            oWordApplic.Application.Quit(ref missing, ref missing, ref missing);
            if (oDoc != null)
            {
                System.Runtime.InteropServices.Marshal.ReleaseComObject(oDoc);
                oDoc = null;
            }
            if (oWordApplic != null)
            {
                System.Runtime.InteropServices.Marshal.ReleaseComObject(oWordApplic);
                oWordApplic = null;
            }
            GC.Collect();
        }
        /**/
        /// <summary>
        /// 返回保存文件的FileName
        /// </summary>
        /// <param name="strDefaultExt">要保存文件的类型</param>
        /// <param name="strFilter">文件名筛选器字符串</param>
        /// <returns>保存的路径</returns>
        private string SaveFileName(string strDefaultExt, string strFilter)
        {
            string fileName = "";
            System.Windows.Forms.SaveFileDialog saveFileDlg = new System.Windows.Forms.SaveFileDialog();
            saveFileDlg.DefaultExt = strDefaultExt;
            saveFileDlg.Filter = strFilter;
            if (saveFileDlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                fileName = saveFileDlg.FileName;
            return fileName;
        }

        /**/
        /// <summary>
        /// 将被 SaveFileName 取代
        /// </summary>
        /// <returns></returns>
        private string SaveFileToHtmlForName()
        {
            string fileName = "";
            System.Windows.Forms.SaveFileDialog saveFileDlg = new System.Windows.Forms.SaveFileDialog();
            saveFileDlg.DefaultExt = "Html";
            saveFileDlg.Filter = "html文件 (*.html)|*.htm";
            if (saveFileDlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                fileName = saveFileDlg.FileName;
            return fileName;
        }

        /**/
        /// <summary>
        /// 保存
        /// </summary>
        private void Save()
        {
            oDoc.Save();
        }

        #endregion

        #region 公有方法

        /**/
        /// <summary>
        /// 打开一个空的Word模板
        /// </summary>
        public bool Open()
        {
            bool result = false;
            try
            {
                object missing = System.Reflection.Missing.Value;
                oDoc = oWordApplic.Documents.Add(ref missing, ref missing, ref missing, ref missing);
                oDoc.Activate();
                result = true;
            }
            catch
            {
                this.Quit();
                //throw ( new Exception() );
            }
            return result;
        }

        /**/
        /// <summary>
        /// 退出
        /// </summary>
        public void Quit()
        {
            GCForQuit();
            GC.Collect();
            foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcesses())
            {
                if (p.ProcessName.ToUpper() == "WINWORD")
                {
                    p.Kill();
                }
            }
        }

        /**/
        /// <summary>
        /// 打开指定的Word文档
        /// </summary>
        /// <param name="strFileName">指定的Word文档</param>
        public bool Open(string strFileName)
        {
            return this.Open(strFileName, true);
        }

        /**/
        /// <summary>
        /// 打开指定的Word文档并判断是否显示
        /// </summary>
        /// <param name="strFileName">指定的Word文档</param>
        /// <param name="isEnabled">显示与否</param>
        public bool Open(string strFileName, bool isEnabled)
        {
            bool result = false;
            if (strFileName == null || strFileName == "") return result;
            try
            {
                object fileName = strFileName;
                object readOnly = false;
                object isVisible = true;
                object missing = System.Reflection.Missing.Value;
                oDoc = oWordApplic.Documents.Open(ref fileName, ref missing, ref readOnly,
                                        ref missing, ref missing, ref missing, ref missing, ref missing, ref missing,
                                        ref missing, ref missing, ref isVisible, ref missing, ref missing, ref missing, ref missing);
                oDoc.Activate();
                oWordApplic.Visible = isEnabled;
                result = true;
            }
            catch
            {
                this.Quit();
                //throw ( new Exception() );
            }
            return result;
        }

        /**/
        /// <summary>
        /// 另存
        /// </summary>
        public bool SaveAs()
        {
            object missing = System.Reflection.Missing.Value;
            object fileName = SaveFileName("doc", "doc文件 (*.doc)|*.doc");
            return this.SaveAs(Convert.ToString(fileName));
        }

        /**/
        /// <summary>
        /// 另存
        /// </summary>
        /// <param name="strFileName"></param>
        public bool SaveAs(string strFileName)
        {
            bool result = false;
            if (strFileName == null || strFileName == "") return result;
            try
            {
                object missing = System.Reflection.Missing.Value;
                object fileName = strFileName;
                oDoc.SaveAs(ref fileName, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing,
                            ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);
                result = true;
            }
            catch
            {
                //throw( new Exception() );
            }
            finally
            {
                this.Quit();
            }
            return result;
        }


        /**/
        /// <summary>
        /// 把Word文档装化为Html文件
        /// </summary>
        /// <param name="strFileName">要转换的Word文档</param>
        public bool WordToHtml(string strFileNameForWord)
        {
            string saveFileName = strFileName + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss") + PostfixForHtml;
            return this.WordToHtml(strFileNameForWord, saveFileName);
        }

        /**/
        /// <summary>
        /// 把Word文档装化为Html文件
        /// </summary>
        /// <param name="strFileName">要转换的Word文档</param>
        /// <param name="strSaveFileName">要生成的具体的Html页面</param>
        public bool WordToHtml(string strFileNameForWord, string strSaveFileName)
        {
            bool result = false;
            if (strFileNameForWord == null || strFileNameForWord == "") return result;
            if (this.Open(strFileNameForWord, false))
            {
                try
                {
                    Type wordType = oWordApplic.GetType();
                    // 打开文件
                    Type docsType = oWordApplic.Documents.GetType();
                    // 转换格式，另存为
                    Type docType = oDoc.GetType();
                    object saveFileName = strSaveFileName;
                    docType.InvokeMember("SaveAs", System.Reflection.BindingFlags.InvokeMethod, null, oDoc, new object[] { saveFileName, Word.WdSaveFormat.wdFormatHTML });
                    #region 其它格式：
                    /**/
                    ///wdFormatHTML
                    ///wdFormatDocument
                    ///wdFormatDOSText
                    ///wdFormatDOSTextLineBreaks
                    ///wdFormatEncodedText
                    ///wdFormatRTF
                    ///wdFormatTemplate
                    ///wdFormatText
                    ///wdFormatTextLineBreaks
                    ///wdFormatUnicodeText
                    //-----------------------------------------------------------------------------------
                    //            docType.InvokeMember( "SaveAs", System.Reflection.BindingFlags.InvokeMethod,
                    //                null, oDoc, new object[]{saveFileName, Word.WdSaveFormat.wdFormatHTML} );
                    // 退出 Word
                    //wordType.InvokeMember( "Quit", System.Reflection.BindingFlags.InvokeMethod,
                    //    null, oWordApplic, null );
                    #endregion
                    result = true;
                }
                catch
                {
                    //throw ( new Exception() );
                }
                finally
                {
                    this.Quit();
                }
            }
            return result;
        }

        /**/
        /// <summary>
        /// 插入文本操作,所有的打开与保存操作在外部执行
        /// </summary>
        /// <param name="strText"></param>
        public void InsertText(string strText)
        {
            oWordApplic.Selection.TypeText(strText);
        }

        public void InsertText(string strText, int iNum)
        {
            for (int i = 0; i < iNum; i++)
                this.InsertText(strText);
        }
        /**/
        /// <summary>
        /// 插入文本操作
        /// </summary>
        /// <param name="strText">要保存的字符串</param>
        public bool InsertTextBySelection(string strText)
        {
            string strsavefilename = strFileName + DateTime.Now.ToString("yyyyMMddHHmmss") + PostfixForWord;
            return this.InsertTextBySelection(strText, strsavefilename);
        }

        /**/
        /// <summary>
        /// 
        /// </summary>
        /// <param name="strText">要保存的字符串</param>
        /// <param name="strSaveFileName">保存后的doc文件名</param>
        public bool InsertTextBySelection(string strText, string strSaveFileName)
        {
            return this.InsertTextBySelection(strText, strSaveFileName, 20, 20, 0, 0, "华文仿宋");
        }

        /**/
        /// <summary>
        /// 
        /// </summary>
        /// <param name="strText">要保存的字符串</param>
        /// <param name="strSaveFileName">保存后的doc文件名</param>
        /// <param name="leftindent">首行缩近多少</=param>
        /// <param name="size">字体大小</param>
        /// <param name="boldbi">是否粗体;1 yes, 0 no</param>
        /// <param name="paragraphalignment">对齐方式</param>
        public bool InsertTextBySelection(string strText, string strSaveFileName, float firstlineindent, int size, int boldbi, int paragraphalignment, string fontname)
        {
            bool result = false;
            if (strText == "" || strText == null) return result;
            if (this.Open())
            {
                try
                {
                    string[] strvalue = strText.Split('$');
                    if (strvalue.Length != 0)
                    {
                        oWordApplic.Selection.TypeText("今天是：" + DateTime.Now.ToString("yyyy-MM-dd"));
                        Word.Paragraph para = this.GoToFirstParagraph();
                        para.Range.Select();
                        this.SetFontName(fontname);
                        this.SetFirstLineIndent(firstlineindent);
                        this.SetFontSize(20);
                        this.setBoldBi(boldbi);
                        switch (paragraphalignment)
                        {
                            case 0:
                                this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphLeft);
                                break;
                            case 1:
                                this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphCenter);
                                break;
                            case 2:
                                this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphRight);
                                break;
                        }
                        int j = 0;
                        for (int i = 0; i < strvalue.Length; i++)
                        {

                            this.InsertParagraphAfterByParagraph(para, 1);    //加1个空行
                            para = this.GoToEndParagraph();                 //定位到第1空行
                            this.InsertTextBeforeByParagraph(para, strvalue[i]);
                            para = this.GoToEndParagraph();
                            para.Range.Select();
                            this.setBoldBi(boldbi);                        //设置标题非粗体字
                            this.SetFontSize(size);                        //设置字体大小
                            this.SetFontName(fontname);                    //设置字体
                            j++;
                            if (j == 9)
                            {
                                this.InsertText("━━━━", 6);
                                j = 0;
                            }

                        }
                        if (this.SaveAs(strSaveFileName))
                            result = true;
                    }
                }
                catch
                {
                    this.Quit();
                    //throw( new Exception() );
                }
            }
            return result;
        }

        /**/
        /// <summary>
        /// 插入空行
        /// </summary>
        public void InsertLineBreakBySelection()
        {
            oWordApplic.Selection.TypeParagraph();
        }

        /**/
        /// <summary>
        /// 插入指定的空行
        /// </summary>
        /// <param name="nline">行数</param>
        public void InsertLineBreakBySelection(int nline)
        {
            for (int i = 0; i < nline; i++)
                this.InsertLineBreakBySelection();
        }

        /**/
        /// <summary>
        /// 换页
        /// </summary>
        public void InsertPagebreak()
        {
            object pBreak = (int)Word.WdBreakType.wdPageBreak;
            oWordApplic.Selection.InsertBreak(ref pBreak);
        }

        public void InsertTextBeforeByParagraph(Word.Paragraph paragraph, string strText)
        {
            paragraph.Range.InsertBefore(strText);
        }

        public void InsertTextAfterByParagraph(Word.Paragraph paragraph, string strText)
        {
            paragraph.Range.InsertAfter(strText);

        }

        public void InsertParagraphBeforeByParagraph(Word.Paragraph paragraph)
        {
            paragraph.Range.InsertParagraphBefore();
        }

        public void InsertParagraphBeforeByParagraph(Word.Paragraph paragraph, int nLine)
        {
            for (int i = 0; i < nLine; i++)
                paragraph.Range.InsertParagraphBefore();
        }

        public void InsertParagraphAfterByParagraph(Word.Paragraph paragraph)
        {
            paragraph.Range.InsertParagraphAfter();
        }

        public void InsertParagraphAfterByParagraph(Word.Paragraph paragraph, int nLine)
        {
            for (int i = 0; i < nLine; i++)
                paragraph.Range.InsertParagraphAfter();
        }

        /**/
        /// <summary>
        /// 数据集转换 即把DataSet转换为Word对象 
        /// </summary>
        /// <param name="ds"></param>
        public bool DataSetToWord(DataSet ds, string strFileName)
        {
            bool result = false;
            if (ds == null) return result;
            if (strFileName == null || strFileName == "") return result;
            if (this.Open())
            {
                try
                {
                    Word.Range para = oWordApplic.Application.Selection.Paragraphs[1].Range;
                    object tableBehavior = System.Reflection.Missing.Value;
                    object autoFitBehavior = System.Reflection.Missing.Value;
                    oDoc.Tables.Add(para,
                        ds.Tables[0].Rows.Count + 1,    //多的一行用来表示表列
                        ds.Tables[0].Columns.Count,
                        ref tableBehavior,
                        ref autoFitBehavior);

                    //填充Word表格的列标
                    for (int intCol = 0; intCol < ds.Tables[0].Columns.Count; intCol++)
                    {
                        oDoc.Tables[1].Cell(1, intCol + 1).Range.InsertBefore(ds.Tables[0].Columns[intCol].ColumnName.Trim());
                    }

                    //填充Word表格的内容
                    for (int intRow = 0; intRow < ds.Tables[0].Rows.Count; intRow++)
                    {
                        for (int intCol = 0; intCol < ds.Tables[0].Columns.Count; intCol++)
                        {
                            oDoc.Tables[1].Cell(intRow + 2, intCol + 1).Range.InsertBefore(ds.Tables[0].Rows[intRow][intCol].ToString().Trim());
                        }
                    }
                    //保存
                    if (this.SaveAs(strFileName))
                        result = true;
                }
                catch
                {
                    this.Quit();
                    //throw ( new Exception() );
                }
            }
            return result;
        }

        /**/
        /// <summary>
        /// 采用默认地址保存
        /// </summary>
        /// <param name="ds"></param>
        public bool DataSetToWord(DataSet ds)
        {
            return this.DataSetToWord(ds, strFileName + ds.Tables[0].TableName.ToString() + PostfixForWord);
        }

 

        /**/
        /// <summary>
        /// 段落的对齐方式
        /// 例如:word.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphCenter)
        /// </summary>
        /// <param name="alignment"></param>
        public void SetAlignment(Word.WdParagraphAlignment alignment)
        {
            oWordApplic.Selection.ParagraphFormat.Alignment = alignment;
        }

        /**/
        /// <summary>
        /// 首行缩进
        /// </summary>
        /// <param name="fltCount">float类型的数值</param>
        public void SetFirstLineIndent(float fltCount)
        {
            oWordApplic.Selection.ParagraphFormat.FirstLineIndent = fltCount;
        }

        /**/
        /// <summary>
        /// 左缩进
        /// </summary>
        /// <param name="fltCount">float类型的数值</param>
        public void SetLeftIndent(float fltCount)
        {
            oWordApplic.Selection.ParagraphFormat.LeftIndent = fltCount;
        }

        /**/
        /// <summary>
        /// 右缩进
        /// </summary>
        /// <param name="fltCount">float类型的数值</param>
        public void SetRightIndent(float fltCount)
        {
            oWordApplic.Selection.ParagraphFormat.RightIndent = fltCount;
        }

        /**/
        /// <summary>
        /// 设置字体类型
        /// </summary>
        /// <param name="strType"></param>
        public void SetFont(string strType)
        {
            switch (strType)
            {
                case "Bold":
                    oWordApplic.Selection.Font.Bold = 1;
                    break;
                case "Italic":
                    oWordApplic.Selection.Font.Italic = 1;
                    break;
                case "Underlined":
                    oWordApplic.Selection.Font.Subscript = 0;
                    break;
            }

        }

        /**/
        /// <summary>
        /// 设置默认字体
        /// </summary>
        public void SetFont()
        {
            oWordApplic.Selection.Font.Bold = 0;
            oWordApplic.Selection.Font.Italic = 0;
            oWordApplic.Selection.Font.Subscript = 0;

        }

        /**/
        /// <summary>
        /// 设置字体名称
        /// </summary>
        /// <param name="strType"></param>
        public void SetFontName(string strType)
        {
            oWordApplic.Selection.Font.Name = strType;

        }

        /**/
        /// <summary>
        /// 设置字体颜色
        /// </summary>
        /// <param name="Color"></param>
        public void SetFontColor(Word.WdColor Color)
        {
            oWordApplic.Selection.Font.Color = Color;
        }

        /**/
        /// <summary>
        /// 设置字体大小
        /// </summary>
        /// <param name="nSize"></param>
        public void SetFontSize(int nSize)
        {
            oWordApplic.Selection.Font.Size = nSize;

        }

        /**/
        /// <summary>
        /// 设置是否有粗体，0->否 ,1->是
        /// </summary>
        /// <param name="intBoldBi"></param>
        public void setBoldBi(int intBoldBi)
        {
            oWordApplic.Selection.Font.BoldBi = intBoldBi;
            //oWordApplic.Selection.Font.Bold = intBoldBi;
        }

        public void SetBoldSize(int intBold)
        {
            oWordApplic.Selection.Font.Bold = intBold;
        }

        public void SetUnderLine(Word.WdUnderline underLine)
        {
            oWordApplic.Selection.Font.Underline = underLine;
        }

        public void SetUnderLineColor(Word.WdColor Color)
        {
            oWordApplic.Selection.Font.UnderlineColor = Color;
        }


        /**/
        /// <summary>
        /// 定位到书签
        /// </summary>
        /// <param name="strBookMarkName"></param>
        public void GotoBookMark(string strBookMarkName)
        {
            object missing = System.Reflection.Missing.Value;
            object Bookmark = (int)Word.WdGoToItem.wdGoToBookmark;
            object NameBookMark = strBookMarkName;
            oWordApplic.Selection.GoTo(ref Bookmark, ref missing, ref missing, ref NameBookMark);
        }

        /**/
        /// <summary>
        /// 定位到文档开头
        /// </summary>
        public void GoToTheBeginning()
        {
            object missing = System.Reflection.Missing.Value;
            object unit;
            unit = Word.WdUnits.wdStory;
            oWordApplic.Selection.HomeKey(ref unit, ref missing);

        }

        /**/
        /// <summary>
        /// 定位到文档结尾
        /// </summary>
        public void GoToTheEnd()
        {
            object missing = System.Reflection.Missing.Value;
            object unit;
            unit = Word.WdUnits.wdStory;
            oWordApplic.Selection.EndKey(ref unit, ref missing);
        }

        /**/
        /// <summary>
        /// 定位到首段
        /// </summary>
        /// <returns></returns>
        public Word.Paragraph GoToFirstParagraph()
        {
            return this.oWordApplic.Selection.Paragraphs.First;
        }

        /**/
        /// <summary>
        /// 定位到尾段
        /// </summary>
        /// <returns></returns>
        public Word.Paragraph GoToEndParagraph()
        {
            return this.oWordApplic.Selection.Paragraphs.Last;
        }

        /**/
        /// <summary>
        /// 向后定位到指定段落
        /// </summary>
        /// <param name="para"></param>
        /// <param name="count"></param>
        public void GoToNextParagraph(ref Word.Paragraph para, ref object count)
        {
            para.Next(ref count);
        }

        /**/
        /// <summary>
        /// 向前定位到指定段落
        /// </summary>
        /// <param name="para"></param>
        /// <param name="count"></param>
        public void GoToPreviousParagraph(ref Word.Paragraph para, ref object count)
        {
            para.Previous(ref count);
        }

        public void GoToTheTable(int ntable)
        {
            object missing = System.Reflection.Missing.Value;
            object what;
            what = Word.WdUnits.wdTable;
            object which;
            which = Word.WdGoToDirection.wdGoToFirst;
            object count;
            count = 1;
            oWordApplic.Selection.GoTo(ref what, ref which, ref count, ref missing);
        }

        public void GoToRightCell()
        {
            object missing = System.Reflection.Missing.Value;
            object direction;
            direction = Word.WdUnits.wdCell;
            oWordApplic.Selection.MoveRight(ref direction, ref missing, ref missing);
        }

        public void GoToLeftCell()
        {
            object missing = System.Reflection.Missing.Value;
            object direction;
            direction = Word.WdUnits.wdCell;
            oWordApplic.Selection.MoveLeft(ref direction, ref missing, ref missing);
        }

        public void GoToDownCell()
        {
            object missing = System.Reflection.Missing.Value;
            object direction;
            direction = Word.WdUnits.wdLine;
            oWordApplic.Selection.MoveDown(ref direction, ref missing, ref missing);
        }

        public void GoToUpCell()
        {
            object missing = System.Reflection.Missing.Value;
            object direction;
            direction = Word.WdUnits.wdLine;
            oWordApplic.Selection.MoveUp(ref direction, ref missing, ref missing);
        }

        public Boolean ExecuteReplace(Word.Find find)
        {
            return ExecuteReplace(find, Word.WdReplace.wdReplaceAll);
        }

        public Boolean ExecuteReplace(string strOld, string strNew)
        {
            Object findText = strOld;
            Object matchCase = Type.Missing;
            Object matchWholeWord = Type.Missing;
            Object matchWildcards = Type.Missing;
            Object matchSoundsLike = Type.Missing;
            Object matchAllWordForms = Type.Missing;
            Object forward = Type.Missing;
            Object wrap = Type.Missing;
            Object format = Type.Missing;
            Object replaceWith = strNew;
            Object replace = Word.WdReplace.wdReplaceAll;
            Object matchKashida = Type.Missing;
            Object matchDiacritics = Type.Missing;
            Object matchAlefHamza = Type.Missing;
            Object matchControl = Type.Missing;

            return oDoc.Content.Find.Execute(ref findText, ref matchCase, ref matchWholeWord,
                ref matchWildcards, ref matchSoundsLike, ref matchAllWordForms,
                ref forward, ref wrap, ref format, ref replaceWith, ref replace,
                ref matchKashida, ref matchDiacritics, ref matchAlefHamza,
                ref matchControl);
        }

        public Boolean ExecuteReplace(Word.Find find, Object replaceOption)
        {
            // Simple wrapper around Find.Execute:
            Object findText = Type.Missing;
            Object matchCase = Type.Missing;
            Object matchWholeWord = Type.Missing;
            Object matchWildcards = Type.Missing;
            Object matchSoundsLike = Type.Missing;
            Object matchAllWordForms = Type.Missing;
            Object forward = Type.Missing;
            Object wrap = Type.Missing;
            Object format = Type.Missing;
            Object replaceWith = Type.Missing;
            Object replace = replaceOption;
            Object matchKashida = Type.Missing;
            Object matchDiacritics = Type.Missing;
            Object matchAlefHamza = Type.Missing;
            Object matchControl = Type.Missing;

            return find.Execute(ref findText, ref matchCase, ref matchWholeWord,
                ref matchWildcards, ref matchSoundsLike, ref matchAllWordForms,
                ref forward, ref wrap, ref format, ref replaceWith, ref replace,
                ref matchKashida, ref matchDiacritics, ref matchAlefHamza,
                ref matchControl);
        }

        public Boolean ExecuteFind(Word.Find find)
        {
            return ExecuteFind(find, find.Text, Type.Missing, Type.Missing);
        }
        public Boolean ExecuteFind(Word.Find find, string strFindText)
        {
            return ExecuteFind(find, strFindText, Type.Missing, Type.Missing);
        }

        public Boolean ExecuteFind(
            Word.Find find, string strFindText, Object wrapFind, Object forwardFind)
        {
            // Simple wrapper around Find.Execute:

            Object findText;
            Object matchCase = Type.Missing;
            Object matchWholeWord = Type.Missing;
            Object matchWildcards = Type.Missing;
            Object matchSoundsLike = Type.Missing;
            Object matchAllWordForms = Type.Missing;
            Object forward = forwardFind;
            Object wrap = wrapFind;
            Object format = Type.Missing;
            Object replaceWith = Type.Missing;
            Object replace = Type.Missing;
            Object matchKashida = Type.Missing;
            Object matchDiacritics = Type.Missing;
            Object matchAlefHamza = Type.Missing;
            Object matchControl = Type.Missing;

            if ((strFindText == "") || (strFindText == string.Empty))
                findText = find.Text;
            else
                findText = strFindText;
            find.ClearFormatting();
            return find.Execute(ref findText, ref matchCase, ref matchWholeWord,
                ref matchWildcards, ref matchSoundsLike, ref matchAllWordForms,
                ref forward, ref wrap, ref format, ref replaceWith, ref replace,
                ref matchKashida, ref matchDiacritics, ref matchAlefHamza,
                ref matchControl);
        }


        public Boolean FindInSelection(Word.Selection Selection, string strFindText)
        {

            return this.ExecuteFind(Selection.Find, strFindText, System.Type.Missing, System.Type.Missing);
        }

        public Boolean FindInSelection(Word.Selection Selection, string strFindText, Object wrapFind, Object forwardFind)
        {

            return this.ExecuteFind(Selection.Find, strFindText, wrapFind, forwardFind);
        }

        public Boolean FindInRange(Word.Range range, string strFindText)
        {
            Boolean blnReturn = this.ExecuteFind(range.Find, strFindText, Type.Missing, Type.Missing);
            range.Select();
            return blnReturn;
        }

        public void FindInAllDocument(string strFindText)
        {
            int intFound = 0;
            Object start = 0;
            Object end = this.oDoc.Characters.Count;
            Word.Range rngDoc = oDoc.Range(ref start, ref end);
            Word.Find fnd = rngDoc.Find;
            fnd.ClearFormatting();
            fnd.Forward = true;
            fnd.Text = strFindText;
            ExecuteFind(fnd);
            while (fnd.Found)
            {
                rngDoc.Font.Color = Word.WdColor.wdColorRed;
                rngDoc.Font.Bold = 600;
                intFound++;
                ExecuteFind(fnd);
            }
            MessageBox.Show(String.Format("lorem found {0} times.", intFound), "FindInLoopAndFormat");
        }
        #endregion
    }
}

 

 

using System;
using System.Data;
using System.Configuration;
using Microsoft.Office.Interop;
using Excel = Microsoft.Office.Interop.Excel;
using Microsoft.Office.Core;
using Microsoft.Office;

namespace StreetControlSystem.Office
{
    /// <SUMMARY>
    /// ExcelEdit 的摘要说明
    /// </SUMMARY>
    public class ExcelAdapt
    {
        public string mFilename;
        public Excel.Application app;
        public Excel.Workbooks wbs;
        public Excel.Workbook wb;
        public Excel.Worksheets wss;
        public Excel.Worksheet ws;
        public ExcelAdapt()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        public void Create()//创建一个Excel对象
        {
            app = new Excel.Application();
            wbs = app.Workbooks;
            wb = wbs.Add(true);
        }
        public void Open(string FileName)//打开一个Excel文件
        {
            app = new Excel.Application();
            wbs = app.Workbooks;
            wb = wbs.Add(FileName);
            //wb = wbs.Open(FileName, 0, true, 5,"", "", true, Excel.XlPlatform.xlWindows, "t", false, false, 0, true,Type.Missing,Type.Missing);
            //wb = wbs.Open(FileName,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Excel.XlPlatform.xlWindows,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing);
            mFilename = FileName;
        }
        public Excel.Worksheet GetSheet(string SheetName)
        //获取一个工作表
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets[SheetName];
            return s;
        }
        public Excel.Worksheet AddSheet(string SheetName)
        //添加一个工作表
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
            s.Name = SheetName;
            return s;
        }

        public void DelSheet(string SheetName)//删除一个工作表
        {
            ((Excel.Worksheet)wb.Worksheets[SheetName]).Delete();
        }
        public Excel.Worksheet ReNameSheet(string OldSheetName, string NewSheetName)//重命名一个工作表一
        {
            Excel.Worksheet s = (Excel.Worksheet)wb.Worksheets[OldSheetName];
            s.Name = NewSheetName;
            return s;
        }

        public Excel.Worksheet ReNameSheet(Excel.Worksheet Sheet, string NewSheetName)//重命名一个工作表二
        {

            Sheet.Name = NewSheetName;

            return Sheet;
        }

        public void SetCellValue(Excel.Worksheet ws, int x, int y, object value)
        //ws：要设值的工作表     X行Y列     value   值
        {
            ws.Cells[x, y] = value;
        }
        public void SetCellValue(string ws, int x, int y, object value)
        //ws：要设值的工作表的名称 X行Y列 value 值
        {

            GetSheet(ws).Cells[x, y] = value;
        }

        public object GetCellValue(string ws, int x, int y)
        {
            return GetSheet(ws).Cells[x, y];
        }

        public object GetCellValue(Excel.Worksheet ws, int x, int y)
        {
            return ws.Cells[x, y];
        }

        public void SetCellProperty(Excel.Worksheet ws, int Startx, int Starty, int Endx, int Endy, int size, string name, Excel.Constants color, Excel.Constants HorizontalAlignment)
        //设置一个单元格的属性   字体，   大小，颜色   ，对齐方式
        {
            name = "宋体";
            size = 12;
            color = Excel.Constants.xlAutomatic;
            HorizontalAlignment = Excel.Constants.xlRight;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;
        }

        public void SetCellProperty(string wsn, int Startx, int Starty, int Endx, int Endy, int size, string name, Excel.Constants color, Excel.Constants HorizontalAlignment)
        {
            //name = "宋体";
            //size = 12;
            //color = Excel.Constants.xlAutomatic;
            //HorizontalAlignment = Excel.Constants.xlRight;

            Excel.Worksheet ws = GetSheet(wsn);
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;
            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;

            ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;
        }


        public void UniteCells(Excel.Worksheet ws, int x1, int y1, int x2, int y2)
        //合并单元格
        {
            ws.get_Range(ws.Cells[x1, y1], ws.Cells[x2, y2]).Merge(Type.Missing);
        }

        public void UniteCells(string ws, int x1, int y1, int x2, int y2)
        //合并单元格
        {
            GetSheet(ws).get_Range(GetSheet(ws).Cells[x1, y1], GetSheet(ws).Cells[x2, y2]).Merge(Type.Missing);

        }


        public void InsertTable(System.Data.DataTable dt, string ws, int startX, int startY)
//将内存中数据表格插入到Excel指定工作表的指定位置 为在使用模板时控制格式时使用一
        {

            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {
                    GetSheet(ws).Cells[startX+i, j + startY] = dt.Rows[i][j].ToString();

                }

            }

        }
        public void InsertTable(System.Data.DataTable dt, Excel.Worksheet ws, int startX, int startY)
//将内存中数据表格插入到Excel指定工作表的指定位置二
        {

            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {

                    ws.Cells[startX+i, j + startY] = dt.Rows[i][j];

                }

            }

        }


        public void AddTable(System.Data.DataTable dt, string ws, int startX, int startY)
//将内存中数据表格添加到Excel指定工作表的指定位置一
        {

            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {

                    GetSheet(ws).Cells[i + startX, j + startY] = dt.Rows[i][j];

                }

            }

        }
        public void AddTable(System.Data.DataTable dt, Excel.Worksheet ws, int startX, int startY)
//将内存中数据表格添加到Excel指定工作表的指定位置二
        {


            for (int i = 0; i <= dt.Rows.Count - 1; i++)
            {
                for (int j = 0; j <= dt.Columns.Count - 1; j++)
                {

                    ws.Cells[i + startX, j + startY] = dt.Rows[i][j];

                }
            }

        }

        public void CopyToTable(ref DataTable dt, Excel.Worksheet ws, int startX, int startY, int width, int height)
        {
            object[] objs = new object[width];
            for (int r = 0; r < height; r++)
            {
                for (int i = 0; i < width; i++)
                {
                    objs[i] = ws.Cells[startX + i, startY + r];
                }
                dt.Rows.Add(objs);
            }
        }

        //public void InsertPictures(string Filename, string ws)
        ////插入图片操作一
        //{
        //    GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoTrue, MsoTriState.msoTrue, 10F, 10F, 150F, 150F);
        //    //后面的数字表示位置
        //}

        //public void InsertPictures(string Filename, string ws, int Height, int Width)
        //插入图片操作二
        //{
        //    GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoFalse, MsoTriState.msoTrue, 10, 10, 150, 150);
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).Height = Height;
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).Width = Width;
        //}
        //public void InsertPictures(string Filename, string ws, int left, int top, int Height, int Width)
        //插入图片操作三
        //{

        //    GetSheet(ws).Shapes.AddPicture(Filename, MsoTriState.msoFalse, MsoTriState.msoTrue, 10, 10, 150, 150);
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).IncrementLeft(left);
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).IncrementTop(top);
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).Height = Height;
        //    GetSheet(ws).Shapes.get_Range(Type.Missing).Width = Width;
        //}

        public void InsertActiveChart(Excel.XlChartType ChartType, string ws, int DataSourcesX1, int DataSourcesY1, int DataSourcesX2, int DataSourcesY2, Excel.XlRowCol ChartDataType)
        //插入图表操作
        {
            ChartDataType = Excel.XlRowCol.xlColumns;
            wb.Charts.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
            {
                wb.ActiveChart.ChartType = ChartType;
                wb.ActiveChart.SetSourceData(GetSheet(ws).get_Range(GetSheet(ws).Cells[DataSourcesX1, DataSourcesY1], GetSheet(ws).Cells[DataSourcesX2, DataSourcesY2]), ChartDataType);
                wb.ActiveChart.Location(Excel.XlChartLocation.xlLocationAsObject, ws);
            }
        }
        public bool Save()
        //保存文档
        {
            if (mFilename == "")
            {
                return false;
            }
            else
            {
                try
                {
                    wb.Save();
                    return true;
                }

                catch
                {
                    return false;
                }
            }
        }
        public bool SaveAs(object FileName)
        //文档另存为
        {
            try
            {
                wb.SaveAs(FileName, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Excel.XlSaveAsAccessMode.xlExclusive, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                return true;

            }

            catch
            {
                return false;

            }
        }
        public void Close()
        //关闭一个Excel对象，销毁对象
        {
            //wb.Save();
            wb.Close(Type.Missing, Type.Missing, Type.Missing);
            wbs.Close();
            app.Quit();
            wb = null;
            wbs = null;
            app = null;
            GC.Collect();
        }
    }
}