C#操作office技术总结

最新推荐文章于 2015-07-03 01:16:00 发布
最新推荐文章于 2015-07-03 01:16:00 发布
阅读量985 收藏
点赞数
分类专栏： 学习笔记 文章标签： c# office dataset null excel 文档

原文出处http://www.soasp.net/FilePage/200803/20080312203849.aspx

C#操作Excel!

     public   class  ImportExportToExcel
     {
         private   string  strConn ;
        
         private  System.Windows.Forms.OpenFileDialog openFileDlg = new  System.Windows.Forms.OpenFileDialog();
         private  System.Windows.Forms.SaveFileDialog saveFileDlg = new  System.Windows.Forms.SaveFileDialog();      
        
         public  ImportExportToExcel()
         {
             //
             //  TODO: 在此处添加构造函数逻辑
             //
              this .openFileDlg.DefaultExt  =   " xls " ;
             this .openFileDlg.Filter  =   " Excel文件 (*.xls)|*.xls " ;

             this .saveFileDlg.DefaultExt = " xls " ;
             this .saveFileDlg.Filter =   " Excel文件 (*.xls)|*.xls " ;

        }

         #region  从Excel文件导入到DataSet
         //          // / <summary>
         //          // / 从Excel导入文件
         //          // / </summary>
         //          // / <param name="strExcelFileName">Excel文件名</param>
         //          // / <returns>返回DataSet</returns>
         //         public DataSet ImportFromExcel(string strExcelFileName)
         //         {
         //             return doImport(strExcelFileName);
         //         }
         ///   <summary>
         ///  从选择的Excel文件导入
         ///   </summary>
         ///   <returns> DataSet </returns>
         public  DataSet ImportFromExcel()
         {
            DataSet ds = new  DataSet();
             if  (openFileDlg.ShowDialog()  ==  System.Windows.Forms.DialogResult.OK) 
                ds = doImport(openFileDlg.FileName);
             return  ds;
        }
         ///   <summary>
         ///  从指定的Excel文件导入
         ///   </summary>
         ///   <param name="strFileName"> Excel文件名 </param>
         ///   <returns></returns>
         public  DataSet ImportFromExcel( string  strFileName)
         {
            DataSet ds = new  DataSet();
            ds = doImport(strFileName);
             return  ds;
        }
         ///   <summary>
         ///  执行导入
         ///   </summary>
         ///   <param name="strFileName"> 文件名 </param>
         ///   <returns> DataSet </returns>
         private  DataSet doImport( string  strFileName)
         {
             if  (strFileName == "" )  return   null ;
              
            strConn  =   " Provider=Microsoft.Jet.OLEDB.4.0; "   +
                 " Data Source= "   +   strFileName  +   " ; "   +
                 " Extended Properties=Excel 8.0; " ;
            OleDbDataAdapter ExcelDA  =   new  OleDbDataAdapter( " SELECT * FROM [Sheet1$] " , strConn);

            DataSet ExcelDs  =   new  DataSet();
             try
             {
                ExcelDA.Fill(ExcelDs,  " ExcelInfo " );
                
            }
             catch (Exception err)
             {
                System.Console.WriteLine( err.ToString() );
            }
             return  ExcelDs;
            
            
        
        }
         #endregion

         #region  从DataSet到出到Excel
         ///   <summary>
         ///  导出指定的Excel文件
         ///   </summary>
         ///   <param name="ds"> 要导出的DataSet </param>
         ///   <param name="strExcelFileName"> 要导出的Excel文件名 </param>
         public   void  ExportToExcel(DataSet ds, string  strExcelFileName)
         {
             if  (ds.Tables.Count == 0   ||  strExcelFileName == "" )  return ;
            doExport(ds,strExcelFileName);
    

        }
         ///   <summary>
         ///  导出用户选择的Excel文件
         ///   </summary>
         ///   <param name="ds"> DataSet </param>
         public   void  ExportToExcel(DataSet ds)
         {
             if  (saveFileDlg.ShowDialog()  ==  System.Windows.Forms.DialogResult.OK) 
                doExport(ds,saveFileDlg.FileName);
            
        }
         ///   <summary>
         ///  执行导出
         ///   </summary>
         ///   <param name="ds"> 要导出的DataSet </param>
         ///   <param name="strExcelFileName"> 要导出的文件名 </param>
         private   void  doExport(DataSet ds, string  strExcelFileName)
         {
            
            Excel.Application excel =   new  Excel.Application();
            
             //             Excel.Workbook obj=new Excel.WorkbookClass();
             //             obj.SaveAs("c:/zn.xls",Excel.XlFileFormat.xlExcel9795,null,null,false,false,Excel.XlSaveAsAccessMode.xlNoChange,null,null,null,null);

             int  rowIndex = 1 ;
             int  colIndex = 0 ;

            excel.Application.Workbooks.Add( true );
            
    
            System.Data.DataTable table = ds.Tables[ 0 ] ;
             foreach (DataColumn col  in  table.Columns)
             {
                colIndex ++ ;    
                excel.Cells[ 1 ,colIndex] = col.ColumnName;                
            }

             foreach (DataRow row  in  table.Rows)
             {
                rowIndex ++ ;
                colIndex = 0 ;
                 foreach (DataColumn col  in  table.Columns)
                 {
                    colIndex ++ ;
                    excel.Cells[rowIndex,colIndex] = row[col.ColumnName].ToString();
                }
            }
            excel.Visible = false ;    
            excel.Sheets[ 0 ]  =   " sss " ;
            excel.ActiveWorkbook.SaveAs(strExcelFileName + " .XLS " ,Excel.XlFileFormat.xlExcel9795, null , null , false , false ,Excel.XlSaveAsAccessMode.xlNoChange, null , null , null , null );
            
            
             // wkbNew.SaveAs strBookName


             // excel.Save(strExcelFileName);
            excel.Quit();
            excel = null ;
            
            GC.Collect(); // 垃圾回收
        }
         #endregion

         #region  从XML导入到Dataset

         ///   <summary>
         ///  从选择的XML文件导入
         ///   </summary>
         ///   <returns> DataSet </returns>
         public  DataSet ImportFromXML()
         {
            DataSet ds = new  DataSet();
            System.Windows.Forms.OpenFileDialog openFileDlg = new  System.Windows.Forms.OpenFileDialog();
            openFileDlg.DefaultExt = " xml " ;
            openFileDlg.Filter =   " xml文件 (*.xml)|*.xml " ;
             if  (openFileDlg.ShowDialog()  ==  System.Windows.Forms.DialogResult.OK) 
                 try {ds.ReadXml(openFileDlg.FileName,System.Data.XmlReadMode.ReadSchema);}
                 catch {}
             return  ds;
        }
         ///   <summary>
         ///  从指定的XML文件导入
         ///   </summary>
         ///   <param name="strFileName"> XML文件名 </param>
         ///   <returns></returns>
         public  DataSet ImportFromXML( string  strFileName)
         {
             if  (strFileName == "" )
                 return   null ;
            DataSet ds = new  DataSet();
             try {ds.ReadXml(strFileName,System.Data.XmlReadMode.ReadSchema);}
             catch {}
             return  ds;
        }
        
         #endregion

         #region  从DataSet导出到XML
         ///   <summary>
         ///  导出指定的XML文件
         ///   </summary>
         ///   <param name="ds"> 要导出的DataSet </param>
         ///   <param name="strXMLFileName"> 要导出的XML文件名 </param>
         public   void  ExportToXML(DataSet ds, string  strXMLFileName)
         {
             if  (ds.Tables.Count == 0   ||  strXMLFileName == "" )  return ;
            doExportXML(ds,strXMLFileName);
        }
         ///   <summary>
         ///  导出用户选择的XML文件
         ///   </summary>
         ///   <param name="ds"> DataSet </param>
         public   void  ExportToXML(DataSet ds)
         {
            System.Windows.Forms.SaveFileDialog saveFileDlg = new  System.Windows.Forms.SaveFileDialog(); 
            saveFileDlg.DefaultExt = " xml " ;
            saveFileDlg.Filter =   " xml文件 (*.xml)|*.xml " ;
             if  (saveFileDlg.ShowDialog()  ==  System.Windows.Forms.DialogResult.OK) 
                doExportXML(ds,saveFileDlg.FileName);
        }

         ///   <summary>
         ///  执行导出
         ///   </summary>
         ///   <param name="ds"> 要导出的DataSet </param>
         ///   <param name="strExcelFileName"> 要导出的XML文件名 </param>
         private   void  doExportXML(DataSet ds, string  strXMLFileName)
         {
             try
             {ds.WriteXml(strXMLFileName,System.Data.XmlWriteMode.WriteSchema );}
             catch (Exception ex)
             {System.Windows.Forms.MessageBox.Show(ex.Message, " Errol " ) ;}     
        }

         #endregion

    
    
    }










