C#

...
using Word = Microsoft.Office.Interop.Word;
...
public class WordInstance : IDisposable {
    private const string WORD_APPLICATION_EXE = "WINWORD.EXE";
    ...
    private static readonly object s_Lock = new object();
    private Word.Application m_WordApp = null;
    ...
    public WordInstance() {
        try {
            int attempt = 0;
            do {
                IList<IntPtr> allWordWinsPrior, allWordWinsAfter;
                lock (s_Lock) {
                    // Get handles to all open instances of Word
                    allWordWinsPrior = WinAPI.GetAllRootWindowsOfClass("OpusApp");
                    // Create two instances of Word, then close the first
                    // MS has a release stating that this methodology will fix
                    // the problem that opening a new instance of Word will
                    // simply use this instance instead of creating a new one.
                    Word.Application temp = new Word.Application();
                    m_WordApp = new Word.Application();
                    temp.Quit(ref s_QuitNoSave, ref s_QuitEmpty, ref s_QuitEmpty);
                    m_WordApp.DocumentOpen += new Microsoft.Office.Interop.Word
                        .ApplicationEvents4_DocumentOpenEventHandler(m_WordApp_DocumentOpen);
                    // Get handles to all open instances of Word
                    allWordWinsAfter = WinAPI.GetAllRootWindowsOfClass("OpusApp");
                }
                foreach (IntPtr ptr in allWordWinsPrior)
                    allWordWinsAfter.Remove(ptr);
                if (allWordWinsAfter.Count > 1) {
                    for (int i = allWordWinsAfter.Count - 1; i >= 0; --i)
                        if (WinAPI.IsWindowVisible(allWordWinsAfter[i]))
                            allWordWinsAfter.RemoveAt(i);
                }
                if (allWordWinsAfter.Count > 0) {
                    m_Handle = allWordWinsAfter[0];
                    return;
                }
            } while (++attempt < 3);
            throw new Exception();
        } catch {
            Dispose();
        }
    }
    ...
    public void Dispose() {
        if (m_WordApp != null) {
            try {
                // Try to quit word normally
                if (m_WordApp.Documents.Count > 0)
                    m_WordApp.Documents.Close(ref s_QuitNoSave, ref s_QuitEmpty, ref s_QuitEmpty);
                m_WordApp.Quit(ref s_QuitNoSave, ref s_QuitEmpty, ref s_QuitEmpty);
            } catch {
                // If the above fails, force word to quit
                if (m_Handle != IntPtr.Zero)
                    WinAPI.DestroyWindow(m_Handle);
            }
            m_WordApp = null;
            m_Handle = IntPtr.Zero;
        }
    }
    ...
    // Event Handler
    private void m_WordApp_DocumentOpen(Word.Document Doc) {
        if (m_WordApp == null)
            return;
        WinAPI.ShowWindow(m_Handle, (uint)WinAPI.SW.HIDE);
        string documentName = Doc.Name;
        string documentFullName = Doc.FullName;

        /*
         * Close document and re-open in new (different) instance of MS Word application 
         * (since we don't want to "share" an instance with a user while they interactively
         * use Word or with any other processing)
         */
        Doc.Close(ref s_QuitNoSave, ref s_QuitEmpty, ref s_QuitEmpty);
        if (documentFullName.Equals(documentName))
            openDocInNewWordInstance(null);
        else
            openDocInNewWordInstance(documentFullName);
    }
    ...
    // Called from the event handler
    private void openDocInNewWordInstance(string pathFileName) {
        ProcessStartInfo wordStartInfo = new ProcessStartInfo(WORD_APPLICATION_EXE);
        wordStartInfo.UseShellExecute = true;
        wordStartInfo.Arguments = (string.IsNullOrEmpty(pathFileName)
            ? "/w" : string.Format("/w \"{0}\"", pathFileName));
        wordStartInfo.WindowStyle = ProcessWindowStyle.Normal;
        Process.Start(wordStartInfo);
    }
}

bashiwala wrote:

I understand that String is a class and string is a premetive type,

using BaseType = System.UInt32; // Allowed
using BaseType = uint; // Invalid!

// Allowed
public enum foo : uint {
    ...
}
// Invalid!
public enum foo : System.UInt32 {
    ...
}

Skippums wrote:

the using statement