namespaceImportExportToOffice
{
usingSystem;
usingSystem.ComponentModel;
usingSystem.Data;
usingSystem.Windows.Forms;
publicclassImportExportToWord
{
privateWord.ApplicationClassoWordApplic;
privateWord.DocumentoDoc;
privateconststringstrFileName=@"F:\";
privateconststringPostfixForWord=@".doc";
privateconststringPostfixForHtml=@".Html";

构造函数#region构造函数
publicImportExportToWord()
{
oWordApplic=newWord.ApplicationClass();
}
#endregion

publicWord.DocumentDocument
{
get
{
returnthis.oDoc;
}
}

publicWord.ApplicationClassApplication
{
get
{
returnthis.oWordApplic;
}
}

私有方法#region私有方法

/**////<summary>
///设置Word文档是否可视
///</summary>
///<paramname="InEnabled">boolean</param>
privatevoidSetVisible(BooleanInEnabled)
{
oWordApplic.Visible=InEnabled;
}

/**////<summary>
///在垃圾回收时，在任务管理器中还存在当前操作的WORD的进程
///查阅资料，必须在另一个方法中在调用GC才可以真正的清楚掉，当前的进程
///</summary>
privatevoidGCForQuit()
{
objectmissing=System.Reflection.Missing.Value;
oWordApplic.Application.Quit(refmissing,refmissing,refmissing);
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>
///<paramname="strDefaultExt">要保存文件的类型</param>
///<paramname="strFilter">文件名筛选器字符串</param>
///<returns>保存的路径</returns>
privatestringSaveFileName(stringstrDefaultExt,stringstrFilter)
{
stringfileName="";
System.Windows.Forms.SaveFileDialogsaveFileDlg=newSystem.Windows.Forms.SaveFileDialog();
saveFileDlg.DefaultExt=strDefaultExt;
saveFileDlg.Filter=strFilter;
if(saveFileDlg.ShowDialog()==System.Windows.Forms.DialogResult.OK)
fileName=saveFileDlg.FileName;
returnfileName;
}

/**////<summary>
///将被SaveFileName取代
///</summary>
///<returns></returns>
privatestringSaveFileToHtmlForName()
{
stringfileName="";
System.Windows.Forms.SaveFileDialogsaveFileDlg=newSystem.Windows.Forms.SaveFileDialog();
saveFileDlg.DefaultExt="Html";
saveFileDlg.Filter="html文件(*.html)|*.htm";
if(saveFileDlg.ShowDialog()==System.Windows.Forms.DialogResult.OK)
fileName=saveFileDlg.FileName;
returnfileName;
}

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

#endregion

公有方法#region公有方法

/**////<summary>
///打开一个空的Word模板
///</summary>
publicboolOpen()
{
boolresult=false;
try
{
objectmissing=System.Reflection.Missing.Value;
oDoc=oWordApplic.Documents.Add(refmissing,refmissing,refmissing,refmissing);
oDoc.Activate();
result=true;
}
catch
{
this.Quit();
//throw(newException());
}
returnresult;
}

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

/**////<summary>
///打开指定的Word文档
///</summary>
///<paramname="strFileName">指定的Word文档</param>
publicboolOpen(stringstrFileName)
{
returnthis.Open(strFileName,true);
}

/**////<summary>
///打开指定的Word文档并判断是否显示
///</summary>
///<paramname="strFileName">指定的Word文档</param>
///<paramname="isEnabled">显示与否</param>
publicboolOpen(stringstrFileName,boolisEnabled)
{
boolresult=false;
if(strFileName==null||strFileName=="")returnresult;
try
{
objectfileName=strFileName;
objectreadOnly=false;
objectisVisible=true;
objectmissing=System.Reflection.Missing.Value;
#ifOFFICEXP
oDoc=oWordApplic.Documents.Open(reffileName,refmissing,refreadOnly,
refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,
refmissing,refmissing,refisVisible,refmissing,refmissing,refmissing);
#else
oDoc=oWordApplic.Documents.Open(reffileName,refmissing,refreadOnly,
refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,
refmissing,refmissing,refisVisible);
#endif
oDoc.Activate();
oWordApplic.Visible=isEnabled;
result=true;
}
catch
{
this.Quit();
//throw(newException());
}
returnresult;
}

/**////<summary>
///另存
///</summary>
publicboolSaveAs()
{
objectmissing=System.Reflection.Missing.Value;
objectfileName=SaveFileName("doc","doc文件(*.doc)|*.doc");
returnthis.SaveAs(Convert.ToString(fileName));
}

/**////<summary>
///另存
///</summary>
///<paramname="strFileName"></param>
publicboolSaveAs(stringstrFileName)
{
boolresult=false;
if(strFileName==null||strFileName=="")returnresult;
try
{
objectmissing=System.Reflection.Missing.Value;
objectfileName=strFileName;
#ifOFFICEXP
oDoc.SaveAs(reffileName,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,
refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing);
#else
oDoc.SaveAs(reffileName,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing,refmissing);
#endif
result=true;
}
catch
{
//throw(newException());
}
finally
{
this.Quit();
}
returnresult;
}


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

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

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

publicvoidInsertText(stringstrText,intiNum)
{
for(inti=0;i<iNum;i++)
this.InsertText(strText);
}
/**////<summary>
///插入文本操作
///</summary>
///<paramname="strText">要保存的字符串</param>
publicboolInsertTextBySelection(stringstrText)
{
stringstrsavefilename=strFileName+DateTime.Now.ToString("yyyyMMddHHmmss")+PostfixForWord;
returnthis.InsertTextBySelection(strText,strsavefilename);
}

/**////<summary>
///
///</summary>
///<paramname="strText">要保存的字符串</param>
///<paramname="strSaveFileName">保存后的doc文件名</param>
publicboolInsertTextBySelection(stringstrText,stringstrSaveFileName)
{
returnthis.InsertTextBySelection(strText,strSaveFileName,20,20,0,0,"华文仿宋");
}

/**////<summary>
///
///</summary>
///<paramname="strText">要保存的字符串</param>
///<paramname="strSaveFileName">保存后的doc文件名</param>
///<paramname="leftindent">首行缩近多少</=param>
///<paramname="size">字体大小</param>
///<paramname="boldbi">是否粗体;1yes,0no</param>
///<paramname="paragraphalignment">对齐方式</param>
publicboolInsertTextBySelection(stringstrText,stringstrSaveFileName,floatfirstlineindent,intsize,intboldbi,intparagraphalignment,stringfontname)
{
boolresult=false;
if(strText==""||strText==null)returnresult;
if(this.Open())
{
try
{
string[]strvalue=strText.Split('$');
if(strvalue.Length!=0)
{
oWordApplic.Selection.TypeText("今天是："+DateTime.Now.ToString("yyyy-MM-dd"));
Word.Paragraphpara=this.GoToFirstParagraph();
para.Range.Select();
this.SetFontName(fontname);
this.SetFirstLineIndent(firstlineindent);
this.SetFontSize(20);
this.setBoldBi(boldbi);
switch(paragraphalignment)
{
case0:
this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphLeft);
break;
case1:
this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphCenter);
break;
case2:
this.SetAlignment(Word.WdParagraphAlignment.wdAlignParagraphRight);
break;
}
intj=0;
for(inti=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(newException());
}
}
returnresult;
}

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

/**////<summary>
///插入指定的空行
///</summary>
///<paramname="nline">行数</param>
publicvoidInsertLineBreakBySelection(intnline)
{
for(inti=0;i<nline;i++)
this.InsertLineBreakBySelection();
}

/**////<summary>
///换页
///</summary>
publicvoidInsertPagebreak()
{
objectpBreak=(int)Word.WdBreakType.wdPageBreak;
oWordApplic.Selection.InsertBreak(refpBreak);
}

publicvoidInsertTextBeforeByParagraph(Word.Paragraphparagraph,stringstrText)
{
paragraph.Range.InsertBefore(strText);
}

publicvoidInsertTextAfterByParagraph(Word.Paragraphparagraph,stringstrText)
{
paragraph.Range.InsertAfter(strText);

}

publicvoidInsertParagraphBeforeByParagraph(Word.Paragraphparagraph)
{
paragraph.Range.InsertParagraphBefore();
}

publicvoidInsertParagraphBeforeByParagraph(Word.Paragraphparagraph,intnLine)
{
for(inti=0;i<nLine;i++)
paragraph.Range.InsertParagraphBefore();
}

publicvoidInsertParagraphAfterByParagraph(Word.Paragraphparagraph)
{
paragraph.Range.InsertParagraphAfter();
}

publicvoidInsertParagraphAfterByParagraph(Word.Paragraphparagraph,intnLine)
{
for(inti=0;i<nLine;i++)
paragraph.Range.InsertParagraphAfter();
}

/**////<summary>
///数据集转换即把DataSet转换为Word对象
///</summary>
///<paramname="ds"></param>
publicboolDataSetToWord(DataSetds,stringstrFileName)
{
boolresult=false;
if(ds==null)returnresult;
if(strFileName==null||strFileName=="")returnresult;
if(this.Open())
{
try
{
Word.Rangepara=oWordApplic.Application.Selection.Paragraphs.Item(1).Range;
objecttableBehavior=System.Reflection.Missing.Value;
objectautoFitBehavior=System.Reflection.Missing.Value;
oDoc.Tables.Add(para,
ds.Tables[0].Rows.Count+1,//多的一行用来表示表列
ds.Tables[0].Columns.Count,
reftableBehavior,
refautoFitBehavior);

//填充Word表格的列标
for(intintCol=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(intintRow=0;intRow<ds.Tables[0].Rows.Count;intRow++)
{
for(intintCol=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(newException());
}
}
returnresult;
}

/**////<summary>
///采用默认地址保存
///</summary>
///<paramname="ds"></param>
publicboolDataSetToWord(DataSetds)
{
returnthis.DataSetToWord(ds,strFileName+ds.Tables[0].TableName.ToString()+PostfixForWord);
}



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

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

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

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

/**////<summary>
///设置字体类型
///</summary>
///<paramname="strType"></param>
publicvoidSetFont(stringstrType)
{
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>
publicvoidSetFont()
{
oWordApplic.Selection.Font.Bold=0;
oWordApplic.Selection.Font.Italic=0;
oWordApplic.Selection.Font.Subscript=0;

}

/**////<summary>
///设置字体名称
///</summary>
///<paramname="strType"></param>
publicvoidSetFontName(stringstrType)
{
oWordApplic.Selection.Font.Name=strType;

}

/**////<summary>
///设置字体颜色
///</summary>
///<paramname="Color"></param>
publicvoidSetFontColor(Word.WdColorColor)
{
oWordApplic.Selection.Font.Color=Color;
}

/**////<summary>
///设置字体大小
///</summary>
///<paramname="nSize"></param>
publicvoidSetFontSize(intnSize)
{
oWordApplic.Selection.Font.Size=nSize;

}

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

publicvoidSetBoldSize(intintBold)
{
oWordApplic.Selection.Font.Bold=intBold;
}

publicvoidSetUnderLine(Word.WdUnderlineunderLine)
{
oWordApplic.Selection.Font.Underline=underLine;
}

publicvoidSetUnderLineColor(Word.WdColorColor)
{
oWordApplic.Selection.Font.UnderlineColor=Color;
}


/**////<summary>
///定位到书签
///</summary>
///<paramname="strBookMarkName"></param>
publicvoidGotoBookMark(stringstrBookMarkName)
{
objectmissing=System.Reflection.Missing.Value;
objectBookmark=(int)Word.WdGoToItem.wdGoToBookmark;
objectNameBookMark=strBookMarkName;
oWordApplic.Selection.GoTo(refBookmark,refmissing,refmissing,refNameBookMark);
}

/**////<summary>
///定位到文档开头
///</summary>
publicvoidGoToTheBeginning()
{
objectmissing=System.Reflection.Missing.Value;
objectunit;
unit=Word.WdUnits.wdStory;
oWordApplic.Selection.HomeKey(refunit,refmissing);

}

/**////<summary>
///定位到文档结尾
///</summary>
publicvoidGoToTheEnd()
{
objectmissing=System.Reflection.Missing.Value;
objectunit;
unit=Word.WdUnits.wdStory;
oWordApplic.Selection.EndKey(refunit,refmissing);
}

/**////<summary>
///定位到首段
///</summary>
///<returns></returns>
publicWord.ParagraphGoToFirstParagraph()
{
returnthis.oWordApplic.Selection.Paragraphs.First;
}

/**////<summary>
///定位到尾段
///</summary>
///<returns></returns>
publicWord.ParagraphGoToEndParagraph()
{
returnthis.oWordApplic.Selection.Paragraphs.Last;
}

/**////<summary>
///向后定位到指定段落
///</summary>
///<paramname="para"></param>
///<paramname="count"></param>
publicvoidGoToNextParagraph(refWord.Paragraphpara,refobjectcount)
{
para.Next(refcount);
}

/**////<summary>
///向前定位到指定段落
///</summary>
///<paramname="para"></param>
///<paramname="count"></param>
publicvoidGoToPreviousParagraph(refWord.Paragraphpara,refobjectcount)
{
para.Previous(refcount);
}

publicvoidGoToTheTable(intntable)
{
objectmissing=System.Reflection.Missing.Value;
objectwhat;
what=Word.WdUnits.wdTable;
objectwhich;
which=Word.WdGoToDirection.wdGoToFirst;
objectcount;
count=1;
oWordApplic.Selection.GoTo(refwhat,refwhich,refcount,refmissing);
}

publicvoidGoToRightCell()
{
objectmissing=System.Reflection.Missing.Value;
objectdirection;
direction=Word.WdUnits.wdCell;
oWordApplic.Selection.MoveRight(refdirection,refmissing,refmissing);
}

publicvoidGoToLeftCell()
{
objectmissing=System.Reflection.Missing.Value;
objectdirection;
direction=Word.WdUnits.wdCell;
oWordApplic.Selection.MoveLeft(refdirection,refmissing,refmissing);
}

publicvoidGoToDownCell()
{
objectmissing=System.Reflection.Missing.Value;
objectdirection;
direction=Word.WdUnits.wdLine;
oWordApplic.Selection.MoveDown(refdirection,refmissing,refmissing);
}

publicvoidGoToUpCell()
{
objectmissing=System.Reflection.Missing.Value;
objectdirection;
direction=Word.WdUnits.wdLine;
oWordApplic.Selection.MoveUp(refdirection,refmissing,refmissing);
}

publicBooleanExecuteReplace(Word.Findfind)
{
returnExecuteReplace(find,Word.WdReplace.wdReplaceAll);
}

publicBooleanExecuteReplace(Word.Findfind,ObjectreplaceOption)
{
//SimplewrapperaroundFind.Execute:
ObjectfindText=Type.Missing;
ObjectmatchCase=Type.Missing;
ObjectmatchWholeWord=Type.Missing;
ObjectmatchWildcards=Type.Missing;
ObjectmatchSoundsLike=Type.Missing;
ObjectmatchAllWordForms=Type.Missing;
Objectforward=Type.Missing;
Objectwrap=Type.Missing;
Objectformat=Type.Missing;
ObjectreplaceWith=Type.Missing;
Objectreplace=replaceOption;
ObjectmatchKashida=Type.Missing;
ObjectmatchDiacritics=Type.Missing;
ObjectmatchAlefHamza=Type.Missing;
ObjectmatchControl=Type.Missing;

returnfind.Execute(reffindText,refmatchCase,refmatchWholeWord,
refmatchWildcards,refmatchSoundsLike,refmatchAllWordForms,
refforward,refwrap,refformat,refreplaceWith,refreplace,
refmatchKashida,refmatchDiacritics,refmatchAlefHamza,
refmatchControl);
}

publicBooleanExecuteFind(Word.Findfind)
{
returnExecuteFind(find,find.Text,Type.Missing,Type.Missing);
}
publicBooleanExecuteFind(Word.Findfind,stringstrFindText)
{
returnExecuteFind(find,strFindText,Type.Missing,Type.Missing);
}

publicBooleanExecuteFind(
Word.Findfind,stringstrFindText,ObjectwrapFind,ObjectforwardFind)
{
//SimplewrapperaroundFind.Execute:

ObjectfindText;
ObjectmatchCase=Type.Missing;
ObjectmatchWholeWord=Type.Missing;
ObjectmatchWildcards=Type.Missing;
ObjectmatchSoundsLike=Type.Missing;
ObjectmatchAllWordForms=Type.Missing;
Objectforward=forwardFind;
Objectwrap=wrapFind;
Objectformat=Type.Missing;
ObjectreplaceWith=Type.Missing;
Objectreplace=Type.Missing;
ObjectmatchKashida=Type.Missing;
ObjectmatchDiacritics=Type.Missing;
ObjectmatchAlefHamza=Type.Missing;
ObjectmatchControl=Type.Missing;

if((strFindText=="")||(strFindText==string.Empty))
findText=find.Text;
else
findText=strFindText;
find.ClearFormatting();
returnfind.Execute(reffindText,refmatchCase,refmatchWholeWord,
refmatchWildcards,refmatchSoundsLike,refmatchAllWordForms,
refforward,refwrap,refformat,refreplaceWith,refreplace,
refmatchKashida,refmatchDiacritics,refmatchAlefHamza,
refmatchControl);
}


publicBooleanFindInSelection(Word.SelectionSelection,stringstrFindText)
{

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

publicBooleanFindInSelection(Word.SelectionSelection,stringstrFindText,ObjectwrapFind,ObjectforwardFind)
{

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

publicBooleanFindInRange(Word.Rangerange,stringstrFindText)
{
BooleanblnReturn=this.ExecuteFind(range.Find,strFindText,Type.Missing,Type.Missing);
range.Select();
returnblnReturn;
}

publicvoidFindInAllDocument(stringstrFindText)
{
intintFound=0;
Objectstart=0;
Objectend=this.oDoc.Characters.Count;
Word.RangerngDoc=oDoc.Range(refstart,refend);
Word.Findfnd=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("loremfound{0}times.",intFound),"FindInLoopAndFormat");
}
#endregion
}
}

转：http://www.cnblogs.com/zhanghl/archive/2005/09/19/239595.html 优质内容筛选与推荐>>
1、ASP.NET中Cookie编程的基础知识
2、java学习笔记12（final ，static修饰符）
3、633. Sum of Square Numbers 一个数是否能由两个数相加所得
4、3.2 发布和显示文章
5、近半年所踩的坑的总结

赞赏

长按二维码向我转账

受苹果公司新规定影响，微信 iOS 版的赞赏功能被关闭，可通过二维码转账支持公众号。

阅读

已发送

发送中