c# – VSTO Word发布保存事件

对不起这个问题的长度,过去我曾经被要求提供我在提出这些问题时尝试过的所有内容.

我正在编写一个Word加载项,需要对使用Word对象模型无法实现的文档进行更改.因此,在将文档保存到磁盘后,我需要捕获该事件,关闭文件,执行我需要执行的操作并重新打开它. (我知道,不是很优雅,但那是我必须要合作的.)

Word具有“保存前”和“关闭前”,但保存事件后没有.通过创建另一个线程并使用COM的IMessageFilter(不是来自System.Windows.Forms)来处理COM重试调用,或者在主线程上发回消息以便我可以在保存后执行代码,我在网上发现了模拟后保存事件的技巧.但这不起作用,因为如果文件是由于用户试图关闭文档而保存的,我无法在“回调”方法中获取文件名,因为Word.Document对象已被删除.

所以我尝试在我的BeforeSave事件处理程序中显式调用Save self并返回Cancel = true.当用户选择保存或者曾经保存到磁盘时,这很有用.但是,如果用户在未保存的情况下关闭新文档,然后对是否要保存选择“是”,则在我从BeforeSave事件返回后已经处理了保存后,Word会显示另一个“SaveAs”对话框,即使我在BeforeSave事件处理程序中设置了Cancel = true.

所以我尝试用BeforeClose事件做类似的事情.我处理关闭并保存自己,然后从我的事件处理程序返回Cancel = true.但是,当用户试图关闭应用程序时,这样做会阻止尝试关闭多个文档.

我甚至尝试过处理WM_CLOSE,但这导致了类似的问题.

有人能提供解决方案吗?

最佳答案
我偶然遇到了this,我认为它可能会做你想要的.这里有一个副本,以防万一它消失.

当我写第一篇Word AfterSave Event条目时,它是专为Word 2007设计的,而且 – 事实证明 – 并非一帆风顺.所以我在这里更新了(感谢抓到Pat Lemm).

文档关闭后,您永远无法访问已保存的文件名.所以,我已经在这里更新了代码,它现在可以在所有条件下运行,并且已经在Word 2013中进行了测试.

下面是它的工作原理:

>初始化后,将其传递给Word对象.
>它附加于Before Save Event.
>当发生任何保存事件时,它会启动一个循环的线程,直到后台保存完成.
>完成后台保存后,它会检查文件Saved == true:

>如果Saved == true:则确实发生了常规保存.
>如果Saved == false:那么它必须是AutoSave

在每种情况下,它都会触发一个独特的事件:

> AfterSaveUiEvent
> AfterSaveEvent
> AfterAutoSaveEvent

此外,如果正在保存的文档也被关闭,我们会在出路时捕获WindowDeactivate事件上的文件名.现在,调用者可以访问它(如下面的示例所示),以获取已关闭文档的完整文件名.

这是该类的代码:

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.

}

转载注明原文:c# – VSTO Word发布保存事件 - 代码日志