C#操作Word!

namespace  ImportExportToOffice
 {
     using  System;
     using  System.ComponentModel;
     using  System.Data;
     using  System.Windows.Forms;
     public   class  ImportExportToWord
     {
         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  ImportExportToWord()
         {
            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;
             #if  OFFICEXP
            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);
             #else
                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);
             #endif
                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 ;
             #if  OFFICEXP
                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 );
             #else
                oDoc.SaveAs(  ref  fileName,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing,  ref  missing );
             #endif
                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 }  );
                     其它格式：
                    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.Item( 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.Item( 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.Item( 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( 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
    }
}
mathewsking
关注
专栏目录
C#的office文档操作
wudi626的专栏
04-28 2万+
Microsoft Office是微软公司推出的办公应用程序，主要包括Microsoft Word，Microsoft Excel、Microsoft Outlook和Microsoft Access等应用程序。提供了诸如字处理、表格处理、邮件处理和数据库等功能。目前被广泛使用的版本是Microsoft Office 2003和Microsoft Office 2007。作为微软公司推出的重量级编
c# office操作
11-09
根据提供的文件信息，我们可以归纳出以下与C#操作Office文档相关的知识点： ### C#操作Office文档概述 在C#中，可以通过多种方式来操作Office文档（如Word、Excel等），通常涉及的操作包括读取、编辑、创建以及...
C# 对word和excel操作
02-13
C#对word 和 excel 的操作实例程序，供学习者参考
C#操作office方面的总结 Excel和Word
weixin_33909059的博客
04-03 152
C#操作Excel!     public class ImportExportToExcel    {        private string strConn ;                private System.Windows.Forms.OpenFileDialog openFileDlg=new System.Windows.Forms.OpenFileDialog()...
[C# 开发技巧系列]使用C#操作Word和Excel程序
weixin_34378969的博客
03-18 220
一、引言　　在我们日常办公中，我们经常可能遇到一些重复性的工作的，比如，我们在写毕业设计的时候，有时候我们写的过程中不注意，当整篇毕业论文写完之后，发现在毕业论文中存在很多空白的段落，这是我们就需要人工重新审阅一遍论文，再手动删除一些空白行，由于毕业论文也不是一篇，有开题报告啊，文献翻译等等，这样就可能需要我们人工都去审阅一篇把一些空白行删除，这样既花时间，我们也看的累。然后还有一个例子就是——我...
C#操作Word
11-08 742
namespace ImportExportToOffice...{    using System;    using System.ComponentModel;    using System.Data;    using System.Windows.Forms;    public class ImportExportToWord    ...{        private Wor
C#操作Office：创建Word文档与引用方法详解
总结来说，C#操作Office文档的能力是开发人员必备的技能之一，掌握如何使用COM对象和特定的API，能够有效扩展应用程序的功能，满足用户在文档生成和处理方面的各种需求。随着技术的发展，C#对Office的支持也在不断...
C#操作Excel的几种方法
07-03
本文介绍了通过C#操作Excel的两种主要方法：使用`Microsoft.Office.Interop.Excel`和第三方库。每种方法都有其适用场景和限制。在实际应用中，开发者应根据项目需求和技术背景选择最合适的方式来处理Excel文件。
C# winform office OA办公
10-31
在C# WinForm环境下开发Office OA（办公自动化）系统是一项常见的任务，这涉及到将桌面应用程序与办公软件集成，实现高效的企业内部流程管理。OA系统旨在提高工作效率，简化工作流程，通常包括日程管理、任务分配、...
Word文档浏览器(不需要安装office)含C#源码.
11-28
【标签】"C#操作word"进一步指明了程序的主要编程语言和功能焦点。C#是一种面向对象的、现代的编程语言，由微软开发，广泛应用于Windows桌面应用开发。在C#中操作Word文档，通常涉及使用Aspose这样的第三方库，因为...
C#的office操作
04-07
C#的office操作，包括对word,excel,powerpoint的创建文档，插入文字，插入表格，图片等等操作
C#下操作Office的Word组件
11-09
在C#下调用Office的word组件，需要加载两个微软的com组件，具体的方法网络上有很多介绍，这里只提供源码
C# 操作Word ,Excel
weixin_30641999的博客
10-11 94
利用GridView控件导出其他文件（导出Excel，导出Word文件） // 注意，在Visual Studio2005平台下，如果使用GridView导出文件， //就必须重载VerifyRenderingInServerForm方法 public override void VerifyRenderingInServerForm(Cont...
C#的office操作[word&Excel]
净心编程
12-31 4056
C#实现对Word文件读写        手头上的一个项目报表相对比较简单，所以报表打印采用VBA引擎，通过定制Word模版，然后根据模版需要填充数据，然后OK,打印即可。　　实现方法：首先需要引用VBA组建,我用的是Office2003 Professional，Dll版本号为Microsoft Word11.0　　另外当然还需要引用Interop.Word.Dll.　　代码如下：///#reg
C# 操作office
u012792791的专栏
06-25 420
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using Ex
C#操作Office文件(一)
ytqxiaoma的专栏
11-20 417
一、使用C#创建Word文档
C#操作Office.word（一）
weixin_33906657的博客
06-24 164
该文章主要是讲述如何使用VS2010创建word文档，因为在项目中我们可能需要点击一个按钮把数据库中的项目表单或图片显示到word文档中，因此该文章主要分析如何使用VS2010创建word文档并填写相应的内容。主要通过C#引用Miscrosoft Word 14.0 Object Library实现的。 一.创建工程 首先是使用VS2010创建一个windows窗体程序，并添加如下图所示的界面...
c#操作 word excel
dieaozhi8291的博客
05-16 130
导出成EXCEL： Excel.Application excel = new Excel.Application(); excel.Application.Workbooks.Add(true); excel.Visible = true; for (int i = 0; i < th...
C#操作Office.word(三）
weixin_33730836的博客
07-03 146
前面两篇博客讲解了怎么通过程序控制word的生成，包括生成文字、添加表格、添加图片等。这篇博客主要说一下怎么把word图片转换成pdf。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.Office.Core; name...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值