C# VSTO Word后期保存事件
很抱歉这么长时间，在过去我被要求在问这类问题时包括我尝试过的所有东西 我正在编写Word加载项，需要对文档进行更改，而这是使用Word对象模型无法实现的。因此，在文档保存到磁盘后，我需要捕获该事件，关闭该文件，执行需要执行的操作并重新打开它。（我知道，这并不优雅，但这正是我必须面对的。） Word有“保存前”和“关闭前”，但没有“保存后”事件。我在网上找到了一些技巧，通过创建另一个线程并使用COM（不是从System.Windows.Forms）来处理COM重试调用，或者在主线程上发回消息，以便在保存代码后执行代码，来模拟保存后事件。但这不起作用，因为如果文件是由于用户试图关闭文档而保存的，我无法在“回调”方法中获取文件名，因为Word.document对象已被删除 因此，我尝试在BeforeSave事件处理程序中显式地调用Save self，并返回Cancel=true。当用户选择save（保存）或他们曾经保存到磁盘时，这种方法非常有效。但是，如果用户在不保存的情况下关闭一个新文档，然后选择“是”以确定是否要保存，Word将在我从BeforeSave事件返回后处理保存后显示另一个“SaveAs”对话框，即使我在BeforeSave事件处理程序中设置了Cancel=true 然后我试着做了一些类似于BeforeClose事件的事情。我处理关闭并保存自己，然后从事件处理程序返回Cancel=true。但是这样做可以阻止word在用户试图关闭应用程序时尝试关闭多个文档 我甚至尝试过关闭WM_，但这会导致类似的问题 有人能提供解决方案吗？我不久前遇到过，我想它可能会满足你的需要。这是它的副本，以防它消失C# VSTO Word后期保存事件,c#,multithreading,events,vsto,C#,Multithreading,Events,Vsto,很抱歉这么长时间，在过去我被要求在问这类问题时包括我尝试过的所有东西 我正在编写Word加载项，需要对文档进行更改，而这是使用Word对象模型无法实现的。因此，在文档保存到磁盘后，我需要捕获该事件，关闭该文件，执行需要执行的操作并重新打开它。（我知道，这并不优雅，但这正是我必须面对的。） Word有“保存前”和“关闭前”，但没有“保存后”事件。我在网上找到了一些技巧，通过创建另一个线程并使用COM（不是从System.Windows.Forms）来处理COM重试调用，或者在主线程上发回消息，以便
当我写第一篇文章时，它是为Word2007设计的，事实证明，它不是一个包罗万象的东西。所以我在这里更新了它（感谢Pat Lemm的帮助） 文档关闭时，您无法访问保存的文件名。因此，我更新了这里的代码，现在它可以在所有条件下工作，并在Word 2013中进行了测试 以下是它的工作原理：
- 如果Saved==true：则确实发生了常规保存
- 如果Saved==false：则它必须是自动保存
- 余震
- 余震
- 自动保存事件后
public class WordSaveHandler
{
public delegate void AfterSaveDelegate(Word.Document doc, bool isClosed);
// public events
public event AfterSaveDelegate AfterUiSaveEvent;
public event AfterSaveDelegate AfterAutoSaveEvent;
public event AfterSaveDelegate AfterSaveEvent;
// module level
private bool preserveBackgroundSave;
private Word.Application oWord;
string closedFilename = string.Empty;
/// <summary>
/// CONSTRUCTOR takes the Word application object to link to.
/// </summary>
/// <param name="oApp"></param>
public WordSaveHandler(Word.Application oApp)
{
oWord = oApp;
// hook to before save
oWord.DocumentBeforeSave += oWord_DocumentBeforeSave;
oWord.WindowDeactivate += oWord_WindowDeactivate;
}
/// <summary>
/// Public property to get the name of the file
/// that was closed and saved
/// </summary>
public string ClosedFilename
{
get
{
return closedFilename;
}
}
/// <summary>
/// WORD EVENT fires before a save event.
/// </summary>
/// <param name="Doc"></param>
/// <param name="SaveAsUI"></param>
/// <param name="Cancel"></param>
void oWord_DocumentBeforeSave(Word.Document Doc, ref bool SaveAsUI, ref bool Cancel)
{
// This could mean one of four things:
// 1) we have the user clicking the save button
// 2) Another add-in or process firing a resular Document.Save()
// 3) A Save As from the user so the dialog came up
// 4) Or an Auto-Save event
// so, we will start off by first:
// 1) Grabbing the current background save flag. We want to force
// the save into the background so that Word will behave
// asyncronously. Typically, this feature is on by default,
// but we do not want to make any assumptions or this code
// will fail.
// 2) Next, we fire off a thread that will keep checking the
// BackgroundSaveStatus of Word. And when that flag is OFF
// no know we are AFTER the save event
preserveBackgroundSave = oWord.Options.BackgroundSave;
oWord.Options.BackgroundSave = true;
// kick off a thread and pass in the document object
bool UiSave = SaveAsUI; // have to do this because the bool from Word
// is passed to us as ByRef
new Thread(() =>
{
Handle_WaitForAfterSave(Doc, UiSave);
}).Start();
}
/// <summary>
/// This method is the thread call that waits for the same to compelte.
/// The way we detect the After Save event is to essentially enter into
/// a loop where we keep checking the background save status. If the
/// status changes we know the save is compelte and we finish up by
/// determineing which type of save it was:
/// 1) UI
/// 2) Regular
/// 3) AutoSave
/// </summary>
/// <param name="Doc"></param>
/// <param name="UiSave"></param>
private void Handle_WaitForAfterSave(Word.Document Doc, bool UiSave)
{
try
{
// we have a UI save, so we need to get stuck
// here until the user gets rid of the SaveAs dialog
if (UiSave)
{
while (isBusy())
Thread.Sleep(1);
}
// check to see if still saving in the background
// we will hang here until this changes.
while (oWord.BackgroundSavingStatus > 0)
Thread.Sleep(1);
}
catch (ThreadAbortException)
{
// we will get a thread abort exception when Word
// is in the process of closing, so we will
// check to see if we were in a UI situation
// or not
if (UiSave)
{
AfterUiSaveEvent(null, true);
}
else
{
AfterSaveEvent(null, true);
}
}
catch
{
oWord.Options.BackgroundSave = preserveBackgroundSave;
return; // swallow the exception
}
try
{
// if it is a UI save, the Save As dialog was shown
// so we fire the after ui save event
if (UiSave)
{
// we need to check to see if the document is
// saved, because of the user clicked cancel
// we do not want to fire this event
try
{
if (Doc.Saved == true)
{
AfterUiSaveEvent(Doc, false);
}
}
catch
{
// DOC is null or invalid. This occurs because the doc
// was closed. So we return doc closed and null as the
// document
AfterUiSaveEvent(null, true);
}
}
else
{
// if the document is still dirty
// then we know an AutoSave happened
try
{
if (Doc.Saved == false)
AfterAutoSaveEvent(Doc, false); // fire autosave event
else
AfterSaveEvent(Doc, false); // fire regular save event
}
catch
{
// DOC is closed
AfterSaveEvent(null, true);
}
}
}
catch { }
finally
{
// reset and exit thread
oWord.Options.BackgroundSave = preserveBackgroundSave;
}
}
/// <summary>
/// WORD EVENT – Window Deactivate
/// Fires just before we close the document and it
/// is the last moment to get the filename
/// </summary>
/// <param name="Doc"></param>
/// <param name="Wn"></param>
void oWord_WindowDeactivate(Word.Document Doc, Word.Window Wn)
{
closedFilename = Doc.FullName;
}
/// <summary>
/// Determines if Word is busy essentially that the File Save
/// dialog is currently open
/// </summary>
/// <param name="oApp"></param>
/// <returns></returns>
private bool isBusy()
{
try
{
// if we try to access the application property while
// Word has a dialog open, we will fail
object o = oWord.ActiveDocument.Application;
return false; // not busy
}
catch
{
// so, Word is busy and we return true
return true;
}
}
}
public partial class ThisAddIn
{
WordSaveHandler wsh = null;
private void ThisAddIn_Startup(object sender,
System.EventArgs e)
{
// attach the save handler
wsh = new WordSaveHandler(Application);
wsh.AfterAutoSaveEvent += new WordSaveHandler.AfterSaveDelegate(wsh_AfterAutoSaveEvent);
wsh.AfterSaveEvent += new WordSaveHandler.AfterSaveDelegate(wsh_AfterSaveEvent);
wsh.AfterUiSaveEvent += new WordSaveHandler.AfterSaveDelegate(wsh_AfterUiSaveEvent);
}
void wsh_AfterUiSaveEvent(Word.Document doc, bool isClosed)
{
if (!isClosed)
MessageBox.Show("After SaveAs Event");
else
MessageBox.Show("After Close and SaveAs Event. The filname was: " + wsh.ClosedFilename);
}
void wsh_AfterSaveEvent(Word.Document doc, bool isClosed)
{
if (!isClosed)
MessageBox.Show("After Save Event");
else
MessageBox.Show("After Close and Save Event. The filname was: " + wsh.ClosedFilename);
}
void wsh_AfterAutoSaveEvent(Word.Document doc, bool isClosed)
{
MessageBox.Show("After AutoSave Event");
}
// etc.
}